"""Return the path to a resource in the libtcod data directory,"""

SCRIPT_DIR = os.path.dirname(__file__)

DATA_DIR = os.path.join(SCRIPT_DIR, "../libtcod/data")

assert os.path.exists(DATA_DIR), (

"Data directory is missing,"

" did you forget to run `git submodule update --init`?"

)

def __init__(self, name: str = ""):

self.name = name

def on_enter(self):

pass

def on_draw(self):

pass

def ev_keydown(self, event: tcod.event.KeyDown):

global cur_sample

if event.sym == tcod.event.K_DOWN:

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

SAMPLES[cur_sample].on_enter()

draw_samples_menu()

elif event.sym == tcod.event.K_UP:

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

SAMPLES[cur_sample].on_enter()

draw_samples_menu()

elif (

event.sym == tcod.event.K_RETURN

and event.mod & tcod.event.KMOD_LALT

):

tcod.console_set_fullscreen(not tcod.console_is_fullscreen())

elif event.sym == tcod.event.K_PRINTSCREEN or event.sym == ord("p"):

print("screenshot")

if event.mod & tcod.event.KMOD_LALT:

tcod.console_save_apf(None, "samples.apf")

print("apf")

else:

tcod.sys_save_screenshot()

print("png")

elif event.sym == tcod.event.K_ESCAPE:

raise SystemExit()

elif event.sym in RENDERER_KEYS:

tcod.sys_set_renderer(RENDERER_KEYS[event.sym])

draw_renderer_menu()

def ev_quit(self, event: tcod.event.Quit):

def __init__(self):

self.name = "True colors"

# corner colors

self.colors = np.array(

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

dtype=np.int16,

)

# color shift direction

self.slide_dir = np.array(

[[1, 1, 1], [-1, -1, 1], [1, -1, 1], [1, 1, -1]], dtype=np.int16

)

# corner indexes

self.corners = np.array([0, 1, 2, 3])

def on_enter(self):

tcod.sys_set_fps(0)

def on_draw(self):

self.slide_corner_colors()

self.interpolate_corner_colors()

self.darken_background_characters()

self.randomize_sample_conole()

self.print_banner()

def slide_corner_colors(self):

# 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):

# 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):

# darken background characters

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

sample_console.fg[:] //= 2

def randomize_sample_conole(self):

# 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):

# 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=tcod.white,

bg=tcod.grey,

bg_blend=tcod.BKGND_MULTIPLY,

alignment=tcod.CENTER,

def __init__(self):

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

self.x = 0

self.y = 0

self.xdir = 1

self.ydir = 1

self.secondary.draw_frame(

0,

0,

sample_console.width // 2,

sample_console.height // 2,

"Offscreen console",

False,

fg=tcod.white,

bg=tcod.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=tcod.white,

bg=None,

alignment=tcod.CENTER,

)

def on_enter(self):

self.counter = time.perf_counter()

tcod.sys_set_fps(0)

# get a "screenshot" of the current sample screen

sample_console.blit(dest=self.screenshot)

def on_draw(self):

if time.perf_counter() - self.counter >= 1:

self.counter = time.perf_counter()

self.x += self.xdir

self.y += self.ydir

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

self.xdir = -1

elif self.x == -5:

self.xdir = 1

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

self.ydir = -1

elif self.y == -5:

self.ydir = 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):

self.name = "Line drawing"

self.mk_flag = tcod.BKGND_SET

self.bk_flag = tcod.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):

if event.sym in (tcod.event.K_RETURN, tcod.event.K_KP_ENTER):

self.bk_flag += 1

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

self.bk_flag = tcod.BKGND_NONE

else:

super().ev_keydown(event)

def on_enter(self):

tcod.sys_set_fps(0)

def on_draw(self):

alpha = 0.0

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

# for the alpha mode, update alpha every frame

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

self.bk_flag = tcod.BKGND_ALPHA(alpha)

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

# for the add alpha mode, update alpha every frame

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

self.bk_flag = tcod.BKGND_ADDALPHA(alpha)

