def __init__(self, name: str = "") -> None:

self.name = name

def on_enter(self) -> None:

pass

def on_draw(self) -> None:

pass

def ev_keydown(self, event: tcod.event.KeyDown) -> None:

global cur_sample

if event.sym == tcod.event.KeySym.DOWN:

cur_sample = (cur_sample + 1) % len(SAMPLES)

SAMPLES[cur_sample].on_enter()

draw_samples_menu()

elif event.sym == tcod.event.KeySym.UP:

cur_sample = (cur_sample - 1) % len(SAMPLES)

SAMPLES[cur_sample].on_enter()

draw_samples_menu()

elif event.sym == tcod.event.KeySym.RETURN and event.mod & tcod.event.Modifier.ALT:

sdl_window = context.sdl_window

if sdl_window:

sdl_window.fullscreen = not sdl_window.fullscreen

elif event.sym in (tcod.event.KeySym.PRINTSCREEN, tcod.event.KeySym.P):

print("screenshot")

if event.mod & tcod.event.Modifier.ALT:

libtcodpy.console_save_apf(root_console, "samples.apf")

print("apf")

else:

libtcodpy.sys_save_screenshot()

print("png")

elif event.sym in RENDERER_KEYS:

# Swap the active context for one with a different renderer.

def __init__(self) -> None:

self.name = "True colors"

# corner colors

self.colors: NDArray[np.int16] = np.array(

[(50, 40, 150), (240, 85, 5), (50, 35, 240), (10, 200, 130)],

dtype=np.int16,

)

# color shift direction

self.slide_dir: NDArray[np.int16] = np.array([[1, 1, 1], [-1, -1, 1], [1, -1, 1], [1, 1, -1]], dtype=np.int16)

# corner indexes

self.corners: NDArray[np.int16] = np.array([0, 1, 2, 3], dtype=np.int16)

def on_draw(self) -> None:

self.slide_corner_colors()

self.interpolate_corner_colors()

self.darken_background_characters()

self.randomize_sample_console()

self.print_banner()

def slide_corner_colors(self) -> None:

# pick random RGB channels for each corner

rand_channels = np.random.randint(low=0, high=3, size=4)

# shift picked color channels in the direction of slide_dir

self.colors[self.corners, rand_channels] += self.slide_dir[self.corners, rand_channels] * 5

# reverse slide_dir values when limits are reached

self.slide_dir[self.colors[:] == 255] = -1

self.slide_dir[self.colors[:] == 0] = 1

def interpolate_corner_colors(self) -> None:

# interpolate corner colors across the sample console

left = np.linspace(self.colors[0], self.colors[2], SAMPLE_SCREEN_HEIGHT)

right = np.linspace(self.colors[1], self.colors[3], SAMPLE_SCREEN_HEIGHT)

sample_console.bg[:] = np.linspace(left, right, SAMPLE_SCREEN_WIDTH)

def darken_background_characters(self) -> None:

# darken background characters

sample_console.fg[:] = sample_console.bg[:]

sample_console.fg[:] //= 2

def randomize_sample_console(self) -> None:

# randomize sample console characters

sample_console.ch[:] = np.random.randint(

low=ord("a"),

high=ord("z") + 1,

size=sample_console.ch.size,

dtype=np.intc,

).reshape(sample_console.ch.shape)

def print_banner(self) -> None:

# print text on top of samples

