def render(self, pokeball: Pokeball, percent_complete: float, message: str) -> libtcod.console:
"""
Render the area and return the full console
"""
rows_complete = int(len(CatchGraphicRenderer.graphic) * (percent_complete / 100))
libtcod.console_clear(self.console)
libtcod.console_set_default_background(self.console, settings.CATCH_GRAPHIC_BG_COLOR)
libtcod.console_set_default_foreground(self.console, settings.LINE_COLOR)
libtcod.console_print_frame(self.console, 0, 0, CatchGraphicRenderer.width, CatchGraphicRenderer.height)
for y, row in enumerate(CatchGraphicRenderer.graphic):
for x, cell in enumerate(row):
if cell[0] != '':
if len(CatchGraphicRenderer.graphic) - y <= rows_complete:
if cell[1] == "upper":
color = pokeball.top_color
elif cell[1] == "lower":
color = pokeball.bottom_color
else:
color = cell[1]
else:
color = libtcod.gray
libtcod.console_set_default_foreground(self.console, color)
libtcod.console_put_char(self.console, x + self.x_offset, y + self.y_offset, cell[0])
if message:
libtcod.console_print_rect_ex(self.console,
CatchGraphicRenderer.width // 2, CatchGraphicRenderer.height - 3,
CatchGraphicRenderer.width - 2, 2,
libtcod.BKGND_NONE, libtcod.CENTER, message)
return self.console
def _render_summary(self, creature: Creature, prev_level: int):
"""
Render the summary line at the top of the console.
"""
summary_str = "Level {0} -> {1}".format(prev_level, creature.level)
libtcod.console_set_default_foreground(self.console, settings.BATTLE_TEXT_COLOR)
libtcod.console_print(self.console, 5, 3, summary_str)
def main_menu():
img = libtcod.image_load('menu_background.png')
while not libtcod.console_is_window_closed():
#show the background image, at twice the regular console resolution
libtcod.image_blit_2x(img, 0, 0, 0)
#show the game's title, and some credits!
libtcod.console_set_default_foreground(0, libtcod.light_yellow)
libtcod.console_print_ex(0, SCREEN_WIDTH//2, SCREEN_HEIGHT//2-4, libtcod.BKGND_NONE, libtcod.CENTER,
'TOMBS OF THE ANCIENT KINGS')
libtcod.console_print_ex(0, SCREEN_WIDTH//2, SCREEN_HEIGHT-2, libtcod.BKGND_NONE, libtcod.CENTER,
'By Jotaf')
#show options and wait for the player's choice
choice = menu('', ['Play a new game', 'Continue last game', 'Quit'], 24)
if choice == 0: #new game
new_game()
play_game()
if choice == 1: #load last game
try:
load_game()
except:
msgbox('\n No saved game to load.\n', 24)
continue
play_game()
elif choice == 2: #quit
break
def draw(self):
#only show if it's visible to the player; or it's set to "always visible" and on an explored tile
if (libtcod.map_is_in_fov(fov_map, self.x, self.y) or
(self.always_visible and map[self.x][self.y].explored)):
#set the color and then draw the character that represents this object at its position
libtcod.console_set_default_foreground(con, self.color)
libtcod.console_put_char(con, self.x, self.y, self.char, libtcod.BKGND_NONE)
def _render_map(self, map_data: MapData):
for y in range(self.start_y, self.start_y + settings.SCREEN_HEIGHT):
for x in range(self.start_x, self.start_x + settings.SCREEN_WIDTH):
if len(map_data.tiles) > y >= 0 and len(map_data.tiles[y]) > x >= 0:
cell = map_data.tiles[y][x]
libtcod.console_set_default_foreground(self.console, cell.color)
libtcod.console_put_char(self.console, x - self.start_x, y - self.start_y, cell.display_character)
def _render_lines(self):
"""
Render the lines which make up the structure of the pokedex.
"""
libtcod.console_set_default_foreground(self.console, settings.POKEDEX_LINE_COLOR)
libtcod.console_hline(self.console, 0, PokedexRenderer.header_height, PokedexRenderer.width)
for i in range(PokedexRenderer.column_width, PokedexRenderer.width, PokedexRenderer.column_width):
libtcod.console_vline(self.console, i, PokedexRenderer.header_height + 1, PokedexRenderer.column_height)
def _render_stats(self, creature: Creature, prev_level: int):
"""
Render the statistics lines one by one.
"""
libtcod.console_set_default_foreground(self.console, settings.BATTLE_TEXT_COLOR)
for idx, stat in enumerate([stat for stat in creature.stats if stat.short_name is not None and stat.short_name != ""]):
stat_str = "{0:7s}: {1:3d} -> {2:3d}".format(stat.short_name, creature.max_stat(stat, level=prev_level), creature.max_stat(stat))
libtcod.console_print(self.console, 5, 4 + idx, stat_str)
def _render_health_values(self, creature: Creature, x: int, y: int):
"""
Utility function to render the health values <current>/<max> at
the given x,y coordinates.
"""
hp_stat = self.game.static_game_data.stat(data.HP_STAT)
current = creature.current_stat(hp_stat)
max_hp = creature.max_stat(hp_stat)
libtcod.console_set_default_foreground(self.console, settings.BATTLE_TEXT_COLOR)
libtcod.console_print(self.console, x, y, "{0}/{1}".format(current, max_hp))
def _render_creature_details(self, creature: Creature, x: int, y: int, include_health_values: bool=False):
"""
Renders the creature box for the defending creature.
"""
height = BattleRenderer.creature_details_height_w_hp if include_health_values else BattleRenderer.creature_details_height_no_hp
libtcod.console_set_default_foreground(self.console, settings.BATTLE_TEXT_COLOR)
libtcod.console_print_frame(self.console, x, y, BattleRenderer.creature_details_width, height)
libtcod.console_print(self.console, x + 1, y + 1, creature.nickname[:10])
libtcod.console_print(self.console, x + BattleRenderer.creature_details_width - 6, y + 1, "LV.{0}".format(creature.level))
self._render_health_bar(creature, BattleRenderer.creature_details_width - 2, x + 1, y + 3)
if include_health_values:
self._render_health_values(creature, x + BattleRenderer.creature_details_width - 8, y + 5)
def render_bar(x, y, total_width, name, value, maximum, bar_color, back_color):
#render a bar (HP, experience, etc). first calculate the width of the bar
bar_width = int(float(value) // maximum * total_width)
#render the background first
libtcod.console_set_default_background(panel, back_color)
libtcod.console_rect(panel, x, y, total_width, 1, False, libtcod.BKGND_SCREEN)
#now render the bar on top
libtcod.console_set_default_background(panel, bar_color)
if bar_width > 0:
libtcod.console_rect(panel, x, y, bar_width, 1, False, libtcod.BKGND_SCREEN)
#finally, some centered text with the values
libtcod.console_set_default_foreground(panel, libtcod.white)
libtcod.console_print_ex(panel, x + total_width // 2, y, libtcod.BKGND_NONE, libtcod.CENTER,
name + ': ' + str(value) + '/' + str(maximum))
def render_all():
global fov_map, color_dark_wall, color_light_wall
global color_dark_ground, color_light_ground
global fov_recompute
if fov_recompute:
#recompute FOV if needed (the player moved or something)
fov_recompute = False
libtcod.map_compute_fov(fov_map, player.x, player.y, TORCH_RADIUS, FOV_LIGHT_WALLS, FOV_ALGO)
#go through all tiles, and set their background color according to the FOV
for y in range(MAP_HEIGHT):
for x in range(MAP_WIDTH):
visible = libtcod.map_is_in_fov(fov_map, x, y)
wall = map[x][y].block_sight
if not visible:
#if it's not visible right now, the player can only see it if it's explored
if map[x][y].explored:
if wall:
libtcod.console_set_char_background(con, x, y, color_dark_wall, libtcod.BKGND_SET)
else:
libtcod.console_set_char_background(con, x, y, color_dark_ground, libtcod.BKGND_SET)
else:
#it's visible
if wall:
libtcod.console_set_char_background(con, x, y, color_light_wall, libtcod.BKGND_SET )
else:
libtcod.console_set_char_background(con, x, y, color_light_ground, libtcod.BKGND_SET )
#since it's visible, explore it
map[x][y].explored = True
#draw all objects in the list, except the player. we want it to
#always appear over all other objects! so it's drawn later.
for object in objects:
if object != player:
object.draw()
player.draw()
#blit the contents of "con" to the root console
libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0)
#show the player's stats
libtcod.console_set_default_foreground(con, libtcod.white)
libtcod.console_print_ex(0, 1, SCREEN_HEIGHT - 2, libtcod.BKGND_NONE, libtcod.LEFT,
'HP: ' + str(player.fighter.hp) + '/' + str(player.fighter.max_hp))
def menu(header, options, width):
if len(options) > 26: raise ValueError('Cannot have a menu with more than 26 options.')
#calculate total height for the header (after auto-wrap) and one line per option
header_height = libtcod.console_get_height_rect(con, 0, 0, width, SCREEN_HEIGHT, header)
if header == '':
header_height = 0
height = len(options) + header_height
#create an off-screen console that represents the menu's window
window = libtcod.console_new(width, height)
#print the header, with auto-wrap
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header)
#print all the options
y = header_height
letter_index = ord('a')
for option_text in options:
text = '(' + chr(letter_index) + ') ' + option_text
libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, text)
y += 1
letter_index += 1
#blit the contents of "window" to the root console
x = SCREEN_WIDTH//2 - width//2
y = SCREEN_HEIGHT//2 - height//2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
#present the root console to the player and wait for a key-press
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
if key.vk == libtcod.KEY_ENTER and key.lalt: #(special case) Alt+Enter: toggle fullscreen
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
#convert the ASCII code to an index; if it corresponds to an option, return it
index = key.c - ord('a')
if index >= 0 and index < len(options): return index
return None
def _render_health_bar(self, creature: Creature, max_length: int, x: int, y: int):
"""
Utility function to render a health bar for the given creature at
the given x and y coordinates.
"""
hp_stat = self.game.static_game_data.stat(data.HP_STAT)
health_bars = int((creature.current_stat(hp_stat) / creature.max_stat(hp_stat)) * max_length)
if health_bars > max_length / 2:
color = settings.GOOD_HEALTH_COLOR
elif health_bars > max_length / 4:
color = settings.HALF_HEALTH_COLOR
else:
color = settings.LOW_HEALTH_COLOR
libtcod.console_set_default_foreground(self.console, color)
for i in range(x, x + health_bars):
libtcod.console_put_char(self.console, i, y, '=')
libtcod.console_set_default_foreground(self.console, settings.BLANK_HEALTH_COLOR)
for i in range(x + health_bars, x + max_length):
libtcod.console_put_char(self.console, i, y, '=')
def _render_details_box(self, species, status):
"""
If a pokemon has been selected then this is called to display a
box with the specific details as an overlay on top of the pokedex.
"""
libtcod.console_set_default_foreground(self.console, settings.POKEDEX_LINE_COLOR)
libtcod.console_print_frame(self.console, 19, 15, 43, 16) # TODO: Generalise to widths
libtcod.console_print(self.console, 23, 16, u"No. {0.pokedex_number:0=3d} {0.name}".format(species))
if status == 2:
libtcod.console_print(self.console, 23, 17, u" {0.genus} Pokemon".format(species))
libtcod.console_print(self.console, 23, 18, u"Type(s): {0}".format(', '.join(str(t) for t in species.types)))
libtcod.console_print(self.console, 23, 19, "Height: {0}".format(species.imperial_height_str()))
libtcod.console_print(self.console, 23, 20, "Weight: {0}".format(species.imperial_weight_str()))
libtcod.console_print_rect(self.console, 20, 22, 41, 14, species.flavor_text)
elif status == 1:
libtcod.console_print(self.console, 23, 17, " ????? Pokemon".format(species))
libtcod.console_print(self.console, 23, 18, "Type(s): ?????")
libtcod.console_print(self.console, 23, 19, "Height: ??'??\"")
libtcod.console_print(self.console, 23, 20, "Weight: ????.? lbs.")
def _render_species(self, pokedex, left_most_column):
"""
Iterate over all species and put them onto the screen in the
appropriate location.
Only displays seen and known species. Each of these can be
displayed differently.
"""
for pokedex_number in pokedex:
status, species = pokedex[pokedex_number]
name = "???"
color = settings.POKEDEX_UNKNOWN_COLOR
if status == 1:
name = species.name
color = settings.POKEDEX_SEEN_COLOR
elif status == 2:
name = species.name
color = settings.POKEDEX_KNOWN_COLOR
column, row = self.calculate_position_of_pokedex_number(pokedex_number - 1, left_most_column)
libtcod.console_set_default_foreground(self.console, color)
libtcod.console_print(self.console, column * PokedexRenderer.column_width + 1, row + PokedexRenderer.header_height + 1, str(pokedex_number) + ". " + name)
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 = tcod.map_is_in_fov(fov_map, x, y)
wall = game_map.tiles[x][y].block_sight
if visible:
if wall:
tcod.console_set_char_background(
con, x, y, colors.get('light_wall'),
tcod.BKGND_SET)
else:
tcod.console_set_char_background(
con, x, y, colors.get('light_ground'),
tcod.BKGND_SET)
game_map.tiles[x][y].explored = True
elif game_map.tiles[x][y].explored:
if wall:
tcod.console_set_char_background(
con, x, y, colors.get('dark_wall'), tcod.BKGND_SET)
else:
tcod.console_set_char_background(
con, x, y, colors.get('dark_ground'),
tcod.BKGND_SET)
# Draw entities
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)
# Draws player health
tcod.console_set_default_foreground(con, tcod.white)
tcod.console_print_ex(
con, 1, screen_height - 2, tcod.BKGND_NONE, tcod.LEFT,
'HP: {0:02}/{1:02}'.format(player.fighter.hp, player.fighter.max_hp))
tcod.console_blit(con, 0, 0, screen_width, screen_height, 0, 0, 0)
# Draws status panel at bottom
tcod.console_set_default_background(panel, tcod.black)
tcod.console_clear(panel)
# Prints game messages, one line at a time
y = 1
for message in message_log.messages:
tcod.console_set_default_foreground(panel, message.color)
tcod.console_print_ex(panel, message_log.x, y, tcod.BKGND_NONE,
tcod.LEFT, message.text)
y += 1
# Renders the HP bar and current dungeon level
render_bar(panel, 1, 1, bar_width, 'HP', player.fighter.hp,
player.fighter.max_hp, tcod.light_red, tcod.darker_red)
tcod.console_print_ex(panel, 1, 3, tcod.BKGND_NONE, tcod.LEFT,
'Dungeon level: {0}'.format(game_map.dungeon_level))
# Displays entity name on mouse-over
tcod.console_set_default_foreground(panel, tcod.light_gray)
tcod.console_print_ex(panel, 1, 0, tcod.BKGND_NONE, tcod.LEFT,
get_names_under_mouse(mouse, entities, fov_map))
tcod.console_blit(panel, 0, 0, screen_width, panel_height, 0, 0, panel_y)
# Displays inventory
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)
# Displays level up menu
elif game_state == GameStates.LEVEL_UP:
level_up_menu(con, 'Level up! Choose a stat to raise:\n', player, 40,
screen_width, screen_height)
# Displays character screen
elif game_state == GameStates.CHARACTER_SCREEN:
character_screen(player, 30, 11, screen_width, screen_height)
def draw(self, con):
# set the color and then draw the character that represents this object at its position
tcod.console_set_default_foreground(con, self.color)
tcod.console_put_char(con, self.x, self.y, self.char, tcod.BKGND_NONE)
def print_entity(entity):
global field
tcod.console_set_default_foreground(field, entity.color)
tcod.console_put_char(field, entity.x, entity.y, entity.char,
tcod.BKGND_NONE)
def draw_s(menu_console, menu_selection):
tcod.console_set_default_foreground(menu_console, constants.COLORS[14])
menu_console.put_char(2, constants.SETTINGS[menu_selection]["yval"], 16,
tcod.BKGND_DEFAULT)
def render_all(god, con, panel, sidebar, entities, player, game_map, fov_map, fov_recompute, msg_log, mouse, game_state):
'''
Draw all the tiles and entities in the game map, taking the console, all entities, game_map, screen vars and colors as input
Starting to draw stats on the screen! Think carefully about this and change stuff acordingly, probably move the UI part into another file
'''
zeit = datetime.now()
if game_state == GameStates.TARGETING_MODE:
blink=True
else:
blink=False
if fov_recompute:
for y in range(const['map_height']):
for x in range(const['map_width']):
visible = tcod.map_is_in_fov(fov_map, x, y)
wall = game_map.tiles[x][y].block_sight
if visible:
if wall:
tcod.console_set_char_background(con, x, y, colors.get('light_wall'), tcod.BKGND_SET)
else:
tcod.console_set_char_background(con, x, y, colors.get('light_ground'), tcod.BKGND_SET)
game_map.tiles[x][y].explored = True
elif game_map.tiles[x][y].explored or god.sight:
if wall:
tcod.console_set_char_background(con, x, y, colors['dark_wall'], tcod.BKGND_SET)
else:
tcod.console_set_char_background(con, x, y, colors['dark_ground'], tcod.BKGND_SET)
else:# if god mode is turned off, it will make all non explored stuff turn black again
tcod.console_set_char_background(con, x, y, colors['black'], tcod.BKGND_SET)
entities_in_render_order = sorted(entities, key=lambda x: x.render_order.value)
for entity in entities_in_render_order:
draw_entity(god, con, entity, fov_map)
'''
############## BLINKING SHENANIGANS WHEN TARGETING
'''
mouse_x, mouse_y = get_mouse_xy(mouse)
if blink and round(zeit.microsecond/900000): #this just gets it every half secondish
tcod.console_set_char_background(con, mouse_x, mouse_y, colors.get('blink'), tcod.BKGND_SET)
############# Bliting the Main Console
tcod.console_blit(con, 0, 0, const['screen_width'], const['screen_height'], 0, 0, const['panel_height'])
######################## PANEL ############################3
tcod.console_set_default_background(panel, tcod.black)
tcod.console_clear(panel)
#print the game msgs, one line at a time, at the apropriate x, and y (message_x and y)
y = 1
for msg in msg_log.msgs:
tcod.console_set_default_foreground(panel, msg.color)
tcod.console_print_ex(panel, msg_log.x, y, tcod.BKGND_NONE, tcod.LEFT, msg.text)
y+=1
#renders hp bar
render_bar(panel, 1, 1, const['bar_width'], 'HP', player.actor.hp, player.actor.max_hp,
tcod.light_red, tcod.darker_red)
#prints names under mouse
tcod.console_set_default_foreground(panel, tcod.light_gray)
tcod.console_print_ex(panel, 1, 0, tcod.BKGND_NONE, tcod.LEFT,
get_names_under_mouse(god, mouse, entities, fov_map))
#Prints info on the player
player = entities[0]
'''
tcod.console_print_ex(panel, 1, 3, tcod.BKGND_NONE, tcod.LEFT,
f'SPI = {player.actor.spiritual} DEF = {player.actor.def_stat}')
tcod.console_print_ex(panel, 1, 4, tcod.BKGND_NONE, tcod.LEFT,
f'PHY = {player.actor.physical} SPD = {player.actor.spd_stat}')
tcod.console_print_ex(panel, 1, 5, tcod.BKGND_NONE, tcod.LEFT,
f'MEN = {player.actor.mental} ATK = {player.actor.atk_stat}')
'''
tcod.console_blit(panel, 0, 0, const['screen_width'], const['panel_height'], 0, 0, 0)
############################## SIDEBAR ##################################3
tcod.console_set_default_background(sidebar, tcod.grey)
tcod.console_clear(sidebar)
y = 1
tcod.console_set_default_foreground(sidebar, tcod.yellow)
for skill in player.knowledge.skill_forest.skills:
tcod.console_print_ex(sidebar, 0, y, tcod.BKGND_NONE, tcod.LEFT, skill.name)
y += 2
tcod.console_blit(sidebar, 0, 0, const['sidebar_width'], const['sidebar_height'], 0, const['sidebar_x'], const['sidebar_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'
elif game_state == GameStates.DROP_INVENTORY:
inventory_title = 'Press the key next to an item to drop it, or Esc to cancel.\n'
inventory_menu(con, inventory_title, player.inventory, 50)
def drawEntity(console, entity):
tcod.console_set_default_foreground(console, entity.color)
tcod.console_put_char(console, entity.x, entity.y, entity.char,
tcod.BKGND_NONE)
def render_stats(self):
tcod.console_set_default_background(self.stat_console, tcod.black)
tcod.console_clear(self.stat_console)
bar_width = int(
float(self.player.entity.get_hp()) /
self.player.entity.get_max_hp() * (stat_console_width - 6))
tcod.console_set_default_background(self.stat_console, tcod.red)
tcod.console_rect(self.stat_console, 5, 5, (stat_console_width - 6), 1,
False, tcod.BKGND_SCREEN)
tcod.console_set_default_background(self.stat_console, tcod.green)
if bar_width > 0:
tcod.console_rect(self.stat_console, 5, 5, bar_width, 1, False,
tcod.BKGND_SCREEN)
tcod.console_print_ex(self.stat_console, 1, 5, tcod.BKGND_NONE,
tcod.LEFT, 'HP:')
tcod.console_set_default_foreground(self.stat_console, tcod.black)
tcod.console_print_ex(
self.stat_console, 5, 5, tcod.BKGND_NONE, tcod.LEFT,
'{0: 3}/{1: 3}'.format(
self.player.entity.get_hp(),
self.player.entity.get_max_hp(),
))
tcod.console_set_default_foreground(self.stat_console, tcod.white)
tcod.console_print_ex(
self.stat_console, 1, 1, tcod.BKGND_NONE,
tcod.LEFT, 'Race: {0}'.format(
str.upper(self.player.entity.monster_race.name)))
class_name = 'None'
if self.player.entity.monster_class is not None:
class_name = str.upper(self.player.entity.monster_class.name)
level = self.player.entity.get_level()
tcod.console_print_ex(self.stat_console, 1, 2, tcod.BKGND_NONE,
tcod.LEFT, 'Class: {0}'.format(class_name))
tcod.console_print_ex(self.stat_console, 1, 3, tcod.BKGND_NONE,
tcod.LEFT, 'Level: {0}'.format(str(level)))
tcod.console_print_ex(
self.stat_console, 1, 4, tcod.BKGND_NONE,
tcod.LEFT, 'Exp: {0} / {1}'.format(
self.player.entity.current_exp,
self.player.entity.get_exp_to_next_level()))
tcod.console_print_ex(
self.stat_console, 1, 7, tcod.BKGND_NONE, tcod.LEFT,
'STR {0:02} DEX {1:02} CON {2:02} INT {3:02}'.format(
self.player.entity.get_strength(),
self.player.entity.get_dexterity(),
self.player.entity.get_constitution(),
self.player.entity.get_intelligence(),
))
tcod.console_print_ex(self.stat_console, 1, 9, tcod.BKGND_NONE,
tcod.LEFT, 'Equipment:')
console_y = 10
if self.player.entity.equip_slots:
for slot in self.player.entity.equip_slots:
slot_name = get_message('equip.slot.' + str(slot.value) +
'.truncate')
equip = self.player.entity.inventory.get_equip(slot)
if equip:
equip_name = equip.get_name()
else:
equip_name = get_message('equip.no_equipment')
tcod.console_print_ex(
self.stat_console, 1, console_y, tcod.BKGND_NONE,
tcod.LEFT, ' {0}: {1}'.format(slot_name, equip_name))
console_y += 1
else:
slot_name = get_message('equip.slot.none')
tcod.console_print_ex(self.stat_console, 1, console_y,
tcod.BKGND_NONE, tcod.LEFT,
' {0}'.format(slot_name))
console_y += 1
console_y += 1
tcod.console_print_ex(self.stat_console, 1, console_y, tcod.BKGND_NONE,
tcod.LEFT, 'Traits:')
console_y += 1
for trait in self.player.entity.traits:
tcod.console_print_ex(self.stat_console, 1, console_y,
tcod.BKGND_NONE, tcod.LEFT,
' {0}'.format(trait.name))
console_y += 1
under_mouse_lines = textwrap.wrap(self.under_mouse, stat_console_width)
i_line = 0
for line in under_mouse_lines:
tcod.console_print_ex(self.stat_console, 1,
field_console_height + i_line,
tcod.BKGND_NONE, tcod.LEFT, line)
i_line += 1
tcod.console_blit(self.stat_console, 0, 0, stat_console_width,
stat_console_height, 0, field_console_width, 0)
def test_console_defaults(console, fg, bg):
libtcodpy.console_set_default_foreground(console, fg)
libtcodpy.console_set_default_background(console, bg)
libtcodpy.console_clear(console)
assert_char(console, 0, 0, None, fg, bg)
def draw(self):
tcod.console_set_default_foreground(con, self.color)
tcod.console_put_char(con, self.x, self.y, self.char, tcod.BKGND_NONE)
def draw_entity_part(con, alt_x, alt_y, entity_part, part_color):
tcod.console_set_default_foreground(con, part_color)
tcod.console_put_char(con, alt_x, alt_y, entity_part, tcod.BKGND_NONE)
def test_console_defaults(console, fg, bg):
libtcodpy.console_set_default_foreground(console, fg)
libtcodpy.console_set_default_background(console, bg)
libtcodpy.console_clear(console)
assert_char(console, 0, 0, None, fg, bg)
playerx -= 1
elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
playerx += 1
#############################################
# Initialization & Main Loop
#############################################
libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'python/libtcod tutorial', False)
libtcod.sys_set_fps(LIMIT_FPS)
playerx = SCREEN_WIDTH//2
playery = SCREEN_HEIGHT//2
while not libtcod.console_is_window_closed():
libtcod.console_set_default_foreground(0, libtcod.white)
libtcod.console_put_char(0, playerx, playery, '@', libtcod.BKGND_NONE)
libtcod.console_flush()
libtcod.console_put_char(0, playerx, playery, ' ', libtcod.BKGND_NONE)
#handle keys and exit game if needed
exit = handle_keys()
if exit:
break
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 = fov_map.fov[y][x]
wall = game_map.tiles[x][y].block_sight
if visible:
if wall:
libtcod.console_set_char_background(
con, x, y, colors.get("light_wall"),
libtcod.BKGND_SET)
else:
libtcod.console_set_char_background(
con, x, y, colors.get("light_ground"),
libtcod.BKGND_SET)
game_map.tiles[x][y].explored = True
elif game_map.tiles[x][y].explored:
if wall:
libtcod.console_set_char_background(
con, x, y, colors.get("dark_wall"),
libtcod.BKGND_SET)
else:
libtcod.console_set_char_background(
con, x, y, colors.get("dark_ground"),
libtcod.BKGND_SET)
entities_in_render_order = sorted(entities,
key=lambda x: x.render_order.value)
for entity in entities_in_render_order:
if fov_map.fov[entity.y][entity.x] or (
entity.stairs and game_map.tiles[entity.x][entity.y].explored):
draw_entity(con, entity)
libtcod.console_set_default_background(panel, libtcod.black)
libtcod.console_clear(panel)
render_bar(panel, 1, 1, bar_width, "HP", player.fighter.hp,
player.fighter.max_hp, libtcod.light_red, libtcod.darker_red)
libtcod.console_print_ex(
panel, 1, 3, libtcod.BKGND_NONE, libtcod.LEFT,
"Dungeon level: {}".format(game_map.dungeon_level))
libtcod.console_set_default_foreground(panel, libtcod.light_gray)
libtcod.console_print_ex(panel, 1, 0, libtcod.BKGND_NONE, libtcod.LEFT,
get_names_under_mouse(mouse, entities, fov_map))
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
libtcod.console_blit(con, 0, 0, screen_width, screen_height, 0, 0, 0)
libtcod.console_blit(panel, 0, 0, screen_width, panel_height, 0, 0,
panel_y)
inventory_title = None
if game_state == GameStates.SHOW_INVENTORY:
inventory_title = "Press the key next to an item to use it, or Esc to cancel.\n"
elif game_state == GameStates.DROP_INVENTORY:
inventory_title = "Press the key next to an item to drop it, or Esc to cancel.\n"
if inventory_title != None:
inventory_menu(con, inventory_title, player, player.inventory, 50,
screen_width, screen_height)
if game_state == GameStates.LEVEL_UP:
level_up_menu(con, "Level up! Choose a stat to raise:", player, 40,
screen_width, screen_height)
if game_state == GameStates.CHARACTER_SCREEN:
character_screen(player, 30, 10, screen_width, screen_height)
def draw(self):
#only show if it's visible to the player
if libtcod.map_is_in_fov(fov_map, self.x, self.y):
#set the color and then draw the character that represents this object at its position
libtcod.console_set_default_foreground(con, self.color)
libtcod.console_put_char(con, self.x, self.y, self.char, libtcod.BKGND_NONE)
def _render_selection(self, selected_row, selected_column, left_most_column):
"""
Render the information on which row, column is currently selected.
"""
libtcod.console_set_default_foreground(self.console, settings.POKEDEX_LINE_COLOR)
libtcod.console_put_char(self.console, (selected_column - left_most_column) * PokedexRenderer.column_width + 19, selected_row + PokedexRenderer.header_height + 1, '<')
def render_all():
global fov_map, color_dark_wall, color_light_wall
global color_dark_ground, color_light_ground
global fov_recompute
if fov_recompute:
#recompute FOV if needed (the player moved or something)
fov_recompute = False
libtcod.map_compute_fov(fov_map, player.x, player.y, TORCH_RADIUS, FOV_LIGHT_WALLS, FOV_ALGO)
#go through all tiles, and set their background color according to the FOV
for y in range(MAP_HEIGHT):
for x in range(MAP_WIDTH):
visible = libtcod.map_is_in_fov(fov_map, x, y)
wall = map[x][y].block_sight
if not visible:
#if it's not visible right now, the player can only see it if it's explored
if map[x][y].explored:
if wall:
libtcod.console_set_char_background(con, x, y, color_dark_wall, libtcod.BKGND_SET)
else:
libtcod.console_set_char_background(con, x, y, color_dark_ground, libtcod.BKGND_SET)
else:
#it's visible
if wall:
libtcod.console_set_char_background(con, x, y, color_light_wall, libtcod.BKGND_SET )
else:
libtcod.console_set_char_background(con, x, y, color_light_ground, libtcod.BKGND_SET )
#since it's visible, explore it
map[x][y].explored = True
#draw all objects in the list, except the player. we want it to
#always appear over all other objects! so it's drawn later.
for object in objects:
if object != player:
object.draw()
player.draw()
#blit the contents of "con" to the root console
libtcod.console_blit(con, 0, 0, MAP_WIDTH, MAP_HEIGHT, 0, 0, 0)
#prepare to render the GUI panel
libtcod.console_set_default_background(panel, libtcod.black)
libtcod.console_clear(panel)
#print the game messages, one line at a time
y = 1
for (line, color) in game_msgs:
libtcod.console_set_default_foreground(panel, color)
libtcod.console_print_ex(panel, MSG_X, y, libtcod.BKGND_NONE, libtcod.LEFT, line)
y += 1
#show the player's stats
render_bar(1, 1, BAR_WIDTH, 'HP', player.fighter.hp, player.fighter.max_hp,
libtcod.light_red, libtcod.darker_red)
#display names of objects under the mouse
libtcod.console_set_default_foreground(panel, libtcod.light_gray)
libtcod.console_print_ex(panel, 1, 0, libtcod.BKGND_NONE, libtcod.LEFT, get_names_under_mouse())
#blit the contents of "panel" to the root console
libtcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0, PANEL_Y)
def draw(self):
#set the color and then draw the character that represents this object at its position
libtcod.console_set_default_foreground(con, self.color)
libtcod.console_put_char(con, self.x, self.y, self.char, libtcod.BKGND_NONE)
def draw_entity(con, entity, fov_map, game_map):
if libtcod.map_is_in_fov(fov_map, entity.x, entity.y) or (
entity.stairs and game_map.tiles[entity.x][entity.y].explored):
libtcod.console_set_default_foreground(con, entity.color)
libtcod.console_put_char(con, entity.x, entity.y, entity.char,
libtcod.BKGND_NONE)
def render(self, console):
if not self.render_next:
return
self.target_tiles = []
if self.mode == MapMode.TARGETING:
if self.target_mode == AbilityTargeting.LOS:
line = line_where(self.player.entity.x, self.player.entity.y,
self.target_x, self.target_y, False)
for _ in range(len(line[0])):
self.target_tiles.append(
self.game_map.field[line[0][_]][line[1][_]])
dx = -(self.player.entity.x - int(field_console_width / 2))
dy = -(self.player.entity.y - int(field_console_height / 2))
if self.fov_recompute:
recompute_fov(self.game_map.fov_map, self.player.entity.x,
self.player.entity.y, 10)
for x in range(self.game_map.width):
for y in range(self.game_map.height):
if x < self.player.entity.x - int(field_console_width / 2) \
or x > self.player.entity.x + int(field_console_width / 2) \
or y < self.player.entity.y - int(field_console_height / 2) \
or y > self.player.entity.y + int(field_console_height / 2):
continue
visible = tcod.map_is_in_fov(self.game_map.fov_map, x, y)
if visible:
tcod.console_set_char_background(
self.field_console, x + dx, y + dy,
self.game_map.field[x][y].background_color,
tcod.BKGND_SET)
if self.mode == MapMode.TARGETING:
if abs(x - self.player.entity.x) > self.target_distance \
or abs(y - self.player.entity.y) > self.target_distance:
tcod.console_set_char_background(
self.field_console, x + dx, y + dy,
(60, 60, 60), tcod.BKGND_DARKEN)
if self.game_map.field[x][y] in self.target_tiles:
tcod.console_set_char_background(
self.field_console, x + dx, y + dy,
(60, 40, 40), tcod.BKGND_ADD)
if x == self.target_x and y == self.target_y:
tcod.console_set_char_background(
self.field_console, x + dx, y + dy,
(60, 40, 20), tcod.BKGND_ADD)
self.game_map.field[x][y].explored = True
elif self.game_map.field[x][y].explored:
tcod.console_set_char_background(
self.field_console, x + dx, y + dy,
self.game_map.field[x][y].background_color_dark,
tcod.BKGND_SET)
else:
tcod.console_set_char_background(
self.field_console, x + dx, y + dy, tcod.black,
tcod.BKGND_SET)
if (visible or self.game_map.field[x][y].explored
) and self.game_map.field[x][y].stairs:
tcod.console_put_char(self.field_console, x + dx,
y + dy, '>', tcod.BKGND_NONE)
for x in range(field_console_width):
for y in range(field_console_height):
if x < (int(field_console_width / 2) - self.player.entity.x) \
or x > (self.game_map.width - 1 - self.player.entity.x + int(field_console_width / 2)) \
or y < (int(field_console_height / 2) - self.player.entity.y) \
or y > (self.game_map.height - 1 - self.player.entity.y + int(field_console_height / 2)):
tcod.console_set_char_background(self.field_console, x, y,
tcod.black,
tcod.BKGND_SET)
for entity in self.game_map.entities:
if entity.x < self.player.entity.x - int(field_console_width / 2) \
or entity.x > self.player.entity.x + int(field_console_width / 2) \
or entity.y < self.player.entity.y - int(field_console_height / 2) \
or entity.y > self.player.entity.y + int(field_console_height / 2):
continue
if not tcod.map_is_in_fov(self.game_map.fov_map, entity.x,
entity.y):
continue
# Don't render an item entity if there's already one on this tile
if isinstance(entity, ItemEntity) and self.game_map.get_monster_at(
entity.x, entity.y) is not None:
continue
# Don't render a dead entity if there's already one on this tile
if isinstance(entity, MonsterEntity) \
and entity.dead \
and self.game_map.get_monster_at(entity.x, entity.y) is not None:
continue
tcod.console_set_default_foreground(self.field_console,
entity.get_color())
tcod.console_put_char(self.field_console,
entity.x + dx, entity.y + dy,
entity.get_char(), tcod.BKGND_NONE)
tcod.console_blit(self.field_console, 0, 0, field_console_width,
field_console_height, 0, 0, 0)
self.render_stats()
self.render_log()
def default_foreground_color(self, color):
tcod.console_set_default_foreground(self._c, color)
def render_all(game_state, con, panel, mouse, entities, player, game_map,
fov_map, light_map, camera, message_log, fov_recompute,
screen_width, screen_height, bar_width, panel_height, panel_y,
colors):
# fov 재계산 시만
if fov_recompute:
#tcod.console_blit(con, 0, 0, screen_width, screen_height, 0, 0, 0)
con.clear()
for y in range(game_map.height):
for x in range(game_map.width):
# 지도 위치
Mapx = x + camera.x
Mapy = y + camera.y
#print(F"{camera.x},{camera.y}")
# wall 불리언에 tile의 block_sight이 True인지 여부를 대입
visible = fov_map.fov[y, x]
wall = game_map.tiles[y, x].block_sight
if light_map[y, x] == 999:
brightness = 0
else:
brightness = light_map[y, x]
if visible:
game_map.tiles[y, x].explored = True
if wall:
draw_background(con, Mapx, Mapy, 'light_wall',
brightness)
else:
draw_background(con, Mapx, Mapy, 'light_ground',
brightness)
elif game_map.tiles[y, x].explored:
if wall:
draw_background(con, Mapx, Mapy, 'dark_wall')
else:
draw_background(con, Mapx, Mapy, 'dark_ground')
else:
draw_background(con, Mapx, Mapy, 'pitch_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, camera)
tcod.console_blit(con, 0, 0, screen_width, screen_height, 0, 0, 0)
tcod.console_set_default_background(panel, tcod.black)
tcod.console_clear(panel)
# Print the game messages, one line at a time
y = 2
for message in message_log.messages:
tcod.console_set_default_foreground(panel, message.color)
tcod.console_print_ex(panel, message_log.x, y, tcod.BKGND_NONE,
tcod.LEFT, message.text)
y += 1
render_bar(panel, 1, 1, bar_width, 'HP', player._Fighter.hp,
player._Fighter.max_hp, tcod.light_red, tcod.darker_red)
tcod.console_set_default_foreground(panel, tcod.light_gray)
tcod.console_print_ex(
panel, 1, 0, tcod.BKGND_NONE, tcod.LEFT,
get_names_under_mouse(mouse, camera, entities, fov_map))
tcod.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 = 'Use which? (Esc to exit)\n'
else:
inventory_title = 'Drop which? , or Esc to cancel.\n'
inventory_menu(con, inventory_title, player._Inventory,
screen_width - 2, screen_width, screen_height)
def main():
# Setting the screen size
screen_width = 80
screen_height = 50
# Variables to keep track of player position
player_x = int(screen_width/2)
player_y = int(screen_height/2)
# Telling libtcod which font to use. We read the font details from the arial10x10.png file that we saved down.
# The other two parts are telling libtcod which type of file we're reading.
libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
# This line actually creates the screen, using the screen heigh and width that we specified.
# The boolean at the end tells it whether to go full screen or not.
libtcod.console_init_root(screen_width, screen_height, 'Adversarial Attacker', False)
# Define console
con = libtcod.console_new(screen_width, screen_height)
# Variables to hold our keyboard and mouse inputs.
key = libtcod.Key()
mouse = libtcod.Mouse()
# This begins what's called our 'game loop'. This won't end until we close the game.
while not libtcod.console_is_window_closed():
# This line captures new events (inputs from the user)
# This updates the key variable with the user input but doesn't actually do anything with it yet.
libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS, key, mouse)
# Provides the font color for our foreground, which is our '@' symbol.
# The first arguement is the console we're drawing to.
libtcod.console_set_default_foreground(con, libtcod.white)
# The first argument is the console we're printing to again.
# The second and third arguments are x and y coordinates for where to draw.
# The third argument is what to draw.
# The fourth argument sets the background to none.
libtcod.console_put_char(con, player_x, player_y, "@", libtcod.BKGND_NONE)
# This part actually draws our symbol.
libtcod.console_blit(con, 0, 0, screen_width, screen_height, 0, 0, 0)
# This line presents everything on the screen.
libtcod.console_flush()
# Removes the trailing '@' symbol when we move (so that we don't create a snake).
libtcod.console_put_char(con, player_x, player_y, ' ', libtcod.BKGND_NONE)
# Use the handle_keys function that we created to translate our key press into an action.
action = handle_keys(key)
# Grab our actions (if they exist)
move = action.get('move')
exit = action.get('exit')
fullscreen = action.get('fullscreen')
# Carry out our movement action if it exists.
if move:
# Set dx and dy values to our move coordinates.
dx, dy = move
# Update player (x,y) position using (dx,dy).
player_x += dx
player_y += dy
# Exit the game if that was the action taken by the user.
if exit:
return True
# Go fullscreen if that was the action taken by the user.
if fullscreen:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
def draw_entity(god, con, entity, fov_map):
if entity_in_fov(god, entity, fov_map):
tcod.console_set_default_foreground(con, entity.color)
tcod.console_put_char(con, entity.x, entity.y, entity.char, tcod.BKGND_NONE)
def draw(self):
if tcod.map_is_in_fov(fovMap, self.x, self.y):
tcod.console_set_default_foreground(con, self.color)
tcod.console_put_char(con, self.x, self.y, self.char, tcod.BKGND_NONE)
def explored_draw(self, topx, topy) -> None:
tcod.console_set_default_foreground(0, self.explored_color)
#find the offset coordinates and draw to that point on the screen
tcod.console_put_char(0, self.x - topx, self.y - topy, self.char,
tcod.BKGND_NONE)
def render_all():
global fov_map, color_dark_wall, color_light_wall
global color_dark_ground, color_light_ground
global fov_recompute
if fov_recompute:
#recompute FOV if needed (the player moved or something)
fov_recompute = False
libtcod.map_compute_fov(fov_map, player.x, player.y, TORCH_RADIUS,
FOV_LIGHT_WALLS, FOV_ALGO)
#go through all tiles, and set their background color according to the FOV
for y in range(MAP_HEIGHT):
for x in range(MAP_WIDTH):
visible = libtcod.map_is_in_fov(fov_map, x, y)
wall = map[x][y].block_sight
if not visible:
#if it's not visible right now, the player can only see it if it's explored
if map[x][y].explored:
if wall:
libtcod.console_set_char_background(
con, x, y, color_dark_wall, libtcod.BKGND_SET)
else:
libtcod.console_set_char_background(
con, x, y, color_dark_ground,
libtcod.BKGND_SET)
else:
#it's visible
if wall:
libtcod.console_set_char_background(
con, x, y, color_light_wall, libtcod.BKGND_SET)
else:
libtcod.console_set_char_background(
con, x, y, color_light_ground, libtcod.BKGND_SET)
#since it's visible, explore it
map[x][y].explored = True
#draw all objects in the list, except the player. we want it to
#always appear over all other objects! so it's drawn later.
for object in objects:
if object != player:
object.draw()
player.draw()
#blit the contents of "con" to the root console
libtcod.console_blit(con, 0, 0, MAP_WIDTH, MAP_HEIGHT, 0, 0, 0)
#prepare to render the GUI panel
libtcod.console_set_default_background(panel, libtcod.black)
libtcod.console_clear(panel)
#print the game messages, one line at a time
y = 1
for (line, color) in game_msgs:
libtcod.console_set_default_foreground(panel, color)
libtcod.console_print_ex(panel, MSG_X, y, libtcod.BKGND_NONE,
libtcod.LEFT, line)
y += 1
#show the player's stats
render_bar(1, 1, BAR_WIDTH, 'HP', player.fighter.hp, player.fighter.max_hp,
libtcod.light_red, libtcod.darker_red)
#display names of objects under the mouse
libtcod.console_set_default_foreground(panel, libtcod.light_gray)
libtcod.console_print_ex(panel, 1, 0, libtcod.BKGND_NONE, libtcod.LEFT,
get_names_under_mouse())
#blit the contents of "panel" to the root console
libtcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0,
PANEL_Y)
def render_inv(root_console, inv_panel, player, map_width, sch_height):
"""
Render the right panel (features, weapons, inventory) except time
"""
tcod.console_clear(inv_panel)
default_fore = const.base0
tcod.console_set_default_foreground(inv_panel, default_fore)
w = inv_panel.width
# Features
y = 0
tcod.console_set_default_foreground(inv_panel, default_fore)
inv_panel.print_frame(0, y, w, 5 * 3 + 1, string="Features")
for fslot in const.FeatureSlot:
y += 1
feature = player.fequiped.get(fslot)
tcod.console_set_char_background(inv_panel, 1, y,
fslot.value.get("color"),
tcod.BKGND_SET)
if feature:
render_feature(inv_panel, feature, default_fore, y, player)
y += 2
else:
tcod.console_set_default_foreground(inv_panel, const.base02)
tcod.console_print_ex(inv_panel, 3, y, tcod.BKGND_NONE, tcod.LEFT,
"(none)")
y += 1
tcod.console_print_ex(inv_panel, 3, y, tcod.BKGND_NONE, tcod.LEFT,
fslot.value.get("name"))
y += 1
y += 1
tcod.console_set_default_foreground(inv_panel, default_fore)
inv_panel.print_frame(0, y, w, 3, string="Resistance")
y += 1
x = 2
at_least_one = False
for fslot in const.FeatureSlot:
r = player.resistances.get(fslot)
if r > 0:
at_least_one = True
tcod.console_set_char_background(inv_panel, x, y,
fslot.value.get("color"),
tcod.BKGND_SET)
x += 1
if fslot in player.synergy:
tcod.console_print_ex(inv_panel, x, y, tcod.BKGND_NONE,
tcod.LEFT, ":" + str(r) + "*")
else:
tcod.console_print_ex(inv_panel, x, y, tcod.BKGND_NONE,
tcod.LEFT, ":" + str(r))
x += 4
else:
x += 5
if not at_least_one:
tcod.console_set_default_foreground(inv_panel, const.base02)
tcod.console_print_ex(inv_panel, int(w / 2), y, tcod.BKGND_NONE,
tcod.CENTER, "(none)")
tcod.console_set_default_foreground(inv_panel, default_fore)
y += 2
inv_panel.print_frame(0, y, w, 3 * 3 + 1, string="Weapons")
for wslot in const.WeaponSlot:
y += 1
weapon = player.wequiped.get(wslot)
if weapon:
render_weapon(inv_panel, weapon, default_fore, y,
weapon == player.active_weapon)
y += 1
else:
tcod.console_set_default_foreground(inv_panel, const.base02)
tcod.console_print_ex(inv_panel, 1, y, tcod.BKGND_NONE, tcod.LEFT,
wslot.value.get("key") + " (none)")
y += 1
tcod.console_print_ex(inv_panel, 3, y, tcod.BKGND_NONE, tcod.LEFT,
wslot.value.get("name"))
string = str(round(
wslot.value.get("success_rate_base") * 100)) + "% " + str(
wslot.value.get("duration_base")) + "s"
if wslot.value.get("unstable"):
string = "Stab- " + string
tcod.console_print_ex(inv_panel, w - 1, y, tcod.BKGND_NONE,
tcod.RIGHT, string)
y += 1
y += 1
tcod.console_set_default_foreground(inv_panel, default_fore)
inv_panel.print_frame(0, y, w, 5 * 3 + 1, string="Inventory")
for k in player.inventory:
y += 1
item = player.inventory.get(k)
if item:
if isinstance(item, ent.Weapon):
render_weapon(inv_panel, item, default_fore, y, False)
tcod.console_put_char(inv_panel, 1, y, k, tcod.BKGND_NONE)
else:
render_feature(inv_panel, item, default_fore, y, player)
tcod.console_set_default_foreground(inv_panel, default_fore)
tcod.console_put_char(inv_panel, 1, y, k, tcod.BKGND_NONE)
else:
tcod.console_set_default_foreground(inv_panel, const.base02)
tcod.console_print_ex(inv_panel, 1, y, tcod.BKGND_NONE, tcod.LEFT,
k + " (none)")
y += 2
inv_panel.blit(dest=root_console, dest_x=map_width, dest_y=sch_height)
def help_screen(help_screen_width, help_screen_height, screen_width,
screen_height):
window = libtcod.console_new(help_screen_width, help_screen_height)
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 1, help_screen_width,
help_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'List of Game Commands')
libtcod.console_print_rect_ex(window, 0, 3, help_screen_width,
help_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Pick up: comma')
libtcod.console_print_rect_ex(window, 0, 5, help_screen_width,
help_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Move: arrow keys, num pad')
libtcod.console_print_rect_ex(window, 0, 7, help_screen_width,
help_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT,
'Wait: full stop / 5 on num pad')
libtcod.console_print_rect_ex(window, 0, 9, help_screen_width,
help_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Down stairs: space')
libtcod.console_print_rect_ex(window, 0, 11, help_screen_width,
help_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Help menu: \'h\'')
libtcod.console_print_rect_ex(window, 0, 13, help_screen_width,
help_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Inventory menu: \'i\'')
libtcod.console_print_rect_ex(window, 0, 15, help_screen_width,
help_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Drop menu: \'d\'')
libtcod.console_print_rect_ex(window, 0, 17, help_screen_width,
help_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Character screen: \'c\'')
libtcod.console_print_rect_ex(window, 0, 19, help_screen_width,
help_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Cancel/exit anything: esc')
libtcod.console_print_rect_ex(window, 0, 21, help_screen_width,
help_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Full screen: Alt-Enter')
libtcod.console_print_rect_ex(
window, 0, 23, help_screen_width, help_screen_height,
libtcod.BKGND_NONE, libtcod.LEFT,
'Using menus: a-z(signified beside the option)')
libtcod.console_print_rect_ex(window, 0, 25, help_screen_width,
help_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT,
'What\'s that?: hover with mouse')
libtcod.console_print_rect_ex(
window, 0, 27, help_screen_width, help_screen_height,
libtcod.BKGND_NONE, libtcod.LEFT,
'If an item is a piece of armour or weapon(excluding bows): select it in inventory menu to (d)equip'
)
libtcod.console_print_rect_ex(window, 0, 31, help_screen_width,
help_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT,
'Any other item is instant use')
libtcod.console_print_rect_ex(
window, 0, 33, help_screen_width, help_screen_height,
libtcod.BKGND_NONE, libtcod.LEFT,
'Most items are fairly self-explanatory(antidotes), but scrolls can make monsters move randomly(confusion), hit the nearest monster(lightning), deal AOE damage(fireball) or freeze a monster(freeze)'
)
libtcod.console_print_rect_ex(
window, 0, 40, help_screen_width, help_screen_height,
libtcod.BKGND_NONE, libtcod.LEFT,
'If in doubt: read the message bar/ask me!!')
libtcod.console_print_rect_ex(window, 0, 42, help_screen_width,
help_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT,
'Game automatically saves with esc')
x = screen_width // 2 - help_screen_width // 2
y = screen_height // 2 - help_screen_width // 2
libtcod.console_blit(window, 0, 0, help_screen_width, help_screen_height,
0, x, y, 1.0, 0.7)
def draw_entity(con, entity, fov_map):
if libtcod.map_is_in_fov(fov_map, entity.x, entity.y):
libtcod.console_set_default_foreground(con, entity.color)
libtcod.console_put_char(con, entity.x, entity.y, entity.char,
libtcod.BKGND_NONE)
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, graphics):
"""
Affiche les pièces, les entites, les menus, et tous les éléments du jeu
Parametres:
----------
con : tcod.console
panel : tcod.console
entities : list
player : Entity
game_map : GameMap
fov_map : tcod.map
fov_recompute : bool
message_log : MessageLog
screen_width : int
screen_height : int
bar_width : int
panel_heidght : int
panel_y : int
mouse : tcod.mouse
colors : tcod.colors
Désormais non utilisé
game_state : int
graphics : dict
Renvoi:
-------
Aucun
"""
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,
graphics.get('wall'),
libtcod.white,
libtcod.black)
else:
libtcod.console_put_char_ex(con, x, y,
graphics.get('floor'),
libtcod.white,
libtcod.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,
graphics.get('wall'),
libtcod.light_grey,
libtcod.black)
else:
libtcod.console_put_char_ex(con, x, y,
graphics.get('floor'),
libtcod.light_grey,
libtcod.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)
if entity.ai:
if entity.ai.ai_name == 'Boss':
if entity.ai.aoeing:
if entity.ai.turn % 10 == 0:
color = libtcod.lightest_red
elif entity.ai.turn % 10 == 1:
color = libtcod.lighter_red
elif entity.ai.turn % 10 == 2:
color = libtcod.light_red
elif entity.ai.turn % 10 == 3:
color = libtcod.red
radius = entity.ai.radius
for x in range(entity.x - radius, entity.x + radius + 1):
for y in range(entity.y - radius,
entity.y + radius + 1):
if ((x - entity.x)**2 +
(y - entity.y)**2)**0.5 <= radius:
libtcod.console_set_char_foreground(
con, x, y, color)
libtcod.console_blit(con, 0, 0, screen_width, screen_height, 0, 0, 0)
libtcod.console_set_default_background(panel, libtcod.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, libtcod.light_red, libtcod.darker_red)
libtcod.console_print_ex(
panel, 1, 2, libtcod.BKGND_NONE, libtcod.LEFT,
'Salle : {0} - LVL : {1}'.format(game_map.dungeon_level,
player.level.current_level))
boss_bar = False
for entity in entities:
if entity.name == 'Boss':
boss_bar = True
boss = entity.fighter
if boss_bar:
render_bar(panel, 1, 3, bar_width, 'Boss HP', boss.hp, boss.max_hp,
libtcod.orange, libtcod.darker_orange)
else:
render_bar(panel, 1, 3, bar_width, 'XP', player.level.current_xp,
player.level.experience_to_next_level, libtcod.light_purple,
libtcod.darker_purple)
libtcod.console_print_ex(
panel, 1, 4, libtcod.BKGND_NONE, libtcod.LEFT,
'ATQ : {0} - DEF : {1}'.format(player.fighter.power,
player.fighter.defense))
libtcod.console_set_default_foreground(panel, libtcod.light_gray)
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 = 'Echap pour quitter, A/B/C... pour utiliser.\n'
else:
inventory_title = 'Echap pour quitter, A/B/C... pour lacher\n'
inventory_menu(con, inventory_title, player, 50, screen_width,
screen_height)
elif game_state == GameStates.LEVEL_UP:
level_up_menu(con, 'Level up, choisis une amelioration :', player, 40,
screen_width, screen_height)
elif game_state == GameStates.CHARACTER_SCREEN:
character_screen(player, 30, 10, screen_width, screen_height)
def _render_player(self, player):
x, y = player.coords
libtcod.console_set_default_foreground(self.console, settings.PLAYER_COLOR)
libtcod.console_put_char(self.console, x - self.start_x, y - self.start_y, '@')
def render(self):
tcod.console_set_default_foreground(0, self.color)
tcod.console_put_char(0, self.col, self.row,
self.symbol, tcod.BKGND_NONE)
def render_all():
global fov_map, color_dark_wall, color_light_wall
global color_dark_ground, color_light_ground
global fov_recompute
if fov_recompute:
# recompute FOV if needed (the player moved or something)
fov_recompute = False
tcod.map_compute_fov(fov_map, player.x, player.y, TORCH_RADIUS, FOV_LIGHT_WALLS, FOV_ALGO)
# go through all tiles, and set their background color according to the FOV
for y in range(MAP_HEIGHT):
for x in range(MAP_WIDTH):
visible = tcod.map_is_in_fov(fov_map, x, y)
wall = map[x][y].block_sight
if EXPLORE_MODE:
if not visible:
# it's out of the player's FOV
if map[x][y].explored:
if wall:
tcod.console_set_char_background(con, x, y, color_dark_wall, tcod.BKGND_SET)
else:
tcod.console_set_char_background(con, x, y, color_dark_ground, tcod.BKGND_SET)
else:
# it's visible
if wall:
tcod.console_set_char_background(con, x, y, color_light_wall, tcod.BKGND_SET)
else:
tcod.console_set_char_background(con, x, y, color_light_ground, tcod.BKGND_SET)
map[x][y].explored = True
else:
if not visible:
# it's out of the player's FOV
if wall:
tcod.console_set_char_background(con, x, y, color_dark_wall, tcod.BKGND_SET)
else:
tcod.console_set_char_background(con, x, y, color_dark_ground, tcod.BKGND_SET)
else:
# it's visible
if wall:
tcod.console_set_char_background(con, x, y, color_light_wall, tcod.BKGND_SET)
else:
tcod.console_set_char_background(con, x, y, color_light_ground, tcod.BKGND_SET)
# draw all objects in the list
for object in objects:
if object != player:
object.draw()
player.draw()
# blit the contents of "con" to the root console
tcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0)
# GUI
tcod.console_set_default_background(panel, tcod.black)
tcod.console_clear(panel)
message_y = 1
for (line, color) in game_msgs:
tcod.console_set_default_foreground(panel, color)
tcod.console_print_ex(panel, MSG_X, message_y, tcod.BKGND_NONE, tcod.LEFT, line)
message_y += 1
tcod.console_set_default_foreground(panel, tcod.light_gray)
name = get_names_under_mouse()
print(name)
tcod.console_print_ex(panel, 1, 0, tcod.BKGND_NONE, tcod.LEFT, name)
render_bar(1, 1, BAR_WIDTH, "HP", player.fighter.hp, player.fighter.max_hp, tcod.light_red, tcod.darker_red)
tcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0, PANEL_Y)
def _render_lines(self):
"""
Renders the lines which separate sections of the screen.
"""
libtcod.console_set_default_foreground(self.console, settings.LINE_COLOR)
libtcod.console_hline(self.console, 0, BattleRenderer.top_section_height, settings.SCREEN_WIDTH)
def draw_entity(con, entity):
libtcod.console_set_default_foreground(con, entity.color)
libtcod.console_put_char(con, entity.x, entity.y, entity.char,
libtcod.BKGND_NONE)
def draw(self):
if tcod.map_is_in_fov(fov_map, self.axis_X, self.axis_Y):
tcod.console_set_default_foreground(char_con, self.color)
tcod.console_put_char(char_con, self.axis_X, self.axis_Y, self.character, tcod.BKGND_NONE)
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):
# Draw all the tiles in the game map
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_set_char_background(
con, x, y, colors.get('light_wall'),
libtcod.BKGND_SET)
else:
libtcod.console_set_char_background(
con, x, y, colors.get('light_ground'),
libtcod.BKGND_SET)
game_map.tiles[x][y].explored = True
elif game_map.tiles[x][y].explored:
if wall:
libtcod.console_set_char_background(
con, x, y, colors.get('dark_wall'),
libtcod.BKGND_SET)
else:
libtcod.console_set_char_background(
con, x, y, colors.get('dark_ground'),
libtcod.BKGND_SET)
entities_in_render_order = sorted(entities,
key=lambda x: x.render_order.value)
# Draw all entities in the list
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, libtcod.black)
libtcod.console_clear(panel)
# Print the game messages, one line at a time
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, libtcod.light_red, libtcod.darker_red)
libtcod.console_print_ex(panel, 1, 3, libtcod.BKGND_NONE, libtcod.LEFT,
f'dungeon level: {game_map.dungeon_level}')
libtcod.console_set_default_foreground(panel, libtcod.light_gray)
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, 10, screen_width, screen_height)
def drawChar(self, drawInfo):
if drawInfo[1]:
libtcod.console_set_default_foreground(drawInfo[0], drawInfo[1])
libtcod.console_put_char(drawInfo[0], drawInfo[2], drawInfo[3],
drawInfo[4], libtcod.BKGND_NONE)
libtcod.console_set_default_foreground(drawInfo[0], libtcod.white)