def __setitem__(self, index, cell):
if isinstance(index, slice):
raise TypeError('Console objects do not support slices. Yet.')
x, y = index
if x > self.width or x < 0 or y > self.height or y < 0:
raise IndexError(
'Attempt to access cell ({0}, {1}), which is out of range. Console size is ({2}, {3}).'.format(x, y,
self.width,
self.height))
if isinstance(cell, tuple) and len(cell) >= 3:
symbol, foreground, background = cell
if isinstance(foreground, str):
foreground = color.string_to_colornum(foreground)
if isinstance(background, str):
background = color.string_to_colornum(background)
elif cell is not tuple:
symbol = cell
foreground = self.get_char_foreground(x, y)
background = self.get_char_background(x, y)
else:
symbol = cell[0]
foreground = cell[1]
background = self.get_char_background(x, y)
if background is None:
background = self.get_char_background(x, y)
if foreground is None:
foreground = self.get_char_foreground(x, y)
# tcod.console_set_char_background(self._c, x, y, background)
# tcod.console_set_char_foreground(self._c, x, y, foreground)
# tcod.console_put_char(self._c, x, y, symbol)
tcod.console_put_char_ex(self._c, x, y, symbol, foreground, background)
def draw(self, con, x, y):
tcod.console_put_char_ex(con,
x,
y,
self.symbol,
fore=self.color,
back=con.default_bg)
def test_array_read_write():
console = tcod.console.Console(width=12, height=10)
FG = (255, 254, 253)
BG = (1, 2, 3)
CH = ord('&')
tcod.console_put_char_ex(console, 0, 0, CH, FG, BG)
assert console.ch[0, 0] == CH
assert tuple(console.fg[0, 0]) == FG
assert tuple(console.bg[0, 0]) == BG
tcod.console_put_char_ex(console, 1, 2, CH, FG, BG)
assert console.ch[2, 1] == CH
assert tuple(console.fg[2, 1]) == FG
assert tuple(console.bg[2, 1]) == BG
console.clear()
assert console.ch[1, 1] == ord(' ')
assert tuple(console.fg[1, 1]) == (255, 255, 255)
assert tuple(console.bg[1, 1]) == (0, 0, 0)
ch_slice = console.ch[1, :]
ch_slice[2] = CH
console.fg[1, ::2] = FG
console.bg[...] = BG
assert tcod.console_get_char(console, 2, 1) == CH
assert tuple(tcod.console_get_char_foreground(console, 2, 1)) == FG
assert tuple(tcod.console_get_char_background(console, 2, 1)) == BG
def draw_entity(self, entry, fov_map):
# put entity character on screen
if fov_map.fov[entry.y, entry.x] or (
entry.stairs
and self.game_map.tiles[entry.x][entry.y].explored):
tcod.console_put_char_ex(self.map_buffer, entry.x, entry.y,
entry.char, entry.color, tcod.black)
def draw(self, target_console):
"""Updates and blits the windows's console buffer to another console."""
tcod.console_print_frame(self.console, 0, 0, self.w, self.h, True, tcod.BKGND_DEFAULT)
for index in range (len(self.contents)):
tcod.console_print(self.console, 3, index+2, self.contents[index])
tcod.console_put_char_ex(self.console, 2, self.selection+2, '>', tcod.white, tcod.black)
tcod.console_blit(self.console, 0, 0, self.w, self.h, target_console, self.x, self.y, 1.0, 0.9)
def render(player, con, fov_map, check_explored):
tcod.map_compute_fov(fov_map, player.xPos, player.yPos, TORCH_RADIUS,
FOV_LIGHT_WALLS, FOV_ALGO)
for y in range(MAP_HEIGHT):
for x in range(MAP_WIDTH):
visible = tcod.map_is_in_fov(fov_map, x, y)
compute_fov = False
wall = map[x][y].wall
if not visible and (map[x][y].explored or not check_explored):
if check_explored:
color = tcod.grey
else:
color = tcod.light_grey
if wall:
tcod.console_put_char_ex(con, x, y, '#', color, tcod.black)
else:
tcod.console_put_char_ex(con, x, y, '.', color, tcod.black)
if visible:
map[x][y].explored = True
if wall:
tcod.console_put_char_ex(con, x, y, '#', tcod.light_yellow,
tcod.black)
else:
tcod.console_put_char_ex(con, x, y, '.', tcod.light_yellow,
tcod.black)
tcod.console_put_char_ex(con, MAP_WIDTH - 2, MAP_HEIGHT - 2, 'X',
tcod.fuchsia, tcod.black)
player.draw(con)
def __setitem__(self, index, cell):
if isinstance(index, slice):
raise TypeError('Console objects do not support slices. Yet.')
x, y = index
if x > self.width or x < 0 or y > self.height or y < 0:
raise IndexError(
'Attempt to access cell ({0}, {1}), which is out of range. Console size is ({2}, {3}).'
.format(x, y, self.width, self.height))
if isinstance(cell, tuple) and len(cell) >= 3:
symbol, foreground, background = cell
if isinstance(foreground, str):
foreground = color.string_to_colornum(foreground)
if isinstance(background, str):
background = color.string_to_colornum(background)
elif cell is not tuple:
symbol = cell
foreground = self.get_char_foreground(x, y)
background = self.get_char_background(x, y)
else:
symbol = cell[0]
foreground = cell[1]
background = self.get_char_background(x, y)
if background is None:
background = self.get_char_background(x, y)
if foreground is None:
foreground = self.get_char_foreground(x, y)
# tcod.console_set_char_background(self._c, x, y, background)
# tcod.console_set_char_foreground(self._c, x, y, foreground)
# tcod.console_put_char(self._c, x, y, symbol)
tcod.console_put_char_ex(self._c, x, y, symbol, foreground, background)
def render(self, con, x: int, y: int):
libtcod.console_put_char_ex(con,
x,
y,
self.char,
fore=self.fg,
back=self.bg)
def render(self, con, x: int, y: int, alignment: int = None):
if alignment is None:
alignment = self.alignment
if self.fill_char != 0:
box = np.full((self.width, self.height), self.fill_char)
for dx, col in enumerate(box):
for dy, char in enumerate(col):
if type(char) == 'int':
char = chr(char)
if char != ScreenObject.NONE_CHAR:
libtcod.console_put_char_ex(con,
x + dx,
y + dy,
char,
fore=self.fg,
back=self.bg)
libtcod.console_set_default_foreground(con, self.fg)
libtcod.console_set_default_background(con, self.bg)
libtcod.console_print_rect_ex(con,
x,
y,
self.width,
self.height,
flag=libtcod.BKGND_SET,
alignment=alignment,
fmt=self.text)
def draw_entity(con, entity, fov_map, game_map):
"""
Affiche une entité visible
Parametres:
----------
con : tcod.console
entity : Entity
fov_map : tcod.map
game_map : GameMap
Renvoi:
-------
Aucun
"""
if libtcod.map_is_in_fov(fov_map, entity.x, entity.y) or (
entity.stairs and game_map.tiles[entity.x][entity.y].explored):
if entity.visible:
libtcod.console_set_default_foreground(con, entity.color)
libtcod.console_put_char_ex(con, entity.x, entity.y, entity.char,
libtcod.white, libtcod.black)
elif game_map.tiles[entity.x][entity.y].explored:
libtcod.console_put_char_ex(con, entity.x, entity.y, 257,
libtcod.light_grey, libtcod.black)
def ClearConsole():
for x in range(SCREEN_WIDTH):
for y in range(SCREEN_HEIGHT):
tcod.console_put_char_ex(0, x, y, " ", tcod.black, tcod.black)
tcod.console_flush()
return
def render(self, con):
for x, y in self.positions:
if self.char != ScreenObject.NONE_CHAR:
libtcod.console_put_char_ex(con,
x,
y,
self.char,
fore=self.fg,
back=self.bg)
def render_bar(x, y, total_width, name, value, maximum, bar_colour, bg_colour):
bar_width = int(value / maximum * total_width)
txt = "{}: {}/{}".format(name, value, maximum)
for i, (char, col) in enumerate(
zip(
txt.center(total_width),
list(repeat(bar_colour, bar_width)) +
list(repeat(bg_colour, total_width - bar_width)))):
tcod.console_put_char_ex(panel, x + i, y, char, tcod.color.white, col)
def test_console_rexpaint_save_load(console, tmpdir, ch, fg, bg):
libtcodpy.console_print(console, 0, 0, 'test')
libtcodpy.console_put_char_ex(console, 1, 1, ch, fg, bg)
xp_file = tmpdir.join('test.xp').strpath
assert libtcodpy.console_save_xp(console, xp_file, 1)
xp_console = libtcodpy.console_from_xp(xp_file)
assert xp_console
assertConsolesEqual(console, xp_console)
assert libtcodpy.console_load_xp(None, xp_file)
assertConsolesEqual(console, xp_console)
def test_console_rexpaint_save_load(console, tmpdir, ch, fg, bg):
libtcodpy.console_print(console, 0, 0, 'test')
libtcodpy.console_put_char_ex(console, 1, 1, ch, fg, bg)
xp_file = tmpdir.join('test.xp').strpath
assert libtcodpy.console_save_xp(console, xp_file, 1)
xp_console = libtcodpy.console_from_xp(xp_file)
assert xp_console
assertConsolesEqual(console, xp_console)
assert libtcodpy.console_load_xp(None, xp_file)
assertConsolesEqual(console, xp_console)
def clear_entity(con, entity, fov_map, game_map): visible = libtcod.map_is_in_fov(fov_map, entity.x, entity.y) if visible: libtcod.console_put_char_ex(con, entity.x, entity.y, '.', libtcod.white, libtcod.black) if not visible and game_map.tiles[entity.x][entity.y].explored: libtcod.console_put_char_ex(con, entity.x, entity.y, '.', libtcod.dark_grey, libtcod.black) else: libtcod.console_put_char(con, entity.x, entity.y, ' ', libtcod.BKGND_NONE)
def render_enemy_panel(game, con, panel_x, panel_y, width, height, color):
setup_console(con, caption='Enemies', borders=True, bordercolor=color)
# check for monsters in FOV
spotted = [
ent for ent in game.npc_ents
if ent.is_visible(game.fov_map) and ent.f.hp > 0
]
#spotted = [ent for ent in game.entities if ent.ai and ent.f.hp > 0 and ent.is_visible(game.fov_map)]
if len(spotted):
spotted.sort(key=game.player.distance_to_ent
) # sort the spotted array by distance to player
# initial offsets from panel borders
y = 2
for ent in spotted: # Go through the object names and wrap them according to the panel's width
if y >= con.height - 2: # If the limit's of the con are reached, cut the con off
tcod.console_set_default_foreground(con, colors.white)
x = center_x_for_text(width, '~ ~ ~ MORE ~ ~ ~')
print_line(con, x, y, '~ ~ ~ MORE ~ ~ ~')
break
char = '*' if ent.pos == game.cursor.pos and game.state in [
GameState.CURSOR_ACTIVE, GameState.CURSOR_TARGETING
] else f'{ent.char}'
# Draw creature name and stats #
tcod.console_set_default_foreground(con, colors.gray)
tcod.console_set_color_control(tcod.COLCTRL_1, ent.color,
tcod.black)
tcod.console_put_char_ex(con, 1, y, char, ent.color, tcod.black)
print_line(con, 3, y, ent.full_name, color=ent.color)
y += 1
x = 1
tcod.console_put_char_ex(con, x, y, chr(192), tcod.gray,
tcod.black)
tcod.console_set_color_control(tcod.COLCTRL_2, ent.f.hp_color,
tcod.black)
tcod.console_set_color_control(tcod.COLCTRL_3, ent.f.stamina_color,
tcod.black)
status_line = f'%c{ent.f.hp_string.title()}%c|%c{ent.f.stamina_string.title()}%c'\
% (tcod.COLCTRL_2, tcod.COLCTRL_STOP, tcod.COLCTRL_3, tcod.COLCTRL_STOP)
for status, active in ent.f.effects.items(
): # Todo does not consider number of status effects > width of panel
if active:
status_line += f' %white%{status.name[0]}%%'
print_line(con, x + 1, y, f'{status_line}')
y += 1
con.blit(game.root, panel_x, panel_y, 0, 0, width, height)
def blind_draw_map(level):
for tile in chain(*level.map_grid.tiles):
if not in_fov(tile.location, level):
tile.explored = False
elif same_location(level.player.location, tile.location):
tile.explored = True
if tile.explored:
tcod.console_put_char_ex(con, tile.location.x, tile.location.y,
tile_char(level, tile.location),
tcod.color.black,
tile_colour(level, "DARK", tile.location))
def _discover_place(self, x,y,char=None):
world=rog.world()
## ent = self.thingat(x,y)
if char:
libtcod.console_put_char_ex(
self.con_memories, x,y, char, COL['dkgray'],COL['black']
)
else:
libtcod.console_put_char_ex(self.con_memories, x,y,
self.get_char(x,y),
COL['dkgray'], COL['black'])
def draw_map(level):
for tile in chain(*level.map_grid.tiles):
if in_fov(tile.location, level):
fov = "LIT"
tile.explored = True
else:
fov = "DARK"
if tile.explored:
tcod.console_put_char_ex(con, tile.location.x, tile.location.y,
tile_char(level, tile.location),
tcod.color.black,
tile_colour(level, fov, tile.location))
def render_all(con, panel, entities, player, game_map, fov_map, fov_recompute, message_log, screen_width, screen_height,
bar_width, panel_height, panel_y, mouse, colors, game_state):
if fov_recompute:
for y in range(game_map.height):
for x in range(game_map.width):
visible = libtcod.map_is_in_fov(fov_map, x, y)
wall = game_map.tiles[x][y].block_sight
if visible:
if wall:
libtcod.console_put_char_ex(con, x, y, '#', colors.lgray(), colors.black())
else:
libtcod.console_put_char_ex(con, x, y, '+', colors.dgray(), colors.black())
game_map.tiles[x][y].explored = True
elif game_map.tiles[x][y].explored:
if wall:
libtcod.console_put_char_ex(con, x, y, '#', colors.dgray(), colors.black())
else:
libtcod.console_put_char_ex(con, x, y, '+', colors.black(), colors.black())
entities_in_render_order = sorted(entities, key=lambda x: x.render_order.value)
for entity in entities_in_render_order:
draw_entity(con, entity, fov_map, game_map)
libtcod.console_blit(con, 0, 0, screen_width, screen_height, 0, 0, 0)
libtcod.console_set_default_background(panel, colors.black())
libtcod.console_clear(panel)
y = 1
for message in message_log.messages:
libtcod.console_set_default_foreground(panel, message.color)
libtcod.console_print_ex(panel, message_log.x, y, libtcod.BKGND_NONE, libtcod.LEFT, message.text)
y += 1
render_bar(panel, 1, 1, bar_width, 'HP', player.fighter.hp, player.fighter.max_hp,
colors.red(), colors.dred(), colors.white())
libtcod.console_print_ex(panel, 1, 3, libtcod.BKGND_NONE, libtcod.LEFT,
'Dungeon level: {0}'.format(game_map.dungeon_level))
libtcod.console_set_default_foreground(panel, colors.lgray())
libtcod.console_print_ex(panel, 1, 0, libtcod.BKGND_NONE, libtcod.LEFT,
get_names_under_mouse(mouse, entities, fov_map))
libtcod.console_blit(panel, 0, 0, screen_width, panel_height, 0, 0, panel_y)
if game_state in (GameStates.SHOW_INVENTORY, GameStates.DROP_INVENTORY):
if game_state == GameStates.SHOW_INVENTORY:
inventory_title = 'Press the key next to an item to use it, or Esc to cancel.\n'
else:
inventory_title = 'Press the key next to an item to drop it, or Esc to cancel.\n'
inventory_menu(con, inventory_title, player, 50, screen_width, screen_height)
elif game_state == GameStates.LEVEL_UP:
level_up_menu(con, 'Level up! Choose a stat to raise:', player, 40, screen_width, screen_height)
elif game_state == GameStates.CHARACTER_SCREEN:
character_screen(player, 30, 18, screen_width, screen_height)
def draw_entity(game, con, entity, fov_map, debug=False):
if entity.render_order != RenderOrder.NONE:
x, y = pos_on_screen(*entity.pos, game.player)
if debug or entity.is_visible(fov_map) or (entity.render_order == RenderOrder.ALWAYS and game.map.tiles[entity.pos].explored > 0):
if entity.is_visible(fov_map) and entity is not game.cursor and not debug:
color = darken_color_by_fov_distance(game.player, entity.color, entity.x, entity.y, min=0.3)
elif entity.render_order == RenderOrder.ALWAYS and not debug and not game.state == GameState.SHOW_MAP:
color = colors.darkest_gray
else:
color = entity.color
bg_color = colors.black if entity.color_bg is None else entity.color_bg
tcod.console_put_char_ex(con, x, y, entity.char, color, bg_color)
def BiomeMap(Chars, Colors):
for x in range(WORLD_WIDTH):
for y in range(WORLD_HEIGHT):
tcod.console_put_char_ex(
0,
x,
y + int(SCREEN_HEIGHT / 2) - int(WORLD_HEIGHT / 2),
Chars[x][y],
Colors[x][y],
tcod.black,
)
tcod.console_flush()
return
def load_layer_to_console(console, xp_file_layer):
if not xp_file_layer['width'] or not xp_file_layer['height']:
raise AttributeError(
'Attempted to call load_layer_to_console on data that didn\'t have a width or height key, check your data'
)
for x in range(xp_file_layer['width']):
for y in range(xp_file_layer['height']):
cell_data = xp_file_layer['cells'][x][y]
fore_color = tcod.Color(cell_data['fore_r'], cell_data['fore_g'],
cell_data['fore_b'])
back_color = tcod.Color(cell_data['back_r'], cell_data['back_g'],
cell_data['back_b'])
tcod.console_put_char_ex(console, x, y, cell_data['keycode'],
fore_color, back_color)
def PrecipGradMap(
World,
): # ------------------------------------------------------------ Print Map (Precipitation Gradient) white -> low blue -> high --------------------------------
for x in range(WORLD_WIDTH):
for y in range(WORLD_HEIGHT):
tempv = World[x][y].precip
tempcolor = tcod.color_lerp(tcod.white, tcod.light_blue, tempv)
tcod.console_put_char_ex(
0,
x,
y + SCREEN_HEIGHT / 2 - WORLD_HEIGHT / 2,
"\333",
tempcolor,
tcod.black,
)
tcod.console_flush()
return
def TempGradMap(
World,
): # ------------------------------------------------------------ Print Map (Surface Temperature Gradient) white -> cold red -> warm --------------------------------
for x in range(WORLD_WIDTH):
for y in range(WORLD_HEIGHT):
tempv = World[x][y].temp
tempcolor = tcod.color_lerp(tcod.white, tcod.red, tempv)
tcod.console_put_char_ex(
0,
x,
y + SCREEN_HEIGHT / 2 - WORLD_HEIGHT / 2,
"\333",
tempcolor,
tcod.black,
)
tcod.console_flush()
return
def testpage_screen(character_screen_width, character_screen_height, screen_width, screen_height):
window = libtcod.console_new(character_screen_width, character_screen_height)
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 1, character_screen_width, character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Test Page')
n = 0
for r in range(0,10):
for c in range(0, 32):
n = n + 1
libtcod.console_put_char_ex(window, c, 3 + r, n, libtcod.white, libtcod.red)
x = screen_width // 2 - character_screen_width // 2
y = screen_height // 2 - character_screen_height // 2
libtcod.console_blit(window, 0, 0, screen_width, screen_height, 0, x, y, 1.0, 0.7)
def render_status_panel(game, con, panel_x, panel_y, width, height):
setup_console(con, fgcolor=colors.light_gray)
draw_console_borders(con, color=colors.dark_gray)
bar_width = round(width // 3)
draw_bar(con, 1, 1, bar_width, f'{game.player.f.hp_string}',
int(game.player.f.hp), game.player.f.max_hp,
game.player.f.hp_color, tcod.darkest_red)
draw_bar(con, width - bar_width - 1, 1,
bar_width, f'{game.player.f.stamina_string}',
int(game.player.f.stamina), game.player.f.max_stamina,
game.player.f.stamina_color, colors.darkest_blue)
draw_quickslots(con, round(r_cons.STATUS_BAR_WIDTH // 2) - 1, 0, game)
tcod.console_put_char_ex(con, 0, 0, 195, colors.dark_gray, colors.black)
#tcod.console_put_char_ex(con, width-1, 0, 180, colors.dark_gray, colors.black)
con.blit(game.map_panel, panel_x, panel_y, 0, 0, width, height)
def draw_tile(game, con, fov_map, tile_x, tile_y, screen_x, screen_y, debug=False):
tile = game.map.tiles[(tile_x, tile_y)]
visible = fov_map.fov[tile_y, tile_x] or debug
if visible:
if debug or game.state == GameState.SHOW_MAP:
color = tile.fg_color
else:
color = darken_color_by_fov_distance(game.player, tile.fg_color, tile_x, tile_y, min = 0.3)
tcod.console_put_char_ex(con, screen_x, screen_y, tile.char, color, colors.black)
tile.explored = 50
elif tile.explored > 0: #and not game.player.in_combat(game):
# "forgetting" tiles disabled for now
# if game.state == GameState.PLAYERS_TURN: # Only active player movement lowers tile exploration state
# tile.explored -= randint(0, 1)
#if game.state == GameStates.PLAYER_RESTING: # Automap is only displayed outside of combat when actively pausing #
color = tile.dark_color if not game.state == GameState.SHOW_MAP else tile.fg_color
tcod.console_put_char_ex(con, screen_x, screen_y, tile.char, color, colors.black)
def look_mode():
global MESSAGES
from game import decode_key
x, y = GAME.player.x, GAME.player.y
_messages = MESSAGES
MESSAGES = []
message('Look mode - use movement keys, ESC/q to exit.', T.green)
new_ui_turn()
_draw_messages()
redraw = True
while True:
if redraw:
T.console_blit(CON_MAP, 0, 0, MAP_W, MAP_H,
None, 1, 1)
c = T.console_get_char(CON_MAP, x, y)
color = T.console_get_char_foreground(CON_MAP, x, y)
T.console_put_char_ex(None, x+1, y+1, c,
T.black, color)
describe_tile(x, y)
_draw_messages()
T.console_flush()
# now clear the message buffer of last messages
while MESSAGES and MESSAGES[-1][0]:
MESSAGES.pop()
redraw = False
cmd = decode_key(readkey())
if cmd == 'quit':
break
elif isinstance(cmd, tuple):
name, args = cmd
if name == 'walk':
dx, dy = args
if in_map(x+dx, y+dy):
x, y = x+dx, y+dy
redraw = True
MESSAGES = _messages
def ProsperityGradMap(
World,
): # ------------------------------------------------------------ Print Map (Prosperity Gradient) white -> low green -> high --------------------------------
for x in range(WORLD_WIDTH):
for y in range(WORLD_HEIGHT):
prosperitynv = World[x][y].prosperity
prosperitycolor = tcod.color_lerp(
tcod.white, tcod.darker_green, prosperitynv
)
tcod.console_put_char_ex(
0,
x,
y + int(SCREEN_HEIGHT / 2) - int(WORLD_HEIGHT / 2),
"\333",
prosperitycolor,
tcod.black,
)
tcod.console_flush()
return
def DrainageGradMap(
World,
): # ------------------------------------------------------------ Print Map (Drainage Gradient) brown -> low white -> high --------------------------------
for x in range(WORLD_WIDTH):
for y in range(WORLD_HEIGHT):
drainv = World[x][y].drainage
draincolor = tcod.color_lerp(
tcod.darkest_orange, tcod.white, drainv
)
tcod.console_put_char_ex(
0,
x,
y + SCREEN_HEIGHT / 2 - WORLD_HEIGHT / 2,
"\333",
draincolor,
tcod.black,
)
tcod.console_flush()
return
def draw_top(game, console):
console.clear()
center_y = SCREEN_HEIGHT / 2.0 + 0.5
center_x = SCREEN_WIDTH / 2.0 + 0.5
for name, body in game.orbits.items():
planet_x, planet_y, planet_z = body.position(game.time / DAYS_PER_YEAR)
planet_x = planet_x * 4.0
planet_y = planet_y * 4.0
planet_z = planet_z * 4.0
tcod.console_put_char_ex(console, int(center_x + planet_x), int(center_y - planet_y), game.planet_symbols[name], game.planet_colors[name], tcod.black)
# Draw Sun
# TODO: refactor this so the sun isn't special
tcod.console_put_char_ex(console, int(center_x), int(center_y), chr(42), tcod.yellow, tcod.black)
info = 'Day: {t:.2f} @ {ts:.2f} d/s'.format(t = game.time, ts = game.time_scale)
console.print(0, SCREEN_HEIGHT-1, info, fg=tcod.constants.white, bg=tcod.constants.black)
def _draw_map():
con = CON_MAP
player = GAME.player
for x in range(MAP_W):
for y in range(MAP_H):
tile = GAME.map.tiles[x][y]
if GAME.map.is_visible(x, y):
c, color = tile.visible_glyph
d = distance(x, y, player.x, player.y)
if d > player.light_range + 1:
color *= 0.6
if 'h' in player.effects:
color = insanize_color(color, player.sanity)
elif 'd' in player.effects:
color = dim_color(color, player.sanity)
else:
c, _ = tile.known_glyph
color = T.dark_grey*((player.sanity/100.0)*0.6+0.4)
T.console_put_char_ex(con, x, y, ord(c),
color, T.black)
T.console_blit(con, 0, 0, MAP_W, MAP_H,
None, 1, 1)
def _draw_items(title, items):
con = CON_INV
T.console_clear(con)
con.default_fg = T.white
con.print_(1, 0, title)
con.default_fg = T.light_grey
for i, item in enumerate(items):
T.console_put_char_ex(con, 2, i+2, (i+ord('a')),
T.light_grey, T.black)
c, color = item.glyph
T.console_put_char_ex(con, 4, i+2, ord(c), color, T.black)
s = item.descr
if GAME.player.has_equipped(item):
T.console_put_char_ex(con, 0, i+2, ord('*'),
T.light_grey, T.black)
con.default_fg = T.white
else:
con.default_fg = T.grey
con.print_(6, i+2, s)
T.console_blit(con, 0, 0, INV_W, INV_H,
None, 1, 1)
def console_put_char_ex(console, ch, fg, bg):
libtcodpy.console_put_char_ex(console, 0, 0, ch, fg, bg)
assert_char(console, 0, 0, ch=ch, fg=fg, bg=bg)