sample_console.print_box(

x=1,

y=5,

width=sample_console.width - 2,

height=sample_console.height - 1,

string="The Doryen library uses 24 bits colors, for both background and foreground.",

fg=WHITE,

bg=GREY,

bg_blend=libtcodpy.BKGND_MULTIPLY,

alignment=libtcodpy.CENTER,

def __init__(self) -> None:

self.name = "Offscreen console"

self.secondary = tcod.console.Console(sample_console.width // 2, sample_console.height // 2)

self.screenshot = tcod.console.Console(sample_console.width, sample_console.height)

self.counter = 0.0

self.x = 0

self.y = 0

self.x_dir = 1

self.y_dir = 1

self.secondary.draw_frame(

0,

0,

sample_console.width // 2,

sample_console.height // 2,

"Offscreen console",

clear=False,

fg=WHITE,

bg=BLACK,

)

self.secondary.print_box(

1,

2,

sample_console.width // 2 - 2,

sample_console.height // 2,

"You can render to an offscreen console and blit in on another one, simulating alpha transparency.",

fg=WHITE,

bg=None,

alignment=libtcodpy.CENTER,

)

def on_enter(self) -> None:

self.counter = _get_elapsed_time()

# get a "screenshot" of the current sample screen

sample_console.blit(dest=self.screenshot)

def on_draw(self) -> None:

if _get_elapsed_time() - self.counter >= 1:

self.counter = _get_elapsed_time()

self.x += self.x_dir

self.y += self.y_dir

if self.x == sample_console.width / 2 + 5:

self.x_dir = -1

elif self.x == -5:

self.x_dir = 1

if self.y == sample_console.height / 2 + 5:

self.y_dir = -1

elif self.y == -5:

self.y_dir = 1

self.screenshot.blit(sample_console)

self.secondary.blit(

sample_console,

self.x,

self.y,

0,

0,

sample_console.width // 2,

sample_console.height // 2,

1.0,

0.75,

FLAG_NAMES = (

"BKGND_NONE",

"BKGND_SET",

"BKGND_MULTIPLY",

"BKGND_LIGHTEN",

"BKGND_DARKEN",

"BKGND_SCREEN",

"BKGND_COLOR_DODGE",

"BKGND_COLOR_BURN",

"BKGND_ADD",

"BKGND_ADDALPHA",

"BKGND_BURN",

"BKGND_OVERLAY",

"BKGND_ALPHA",

)

def __init__(self) -> None:

self.name = "Line drawing"

self.mk_flag = libtcodpy.BKGND_SET

self.bk_flag = libtcodpy.BKGND_SET

self.bk = tcod.console.Console(sample_console.width, sample_console.height, order="F")

# initialize the colored background

self.bk.bg[:, :, 0] = np.linspace(0, 255, self.bk.width)[:, np.newaxis]

self.bk.bg[:, :, 2] = np.linspace(0, 255, self.bk.height)

self.bk.bg[:, :, 1] = (self.bk.bg[:, :, 0].astype(int) + self.bk.bg[:, :, 2]) / 2

self.bk.ch[:] = ord(" ")

def ev_keydown(self, event: tcod.event.KeyDown) -> None:

if event.sym in (tcod.event.KeySym.RETURN, tcod.event.KeySym.KP_ENTER):

self.bk_flag += 1

if (self.bk_flag & 0xFF) > libtcodpy.BKGND_ALPH:

self.bk_flag = libtcodpy.BKGND_NONE

else:

super().ev_keydown(event)

def on_draw(self) -> None:

alpha = 0.0

if (self.bk_flag & 0xFF) == libtcodpy.BKGND_ALPH:

# for the alpha mode, update alpha every frame

alpha = (1.0 + math.cos(time.time() * 2)) / 2.0

self.bk_flag = libtcodpy.BKGND_ALPHA(int(alpha))

elif (self.bk_flag & 0xFF) == libtcodpy.BKGND_ADDA:

# for the add alpha mode, update alpha every frame

alpha = (1.0 + math.cos(time.time() * 2)) / 2.0

self.bk_flag = libtcodpy.BKGND_ADDALPHA(int(alpha))

self.bk.blit(sample_console)

rect_y = int((sample_console.height - 2) * ((1.0 + math.cos(time.time())) / 2.0))

for x in range(sample_console.width):

value = x * 255 // sample_console.width

col = (value, value, value)

libtcodpy.console_set_char_background(sample_console, x, rect_y, col, self.bk_flag)

libtcodpy.console_set_char_background(sample_console, x, rect_y + 1, col, self.bk_flag)

libtcodpy.console_set_char_background(sample_console, x, rect_y + 2, col, self.bk_flag)

angle = time.time() * 2.0

cos_angle = math.cos(angle)

sin_angle = math.sin(angle)

xo = int(sample_console.width // 2 * (1 + cos_angle))

yo = int(sample_console.height // 2 + sin_angle * sample_console.width // 2)

xd = int(sample_console.width // 2 * (1 - cos_angle))

yd = int(sample_console.height // 2 - sin_angle * sample_console.width // 2)

# draw the line

# in python the easiest way is to use the line iterator

for x, y in tcod.los.bresenham((xo, yo), (xd, yd)).tolist():

if 0 <= x < sample_console.width and 0 <= y < sample_console.height:

libtcodpy.console_set_char_background(sample_console, x, y, LIGHT_BLUE, self.bk_flag)

sample_console.print(

2,

2,

f"{self.FLAG_NAMES[self.bk_flag & 0xFF]} (ENTER to change)",

fg=WHITE,

bg=None,

NOISE_OPTIONS = ( # (name, algorithm, implementation)

(

"perlin noise",

tcod.noise.Algorithm.PERLIN,

tcod.noise.Implementation.SIMPLE,

),

(

"simplex noise",

tcod.noise.Algorithm.SIMPLEX,

tcod.noise.Implementation.SIMPLE,

),

(

"wavelet noise",

tcod.noise.Algorithm.WAVELET,

tcod.noise.Implementation.SIMPLE,

),

(

"perlin fbm",

tcod.noise.Algorithm.PERLIN,

tcod.noise.Implementation.FBM,

),

(

"perlin turbulence",

tcod.noise.Algorithm.PERLIN,

tcod.noise.Implementation.TURBULENCE,

),

(

"simplex fbm",

tcod.noise.Algorithm.SIMPLEX,

tcod.noise.Implementation.FBM,

),

(

"simplex turbulence",

tcod.noise.Algorithm.SIMPLEX,

tcod.noise.Implementation.TURBULENCE,

),

(

"wavelet fbm",

tcod.noise.Algorithm.WAVELET,

tcod.noise.Implementation.FBM,

),

(

"wavelet turbulence",

tcod.noise.Algorithm.WAVELET,

tcod.noise.Implementation.TURBULENCE,

),

)

def __init__(self) -> None:

self.name = "Noise"

self.func = 0

self.dx = 0.0

self.dy = 0.0

self.octaves = 4.0

self.zoom = 3.0

self.hurst = libtcodpy.NOISE_DEFAULT_HURST

self.lacunarity = libtcodpy.NOISE_DEFAULT_LACUNARITY

self.noise = self.get_noise()

self.img = tcod.image.Image(SAMPLE_SCREEN_WIDTH * 2, SAMPLE_SCREEN_HEIGHT * 2)

@property

def algorithm(self) -> int:

return self.NOISE_OPTIONS[self.func][1]

@property

def implementation(self) -> int:

return self.NOISE_OPTIONS[self.func][2]

def get_noise(self) -> tcod.noise.Noise:

return tcod.noise.Noise(

2,

self.algorithm,

self.implementation,

self.hurst,

self.lacunarity,

self.octaves,

seed=None,

)

def on_draw(self) -> None:

self.dx = _get_elapsed_time() * 0.25

self.dy = _get_elapsed_time() * 0.25

for y in range(2 * sample_console.height):

for x in range(2 * sample_console.width):

f = [

self.zoom * x / (2 * sample_console.width) + self.dx,

self.zoom * y / (2 * sample_console.height) + self.dy,

]

value = self.noise.get_point(*f)

c = int((value + 1.0) / 2.0 * 255)

c = max(0, min(c, 255))

self.img.put_pixel(x, y, (c // 2, c // 2, c))

rect_w = 24

rect_h = 13

if self.implementation == tcod.noise.Implementation.SIMPLE:

rect_h = 10

sample_console.draw_semigraphics(np.asarray(self.img))

sample_console.draw_rect(

2,

2,

rect_w,

rect_h,

ch=0,

fg=None,

bg=GREY,

bg_blend=libtcodpy.BKGND_MULTIPLY,

)

sample_console.fg[2 : 2 + rect_w, 2 : 2 + rect_h] = (

sample_console.fg[2 : 2 + rect_w, 2 : 2 + rect_h] * GREY / 255

)

for cur_func in range(len(self.NOISE_OPTIONS)):

text = f"{cur_func + 1} : {self.NOISE_OPTIONS[cur_func][0]}"

if cur_func == self.func:

sample_console.print(2, 2 + cur_func, text, fg=WHITE, bg=LIGHT_BLUE)

else:

sample_console.print(2, 2 + cur_func, text, fg=GREY, bg=None)

sample_console.print(2, 11, f"Y/H : zoom ({self.zoom:2.1f})", fg=WHITE, bg=None)

if self.implementation != tcod.noise.Implementation.SIMPLE:

sample_console.print(

2,

12,

f"E/D : hurst ({self.hurst:2.1f})",

fg=WHITE,

bg=None,

)

sample_console.print(

2,

13,

f"R/F : lacunarity ({self.lacunarity:2.1f})",

fg=WHITE,

bg=None,

)

sample_console.print(

2,

14,

f"T/G : octaves ({self.octaves:2.1f})",

fg=WHITE,

bg=None,

)

def ev_keydown(self, event: tcod.event.KeyDown) -> None:

if tcod.event.KeySym.N9 >= event.sym >= tcod.event.KeySym.N1:

self.func = event.sym - tcod.event.KeySym.N1

self.noise = self.get_noise()

elif event.sym == tcod.event.KeySym.E:

self.hurst += 0.1

self.noise = self.get_noise()

elif event.sym == tcod.event.KeySym.D:

self.hurst -= 0.1

self.noise = self.get_noise()

elif event.sym == tcod.event.KeySym.R:

self.lacunarity += 0.5

self.noise = self.get_noise()

elif event.sym == tcod.event.KeySym.F:

self.lacunarity -= 0.5

self.noise = self.get_noise()

elif event.sym == tcod.event.KeySym.T:

self.octaves += 0.5

self.noise.octaves = self.octaves

elif event.sym == tcod.event.KeySym.G:

self.octaves -= 0.5

self.noise.octaves = self.octaves

elif event.sym == tcod.event.KeySym.Y:

self.zoom += 0.2

elif event.sym == tcod.event.KeySym.H:

self.zoom -= 0.2

else:

"##############################################",

"####################### #################",

"##################### # ###############",

"###################### ### ###########",

"################## ##### ####",

"################ ######## ###### ####",

"############### #################### ####",

"################ ###### ##",

"######## ####### ###### # # # ##",

"######## ###### ### ##",

"######## ##",

"#### ###### ### # # # ##",

"#### ### ########## #### ##",

"#### ### ########## ###########=##########",

"#### ################## ##### #####",

"#### ### #### ##### #####",

"#### # #### #####",

"######## # #### ##### #####",

"######## ##### ####################",

"##############################################",

"BASIC ",

"DIAMOND ",

"SHADOW ",

"PERMISSIVE0",

"PERMISSIVE1",

"PERMISSIVE2",

"PERMISSIVE3",

"PERMISSIVE4",

"PERMISSIVE5",

"PERMISSIVE6",

"PERMISSIVE7",

"PERMISSIVE8",

"RESTRICTIVE",

"SYMMETRIC_SHADOWCAST",

def __init__(self) -> None:

self.name = "Field of view"

self.player_x = 20

self.player_y = 10

self.torch = False

self.light_walls = True

self.algo_num = libtcodpy.FOV_SYMMETRIC_SHADOWCAST

self.noise = tcod.noise.Noise(1) # 1D noise for the torch flickering.

map_shape = (SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT)

self.walkable: NDArray[np.bool_] = np.zeros(map_shape, dtype=bool, order="F")

self.walkable[:] = SAMPLE_MAP[:] == ord(" ")

self.transparent: NDArray[np.bool_] = np.zeros(map_shape, dtype=bool, order="F")

self.transparent[:] = self.walkable[:] | (SAMPLE_MAP[:] == ord("="))

# Lit background colors for the map.

self.light_map_bg: NDArray[np.uint8] = np.full(SAMPLE_MAP.shape, LIGHT_GROUND, dtype="3B")

self.light_map_bg[SAMPLE_MAP[:] == ord("#")] = LIGHT_WALL

# Dark background colors for the map.

self.dark_map_bg: NDArray[np.uint8] = np.full(SAMPLE_MAP.shape, DARK_GROUND, dtype="3B")

self.dark_map_bg[SAMPLE_MAP[:] == ord("#")] = DARK_WALL

def draw_ui(self) -> None:

sample_console.print(

1,

1,

"IJKL : move around\nT : torch fx {}\nW : light walls {}\n+-: algo {}".format(

"on " if self.torch else "off",

"on " if self.light_walls else "off",

FOV_ALGO_NAMES[self.algo_num],

),

fg=WHITE,

bg=None,

)

def on_draw(self) -> None:

sample_console.clear()

# Draw the help text & player @.

self.draw_ui()

sample_console.print(self.player_x, self.player_y, "@")

# Draw windows.

sample_console.rgb["ch"][SAMPLE_MAP[:] == ord("=")] = 0x2550 # BOX DRAWINGS DOUBLE HORIZONTAL

sample_console.rgb["fg"][SAMPLE_MAP[:] == ord("=")] = BLACK

# Get a 2D boolean array of visible cells.

fov = tcod.map.compute_fov(

transparency=self.transparent,

pov=(self.player_x, self.player_y),

radius=TORCH_RADIUS if self.torch else 0,

light_walls=self.light_walls,

algorithm=self.algo_num,

)

if self.torch:

# Derive the touch from noise based on the current time.

torch_t = _get_elapsed_time() * 5

# Randomize the light position between -1.5 and 1.5

torch_x = self.player_x + self.noise.get_point(torch_t) * 1.5

torch_y = self.player_y + self.noise.get_point(torch_t + 11) * 1.5

# Extra light brightness.

brightness = 0.2 * self.noise.get_point(torch_t + 17)

# Get the squared distance using a mesh grid.

x, y = np.mgrid[:SAMPLE_SCREEN_WIDTH, :SAMPLE_SCREEN_HEIGHT]

# Center the mesh grid on the torch position.

x = x.astype(np.float32) - torch_x

y = y.astype(np.float32) - torch_y

distance_squared = x**2 + y**2 # 2D squared distance array.

# Get the currently visible cells.

visible = (distance_squared < SQUARED_TORCH_RADIUS) & fov

# Invert the values, so that the center is the 'brightest' point.

light = SQUARED_TORCH_RADIUS - distance_squared

light /= SQUARED_TORCH_RADIUS # Convert into non-squared distance.

light += brightness # Add random brightness.

light.clip(0, 1, out=light) # Clamp values in-place.

light[~visible] = 0 # Set non-visible areas to darkness.

# Setup background colors for floating point math.

light_bg: NDArray[np.float16] = self.light_map_bg.astype(np.float16)

dark_bg: NDArray[np.float16] = self.dark_map_bg.astype(np.float16)

# Linear interpolation between colors.

sample_console.rgb["bg"] = dark_bg + (light_bg - dark_bg) * light[..., np.newaxis]

else:

sample_console.bg[...] = np.select(

condlist=[fov[:, :, np.newaxis]],

choicelist=[self.light_map_bg],

default=self.dark_map_bg,

)

def ev_keydown(self, event: tcod.event.KeyDown) -> None:

MOVE_KEYS = { # noqa: N806

tcod.event.KeySym.I: (0, -1),

tcod.event.KeySym.J: (-1, 0),

tcod.event.KeySym.K: (0, 1),

tcod.event.KeySym.L: (1, 0),

}

FOV_SELECT_KEYS = { # noqa: N806

tcod.event.KeySym.MINUS: -1,

tcod.event.KeySym.EQUALS: 1,

tcod.event.KeySym.KP_MINUS: -1,

tcod.event.KeySym.KP_PLUS: 1,

}

if event.sym in MOVE_KEYS:

x, y = MOVE_KEYS[event.sym]

if self.walkable[self.player_x + x, self.player_y + y]:

self.player_x += x

self.player_y += y

elif event.sym == tcod.event.KeySym.T:

self.torch = not self.torch

elif event.sym == tcod.event.KeySym.W:

self.light_walls = not self.light_walls

elif event.sym in FOV_SELECT_KEYS:

self.algo_num += FOV_SELECT_KEYS[event.sym]

self.algo_num %= len(FOV_ALGO_NAMES)

else:

def __init__(self) -> None:

"""Initialize this sample."""

self.name = "Path finding"

self.player_x = 20

self.player_y = 10

self.dest_x = 24

self.dest_y = 1

self.using_astar = True

self.busy = 0.0

self.cost = SAMPLE_MAP.T[:] == ord(" ")

self.graph = tcod.path.SimpleGraph(cost=self.cost, cardinal=70, diagonal=99)

self.pathfinder = tcod.path.Pathfinder(graph=self.graph)

self.background_console = tcod.console.Console(SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT)

# draw the dungeon

self.background_console.rgb["fg"] = BLACK

self.background_console.rgb["bg"] = DARK_GROUND

self.background_console.rgb["bg"][SAMPLE_MAP.T[:] == ord("#")] = DARK_WALL

self.background_console.rgb["ch"][SAMPLE_MAP.T[:] == ord("=")] = ord("═")

def on_enter(self) -> None:

"""Do nothing."""

def on_draw(self) -> None:

"""Recompute and render pathfinding."""

self.pathfinder = tcod.path.Pathfinder(graph=self.graph)

# self.pathfinder.clear() # Known issues, needs fixing # noqa: ERA001

self.pathfinder.add_root((self.player_y, self.player_x))

# draw the dungeon

self.background_console.blit(dest=sample_console)

sample_console.print(self.dest_x, self.dest_y, "+", fg=WHITE)

sample_console.print(self.player_x, self.player_y, "@", fg=WHITE)

sample_console.print(1, 1, "IJKL / mouse :\nmove destination\nTAB : A*/dijkstra", fg=WHITE, bg=None)

sample_console.print(1, 4, "Using : A*", fg=WHITE, bg=None)

if not self.using_astar:

self.pathfinder.resolve(goal=None)

reachable = self.pathfinder.distance != np.iinfo(self.pathfinder.distance.dtype).max

# draw distance from player

dijkstra_max_dist = float(self.pathfinder.distance[reachable].max())

np.array(self.pathfinder.distance, copy=True, dtype=np.float32)

interpolate = self.pathfinder.distance[reachable] * 0.9 / dijkstra_max_dist

color_delta = (np.array(DARK_GROUND) - np.array(LIGHT_GROUND)).astype(np.float32)

sample_console.rgb.T["bg"][reachable] = np.array(LIGHT_GROUND) + interpolate[:, np.newaxis] * color_delta

# draw the path

path = self.pathfinder.path_to((self.dest_y, self.dest_x))[1:, ::-1]

sample_console.rgb["bg"][tuple(path.T)] = LIGHT_GROUND

# move the creature

self.busy -= frame_length[-1]

if self.busy <= 0.0:

self.busy = 0.2

if len(path):

self.player_x = int(path.item(0, 0))

self.player_y = int(path.item(0, 1))

def ev_keydown(self, event: tcod.event.KeyDown) -> None:

"""Handle movement and UI."""

if event.sym == tcod.event.KeySym.I and self.dest_y > 0: # destination move north

self.dest_y -= 1

elif event.sym == tcod.event.KeySym.K and self.dest_y < SAMPLE_SCREEN_HEIGHT - 1: # destination move south

self.dest_y += 1

elif event.sym == tcod.event.KeySym.J and self.dest_x > 0: # destination move west

self.dest_x -= 1

elif event.sym == tcod.event.KeySym.L and self.dest_x < SAMPLE_SCREEN_WIDTH - 1: # destination move east

self.dest_x += 1

elif event.sym == tcod.event.KeySym.TAB:

self.using_astar = not self.using_astar

else:

super().ev_keydown(event)

def ev_mousemotion(self, event: tcod.event.MouseMotion) -> None:

"""Move destination via mouseover."""

mx = event.tile.x - SAMPLE_SCREEN_X

my = event.tile.y - SAMPLE_SCREEN_Y

if 0 <= mx < SAMPLE_SCREEN_WIDTH and 0 <= my < SAMPLE_SCREEN_HEIGHT:

self.dest_x = int(mx)

if y1 > y2:

y1, y2 = y2, y1

for y in range(y1, y2 + 1):

if x1 > x2:

x1, x2 = x2, x1

for x in range(x1, x2 + 1):

if not node.children:

# calculate the room size

if bsp_room_walls:

node.width -= 1

node.height -= 1

if bsp_random_room:

new_width = random.randint(min(node.width, bsp_min_room_size), node.width)

new_height = random.randint(min(node.height, bsp_min_room_size), node.height)

node.x += random.randint(0, node.width - new_width)

node.y += random.randint(0, node.height - new_height)

node.width, node.height = new_width, new_height

# dig the room

bsp_map[node.x : node.x + node.width, node.y : node.y + node.height] = True

else:

# resize the node to fit its sons

left, right = node.children

node.x = min(left.x, right.x)

node.y = min(left.y, right.y)

node.width = max(left.x + left.width, right.x + right.width) - node.x

node.height = max(left.y + left.height, right.y + right.height) - node.y

# create a corridor between the two lower nodes

if node.horizontal:

# vertical corridor

if left.x + left.width - 1 < right.x or right.x + right.width - 1 < left.x:

# no overlapping zone. we need a Z shaped corridor

x1 = random.randint(left.x, left.x + left.width - 1)

x2 = random.randint(right.x, right.x + right.width - 1)

y = random.randint(left.y + left.height, right.y)

vline_up(bsp_map, x1, y - 1)

hline(bsp_map, x1, y, x2)

vline_down(bsp_map, x2, y + 1)

else:

# straight vertical corridor

min_x = max(left.x, right.x)

max_x = min(left.x + left.width - 1, right.x + right.width - 1)

x = random.randint(min_x, max_x)

vline_down(bsp_map, x, right.y)

vline_up(bsp_map, x, right.y - 1)

elif left.y + left.height - 1 < right.y or right.y + right.height - 1 < left.y: # horizontal corridor

# no overlapping zone. we need a Z shaped corridor

y1 = random.randint(left.y, left.y + left.height - 1)

y2 = random.randint(right.y, right.y + right.height - 1)

x = random.randint(left.x + left.width, right.x)

hline_left(bsp_map, x - 1, y1)

vline(bsp_map, x, y1, y2)

hline_right(bsp_map, x + 1, y2)

else:

# straight horizontal corridor

min_y = max(left.y, right.y)

max_y = min(left.y + left.height - 1, right.y + right.height - 1)

y = random.randint(min_y, max_y)

hline_left(bsp_map, right.x - 1, y)

def __init__(self) -> None:

self.name = "Bsp toolkit"

self.bsp = tcod.bsp.BSP(1, 1, SAMPLE_SCREEN_WIDTH - 1, SAMPLE_SCREEN_HEIGHT - 1)

self.bsp_map: NDArray[np.bool_] = np.zeros((SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT), dtype=bool, order="F")

self.bsp_generate()

def bsp_generate(self) -> None:

self.bsp.children = ()

if bsp_room_walls:

self.bsp.split_recursive(

bsp_depth,

bsp_min_room_size + 1,

bsp_min_room_size + 1,

1.5,

1.5,

)

else:

self.bsp.split_recursive(bsp_depth, bsp_min_room_size, bsp_min_room_size, 1.5, 1.5)

self.bsp_refresh()

def bsp_refresh(self) -> None:

self.bsp_map[...] = False

for node in copy.deepcopy(self.bsp).inverted_level_order():

traverse_node(self.bsp_map, node)

def on_draw(self) -> None:

sample_console.clear()

rooms = "OFF"

if bsp_random_room:

rooms = "ON"

sample_console.print(

1,

1,

"ENTER : rebuild bsp\n"

"SPACE : rebuild dungeon\n"

f"+-: bsp depth {bsp_depth}\n"

f"*/: room size {bsp_min_room_size}\n"

f"1 : random room size {rooms}",

fg=WHITE,

bg=None,