def target_tile(max_range=None): box = libtcod.console_new(1, 1) x = Game.player.x y = Game.player.y libtcod.console_set_default_background(box, libtcod.orange) libtcod.console_clear(box) key = Game.key while (x, y) != (0, 0): Game.renderer.render_all() Game.renderer.render_names_under_target(x, y) Game.renderer.render_target_tile(box, x, y) key = libtcod.console_wait_for_keypress(True) key = libtcod.console_wait_for_keypress(True) direction = Game.get_direction(key) if direction is not None: x += direction[0] y += direction[1] else: return (None, None) if direction == (0, 0): if Game.map.is_tile_in_fov(x, y) and (max_range is None or Game.player.distance(x, y) <= max_range): return (x, y) else: Game.message('That is out of range.', libtcod.red)
def show_menu(self, options, header, hide_options=False): """ Show menu with header and options in the screen. """ #calculate total height for the header (after auto-wrap) header_height = libtcod.console_get_height_rect(self.inv_window, 0, 0, MAP_WIDTH, MAP_HEIGHT, header) #print the header, with auto-wrap libtcod.console_set_default_foreground(self.inv_window, libtcod.white) libtcod.console_print_rect_ex(self.inv_window, 0, 0, MAP_WIDTH, MAP_HEIGHT, libtcod.BKGND_NONE, libtcod.LEFT, header) #print all the options y = header_height for (option_key, option_text) in options: if hide_options is True: text = option_text else: text = '(' + option_key + ') ' + option_text libtcod.console_print_ex(self.inv_window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, text) y += 1 #blit the contents of "self.inv_window" to the root console x, y, _ = SCREEN_RECT.top_left.coords libtcod.console_blit(self.inv_window, 0, 0, MAP_WIDTH, MAP_HEIGHT, 0, x, y, 1.0, 0.7) libtcod.console_flush() libtcod.console_clear(self.inv_window)
def render(self): libtcod.console_set_default_background(0, libtcod.black) libtcod.console_set_default_background(self.panel, libtcod.black) libtcod.console_clear(0) libtcod.console_clear(self.panel) self.screens[-1].render() libtcod.console_blit(self.panel, 0, 0, self.screen_width, self.screen_height, 0, 0, 0, 1, 1)
def render_all(): # Go through all Tiles, and set their character and color. for y in range(MAP_HEIGHT): for x in range(MAP_WIDTH): # Draw it. libtcod.console_put_char_ex(con, x, y, map[x][y].char, map[x][y].color, libtcod.black) # Draw all objects in the list. for object in objects: object.draw() # Blit the contents of "con" to the root console. libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0) # Prepare to render the GUI panel. libtcod.console_set_default_background(panel, libtcod.black) libtcod.console_clear(panel) # Show the player's stats. libtcod.console_set_default_foreground(panel, libtcod.red) libtcod.console_print_ex(panel, 1, 1, libtcod.BKGND_NONE, libtcod.LEFT, 'Lives: ' + str(player.lives) + '/' + str(player.max_lives)) libtcod.console_set_default_foreground(panel, libtcod.white) libtcod.console_print_ex(panel, 1, 3, libtcod.BKGND_NONE, libtcod.LEFT, 'Level ' + str(level_number)) # 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_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, 'Dungeon level: {0}'.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)) 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 the 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.inventory, 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 play_game(): player_action = None while not libtcod.console_is_window_closed(): # Render the screen. render_all() libtcod.console_flush() # Clean the console. libtcod.console_clear(con) # Handle keys and exit game if needed. player_action = handle_keys() if player_action == 'exit': break # Let the monsters take their turn. if game_state == 'playing' or game_state == 'custom playing': for object in objects: if object.ai: if object.wait > 0: object.wait -= 1 else: object.ai.take_turn() object.wait = object.speed
def main_menu(): while not libtcod.console_is_window_closed(): libtcod.console_disable_keyboard_repeat() libtcod.console_set_default_background(0, libtcod.black) libtcod.console_set_default_foreground(0, libtcod.black) libtcod.console_clear(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, 'BALL LABYRINTH') libtcod.console_print_ex(0, SCREEN_WIDTH / 2, SCREEN_HEIGHT - 2, libtcod.BKGND_NONE, libtcod.CENTER, 'By Eric Williams') # Show options and wait for the player's choice. choice = menu('', ['Play a new game', 'Load saved game', 'Play custom level', 'Quit'], 24) if choice == 0: # New game. new_game() libtcod.console_set_keyboard_repeat(5, 5) play_game() elif choice == 1: # Load saved game. loaded = load_game() if loaded: libtcod.console_set_keyboard_repeat(5, 5) play_game() elif choice == 2: # Open the test arena level. custom = new_custom_game() if custom: libtcod.console_set_keyboard_repeat(5, 5) play_game() elif choice == 3: # Quit. break
def panel2_display(): str_s = 'Str:' + str(player.fighter.status.Str) con_s = 'Con:' + str(player.fighter.status.Con) dex_s = 'Dex:' + str(player.fighter.status.Dex) int_s = 'Int:' + str(player.fighter.status.Int) car_s = player.fighter.status.career panel2_msgs = [player.name, str_s, con_s, dex_s, int_s, ' ', 'career', car_s, ' '] skill_msgs = ['Skills:'] #print skills s = player.fighter.total_skills for index in s: skill_msgs.append(str(index) + ')' + s[index][0] + ' [' + s[index][1] + ']') passive_msgs = ['','Passive:'] #print passive for index in player.fighter.status.passives: passive_msgs.append(player.fighter.status.passives[index]) panel2_msgs.extend(skill_msgs) panel2_msgs.extend(passive_msgs) libtcod.console_set_default_background(panel2, libtcod.black) libtcod.console_clear(panel2) y = 1 for lines in panel2_msgs: libtcod.console_set_default_foreground(panel2, libtcod.white) libtcod.console_print_ex(panel2, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, lines) y += 1 libtcod.console_blit(panel2, 0 , 0, PANEL2_WIDTH, PANEL2_HEIGHT, 0 ,PANEL2_X, 0)
def draw(self): libtcod.console_set_alignment(0, libtcod.CENTER) libtcod.console_print(0, self.text_base[0], self.text_base[1], self.title_text) libtcod.console_print(0, self.text_base[0], self.text_base[1] + 2, "a " + self.option_one_text) libtcod.console_print(0, self.text_base[0], self.text_base[1] + 4, "b " + self.option_two_text) libtcod.console_flush() libtcod.console_clear(0)
def new_game(): global game_msgs, game_state map_number = 0 list_of_maps = [] #generate map, but at this point it's not drawn to the screen newmap, objects_for_this_map = make_bare_surface_map() # a fresh level! # Append this new level to the list_of_maps, and then append all the objects to that GameMap's # object list. list_of_maps.append( GameMap(map_number, newmap, 'surface') ) for item in objects_for_this_map: list_of_maps[map_number].objects.append(item) list_of_maps[map_number].initialize_fov() libtcod.console_clear(con) game_state = 'playing' # Inventory assignment used to be here ("inventory = []") but now the list gets created on the line above where we create # the player gamepiece. #create the list of game messages and their colors. message('Welcome to Mars! This is a test of a roguelike game engine in Python and Libtcod. Push h for help.',\ libtcod.red) return list_of_maps, map_number
def render_all(self): libtcod.console_clear(self.con) for y in range(self.CAMERA_HEIGHT): for x in range(self.CAMERA_WIDTH): #First, get the absolute map coordinates of whatever's in view (map_x, map_y) = (self.camera.x + x - self.CAMERA_WIDTH/2, self.camera.y + y - self.CAMERA_HEIGHT/2) #Then, get which chunk it's on, and where on that chunk it is chunk_count_x, chunk_count_y, local_x, local_y = self.to_chunk_and_local_coords(map_x, map_y) #Now, render the appropriate char based on the coords libtcod.console_put_char(self.con, x, y, self.map.map[chunk_count_x][chunk_count_y].chunk[local_x][local_y].char, libtcod.BKGND_NONE) libtcod.console_set_char_foreground(self.con, x, y, self.map.map[chunk_count_x][chunk_count_y].chunk[local_x][local_y].color) #Draw all objects in range of the player to be active self.active_objects = self.get_active_objects() for object in self.active_objects: self.draw_object(object) if self.cursor!= None: self.draw_object(self.cursor) #blit the contents of "con" to the root console libtcod.console_blit(self.con, 0, 0, self.SCREEN_WIDTH, self.SCREEN_HEIGHT, 0, 0, 0) #blit the infobar to the root console self.refresh_infobar(self.infobar) libtcod.console_blit(self.infobar, 0, 0, self.SCREEN_WIDTH, self.SCREEN_HEIGHT, 0, 0, self.SCREEN_HEIGHT - 1) #if we're showing the right-side menu, show it if self.show_menu == True: self.refresh_menu(self.menu) libtcod.console_blit(self.menu, 0, 0, self.SCREEN_WIDTH, self.SCREEN_HEIGHT, 0, self.SCREEN_WIDTH - self.MENU_WIDTH, 0)
def disable_panels(): tcod.console_clear(0) tcod.console_clear(MESSAGE_WINDOW) SETTINGS['draw life info'] = False remove_view_from_scene_by_name('message_box')
def _draw_fov_using_terrain(player): """ Overly optimized: this code inlines Map.terrain_at(), Map.is_explored(), and ScreenCoords.toWorldCoords() in order to get a 2.5x speedup on large maps. """ libtcod.console_clear(_con) current_map = player.current_map pos = algebra.Location(0, 0) for screen_y in range(min(current_map.height, config.MAP_PANEL_HEIGHT)): pos.set(player.camera_position.x, player.camera_position.y + screen_y) for screen_x in range(min(current_map.width, config.MAP_PANEL_WIDTH)): # pos = ScreenCoords.toWorldCoords(player.camera_position, (screen_x, screen_y)) visible = libtcod.map_is_in_fov(current_map.fov_map, pos.x, pos.y) # terrain = current_map.terrain_at(pos) terrain = map.terrain_types[current_map.terrain[pos.x][pos.y]] if not visible: # if current_map.is_explored(pos): if current_map._explored[pos.x][pos.y]: libtcod.console_set_char_background(_con, screen_x, screen_y, terrain.unseen_color, libtcod.BKGND_SET) else: libtcod.console_set_char_background(_con, screen_x, screen_y, terrain.seen_color, libtcod.BKGND_SET) current_map.explore(pos) pos.x += 1
def draw(self): libtcod.console_clear(self.console) for y in range(len(self.entity_manager.world_tiles)): for x in range(len(self.entity_manager.world_tiles[y])): self.draw_world_tile(x, y, self.entity_manager.world_tiles[x][y]['tile']) #handy thing about this is it should help farther down the line when I go to implement FOV render_data = [] for id, entity in self.entity_manager.entities.iteritems(): if entity.get_attribute(AttributeTag.Visible): position_info = entity.get_attribute(AttributeTag.WorldPosition) if not position_info: raise LookupError('entity ' + str(entity) + ' is flagged as visible, but does not have any world position') draw_info = entity.get_attribute(AttributeTag.DrawInfo) if not draw_info: raise LookupError('entity ' + str(entity) + ' is flagged as visible, but does not have any draw info') render_data.append({'draw_type': draw_info.data['draw_type'], 'z_level':draw_info.data['z_level'],'entity': entity}) #z-sort the entities we're rendering so that things like world tiles can be drawn behind entities on those tiles render_data.sort(lambda data,other: cmp(data['z_level'], other['z_level'])) for to_render in render_data: if to_render['draw_type'] in render_type_dict: render_type_dict[to_render['draw_type']](self, to_render['entity']) libtcod.console_blit(self.console, 0, 0, self.width, self.height, 0, self.world_x_start, self.world_y_start)
def draw_panel(player, pointer_location): """ Refreshes the UI display and blits it to the window. """ libtcod.console_set_default_background(_panel, libtcod.black) libtcod.console_clear(_panel) # Only display the (log.MSG_HEIGHT) most recent write_log(log.game_msgs[-log.MSG_HEIGHT:], _panel, MSG_X, 1) _render_bar(1, 1, config.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 ' + str(player.current_map.dungeon_level)) # _debug_positions(player, mouse) # _debug_room(player) # _debug_danger(player) _debug_fps() 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(player, pointer_location)) # Done with "_panel", blit it to the root console. libtcod.console_blit(_panel, 0, 0, config.SCREEN_WIDTH, config.PANEL_HEIGHT, 0, 0, PANEL_Y)
def render_all(self): tcod.console_clear(0) render_conway_sim(self.conway) self.render_players() self.render_ball() self.render_scores() self.render_fps()
def main_menu(): #Set up the main menu, which is presented to the player when they first load the game img = libtcod.image_load('images/menu_background1.png') while not libtcod.console_is_window_closed(): #Show the image at twice its usual resolution of the console libtcod.image_blit_2x(img, 0, SCREEN_WIDTH / 6, SCREEN_HEIGHT / 6) #Show the games 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, 'DUNGEONCRAWLER') libtcod.console_print_ex(0, SCREEN_WIDTH / 2, SCREEN_HEIGHT - 2, libtcod.BKGND_NONE, libtcod.CENTER, 'By Jeremy Cerise') #Show menu options and wait for the players choice choice = menu('', ['Play a new game', 'Continue last game', 'Quit'], 24) if choice == 0: #Start a new game #Clear the base conosle, so the menu image and options don't show up under the rest of the UI libtcod.console_set_default_background(0, libtcod.brass) libtcod.console_clear(0) new_game() play_game() elif choice == 1: try: libtcod.console_set_default_background(0, libtcod.brass) libtcod.console_clear(0) load_game() except: msgbox('\n No saved game to load!\n', 24) elif choice == 2: #Exit the program break;
def render_gui(): """ Renders just the gui. """ # Set globals. global turns, game_messages # Clear console before drawing on it. roguelib.console_set_default_background(console_gui, roguelib.black) roguelib.console_clear(console_gui) # Display health and energy bars for player. render_bar(console_gui, 1, 1, BAR_WIDTH, "HP", player.alive.hp, player.alive.maxhp, roguelib.dark_flame, roguelib.dark_grey, roguelib.white) render_bar(console_gui, 1, 3, BAR_WIDTH, "Energy", player.alive.energy, player.alive.maxenergy, roguelib.dark_green, roguelib.dark_grey, roguelib.white) # Prints number of turns and dungeon level on screen. roguelib.console_set_default_foreground(console_gui, eval(SETTING_DATA[b"Text Color"][b"COLOR"])) roguelib.console_print(console_gui, SCREEN_WIDTH - 15, 2, "Turns:" + str(turns)) roguelib.console_print(console_gui, SCREEN_WIDTH // 2, 2, "Depth:" + str(depth)) # Display messages in message box. y = 1 for (line, color) in game_messages: roguelib.console_set_default_foreground(console_message, color) roguelib.console_print_ex(console_message, 0, y, roguelib.BKGND_NONE, roguelib.LEFT, line) y += 1 # Blit contents of consoles to screen. roguelib.console_blit(console_gui, 0, 0, SCREEN_WIDTH, CONSOLE_GUI_HEIGHT, 0, 0, 0) roguelib.console_blit(console_message, 0, 0, SCREEN_WIDTH, MESSAGE_CONSOLE_HEIGHT, 0, 0, MESSAGE_CONSOLE_Y)
def draw_main_menu(con, has_file=False): tcod.console_set_default_foreground(con, COL_A) img = tcod.image_load('small.png') tcod.image_set_key_color(img, tcod.red) tcod.image_blit(img, 0, 45, 30, tcod.BKGND_LIGHTEN, .5, .25, 0) xx=-20 yy=15 can_cont = "" can_del = '' if has_file: can_cont = '-- (c)ontinue' can_del = '-- (D)elete' options=( """ GAME TITLE """+chr(tcod.CHAR_BLOCK2)+chr(tcod.CHAR_BLOCK1)+chr(tcod.CHAR_BLOCK1)+""" | | \t-- (n)ew game | \t--\t%s | | | \t%s | \t-- (esc)cape """ % (can_cont, can_del) ) tcod.console_print_ex(con, game.GAME_WIDTH/4+xx, game.GAME_HEIGHT/3+yy, tcod.BKGND_LIGHTEN, tcod.LEFT,options) tcod.console_print(con, 2, game.GAME_HEIGHT-2, 'oyyooyoyoyoyyooyoyoy') tcod.console_flush() tcod.console_clear(con)
def draw(self): """Draws borders around the info panel.""" libt.console_set_default_background(self.handler.gui, data.COLOURS['gui_bg']) libt.console_clear(self.handler.gui) upper_height = config.BORDER_WIDTH / 2 left_height = config.GUI_HEIGHT - upper_height*2 libt.console_set_default_background(self.handler.gui, data.COLOURS['gui_border']) # Upper border libt.console_rect(self.handler.gui, 0, 0, config.GUI_WIDTH, upper_height, False, libt.BKGND_SCREEN) # Lower border libt.console_rect(self.handler.gui, 0, config.GUI_HEIGHT - config.BORDER_WIDTH/2, config.GUI_WIDTH, upper_height, False, libt.BKGND_SCREEN) # Left border libt.console_rect(self.handler.gui, 0, upper_height, config.BORDER_WIDTH / 2, left_height, False, libt.BKGND_SCREEN) # Right border libt.console_rect(self.handler.gui, config.GUI_WIDTH - config.BORDER_WIDTH/2, upper_height, config.BORDER_WIDTH / 2, left_height, False, libt.BKGND_SCREEN) # Middle border libt.console_rect(self.handler.gui, (config.GUI_WIDTH - 1)/2 - config.BORDER_WIDTH/2, upper_height, config.BORDER_WIDTH, left_height, False, libt.BKGND_SCREEN) # Hover details libt.console_set_default_foreground(self.handler.gui, data.COLOURS['text']) libt.console_print_ex(self.handler.gui, (config.GUI_WIDTH - 1)/2, 0, libt.BKGND_NONE, libt.CENTER, self.objects_under_mouse())
def stat_menu(): """ | Shows a menu displaying the Player's Stats and a possibility to distribute EXP Points. | Derives from menu() """ libtcod.console_clear(gvar.window) text = 'Skills:\n\n' text2 = '' for skill in sorted(gvar.game.player.fighter.skills): text += ' ' + skill + '\n' text2 += str(gvar.game.player.fighter.skills[skill]) + '\n' menu_supplement(text, gvar.SCREEN_WIDTH/2, 2) menu_supplement(text2, gvar.SCREEN_WIDTH/2 + 15, 4) return menu('Character Sheet\n\nExperience: ' + str(gvar.game.player.exp) + '\n\nHealth Levels:' + '\n-0: ' + str(gvar.game.player.fighter.max_hl[0]) + '\n-1: ' + str(gvar.game.player.fighter.max_hl[1]) + '\n-2: ' + str(gvar.game.player.fighter.max_hl[2]) + '\n-4: ' + str(gvar.game.player.fighter.max_hl[3]) + '\n\nStrength: ' + str(gvar.game.player.fighter.strength) + '\nDexterity: ' + str(gvar.game.player.fighter.dexterity) + '\nStamina: ' + str(gvar.game.player.fighter.stamina) + '\n\nSoak (B/L): ' + str(gvar.game.player.fighter.bashing_soak()) + '/' + str(gvar.game.player.fighter.lethal_soak()) + '\nDodge DV: ' + str(gvar.game.player.fighter.dodgeDV()) + '\n\n\n\n\n\n\n\n\n\n\n\n', ['Distribute experience points'], gvar.SCREEN_WIDTH, libtcod.darker_grey, flush=False)
def renderAll(): global fovNeedsToBeRecomputed if fovNeedsToBeRecomputed: #If this is true, then we must recalculate the field of view and render the map. fovNeedsToBeRecomputed = False libtcod.map_compute_fov(fovMap, player.x, player.y, TORCH_RADIUS, FOV_LIGHT_WALLS, FOV_ALGO) #Iterate through the list of map tiles and set their background colors. for y in range(MAP_HEIGHT): for x in range(MAP_WIDTH): visible = libtcod.map_is_in_fov(fovMap, x, y) wall = map[x][y].blockSight if not visible: #If a tile is out of the player's field of view... if map[x][y].explored: #...it will only be drawn if the player has explored it if wall: libtcod.console_set_char_background(con, x, y, cDarkWall, libtcod.BKGND_SET) else: libtcod.console_set_char_background(con, x, y, cDarkGround, libtcod.BKGND_SET) else: #If a tile is in the player's field of view... if wall: libtcod.console_set_char_background(con, x, y, cLitWall, libtcod.BKGND_SET) else: libtcod.console_set_char_background(con, x, y, cLitGround, libtcod.BKGND_SET) map[x][y].explored = True #Draw all objects in the list, except the player, which needs to be drawn last. 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 status panel. libtcod.console_set_default_background(panel, libtcod.black) libtcod.console_clear(panel) #Print the message log, one line at a time. y = 1 for (line, color) in messageLog: libtcod.console_set_default_foreground(panel, color) libtcod.console_print_ex(panel, MESSAGE_X, y, libtcod.BKGND_NONE, libtcod.LEFT, line) y += 1 #Show the player's stats renderStatusBar(1, 1, BAR_WIDTH, "Health", player.fighter.cond, player.fighter.hits, libtcod.red, libtcod.darkest_red) libtcod.console_print_ex(panel, 1, 3, libtcod.BKGND_NONE, libtcod.LEFT, "Dungeon Level: " + str(dungeonLevel)) #Display the names of objects under the mouse cursor. libtcod.console_set_default_foreground(panel, libtcod.light_gray) libtcod.console_print_ex(panel, 1, 0, libtcod.BKGND_NONE, libtcod.LEFT, getNamesUnderMouse()) #Blit the contents of panel to the root console. libtcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0, PANEL_Y)
def display(self, console): libtcod.console_clear(console) self.display_string(console, 1, self.menu.current_branch.label) i = 3 for item in self.menu.current_branch.children: i = i + 1 self.display_string(console, i, item.label)
def admin_menu(): """ Shows an admin menu fpr debugging purposes """ libtcod.console_clear(gvar.window) menu_supplement("Current Dungeon: " + str(gvar.game.player.currentmap().owner.id), 2, gvar.SCREEN_HEIGHT-2) choice = menu('Admin Menu', ['Toggle FOV'], gvar.SCREEN_WIDTH, libtcod.desaturated_red, flush=False) if choice == 0: gvar.admin.light_all = False if gvar.admin.light_all else True
def renderAll(objects, player, con, panel, infobar): # draw objects without actors first for object in objects: if not object.actor: object.graphic.draw(con) for object in objects: if object.actor: object.graphic.draw(con) libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, GAME_HEIGHT, 0, 0, GAME_Y) # do panel stuff libtcod.console_set_default_background(panel, PANEL_BACKGROUND_COLOUR) libtcod.console_clear(panel) # print the current game message libtcod.console_set_default_foreground(panel, getMessageColour()) libtcod.console_print_rect(panel, 1, 1, SCREEN_WIDTH-1, PANEL_HEIGHT, getMessage()) # blit the panel to the screen libtcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0, PANEL_Y) # do info bar stuff libtcod.console_set_default_background(infobar, INFO_BAR_BACKGROUND_COLOUR) libtcod.console_clear(infobar) # print their current money and the time libtcod.console_set_default_foreground(infobar, getMoneyColour(player.actor.money)) libtcod.console_print_rect(infobar, SCREEN_WIDTH/2 - 3, 0, SCREEN_WIDTH, INFO_BAR_HEIGHT, "$"+str(player.actor.money)) libtcod.console_set_default_foreground(infobar, getTimeColour()) libtcod.console_print_rect(infobar, SCREEN_WIDTH/2 + 3, 0, SCREEN_WIDTH, INFO_BAR_HEIGHT, getTimeString()) libtcod.console_blit(infobar, 0, 0, SCREEN_WIDTH, INFO_BAR_HEIGHT, 0, 0, INFO_BAR_Y)
def main_menu(): img = libtcod.image_load('title.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.black) libtcod.console_print_ex(0, SCREEN_WIDTH / 2, int(SCREEN_HEIGHT * .75), libtcod.BKGND_NONE, libtcod.CENTER, 'WizRL') libtcod.console_print_ex(0, SCREEN_WIDTH / 2, int(SCREEN_HEIGHT * .75) + 2, libtcod.BKGND_NONE, libtcod.CENTER, 'By Dragyn') # 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 libtcod.console_clear(0) 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 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) # prepare to render the GUI console libtcod.console_set_default_background(panel, libtcod.black) libtcod.console_clear(panel) # 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) # 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 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 GUI to screen libtcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0, PANEL_Y)
def splashScreen(console): libtcod.console_set_default_background(console, SPLASH_BACKGROUND_COLOUR) libtcod.console_clear(console) done = False counter = 0 blinkOn = True blinkSpeed = 10 while not done and not libtcod.console_is_window_closed(): key = libtcod.console_check_for_keypress(True) if not key.vk == libtcod.KEY_NONE: done = True #print the splash messages libtcod.console_set_default_foreground(console, SPLASH_FOREGROUND_COLOUR1) libtcod.console_print_rect(console, 4, 5, SCREEN_WIDTH, SCREEN_HEIGHT, "SWORD SHOP") libtcod.console_set_default_foreground(console, SPLASH_FOREGROUND_COLOUR2) libtcod.console_print_rect(console, 4, 8, SCREEN_WIDTH, SCREEN_HEIGHT, "by luke david\n fitzpatrick") if(blinkOn): libtcod.console_set_default_foreground(console, SPLASH_FOREGROUND_COLOUR3) libtcod.console_print_rect(console, 16, 13, SCREEN_WIDTH, SCREEN_HEIGHT, "press any key") # blit the panel to the screen libtcod.console_blit(console, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT-(2*6), 0, 0, 6) libtcod.console_flush() counter += 1 if counter >= blinkSpeed: counter = 0 blinkOn = not blinkOn libtcod.console_clear(console)
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: fov_recompute = False libtcod.map_compute_fov(fov_map, player.x, player.y, TORCH_RADIUS, FOV_LIGHT_WALLS, FOV_ALGO) for y in range(MAP_HEIGHT): for x in range(MAP_WIDTH): visible = libtcod.map_is_in_fov(fov_map, x, y) tile = map[x][y].sort if not visible: if map[x][y].explored: if tile == 'wall': libtcod.console_set_back(con, x, y, color_dark_wall, libtcod.BKGND_SET) elif tile == 'metal1': libtcod.console_set_back(con, x, y, color_dark_metal1, libtcod.BKGND_SET) elif tile == 'metal2': libtcod.console_set_back(con, x, y, color_dark_metal2, libtcod.BKGND_SET) else: libtcod.console_set_back(con, x, y, color_dark_ground, libtcod.BKGND_SET) else: if tile == 'wall': libtcod.console_set_back(con, x, y, color_light_wall, libtcod.BKGND_SET) elif tile == 'metal1': libtcod.console_set_back(con, x, y, color_light_metal1, libtcod.BKGND_SET) elif tile == 'metal2': libtcod.console_set_back(con, x, y, color_light_metal2, libtcod.BKGND_SET) else: libtcod.console_set_back(con, x, y, color_light_ground, libtcod.BKGND_SET) map[x][y].explored = True for object in objects: if object != player: object.draw() player.draw() libtcod.console_blit(con, 0, 0, MAP_WIDTH, MAP_HEIGHT, 0, 0, 0) libtcod.console_set_background_color(panel, libtcod.black) libtcod.console_clear(panel) y = 1 for (line, color) in game_msgs: libtcod.console_set_foreground_color(panel, color) libtcod.console_print_left(panel, MSG_X, y, libtcod.BKGND_NONE, line) y += 1 render_bar(1, 1, BAR_WIDTH, 'John\'s Oxygen', player.spaceman.oxygen, player.spaceman.max_oxygen, libtcod.light_red, libtcod.darker_red) render_bar(1, 3, BAR_WIDTH, 'Adam\'s Oxygen', npc.spaceman.oxygen, npc.spaceman.max_oxygen, libtcod.light_magenta, libtcod.darker_magenta) libtcod.console_set_foreground_color(panel, libtcod.light_gray) libtcod.console_print_left(panel, 1, 0, libtcod.BKGND_NONE, get_names_under_mouse()) libtcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0, PANEL_Y) for object in objects: object.clear()
def main_menu(): libtcod.console_flush() while not libtcod.console_is_window_closed(): libtcod.console_clear(con) libtcod.console_blit(con,0,0,game.screen_width,game.screen_height,0,0,0) # Show the title, credits etc libtcod.console_set_default_foreground(0, libtcod.light_yellow) libtcod.console_print_ex(0,game.screen_width/2,game.screen_height/2-4, libtcod.BKGND_NONE, libtcod.CENTER, game.name) libtcod.console_print_ex(0,game.screen_width/2, game.screen_height-2,libtcod.BKGND_NONE, libtcod.CENTER, game.author + '2013') # Show options and wait for player's choice choice = menu('',['Play a new game', 'Continue from last game', 'Quit'], 30) if choice == 0: # new game new_game() play_game() elif choice == 1: # load game try: load_game() except: msgbox('\n No saved game to load.\n', 30) continue play_game() elif choice == 2: # quit break
def new_game(): Game.state = 'playing' Game.dungeon_level = 1 Game.game_msgs = [] Game.mouse = libtcod.Mouse() Game.key = libtcod.Key() Game.inventory = [] Game.panel = libtcod.console_new(Game.SCREEN_WIDTH, Game.PANEL_HEIGHT) Game.map = Map(Game.MAP_WIDTH, Game.MAP_HEIGHT) libtcod.console_clear(Game.main_console) _fighter_component = Components.Fighter( hp=100, dexterity=4, accuracy=20, power=4, xp=0, death_function=Components.player_death) Game.player = Object(Game.map.origin[0], Game.map.origin[1], '@', 'Drew', libtcod.pink, blocks=True, fighter=_fighter_component) Game.player.level = 1 Game.map.add_object(Game.player) _equipment_component = Equipment(slot='right hand', power_bonus=2) _obj = Object(0, 0, '-', 'dagger', libtcod.sky, equipment=_equipment_component) Game.inventory.append(_obj) _equipment_component.equip() Game.message( 'Welcome stranger! Prepare to perish in the Tombs of the Ancient Kings.', libtcod.light_green)
def enter_player_name(screen_width, screen_height): letters = [ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' ] name = '' x = len(name) + int(screen_width / 2 - 11) + 10 y = int(screen_height / 2) + 1 key = libtcod.console_wait_for_keypress(True) while True: if key.vk == libtcod.KEY_BACKSPACE: if len(name) >= 0: name = name[0:len(name) - 1] libtcod.console_print_ex(0, x, y, libtcod.BKGND_NONE, libtcod.LEFT, ' ') libtcod.console_flush() else: letter = chr(key.c) for item in letters: if letter == item: if len(name) <= 12: name = name + letter #add to the string if len(name) == 1: name = name.capitalize() letter = letter.capitalize() #libtcod.console_set_char(0, x, y, letter) #print new character at appropriate position on screen libtcod.console_print_ex(0, x, y, libtcod.BKGND_NONE, libtcod.LEFT, letter) libtcod.console_set_default_foreground( 0, libtcod.white) #make it white or something libtcod.console_flush() break x = len(name) + int(screen_width / 2 - 11) + 10 key = libtcod.console_wait_for_keypress(True) if key.vk == libtcod.KEY_ESCAPE: libtcod.console_clear(0) libtcod.console_flush() return None elif len(name) > 0 and key.vk == libtcod.KEY_ENTER: return name
def get_user_input(self, x, y): ''' Getting user to type something in ''' mouse = libtcod.Mouse() key = libtcod.Key() player_input = '' key_pressed = '' while not key_pressed == libtcod.KEY_ENTER: # Clear console, print the current iteration of string, and blit self.clear() libtcod.console_print(self.con, x, y, '>> %s_' % player_input) self.blit() libtcod.console_flush() #key = libtcod.console_wait_for_keypress(True) event = libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS | libtcod.EVENT_MOUSE, key, mouse) #key_pressed = get_key(key) if key.vk == libtcod.KEY_CHAR: key_pressed = chr(key.c) else: key_pressed = key.vk # Handle special keypresses if key_pressed == libtcod.KEY_SPACE: key_pressed = ' ' elif key_pressed == libtcod.KEY_BACKSPACE and len(player_input) > 0: key_pressed = '' player_input = player_input[0:len(player_input) - 1] libtcod.console_clear(self.con) libtcod.console_flush() elif key_pressed == libtcod.KEY_ENTER: break # Try to add keypress to thing if isinstance(key_pressed, str): player_input += key_pressed return player_input
def inspect_item_menu(con, header, item, menu_width, menu_height, screen_width, screen_height): y = 0 window = libtcod.console_new(menu_width, menu_height) libtcod.console_set_default_background(window, libtcod.darkest_blue) libtcod.console_set_default_foreground(window, libtcod.white) libtcod.console_clear(window) libtcod.console_print_rect_ex(window, 0, y, menu_width, menu_height, libtcod.BKGND_NONE, libtcod.LEFT, '{0}'.format(item.name)) y += 2 libtcod.console_print_rect_ex(window, 0, y, menu_width, menu_height, libtcod.BKGND_NONE, libtcod.LEFT, '{0}'.format(item.item.description)) x = screen_width // 2 - menu_width // 2 y = screen_height // 2 - menu_height // 2 libtcod.console_blit(window, 0, 0, menu_width, menu_height, 0, x, y, 1.0, 1.0)
def display_status(self, state, console): tcod.console_clear(console.console) if self.status.pause: display_text(console.console, "*PAUSED*", 0, 0) display_text(console.console, str(tcod.sys_get_fps()), 10, 0) display_text(console.console, self.status.current_state, 15, 0) cash_display = 'Cash: %s' % self.status.money display_text(console.console, cash_display, 50, 0) if self.status.last_money_movement: color = tcod.red to_display = str(self.status.last_money_movement) if self.status.last_money_movement > 0: color = tcod.yellow to_display = '+ %s' % to_display display_text(console.console, to_display, 52 + len(cash_display), 0, color) self.status.delta_increment() for idx, f in enumerate(self.status.flags): display_highlighted_text(console.console, f, console.w - idx - 1, 0)
def play_game(): # clear the root console (Clears the startup images) tcod.console_clear(0) settings.mouse = tcod.Mouse() settings.key = tcod.Key() settings.highlight_xy = (settings.player.x, settings.player.y) # MAIN LOOP while not tcod.console_is_window_closed(): handle_rendering_tasks() check_level_up() settings.player_action = input_controller(settings.game_state) if settings.player_action == 'exit' and settings.game_state == 'playing': settings.save_game() break elif settings.player_action == 'exit': settings.game_state = 'playing' settings.highlight_state = 'play'
def next_floor(self, player, message_log, constants): self.dungeon_level += 1 entities = [player] self.tiles = self.initialize_tiles() self.make_map(constants['max_rooms'], constants['room_min_size'], constants['room_max_size'], constants['max_maze_rooms'], constants['maze_min_size'], constants['maze_max_size'], constants['map_width'], constants['map_height'], player, entities) libtcod.console_flush() libtcod.console_clear(constants) player.fighter.heal(player.fighter.max_hp // 2) message_log.add_message( Message('You take a moment to rest, and recover your strength.', libtcod.light_violet)) return entities
def draw(self): libtcod.console_clear(self.console) for y in range(len(self.entity_manager.world_tiles)): for x in range(len(self.entity_manager.world_tiles[y])): self.draw_world_tile( x, y, self.entity_manager.world_tiles[x][y]['tile']) #handy thing about this is it should help farther down the line when I go to implement FOV render_data = [] for id, entity in self.entity_manager.entities.iteritems(): if entity.get_attribute(AttributeTag.Visible): position_info = entity.get_attribute( AttributeTag.WorldPosition) if not position_info: raise LookupError( 'entity ' + str(entity) + ' is flagged as visible, but does not have any world position' ) draw_info = entity.get_attribute(AttributeTag.DrawInfo) if not draw_info: raise LookupError( 'entity ' + str(entity) + ' is flagged as visible, but does not have any draw info' ) render_data.append({ 'draw_type': draw_info.data['draw_type'], 'z_level': draw_info.data['z_level'], 'entity': entity }) #z-sort the entities we're rendering so that things like world tiles can be drawn behind entities on those tiles render_data.sort( lambda data, other: cmp(data['z_level'], other['z_level'])) for to_render in render_data: if to_render['draw_type'] in render_type_dict: render_type_dict[to_render['draw_type']](self, to_render['entity']) libtcod.console_blit(self.console, 0, 0, self.width, self.height, 0, self.world_x_start, self.world_y_start)
def show_target(cursor, mouse, key, map_width, map_height, targeting_item): """Show target and impact radius (when applicable).""" (x, y) = (mouse.cx, mouse.cy) # Check if item component has a radius defined item_component = targeting_item.item radius = item_component.function_kwargs.get('radius') libtcod.console_clear(cursor) #libtcod.console_set_key_color(cursor, libtcod.black) if radius: for a in range(x - radius, x + radius + 1): for b in range(y - radius, y + radius + 1): libtcod.console_set_char_background(cursor, a, b, targeting_item.color) else: libtcod.console_set_char_background(cursor, x, y, libtcod.lightest_grey) libtcod.console_blit(cursor, 0, 0, map_width, map_height, 0, 0, 0, 1.0, 0.5)
def render_all(self, game): libtcod.console_clear(self.game_area) libtcod.console_blit(self.game_area, 0, 0, self.game_width, self.game_height, self.root_console, 0, 0) game.game_state.handle_video(game) libtcod.console_set_default_background(self.bottom_bar, libtcod.darker_grey) libtcod.console_clear(self.bottom_bar) for index, message in enumerate( self.message_log.on_screen_message_list): libtcod.console_set_default_foreground(self.bottom_bar, message.color) libtcod.console_print_ex(self.bottom_bar, self.message_log.x, index + 1, libtcod.BKGND_NONE, libtcod.LEFT, message.text) libtcod.console_blit(self.bottom_bar, 0, 0, self.bottom_bar_width, self.bottom_bar.height, self.root_console, 0, self.game_height) libtcod.console_flush()
def render_panel(self, map_scale, mouse): if self.render: libtcod.console_set_default_background(self.con, self.backcolor) libtcod.console_set_default_foreground(self.con, self.frontcolor) libtcod.console_clear(self.con) self.draw_box(0, self.width-1, 0, self.height-1, self.frontcolor) self.render_text_func(*self.render_text_args) ## "General" buttons for button in self.gen_buttons: button.display(mouse) # Specific to worldmap ( TODO - fix.... ) if map_scale == 'world': for button in self.wmap_dynamic_buttons + self.wmap_buttons: button.display(mouse) elif map_scale == 'human': for button in self.bmap_dynamic_buttons + self.bmap_buttons: button.display(mouse)
def city_production_menu(): width, height = R.MAP_VIEW_WIDTH - 4, R.MAP_VIEW_HEIGHT - 4 city_select_pop = libtcod.console_new(width, height) selected_city = None limit = len(cities) - 1 pos_x = R.MAP_VIEW_WIDTH / 2 - width / 2 pos_y = R.MAP_VIEW_HEIGHT / 2 - height / 2 for a in range(R.MAP_VIEW_WIDTH - 4): #clear screen, colour dark grey, every cycle for b in range(R.MAP_VIEW_HEIGHT - 4): #libtcod.console_print_rect(window, a, b, libtcod.console_print_rect_ex(city_select_pop, a, b, R.MAP_VIEW_WIDTH - 4, R.MAP_VIEW_HEIGHT - 4, libtcod.BKGND_NONE, libtcod.LEFT, " ") libtcod.console_blit(city_select_pop, 0, 0, width, height, 0, pos_x, pos_y, 1.0, 0.9) libtcod.console_flush() offset = 0 while True: libtcod.console_clear(city_select_pop) libtcod.console_set_default_foreground(city_select_pop, libtcod.yellow) libtcod.console_set_default_foreground(city_select_pop, libtcod.light_yellow) #city_length = len(cities) for city in range(len(cities)): # picks the smaller of the two. location = cities[city] resources = "\n" for resource in location.producing: supply_demand = location.trade_house.supply_demand[resource] resources += resource + " " + str(location.producing[resource][1]) + " \t " + str( supply_demand[0]) + " " + str(supply_demand[1]) + ", " + str(supply_demand[2]) + "\n" libtcod.console_print_ex(city_select_pop, 1, 1 + offset, libtcod.BKGND_NONE, libtcod.LEFT, location.name + " " + resources) offset += 6 libtcod.console_blit(city_select_pop, 0, 0, width, height, 0, pos_x, pos_y, 1.0, 0.9) libtcod.console_flush() key = libtcod.console_wait_for_keypress(True) if key.vk == libtcod.KEY_ENTER or key.vk == libtcod.KEY_BACKSPACE or key.vk == libtcod.KEY_ESCAPE: break
def render_panel(): global game_msgs #Render the information panel on the right side of the screen #Clear the panel ready to render libtcod.console_set_default_background(panel, libtcod.black) libtcod.console_clear(panel) #Render the HP bar render_bar(1, 1, PANEL_WIDTH - 2, 'HP', data.player.creature.hp, data.player.creature.max_hp, libtcod.red, libtcod.dark_red) #Render the stamina bar render_bar(1, 3, PANEL_WIDTH - 2, 'STA', data.player.creature.stamina, data.player.creature.max_stamina, libtcod.blue, libtcod.dark_blue) #Show the player stats libtcod.console_set_default_foreground(panel, libtcod.white) stats = [ 'STR: ' + str(data.player.creature.strength), 'TOU: ' + str(data.player.creature.toughness), 'DEX: ' + str(data.player.creature.dexterity) ] y = 5 for line in stats: libtcod.console_print_ex(panel, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, line) y += 1 #Write the game messages y = 0 for line, color in game_msgs: libtcod.console_set_default_foreground(panel, color) libtcod.console_print_ex(panel, 0, PANEL_HEIGHT - MSG_HEIGHT + y, libtcod.BKGND_NONE, libtcod.LEFT, line) y += 1 libtcod.console_blit(panel, 0, 0, PANEL_WIDTH, PANEL_HEIGHT, 0, MAP_WINDOW_WIDTH, 0)
def render_messages(Player): libtcod.console_set_default_foreground(var.MessagePanel, var.TextColor) libtcod.console_set_default_background(var.MessagePanel, libtcod.black) libtcod.console_clear(var.MessagePanel) if len(var.MessageHistory) > 10: s = len(var.MessageHistory) - 10 else: s = 0 y = 0 if Player != None: diff = int(math.ceil( Player.getMoveAPCost())) # This makes messages colored else: # even if player needs more than diff = 1 # Otherise, use 1 turn. # one turn to move due to burden # or lost limbs. while y <= var.PanelHeight: try: (line, color, turn) = var.MessageHistory[s] if turn >= (var.TurnCount - diff): # Turn count increases before redrawing # screen, so here we need T - 1 for color. libtcod.console_set_default_foreground(var.MessagePanel, color) else: libtcod.console_set_default_foreground(var.MessagePanel, libtcod.darker_grey) libtcod.console_print_ex(var.MessagePanel, 1, y, libtcod.BKGND_NONE, libtcod.LEFT, line) except: break y += 1 s += 1 # Render messages: libtcod.console_blit(var.MessagePanel, 0, 0, var.ScreenWidth - var.PanelWidth, var.PanelHeight, 0, 0, var.ScreenHeight - var.PanelHeight)
def render_all(): global fov_map, color_dark_wall, color_lit_wall global color_dark_floor, color_lit_floor global fov_recompute if fov_recompute: #recompute FOV is needed ( after player movement etc ) fov_recompute = False libtcod.map_compute_fov(fov_map, player.x, player.y, TORCH_RADIUS, FOV_LIGHT_WALLS, FOV_ALGO) render_map() #draw all objects in the list for object in objects: if object != player: object.draw() player.draw() #blits content of offscreen console to root console libtcod.console_blit(con, 0, 0, MAP_WIDTH, MAP_HEIGHT, 0, 0, 0) #prepare to render the gui log panel libtcod.console_set_default_background(log_panel, libtcod.black) libtcod.console_clear(log_panel) print_msg_log() #PLAYER STAT BARS #HP render_bar(1, 3, BAR_WIDTH, log_panel, "BLOOD", player.fighter.hp, player.fighter.max_hp, libtcod.darker_red, libtcod.darkest_red) #HUNGER render_bar(1, 5, BAR_WIDTH, log_panel, 'HNGR', player.needs.hunger, player.needs.max_hunger, libtcod.grey, libtcod.desaturated_red) #THIRST render_bar(1, 7, BAR_WIDTH, log_panel, 'THRST', player.needs.thirst, player.needs.max_thirst, libtcod.light_blue, libtcod.desaturated_blue) #blit the contents of log panel to root console libtcod.console_blit(log_panel, 0, 0, SCREEN_WIDTH, LOG_PANEL_HEIGHT, 0, 0, LOG_PANEL_Y)
def draw(first): global fov_px, fov_py, fov_map global fov_init, fov_recompute, smap if first: #initialize the window and libtcod.console_clear(0) libtcod.console_set_default_foreground(0, libtcod.white) text = 'what?' libtcod.console_print_ex(0, 1, 1, libtcod.BKGND_NONE, libtcod.LEFT, text) libtcod.console_put_char(0, fov_px, fov_py, '@', libtcod.BKGND_NONE) for y in range(window_height): for x in range(window_width): if smap[y][x] == '=': libtcod.console_put_char(0, x, y, libtcod.CHAR_DHLINE, libtcod.BKGND_NONE) if not fov_init: fov_init = True fov_map = libtcod.map_new(window_width, window_height) for y in range(window_height): for x in range(window_width): if smap[y][x] == ' ': libtcod.map_set_properties(fov_map, x, y, True, True) elif smap[y][x] == '=': libtcod.map_set_properties(fov_map, x, y, True, False) if fov_recompute: fov_recompute = False libtcod.map_compute_fov(fov_map, fov_px, fov_py, fov_radius, True) for y in range(window_height): # color in the map for x in range(window_width): affect, cell = 'dark', 'ground' if libtcod.map_is_in_fov(fov_map, x, y): affect = 'light' if (smap[y][x] == '#'): cell = 'wall' color = fov_colors['%s %s' % (affect, cell)] libtcod.console_set_char_background(0, x, y, color, libtcod.BKGND_SET)
def render_gui(): """ Renders just the gui. """ # Set globals. global turns, game_messages # Clear console before drawing on it. roguelib.console_set_default_background(console_gui, roguelib.black) roguelib.console_clear(console_gui) # Display health and energy bars for player. render_bar(console_gui, 1, 1, BAR_WIDTH, "HP", player.alive.hp, player.alive.maxhp, roguelib.dark_flame, roguelib.dark_grey, roguelib.white) render_bar(console_gui, 1, 3, BAR_WIDTH, "Energy", player.alive.energy, player.alive.maxenergy, roguelib.dark_green, roguelib.dark_grey, roguelib.white) # Prints number of turns and dungeon level on screen. roguelib.console_set_default_foreground( console_gui, eval(SETTING_DATA[b"Text Color"][b"COLOR"])) roguelib.console_print(console_gui, SCREEN_WIDTH - 15, 2, "Turns:" + str(turns)) roguelib.console_print(console_gui, SCREEN_WIDTH // 2, 2, "Depth:" + str(depth)) # Display messages in message box. y = 1 for (line, color) in game_messages: roguelib.console_set_default_foreground(console_message, color) roguelib.console_print_ex(console_message, 0, y, roguelib.BKGND_NONE, roguelib.LEFT, line) y += 1 # Blit contents of consoles to screen. roguelib.console_blit(console_gui, 0, 0, SCREEN_WIDTH, CONSOLE_GUI_HEIGHT, 0, 0, 0) roguelib.console_blit(console_message, 0, 0, SCREEN_WIDTH, MESSAGE_CONSOLE_HEIGHT, 0, 0, MESSAGE_CONSOLE_Y)
def doMenu(self): tcod.console_set_foreground_color(0, tcod.white) selectedLine = 1 while True: tcod.console_clear(0) index = 1 for mode, name in self.options: tcod.console_print_left(0, self.MENU_LEFT + 2, self.MENU_TOP + index, tcod.BKGND_NONE, name) if (selectedLine == index): self._selection = mode tcod.console_put_char(0, self.MENU_LEFT + 1, self.MENU_TOP + index, '>') index += 1 tcod.console_flush() # Get Input key = tcod.console_wait_for_keypress(True) if (key.vk == tcod.KEY_DOWN): selectedLine += 1 if (selectedLine > len(self.options)): selectedLine = 1 elif (key.vk == tcod.KEY_UP): selectedLine -= 1 if (selectedLine <= 0): selectedLine = len(self.options) if (key.vk == tcod.KEY_ENTER): return self._selection
def render_panel(msgs, panel): y = 1 libtcod.console_clear(panel) for msg in msgs: libtcod.console_set_default_background(panel, libtcod.black) libtcod.console_set_default_foreground(panel, msg[1]) libtcod.console_print_ex(panel, 2, y, libtcod.BKGND_NONE, libtcod.LEFT, msg[0]) libtcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0, PANEL_Y) y = y + 1 global move_count if move_count != 0: libtcod.console_set_default_background(panel, libtcod.black) libtcod.console_set_default_foreground(panel, libtcod.sky) libtcod.console_print_ex(panel, 70, 1, libtcod.BKGND_NONE, libtcod.LEFT, "Move count: " + str(move_count)) libtcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0, PANEL_Y)
def render_all(gldir, camera, panel, con): if gldir.fov_recompute: gldir.fov_recompute = False libtcod.map_compute_fov(gldir.fov_map, gldir.player.x, gldir.player.y, TORCH_RADIUS, FOV_LIGHT_WALLS, FOV_ALGO) camera.camera_render() for obj in gldir.game_objs: if obj.in_camera(): obj.draw() gldir.player.draw() for obj in gldir.game_objs: if obj.name == 'targeter': obj.draw() #blits the content of the 'con' console to the root console libtcod.console_blit(con, 0, 0, CAMERA_WIDTH, CAMERA_HEIGHT, 0, 0, 0) libtcod.console_set_default_background(panel, libtcod.black) libtcod.console_clear(panel) #print game messages, one line at a time y = 1 for (line, color) in gldir.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 render_bar(1, 1, BAR_WIDTH, 'Health', gldir.player.fighter.hp, gldir.player.fighter.max_hp, libtcod.dark_red, libtcod.darkest_red, panel) # display health libtcod.console_print_ex(panel, 1, 3, libtcod.BKGND_NONE, libtcod.LEFT, 'Dungeon level ' + str(gldir.dungeon_level)) #display dungeon level #blits the content of the 'panel' console to the root console libtcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0, PANEL_Y)
def main_menu(): #Set up the main menu, which is presented to the player when they first load the game img = libtcod.image_load('images/menu_background1.png') while not libtcod.console_is_window_closed(): #Show the image at twice its usual resolution of the console libtcod.image_blit_2x(img, 0, SCREEN_WIDTH / 6, SCREEN_HEIGHT / 6) #Show the games 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, 'DUNGEONCRAWLER') libtcod.console_print_ex(0, SCREEN_WIDTH / 2, SCREEN_HEIGHT - 2, libtcod.BKGND_NONE, libtcod.CENTER, 'By Jeremy Cerise') #Show menu options and wait for the players choice choice = menu('', ['Play a new game', 'Continue last game', 'Quit'], 24) if choice == 0: #Start a new game #Clear the base conosle, so the menu image and options don't show up under the rest of the UI libtcod.console_set_default_background(0, libtcod.brass) libtcod.console_clear(0) new_game() play_game() elif choice == 1: try: libtcod.console_set_default_background(0, libtcod.brass) libtcod.console_clear(0) load_game() except: msgbox('\n No saved game to load!\n', 24) elif choice == 2: #Exit the program break
def update_info_bar(): #TODO: seperate the UI updating into THIS function. the rest of the game updates in the render_all. # Fetch all the code into this function basically. #TODO: make a function for the ui to prin a message in this area. Possibly with choices whether to wipe it first or add to it. libtcod.console_clear(inf) y = 2 if len(selected) > 0: for sel in selected: libtcod.console_print_ex(inf, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, sel.name) libtcod.console_print_ex(inf, 0, y + 1, libtcod.BKGND_NONE, libtcod.LEFT, sel.type) y += 2 try: if sel.component.trade_house: libtcod.console_print_ex( inf, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, sel.char) resources = [obj + " " + str(sel.component.resources[obj][1]) for obj in sel.component.resources] resources = "\n".join(resources) libtcod.console_print_ex(inf, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, resources) y += 1 except: libtcod.console_print_ex(inf, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, sel.char) y += 4 for (line, colour) in test_msgs: libtcod.console_set_default_foreground(inf, colour) libtcod.console_print_ex(inf, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, line) y += 1 # y = 1 # for (line, colour) in test_msgs: # libtcod.console_set_default_foreground(inf, colour) # libtcod.console_print_ex(inf, 2, y, libtcod.BKGND_NONE, libtcod.LEFT, line) # y += 1 libtcod.console_blit(inf, 0, 0, R.INFO_BAR_WIDTH, R.SCREEN_HEIGHT, 0, R.MAP_VIEW_WIDTH, 0) libtcod.console_flush()
def DrawScreen(gameState): libtcod.console_clear(0) # ---- Eventually this needs to take into account the window of view you have. # ---- Get the player's current location x, y = gameState.Player.GetLocation() # ---- Eventually take into account some theoretical maximum map size, but meh. # ---- Use the player's current location to determine the visible window. visibleOffsetX = (VISIBLE_MAP_WIDTH / 2) - x # the `- 10` makes the action take player higher to the top of the screen. visibleOffsetY = (VISIBLE_MAP_HEIGHT / 2) - y - 10 drawTiles(gameState.Map, visibleOffsetX, visibleOffsetY) drawTrains(gameState.Trains, gameState.Player, visibleOffsetX, visibleOffsetY) drawPlayers(gameState.Player, visibleOffsetX, visibleOffsetY) drawUi(gameState) libtcod.console_flush()
def build(self): #print 'built!' libtcod.console_set_default_foreground(self.console, self.get_color()) libtcod.console_set_default_background(self.console, self.get_bk_color()) libtcod.console_print_frame(self.console, 0, 0, self.width, self.height, True, libtcod.BKGND_SET, self.id) temp = libtcod.console_new(self.width - 2, self.height - 2) y = 1 if self.vertical: for elem in self.content: libtcod.console_clear(temp) elem.build(temp) height = elem.height libtcod.console_blit(temp, 0, 0, elem.width, elem.height, self.console, 1, y) y += height
def show_stats(player, inventory, score): global game_msgs #prepare to render the GUI panel libtcod.console_set_default_background(gui_con, libtcod.black) libtcod.console_clear(gui_con) #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) #print the game messages, one line at a time y = 1 for (line, color) in game_msgs: libtcod.console_set_default_foreground(gui_con, color) libtcod.console_print_ex(gui_con, MSG_X, y, libtcod.BKGND_NONE, libtcod.LEFT, line) y += 1 #calculate toy and candy count toys = 0 candy = 0 for thing in inventory: if thing.item.type == 'candy': candy += 1 elif thing.item.type == 'toy': toys += 1 libtcod.console_set_default_foreground(gui_con, libtcod.white) libtcod.console_print_ex(gui_con, 1, 3, libtcod.BKGND_NONE, libtcod.LEFT, 'Toys: ' + str(toys) + ' Candy: ' + str(candy)) libtcod.console_print_ex(gui_con, 1, 4, libtcod.BKGND_NONE, libtcod.LEFT, 'Score: ' + str(score)) #blit the contents of "panel" to the root console libtcod.console_blit(gui_con, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0, PANEL_Y)
def castBanish(spell, targetList, game_msgs, context): messagePrinter('Left click to select your target', game_msgs) target = target_monster(context[0], context[1], context[2], context[3], context[4], context[5], context[6]) maxDist = BANISH_MULTIPLIER * spell.effectMultiplier #TODO: handle the fact that the spell might be enhanced by nouns #ex: "banish orc" should increase the range but affect orcs only #here we should re-render the map so we can see where to put them messagePrinter('Left click to select the location to banish them to', game_msgs) messagePrinter( 'The spell can banish up to a maximum of ' + str(maxDist) + ' squares', game_msgs) context[3].fighter.casting = -1 #one-shot - always stop casting (x, y) = target_tile(context[0], context[1], context[2], context[3], context[4], context[5], context[6]) if x is not None: dx = x - target.x dy = y - target.y if (target is not None) and (dx < maxDist) and (dy < maxDist): targetList.append(target) messagePrinter('Banishing: ' + target.name, game_msgs) if target.fighter.hp > 0: target.move(x - target.x, y - target.y) libtcod.console_clear(con) else: messagePrinter('Target location is too far!', game_msgs) context[3].fighter.casting = -1 return 'No target' else: return 'No target'
def menu(con, header, background_color, options, width, screen_width, screen_height, ordered=True): 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) 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_background(window, background_color) libtcod.console_set_default_foreground(window, libtcod.white) libtcod.console_clear(window) libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header) if ordered: # 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 else: # Print all the options y = header_height for option_text in options: libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, option_text) y += 1 # Blit the contents of "window" to the root console x = int(screen_width / 2 - width / 2) y = int(screen_height / 2 - height / 2) libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 1.0)
def draw(self): libtcod.console_clear(self.console) libtcod.console_set_default_background(self.console, libtcod.Color(255, 0, 255)) libtcod.console_rect(self.console, 0, 0, self.width, self.height, libtcod.BKGND_SET) libtcod.console_set_default_background(self.console, libtcod.black) libtcod.console_set_alignment(self.console, libtcod.LEFT) current_height = 0 for line in self.console_command_history: libtcod.console_print(self.console, 0, current_height, line) current_height += 1 if self.input_enabled: libtcod.console_print( self.console, 0, current_height, self.prompt_string + self.input_command + self.blinking_cursor) libtcod.console_vline(self.console, self.width - 1, 0, self.height) libtcod.console_blit(self.console, 0, 0, self.width, self.height, 0, 0, self.root_console_height - self.height)
def render(console): global entities, player, fov_recompute while (True): # Refreshes the screen tcod.console_set_default_background(console, tcod.black) tcod.console_clear(console) if fov_recompute: recompute_fov(fov_map, player.x, player.y, fov_radius, fov_light_walls, fov_algorithm) render_all(console, entities, player, game_map, fov_map, fov_recompute, SCREEN_WIDTH, SCREEN_HEIGHT, colors) tcod.console_set_default_background(console, tcod.black) renderBottomPanel(console, message_log, player) renderSidePanel(console, entities, fov_map) tcod.console_flush() tcod.console_blit(console, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0) sleep(1 / FRAME_RATE)
def refresh_infobar(self, infobar): libtcod.console_clear(infobar) infobar_text = "" if self.mode == "move": chunk_count_x, chunk_count_y, local_x, local_y = self.to_actv_and_local_coords( self.player.x, self.player.y) infobar_text = self.active_chunks.map[chunk_count_x][ chunk_count_y].chunk[local_x][local_y].name + " " for mob in self.active_objects: if mob.x == self.player.x and mob.y == self.player.y and hasattr( mob, "name") == True: if mob.name != "Player": infobar_text = infobar_text + mob.name + " " libtcod.console_print(infobar, 0, 0, infobar_text) if self.mode == "look": chunk_count_x, chunk_count_y, local_x, local_y = self.to_actv_and_local_coords( self.cursor.x, self.cursor.y) infobar_text = self.active_chunks.map[chunk_count_x][ chunk_count_y].chunk[local_x][local_y].name + " " for mob in self.active_objects: if mob.x == self.cursor.x and mob.y == self.cursor.y and hasattr( mob, "name") == True: infobar_text = infobar_text + mob.name + " " libtcod.console_print(infobar, 0, 0, infobar_text)