self.bk.blit(sample_console)

recty = int(

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

)

for x in range(sample_console.width):

col = [x * 255 // sample_console.width] * 3

tcod.console_set_char_background(

sample_console, x, recty, col, self.bk_flag

)

tcod.console_set_char_background(

sample_console, x, recty + 1, col, self.bk_flag

)

tcod.console_set_char_background(

sample_console, x, recty + 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.line_iter(xo, yo, xd, yd):

if (

0 <= x < sample_console.width

and 0 <= y < sample_console.height

):

tcod.console_set_char_background(

sample_console, x, y, tcod.light_blue, self.bk_flag

)

sample_console.print(

2,

2,

"%s (ENTER to change)" % self.FLAG_NAMES[self.bk_flag & 0xFF],

fg=tcod.white,

bg=None,

NOISE_OPTIONS = [ # [name, algorithm, implementation],

["perlin noise", tcod.NOISE_PERLIN, tcod.noise.SIMPLE],

["simplex noise", tcod.NOISE_SIMPLEX, tcod.noise.SIMPLE],

["wavelet noise", tcod.NOISE_WAVELET, tcod.noise.SIMPLE],

["perlin fbm", tcod.NOISE_PERLIN, tcod.noise.FBM],

["perlin turbulence", tcod.NOISE_PERLIN, tcod.noise.TURBULENCE],

["simplex fbm", tcod.NOISE_SIMPLEX, tcod.noise.FBM],

["simplex turbulence", tcod.NOISE_SIMPLEX, tcod.noise.TURBULENCE],

["wavelet fbm", tcod.NOISE_WAVELET, tcod.noise.FBM],

["wavelet turbulence", tcod.NOISE_WAVELET, tcod.noise.TURBULENCE],

]

def __init__(self):

self.name = "Noise"

self.func = 0

self.dx = 0.0

self.dy = 0.0

self.octaves = 4.0

self.zoom = 3.0

self.hurst = tcod.NOISE_DEFAULT_HURST

self.lacunarity = tcod.NOISE_DEFAULT_LACUNARITY

self.noise = self.get_noise()

self.img = tcod.image_new(

SAMPLE_SCREEN_WIDTH * 2, SAMPLE_SCREEN_HEIGHT * 2

)

@property

def algorithm(self):

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

@property

def implementation(self):

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

def get_noise(self):

return tcod.noise.Noise(

2,

self.algorithm,

self.implementation,

self.hurst,

self.lacunarity,

self.octaves,

seed=None,

)

def on_enter(self):

tcod.sys_set_fps(0)

def on_draw(self):

self.dx = time.perf_counter() * 0.25

self.dy = time.perf_counter() * 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))

rectw = 24

recth = 13

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

recth = 10

sample_console.draw_semigraphics(self.img)

sample_console.draw_rect(

2,

2,

rectw,

recth,

ch=0,

fg=None,

bg=tcod.grey,

bg_blend=tcod.BKGND_MULTIPLY,

)

sample_console.fg[2 : 2 + rectw, 2 : 2 + recth] = (

sample_console.fg[2 : 2 + rectw, 2 : 2 + recth] * tcod.grey / 255

)

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

text = "%i : %s" % (curfunc + 1, self.NOISE_OPTIONS[curfunc][0])

if curfunc == self.func:

sample_console.print(

2, 2 + curfunc, text, fg=tcod.white, bg=tcod.light_blue

)

else:

sample_console.print(

2, 2 + curfunc, text, fg=tcod.grey, bg=None

)

sample_console.print(

2, 11, "Y/H : zoom (%2.1f)" % self.zoom, fg=tcod.white, bg=None

)

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

sample_console.print(

2,

12,

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

fg=tcod.white,

bg=None,

)

sample_console.print(

2,

13,

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

fg=tcod.white,

bg=None,

)

sample_console.print(

2,

14,

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

fg=tcod.white,

bg=None,

)

def ev_keydown(self, event: tcod.event.KeyDown):

if ord("9") >= event.sym >= ord("1"):

self.func = event.sym - ord("1")

self.noise = self.get_noise()

elif event.sym == ord("e"):

self.hurst += 0.1

self.noise = self.get_noise()

elif event.sym == ord("d"):

self.hurst -= 0.1

self.noise = self.get_noise()

elif event.sym == ord("r"):

self.lacunarity += 0.5

self.noise = self.get_noise()

elif event.sym == ord("f"):

self.lacunarity -= 0.5

self.noise = self.get_noise()

elif event.sym == ord("t"):

self.octaves += 0.5

self.noise.octaves = self.octaves

elif event.sym == ord("g"):

self.octaves -= 0.5

self.noise.octaves = self.octaves

elif event.sym == ord("y"):

self.zoom += 0.2

elif event.sym == ord("h"):

self.zoom -= 0.2

else:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

"BASIC ",

"DIAMOND ",

"SHADOW ",

"PERMISSIVE0",

"PERMISSIVE1",

"PERMISSIVE2",

"PERMISSIVE3",

"PERMISSIVE4",

"PERMISSIVE5",

"PERMISSIVE6",

"PERMISSIVE7",

"PERMISSIVE8",

"RESTRICTIVE",

"SYMMETRIC_SHADOWCAST",

def __init__(self):

self.name = "Field of view"

self.player_x = 20

self.player_y = 10

self.torch = False

self.light_walls = True

self.algo_num = 0

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

map_shape = (SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT)

self.walkable = np.zeros(map_shape, dtype=bool, order="F")

self.walkable[:] = SAMPLE_MAP[:] == " "

self.transparent = np.zeros(map_shape, dtype=bool, order="F")

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

# Lit background colors for the map.

self.light_map_bg = np.full(SAMPLE_MAP.shape, LIGHT_GROUND, dtype="3B")

self.light_map_bg[SAMPLE_MAP[:] == "#"] = LIGHT_WALL

# Dark background colors for the map.

self.dark_map_bg = np.full(SAMPLE_MAP.shape, DARK_GROUND, dtype="3B")

self.dark_map_bg[SAMPLE_MAP[:] == "#"] = DARK_WALL

def draw_ui(self):

sample_console.print(

1,

1,

"IJKL : move around\n"

"T : torch fx %s\n"

"W : light walls %s\n"

"+-: algo %s"

% (

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

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

FOV_ALGO_NAMES[self.algo_num],

),

fg=tcod.white,

bg=None,

)

def on_enter(self):

tcod.sys_set_fps(60)

def on_draw(self):

sample_console.clear()

# Draw the help text & player @.

self.draw_ui()

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

# Draw windows.

sample_console.tiles_rgb["ch"][SAMPLE_MAP == "="] = tcod.CHAR_DHLINE

sample_console.tiles_rgb["fg"][SAMPLE_MAP == "="] = tcod.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 = time.perf_counter() * 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 = self.light_map_bg.astype(np.float16)

dark_bg = self.dark_map_bg.astype(np.float16)

# Linear interpolation between colors.

sample_console.tiles_rgb["bg"] = (

dark_bg + (light_bg - dark_bg) * light[..., np.newaxis]

)

else:

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

fov[:, :, np.newaxis], self.light_map_bg, self.dark_map_bg

)

def ev_keydown(self, event: tcod.event.KeyDown):

MOVE_KEYS = {

ord("i"): (0, -1),

ord("j"): (-1, 0),

ord("k"): (0, 1),

ord("l"): (1, 0),

}

FOV_SELECT_KEYS = {

ord("-"): -1,

ord("="): 1,

tcod.event.K_KP_MINUS: -1,

tcod.event.K_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 == ord("t"):

self.torch = not self.torch

elif event.sym == ord("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):

self.name = "Path finding"

self.px = 20

self.py = 10

self.dx = 24

self.dy = 1

self.map = None

self.path = None

self.dijk_dist = 0.0

self.using_astar = True

self.dijk = None

self.recalculate = False

self.busy = 0.0

self.oldchar = " "

self.map = tcod.map_new(SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT)

for y in range(SAMPLE_SCREEN_HEIGHT):

for x in range(SAMPLE_SCREEN_WIDTH):

if SAMPLE_MAP[x, y] == " ":

# ground

tcod.map_set_properties(self.map, x, y, True, True)

elif SAMPLE_MAP[x, y] == "=":

# window

tcod.map_set_properties(self.map, x, y, True, False)

self.path = tcod.path_new_using_map(self.map)

self.dijk = tcod.dijkstra_new(self.map)

def on_enter(self):

tcod.sys_set_fps(60)

# we draw the foreground only the first time.

# during the player movement, only the @ is redrawn.

# the rest impacts only the background color

# draw the help text & player @

sample_console.clear()

sample_console.ch[self.dx, self.dy] = ord("+")

sample_console.fg[self.dx, self.dy] = tcod.white

sample_console.ch[self.px, self.py] = ord("@")

sample_console.fg[self.px, self.py] = tcod.white

sample_console.print(

1,

1,

"IJKL / mouse :\nmove destination\nTAB : A*/dijkstra",

fg=tcod.white,

bg=None,

)

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

# draw windows

for y in range(SAMPLE_SCREEN_HEIGHT):

for x in range(SAMPLE_SCREEN_WIDTH):

if SAMPLE_MAP[x, y] == "=":

tcod.console_put_char(

sample_console, x, y, tcod.CHAR_DHLINE, tcod.BKGND_NONE

)

self.recalculate = True

def on_draw(self):

if self.recalculate:

if self.using_astar:

tcod.path_compute(

self.path, self.px, self.py, self.dx, self.dy

)

else:

self.dijk_dist = 0.0

# compute dijkstra grid (distance from px,py)

tcod.dijkstra_compute(self.dijk, self.px, self.py)

# get the maximum distance (needed for rendering)

for y in range(SAMPLE_SCREEN_HEIGHT):

for x in range(SAMPLE_SCREEN_WIDTH):

d = tcod.dijkstra_get_distance(self.dijk, x, y)

if d > self.dijk_dist:

self.dijk_dist = d

# compute path from px,py to dx,dy

tcod.dijkstra_path_set(self.dijk, self.dx, self.dy)

self.recalculate = False

self.busy = 0.2

# draw the dungeon

for y in range(SAMPLE_SCREEN_HEIGHT):

for x in range(SAMPLE_SCREEN_WIDTH):

if SAMPLE_MAP[x, y] == "#":

tcod.console_set_char_background(

sample_console, x, y, DARK_WALL, tcod.BKGND_SET

)

else:

tcod.console_set_char_background(

sample_console, x, y, DARK_GROUND, tcod.BKGND_SET

)

# draw the path

if self.using_astar:

for i in range(tcod.path_size(self.path)):

x, y = tcod.path_get(self.path, i)

tcod.console_set_char_background(

sample_console, x, y, LIGHT_GROUND, tcod.BKGND_SET

)

else:

for y in range(SAMPLE_SCREEN_HEIGHT):

for x in range(SAMPLE_SCREEN_WIDTH):

if SAMPLE_MAP[x, y] != "#":

tcod.console_set_char_background(

sample_console,

x,

y,

tcod.color_lerp(

LIGHT_GROUND,

DARK_GROUND,

0.9

* tcod.dijkstra_get_distance(self.dijk, x, y)

/ self.dijk_dist,

),

tcod.BKGND_SET,

)

for i in range(tcod.dijkstra_size(self.dijk)):

x, y = tcod.dijkstra_get(self.dijk, i)

tcod.console_set_char_background(

sample_console, x, y, LIGHT_GROUND, tcod.BKGND_SET

)

# move the creature

self.busy -= tcod.sys_get_last_frame_length()

if self.busy <= 0.0:

self.busy = 0.2

if self.using_astar:

if not tcod.path_is_empty(self.path):

tcod.console_put_char(

sample_console, self.px, self.py, " ", tcod.BKGND_NONE

)

self.px, self.py = tcod.path_walk(self.path, True)

tcod.console_put_char(

sample_console, self.px, self.py, "@", tcod.BKGND_NONE

)

else:

if not tcod.dijkstra_is_empty(self.dijk):

tcod.console_put_char(

sample_console, self.px, self.py, " ", tcod.BKGND_NONE

)

self.px, self.py = tcod.dijkstra_path_walk(self.dijk)

tcod.console_put_char(

sample_console, self.px, self.py, "@", tcod.BKGND_NONE

)

self.recalculate = True

def ev_keydown(self, event: tcod.event.KeyDown):

if event.sym == ord("i") and self.dy > 0:

# destination move north

tcod.console_put_char(

sample_console, self.dx, self.dy, self.oldchar, tcod.BKGND_NONE

)

self.dy -= 1

self.oldchar = sample_console.ch[self.dx, self.dy]

tcod.console_put_char(

sample_console, self.dx, self.dy, "+", tcod.BKGND_NONE

)

if SAMPLE_MAP[self.dx, self.dy] == " ":

self.recalculate = True

elif event.sym == ord("k") and self.dy < SAMPLE_SCREEN_HEIGHT - 1:

# destination move south

tcod.console_put_char(

sample_console, self.dx, self.dy, self.oldchar, tcod.BKGND_NONE

)

self.dy += 1

self.oldchar = sample_console.ch[self.dx, self.dy]

tcod.console_put_char(

sample_console, self.dx, self.dy, "+", tcod.BKGND_NONE

)

if SAMPLE_MAP[self.dx, self.dy] == " ":

self.recalculate = True

elif event.sym == ord("j") and self.dx > 0:

# destination move west

tcod.console_put_char(

sample_console, self.dx, self.dy, self.oldchar, tcod.BKGND_NONE

)

self.dx -= 1

self.oldchar = sample_console.ch[self.dx, self.dy]

tcod.console_put_char(

sample_console, self.dx, self.dy, "+", tcod.BKGND_NONE

)

if SAMPLE_MAP[self.dx, self.dy] == " ":

self.recalculate = True

elif event.sym == ord("l") and self.dx < SAMPLE_SCREEN_WIDTH - 1:

# destination move east

tcod.console_put_char(

sample_console, self.dx, self.dy, self.oldchar, tcod.BKGND_NONE

)

self.dx += 1

self.oldchar = sample_console.ch[self.dx, self.dy]

tcod.console_put_char(

sample_console, self.dx, self.dy, "+", tcod.BKGND_NONE

)

if SAMPLE_MAP[self.dx, self.dy] == " ":

self.recalculate = True

elif event.sym == tcod.event.K_TAB:

self.using_astar = not self.using_astar

if self.using_astar:

tcod.console_print(sample_console, 1, 4, "Using : A* ")

else:

tcod.console_print(sample_console, 1, 4, "Using : Dijkstra")

self.recalculate = True

else:

super().ev_keydown(event)

def ev_mousemotion(self, event: tcod.event.MouseMotion):

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

and (self.dx != mx or self.dy != my)

):

tcod.console_put_char(

sample_console, self.dx, self.dy, self.oldchar, tcod.BKGND_NONE

)

self.dx = mx

self.dy = my

self.oldchar = sample_console.ch[self.dx, self.dy]

tcod.console_put_char(

sample_console, self.dx, self.dy, "+", tcod.BKGND_NONE

)

if SAMPLE_MAP[self.dx, self.dy] == " ":

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

for x in range(node.x, node.x + node.width):

for y in range(node.y, node.y + node.height):

bsp_map[x][y] = 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.w = max(left.x + left.w, right.x + right.w) - node.x

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

# create a corridor between the two lower nodes

if node.horizontal:

# vertical corridor

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

# no overlapping zone. we need a Z shaped corridor

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

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

y = random.randint(left.y + left.h, 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

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

maxx = min(left.x + left.w - 1, right.x + right.w - 1)