def dbox(x, y, w, h, text, wrap=True, border=0, margin=0, con=0, disp='poly'): con_box = libtcod.console_new(w, h) pad = 0 if border == None else 1 offset = margin + pad fulltext = textwrap.fill(text, w - 2 * (margin + pad)) if wrap else text boxes = word.split_stanza( fulltext, h - 2 * (margin + pad)) if disp == 'poly' else [fulltext] length = len(boxes) i = 0 for box in boxes: i += 1 libtcod.console_clear(con_box) # print if border is not None: rectangle(con_box, 0, 0, w, h, border) libtcod.console_print(con_box, offset, offset, box) put_text_special_colors(con_box, box, offset) libtcod.console_blit( con_box, 0, 0, w, h, # Source con, x, y) # Destination # wait for user input to continue... if i < length: rog.blit_to_final(con, 0, 0) rog.refresh() while True: reply = rog.Input(x + w - 1, y + h - 1, mode="wait") if (reply == ' ' or reply == ''): break libtcod.console_delete(con_box)
def create_map_images(self, mode=0): if mode == 0: print 'Creating images....' t0 = libtcod.sys_elapsed_seconds() con = libtcod.console_new(game.WORLDMAP_WIDTH, game.WORLDMAP_HEIGHT) self.map_image_small = libtcod.image_new(game.WORLDMAP_WIDTH, game.WORLDMAP_HEIGHT) self.create_map_legend(con, mode) libtcod.image_scale(self.map_image_small, (game.SCREEN_WIDTH - 2) * 2, (game.SCREEN_HEIGHT - 2) * 2) if mode == 0: while self.player_positionx == 0: start = self.randomize('int', 0, (game.WORLDMAP_WIDTH * game.WORLDMAP_HEIGHT) - 1, 3) if int(self.hm_list[start] * 1000) in range(int(game.terrain['Forest']['elevation'] * 1000), int(game.terrain['Forest']['maxelev'] * 1000)): self.player_positionx = start % game.WORLDMAP_WIDTH self.player_positiony = start / game.WORLDMAP_WIDTH self.originx = self.player_positionx self.originy = self.player_positiony path = self.set_dijkstra_map() for y in range(game.WORLDMAP_HEIGHT): for x in range(game.WORLDMAP_WIDTH): dist = libtcod.dijkstra_get_distance(path, x, y) if dist > self.max_distance: self.max_distance = int(round(dist)) #libtcod.image_put_pixel(self.map_image_small, self.player_positionx, self.player_positiony, libtcod.white) if mode == 2: self.map_image_big = libtcod.image_from_console(con) libtcod.image_save(self.map_image_big, 'maps/worldmap-' + game.player.name + '.png') self.map_image_big = None libtcod.console_delete(con) if mode == 0: t1 = libtcod.sys_elapsed_seconds() print ' done! (%.3f seconds)' % (t1 - t0)
def render_effects(): global activeeffects for effect in activeeffects: if effect.duration == 0: libtcod.console_delete(effect.console) activeeffects.remove(effect) else: effect.draw()
def offscreen(console): """Return an off-screen console with the same size as the root console.""" offscreen = libtcodpy.console_new( libtcodpy.console_get_width(console), libtcodpy.console_get_height(console), ) yield offscreen libtcodpy.console_delete(offscreen)
def resize(self, w,h): """Changes the size of the canvas, copying over the contents of this canvas. Content outside of the new canvas bounds is clipped. """ new = dlib.console_new(w,h) bw = min(w, self.width) bh = min(h, self.height) dlib.console_blit(self._intern, 0, 0, bw, bh, new, 0, 0) #copy contents dlib.console_delete(self._intern) #dispose old console self._intern = new
def settings(): width, height = 44, 10 box = libtcod.console_new(width, height) game.messages.box_gui(box, 0, 0, width, height, libtcod.green) libtcod.console_set_default_foreground(box, libtcod.black) libtcod.console_set_default_background(box, libtcod.green) libtcod.console_print_ex(box, width / 2, 0, libtcod.BKGND_SET, libtcod.CENTER, ' Settings ') libtcod.console_set_default_foreground(box, libtcod.white) util.change_settings(box, width, height, blitmap=True) libtcod.console_delete(box) game.draw_gui = True
def main(): while True: render_all() player_action = player.ai.take_turn() if player_action == "exit": for console in [area.con, frame, panel, log]: lt.console_delete(console) lt.console_clear(0) lt.console_flush() return 'exit'
def settings(self): width, height = 44, 10 box = libtcod.console_new(width, height) messages.box_gui(box, 0, 0, width, height, libtcod.green) libtcod.console_set_default_foreground(box, libtcod.black) libtcod.console_set_default_background(box, libtcod.green) libtcod.console_print_ex(box, 20, 0, libtcod.BKGND_SET, libtcod.CENTER, ' Settings ') libtcod.console_set_default_foreground(box, libtcod.white) util.change_settings(box, width, height, blitmap=False) libtcod.console_delete(box) IO.load_settings()
def test_console_rexpaint_list_save_load(console, tmpdir): con1 = libtcodpy.console_new(8, 2) con2 = libtcodpy.console_new(8, 2) libtcodpy.console_print(con1, 0, 0, 'hello') libtcodpy.console_print(con2, 0, 0, 'world') xp_file = tmpdir.join('test.xp').strpath assert libtcodpy.console_list_save_xp([con1, con2], xp_file, 1) for a, b in zip([con1, con2], libtcodpy.console_list_load_xp(xp_file)): assertConsolesEqual(a, b) libtcodpy.console_delete(a) libtcodpy.console_delete(b)
def show_worldmap(): box = libtcod.console_new(game.SCREEN_WIDTH, game.SCREEN_HEIGHT) game.messages.box_gui(box, 0, 0, game.SCREEN_WIDTH, game.SCREEN_HEIGHT, libtcod.green) libtcod.console_set_default_foreground(box, libtcod.black) libtcod.console_set_default_background(box, libtcod.green) libtcod.console_print_ex(box, game.SCREEN_WIDTH / 2, 0, libtcod.BKGND_SET, libtcod.CENTER, ' World Map ') libtcod.console_set_default_foreground(box, libtcod.green) libtcod.console_set_default_background(box, libtcod.black) libtcod.console_print_ex(box, game.SCREEN_WIDTH / 2, game.SCREEN_HEIGHT - 1, libtcod.BKGND_SET, libtcod.CENTER, '[ Red dot - You, Black dots - Dungeons, S - Save map, Z - Zoom, TAB - Exit ]') libtcod.console_set_default_foreground(box, libtcod.white) util.showmap(box) libtcod.console_delete(box) game.draw_gui = True
def start_new_round(self, winner_of_last_round=None): """starts a new round of pong says who won, shows a countdown, moves the ball to the center, resets the players at the end, wipes the conway sim and resumes play """ # lets do stuff in an off-screen console, so we can use transparency # so the player can see the map con = tcod.console_new(self.width, self.height) time_elapsed = 0.0 # in seconds x = self.width / 2 tcod.console_set_alignment(con, tcod.CENTER) while self.alive and not tcod.console_is_window_closed() and \ time_elapsed < 3.0: y = self.height / 2 if winner_of_last_round: tcod.console_set_default_foreground(con, winner_of_last_round.color) player_num = self.players.index(winner_of_last_round) + 1 string = "Player %d scores!" % player_num height = tcod.console_get_height_rect(con, x, y, self.width, self.height, string) tcod.console_print_rect(con, x, y, self.width, height, string) y += height tcod.console_set_default_foreground(con, tcod.white) string = "New round starting in %d seconds..." % int(3 - time_elapsed) height = tcod.console_get_height_rect(con, x, y, self.width, self.height, string) tcod.console_print_rect(con, x, y, self.width, height, string) self.handle_input() self.update_conway() self.render_all() tcod.console_blit(con, 0, 0, 0, 0, 0, 0, 0, 1.0, 0.75) tcod.console_flush() time_elapsed += tcod.sys_get_last_frame_length() # delete tcod console we created tcod.console_delete(con) #reset the ball self.ball = Ball(1, 1) #reset the player positions for player in self.players: player.top = self.height / 2 # wipe the conway simulation (by creating a new one) self.init_map(self.conway.size, self.conway.color)
def reset_game(self): global savefiles, current_map, border_maps, old_maps, turns, old_msg, hp_anim, times_saved, draw_gui, draw_map, fov_recompute, wm savefiles = [f for f in os.listdir('saves') if os.path.isfile(os.path.join('saves', f))] current_map = None border_maps = [0] * 8 old_maps = [] turns = 0 old_msg = 0 hp_anim = [] times_saved = 0 draw_gui = True draw_map = True fov_recompute = True if 'wm' in globals(): libtcod.console_delete(wm) libtcod.console_clear(con)
def display_help(): help_menu_console = libtcod.console_new(80, 50) while True: for line, text in enumerate(HELP_TEXT): parsed_text, parse_data = parse_colors(text) libtcod.console_print_left(help_menu_console, 0, line, libtcod.BKGND_NONE, parsed_text%parse_data) libtcod.console_blit(help_menu_console, 0, 0, 80, 50, 0, 0, 0) libtcod.console_flush() key = libtcod.console_wait_for_keypress(True) if key.vk == libtcod.KEY_ESCAPE or key.c == ord('?'): break libtcod.console_delete(help_menu_console)
def export(self): print("Exporting world map with dimensions [" + str(self.width) + ',' + str(self.height) + ']') con = tcod.console_new(self.width, self.height) con = self.render(con, True) bmp = tcod.image_from_console(con) tcod.console_delete(con) date = datetime.datetime.now() timestamp = date.strftime("%Y%m%d-%H%M%S") tcod.image_save(bmp, 'export/WorldMap' + timestamp + '.png') print "Done."
def export(self): print("Exporting world map with dimensions [" + str(self.width) + ',' + str(self.height) + ']'); con = tcod.console_new(self.width, self.height); con = self.render(con, True) bmp = tcod.image_from_console(con) tcod.console_delete(con) date = datetime.datetime.now() timestamp = date.strftime("%Y%m%d-%H%M%S") tcod.image_save(bmp, 'export/WorldMap'+ timestamp + '.png') print "Done."
def resize(self, width=None, height=None): """ Resize a console by destroying and recreating it """ if self.console_id == self.ROOT_ID: raise AttributeError("The root console cannot be resized!") if width is None: width = self.width if height is None: height = self.height if self.height == height and self.width == width: return # No resize needed. libtcod.console_delete(self.console_id) self.console_id = libtcod.console_new(width, height) self.width = width self.height = height
def session_console(): libtcodpy.console_set_custom_font(FONT_FILE) console = libtcodpy.console_init_root(WIDTH, HEIGHT, TITLE, FULLSCREEN, RENDERER) assert libtcodpy.console_get_width(console) == WIDTH assert libtcodpy.console_get_height(console) == HEIGHT assert libtcodpy.console_is_fullscreen() == FULLSCREEN libtcodpy.console_set_window_title(TITLE) assert not libtcodpy.console_is_window_closed() libtcodpy.sys_get_current_resolution() libtcodpy.sys_get_char_size() libtcodpy.sys_set_renderer(RENDERER) libtcodpy.sys_get_renderer() yield console libtcodpy.console_delete(console)
def rectangle(con, x, y, w, h, border): con_box = libtcod.console_new(w, h) b = border ch_hw = CH_HW[b] ch_vw = CH_VW[b] ch_tlc = CH_TLC[b] ch_trc = CH_TRC[b] ch_brc = CH_BRC[b] ch_blc = CH_BLC[b] # sides for i in range(w - 2): libtcod.console_put_char_ex(con_box, i + 1, 0, ch_hw, COL['white'], COL['black']) for i in range(w - 2): libtcod.console_put_char_ex(con_box, i + 1, h - 1, ch_hw, COL['white'], COL['black']) for i in range(h - 2): libtcod.console_put_char_ex(con_box, 0, i + 1, ch_vw, COL['white'], COL['black']) for i in range(h - 2): libtcod.console_put_char_ex(con_box, w - 1, i + 1, ch_vw, COL['white'], COL['black']) # corners libtcod.console_put_char_ex(con_box, 0, 0, ch_tlc, COL['white'], COL['black']) libtcod.console_put_char_ex(con_box, w - 1, 0, ch_trc, COL['white'], COL['black']) libtcod.console_put_char_ex(con_box, 0, h - 1, ch_blc, COL['white'], COL['black']) libtcod.console_put_char_ex(con_box, w - 1, h - 1, ch_brc, COL['white'], COL['black']) # blit libtcod.console_blit( con_box, 0, 0, w, h, # Source con, x, y) # Destination libtcod.console_delete(con_box)
def hover(self): width = len(max(self.text + self.header, key=len)) + (self.xoffset * 2) if self.header == []: header_height = 0 else: header_height = len(self.header) + 2 height = len(self.text) + header_height + self.yoffset + self.hoffset wpanel = GuiPanel(width=width, height=height, xoff=0, yoff=0, interface=self.interface, is_root=0, append_to_panels=0) # Header libtcod.console_set_default_foreground(wpanel.con, self.textc) y = self.yoffset for line in self.header: libtcod.console_print(wpanel.con, self.xoffset, y, line) y += 1 # Text y = header_height + self.hoffset for line in self.text: #color_current = self.textc libtcod.console_print(wpanel.con, self.xoffset, y, line) y += 1 # Draw box around menu if parameter is selected if self.bcolor is not None: wpanel.draw_box(0, width - 1, 0, height - 1, self.textc) if not self.xy_corner: # center to coords. Fix for hanging over the left side of the screen and the top of the screen, not yet fixed for right/bottom side. x = max(0, int(self.cx - int(width/2) )) y = max(0, self.cy - height) else: x, y = self.cx, self.cy # Blit to root console + flush to present changes libtcod.console_blit(wpanel.con, 0, 0, width, height, 0, x, y, 1.0, self.transp) #libtcod.console_flush() libtcod.console_delete(wpanel.con) if not self.do_hover: self.interface.clear_hover_info()
def box(header, footer, startx, starty, width, height, contents, default=0, input=True, color=libtcod.green, align=libtcod.LEFT, nokeypress=False, inv=False, step=1, mouse_exit=False, scrollbar=True): box = libtcod.console_new(width, height) if startx == 'center_screenx': startx = (game.SCREEN_WIDTH - (len(max(contents, key=len)) + 16)) / 2 if startx == 'center_mapx': startx = game.PLAYER_STATS_WIDTH + ((game.MAP_WIDTH - (width - 4)) / 2) if starty == 'center_screeny': starty = (game.SCREEN_HEIGHT - (len(contents) + 4)) / 2 if starty == 'center_mapy': starty = ((game.MAP_HEIGHT + 2) - height) / 2 if color is not None: box_gui(box, 0, 0, width, height, color) if header is not None: libtcod.console_set_default_foreground(box, libtcod.black) libtcod.console_set_default_background(box, color) libtcod.console_print_ex(box, width / 2, 0, libtcod.BKGND_SET, libtcod.CENTER, ' ' + header + ' ') libtcod.console_set_default_foreground(box, color) libtcod.console_set_default_background(box, libtcod.black) if footer is not None: libtcod.console_print_ex(box, width / 2, height - 1, libtcod.BKGND_SET, libtcod.CENTER, '[ ' + footer + ' ]') if mouse_exit: libtcod.console_print_ex(box, width - 5, 0, libtcod.BKGND_SET, libtcod.LEFT, '[x]') libtcod.console_set_default_foreground(box, libtcod.white) if input: choice = box_options(box, startx, starty, width - 2, height - 2, contents, default, inv, step, mouse_exit, align, scrollbar) else: for i, line in enumerate(contents): if align == libtcod.LEFT: libtcod.console_print_ex(box, 2, 2 + i, libtcod.BKGND_SET, libtcod.LEFT, line) if align == libtcod.RIGHT: libtcod.console_print_ex(box, width - 2, 2 + i, libtcod.BKGND_SET, libtcod.RIGHT, line) if align == libtcod.CENTER: libtcod.console_print_ex(box, width / 2, 2 + i, libtcod.BKGND_SET, libtcod.CENTER, line) libtcod.console_blit(box, 0, 0, width, height, 0, startx, starty, 1.0, 0.9) libtcod.console_flush() if not nokeypress: libtcod.sys_wait_for_event(libtcod.EVENT_KEY_PRESS, libtcod.Key(), libtcod.Mouse(), True) choice = default libtcod.console_delete(box) return choice
def menu(self, header, options, width, back_color=libtcod.black, fore_color=libtcod.white): if self.con is None: self.con = 0 if len(options) > 26: raise ValueError('too many items') con = self.con header_height = libtcod.console_get_height_rect(con, 0,0, width, self.SCREEN_HEIGHT, header) height = len(options) + header_height window = libtcod.console_new(width, height) print 'window id is:', window print libtcod.console_set_default_foreground(window, fore_color) libtcod.console_print_rect(window, 0,0, width,height, header) y = header_height for option_text in zip('abcdefghijklmnopqrstuvwxyz', options): text = '(%s) %s' % option_text libtcod.console_print(window, 0, y, text) y += 1 x = self.SCREEN_WIDTH/2 - width/2 y = self.SCREEN_HEIGHT/2 - height/2 libtcod.console_blit(window, 0,0, width,height, 0, x,y, 1.0, 0.9) key = libtcod.Key() mouse = libtcod.Mouse() libtcod.console_flush() libtcod.sys_wait_for_event(libtcod.KEY_PRESSED, key, mouse, True) libtcod.console_clear(window) libtcod.console_blit(window, 0,0, width,height, 0, x,y, 1.0, 0.9) libtcod.console_delete(window) libtcod.console_flush() index = key.c - ord('a') if index >= 0 and index < len(options): return index return None
def see_message_history(): box_width = game.MESSAGE_WIDTH + 2 box_height = (game.SCREEN_HEIGHT / 2) + 4 box = libtcod.console_new(box_width, box_height) game.messages.box_gui(box, 0, 0, box_width, box_height, libtcod.green) libtcod.console_set_default_foreground(box, libtcod.black) libtcod.console_set_default_background(box, libtcod.green) libtcod.console_print_ex(box, box_width / 2, 0, libtcod.BKGND_SET, libtcod.CENTER, ' Message History ') libtcod.console_set_default_foreground(box, libtcod.green) libtcod.console_set_default_background(box, libtcod.black) libtcod.console_print_ex(box, box_width / 2, box_height - 1, libtcod.BKGND_SET, libtcod.CENTER, ' Arrow keys - Scroll up/down, ESC - exit ') libtcod.console_set_default_foreground(box, libtcod.white) scroll = 0 exit = False key = libtcod.Key() while exit is False: libtcod.console_rect(box, 1, 1, box_width - 2, box_height - 2, True, libtcod.BKGND_SET) for i in range(min(box_height - 4, len(game.message.history))): libtcod.console_set_default_foreground(box, game.message.history[i + scroll][1]) libtcod.console_print(box, 2, i + 2, game.message.history[i + scroll][0]) util.scrollbar(box, box_width - 2, 2, scroll, box_height - 4, len(game.message.history)) libtcod.console_blit(box, 0, 0, box_width, box_height, 0, (game.SCREEN_WIDTH - box_width) / 2, (game.MAP_HEIGHT - box_height + 2) / 2, 1.0, 1.0) libtcod.console_flush() ev = libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS, key, libtcod.Mouse()) if ev == libtcod.EVENT_KEY_PRESS: if key.vk == libtcod.KEY_ESCAPE: exit = True elif key.vk == libtcod.KEY_UP or key.vk == libtcod.KEY_KP8: if scroll > 0: scroll -= 1 elif key.vk == libtcod.KEY_DOWN or key.vk == libtcod.KEY_KP2: if box_height - 4 + scroll < len(game.message.history): scroll += 1 libtcod.console_delete(box) game.draw_gui = True
def character_sheet(screen=0): width, height = 62, 21 pick_skill, modify_skill = 0, 0 exit = False key = libtcod.Key() stats = libtcod.console_new(width, height) pool = game.player.skill_points while exit is False: if screen == 0: character_sheet_attributes(stats, width, height) elif screen == 1: pool = character_sheet_skills(stats, width, height, pick_skill, modify_skill, pool) elif screen == 2: character_sheet_equipment(stats, width, height) elif screen == 3: character_sheet_inventory(stats, width, height) modify_skill = 0 libtcod.console_set_default_foreground(stats, libtcod.black) libtcod.console_set_default_background(stats, libtcod.green) libtcod.console_print_ex(stats, width / 2, height - 1, libtcod.BKGND_SET, libtcod.CENTER, ' [ Arrow keys to change page, +/- to change skill pts ] ') libtcod.console_blit(stats, 0, 0, width, height, 0, ((game.MAP_WIDTH - width) / 2) + game.MAP_X, ((game.MAP_HEIGHT - height) / 2) + 1, 1.0, 1.0) libtcod.console_flush() libtcod.sys_wait_for_event(libtcod.EVENT_KEY_PRESS, key, game.mouse, True) key_char = chr(key.c) if screen == 1: if key.vk == libtcod.KEY_UP: pick_skill -= 1 if pick_skill < 1: pick_skill = 1 elif key.vk == libtcod.KEY_DOWN: pick_skill += 1 if pick_skill > len(game.player.skills): pick_skill = len(game.player.skills) elif key_char == '+': if pick_skill in range(1, len(game.player.skills)) and pool > 0: modify_skill = 1 elif key_char == '-': if pick_skill in range(1, len(game.player.skills)) and (pool > 0 or (pool == 0 and game.player.skill_points > 0)): modify_skill = -1 if key.vk == libtcod.KEY_LEFT: screen -= 1 if screen < 0: screen = 3 elif key.vk == libtcod.KEY_RIGHT: screen += 1 if screen > 3: screen = 0 elif key.vk == libtcod.KEY_ESCAPE: exit = True for i in range(len(game.player.skills)): if game.player.skills[i].temp > 0: game.player.skill_points -= game.player.skills[i].temp game.player.skills[i].base_level += game.player.skills[i].temp game.player.skills[i].level += game.player.skills[i].temp game.player.skills[i].temp = 0 libtcod.console_delete(stats) game.draw_gui = True
def exit_game() -> bool: # TODO save etc libtcod.console_delete(0) return True
def console_remove_console(self,con): if con > 1: # so we dont try to delete root, or index oob error c = self.mConsole.pop(con-1) libtcod.console_delete(c)
def close(self): if self.console_id != self.ROOT_ID: # Root console cannot be console_delete()d libtcod.console_delete(self.console_id)
def redraw(self, w, h): libtcod.console_delete(self.console) self.w = w self.h = h self.create_console()
xp_loader.transparent_cell_back_g, xp_loader.transparent_cell_back_b)) #################### # libtcod piping to actually put the console layers on screen. This will probably change quite a bit for your actual usage of libtcod #################### draw_layers = False while not libtcod.console_is_window_closed(): key = libtcod.console_check_for_keypress() if key.vk == libtcod.KEY_ESCAPE: break #exit game if key.c == ord('a'): draw_layers = not draw_layers libtcod.console_clear(0) libtcod.console_blit(layer_0_console, 0, 0, xp_data['layer_data'][0]['width'], xp_data['layer_data'][0]['height'], 0, 0, 0) if draw_layers: libtcod.console_blit(layer_1_console, 0, 0, xp_data['layer_data'][1]['width'], xp_data['layer_data'][1]['height'], 0, 0, 0) libtcod.console_flush() libtcod.console_delete(layer_0_console) libtcod.console_delete(layer_1_console)
def delete_panel(self, panel): self.gui_panels.remove(panel) libtcod.console_delete(panel.con) self.panel_deletions.remove(panel) self.game.handle_fov_recompute()
def create_character(): cancel = False cs_width = 55 cs_height = game.SCREEN_HEIGHT - 4 cs = libtcod.console_new(cs_width, cs_height) stats = libtcod.console_new(34, cs_height) while not cancel: game.messages.box_gui(0, 0, 0, game.SCREEN_WIDTH, game.SCREEN_HEIGHT, color=libtcod.Color(245, 222, 179), lines=[{'dir': 'h', 'x': 0, 'y': 2}, {'dir': 'v', 'x': game.SCREEN_WIDTH - 36, 'y': 2}]) libtcod.console_set_default_foreground(0, libtcod.white) libtcod.console_print_ex(0, game.SCREEN_WIDTH / 2, 1, libtcod.BKGND_NONE, libtcod.CENTER, 'CHARACTER GENERATION') show_stats_panel(stats) libtcod.console_print(0, 2, 4, 'Enter a name for your character: _') libtcod.console_flush() game.player.name = game.messages.input('chargen', 0, 35, 4, min=3, max=21) show_stats_panel(stats) libtcod.console_clear(cs) libtcod.console_print(cs, 1, 1, 'Select a gender:') libtcod.console_blit(cs, 0, 0, cs_width, cs_height, 0, 1, 3) game.player.gender = game.GENDER[chargen_options(2, 6, 10, game.GENDER, None)] show_stats_panel(stats) libtcod.console_clear(cs) libtcod.console_print(cs, 1, 1, 'Select a race:') libtcod.console_print(cs, 16, 2, 'Modifiers') libtcod.console_print(cs, 16, 3, 'None') libtcod.console_print(cs, 16, 4, '+2 Int, +1 Wis, -2 Str, -1 End') libtcod.console_print(cs, 16, 5, '+2 Str, +3 End, -2 Dex, -2 Int, -1 Wis') libtcod.console_print(cs, 16, 6, '+1 Dex, +1 Int, -1 Str, -1 Wis') libtcod.console_blit(cs, 0, 0, cs_width, cs_height, 0, 1, 3) game.player.race = game.RACES[chargen_options(2, 6, 12, game.RACES, 'race')] show_stats_panel(stats, 0) libtcod.console_clear(cs) libtcod.console_print(cs, 1, 1, 'Select a class:') libtcod.console_print(cs, 16, 2, 'Modifiers') libtcod.console_print(cs, 16, 3, '+3 Str, +2 End, -2 Int, -1 Wis') libtcod.console_print(cs, 16, 4, '+3 Dex, +1 Str, -1 Int, -1 End') libtcod.console_print(cs, 16, 5, '+3 Wis, +1 Str, -1 Dex, -1 End') libtcod.console_print(cs, 16, 6, '+4 Int, +1 Wis, -2 Str, -1 End') libtcod.console_print(cs, 16, 7, 'None') libtcod.console_blit(cs, 0, 0, cs_width, cs_height, 0, 1, 3) game.player.profession = game.CLASSES[chargen_options(2, 6, 12, game.CLASSES, 'class')] show_stats_panel(stats, 0, 0) libtcod.console_clear(cs) libtcod.console_print(cs, 1, 1, 'Options:') libtcod.console_blit(cs, 0, 0, cs_width, cs_height, 0, 1, 3) final_choice = False while not final_choice: choice = chargen_options(2, 6, 33, ['Reroll stats', 'Keep character and start game', 'Cancel and restart', 'Return to main menu'], None) if choice == 0: show_stats_panel(stats, 0, 0) if choice == 1: final_choice = True libtcod.console_delete(cs) libtcod.console_delete(stats) return 'playing' if choice == 2: game.player.name = '' game.player.gender = '' game.player.race = '' game.player.profession = '' final_choice = True if choice == 3: final_choice = True libtcod.console_delete(cs) libtcod.console_delete(stats) return 'quit'
#################### # libtcod piping to actually put the console layers on screen. This will probably change quite a bit for your actual usage of libtcod #################### draw_layers = False while not libtcod.console_is_window_closed(): key = libtcod.console_check_for_keypress() if key.vk == libtcod.KEY_ESCAPE: break # exit game if key.c == ord("a"): draw_layers = not draw_layers libtcod.console_clear(0) libtcod.console_blit( layer_0_console, 0, 0, xp_data["layer_data"][0]["width"], xp_data["layer_data"][0]["height"], 0, 0, 0 ) if draw_layers: libtcod.console_blit( layer_1_console, 0, 0, xp_data["layer_data"][1]["width"], xp_data["layer_data"][1]["height"], 0, 0, 0 ) libtcod.console_flush() libtcod.console_delete(layer_0_console) libtcod.console_delete(layer_1_console)
def display_message_log(player): message_log_console = libtcod.console_new(80, 40) start_on_line = 0 focus = 0 n_messages = len(player.message_log) while True: # draw the log libtcod.console_clear(message_log_console) libtcod.console_set_foreground_color(message_log_console, libtcod.white) libtcod.console_print_center(message_log_console, 40, 1, libtcod.BKGND_NONE, 'Message Log') offset = 3 line_n = 0 focus_age = player.message_log[focus].age focus_drawn = False try: for n, message in enumerate(player.message_log): for line, text in enumerate(wrap_text(message.text, 75, subsequent_indent = ' ')): if line_n < start_on_line: line_n += 1 if n == focus: raise FocusAboveScreen() continue if message.age == focus_age: shade = 1 else: shade = 0.5 libtcod.console_set_foreground_color(message_log_console, libtcod.white * shade) if line == 0: if n == focus: libtcod.console_put_char_ex( message_log_console, 0, offset, libtcod.CHAR_ARROW_E, libtcod.white, libtcod.black) if message.symbol1: libtcod.console_put_char_ex( message_log_console, (message.symbol2 is None) and 2 or 1, offset, message.symbol1[0], message.symbol1[1] * shade, message.symbol1[2] * shade ) if message.symbol2: libtcod.console_put_char_ex( message_log_console, 2, offset, message.symbol2[0], message.symbol2[1] * shade, message.symbol2[2] * shade ) parsed_text, parse_data = parse_colors(text) libtcod.console_print_left(message_log_console, 4, offset, libtcod.BKGND_NONE, parsed_text%parse_data) offset += 1 if offset >= 39: if focus_drawn: raise LogIsFull() else: raise FocusBelowScreen() if n == focus: focus_drawn = True except LogIsFull: pass except FocusAboveScreen: start_on_line = max(0, start_on_line - 35) continue except FocusBelowScreen: start_on_line += 35 continue libtcod.console_blit(message_log_console, 0, 0, 80, 40, 0, 0, 0) draw_hud(player) libtcod.console_flush() # wait for input key = libtcod.console_wait_for_keypress(True) if key.vk == libtcod.KEY_ESCAPE or key.c == ord('m'): break elif key.vk in DIRECTION_KEYS and DIRECTION_KEYS[key.vk][0] == 0: focus += DIRECTION_KEYS[key.vk][1] focus %= n_messages libtcod.console_delete(message_log_console)
def close(self): ##do not inherit libtcod.console_delete(self.console)
def msg_clear(): clr=libtcod.console_new(msgs_w(), msgs_h()) libtcod.console_blit(clr, 0,0, msgs_w(),msgs_h(), con_game(), 0,0) libtcod.console_delete(clr)
# John Mason, 2012 ############################################################################### import libtcodpy as libtcod import game import default_config as config libtcod.console_set_custom_font('courier12x12_aa_tc.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD) libtcod.console_init_root(80, 50, 'BRUTAL ROGUELIKE: Slaves to Slaughter', False) libtcod.sys_set_fps(60) if config.QUICK_START: game_state = game.new_game else: game_state = game.start_menu while True: try: game_state() except game.SetState as exception: if exception.new_state == 'quit': break else: game_state = exception.new_state libtcod.console_delete(0)
def close(self): super(Manager_Menu, self).close() libtcod.console_delete(self.con) rog.refresh()
def look(player): look_console = libtcod.console_new(50, 10) cursor_x = player.x cursor_y = player.y map = player.map memory = player.memory while True: draw_map(player) highlight_tile(cursor_x, cursor_y) can_see = player.fov.is_visible(cursor_x, cursor_y) actor = can_see and map.actor_at(cursor_x, cursor_y) or memory.actor_at(cursor_x, cursor_y) item = can_see and map.item_at(cursor_x, cursor_y) or memory.item_at(cursor_x, cursor_y) feature = can_see and map.feature_at(cursor_x, cursor_y) or memory.feature_at(cursor_x, cursor_y) libtcod.console_clear(look_console) if actor or item or feature: if can_see: libtcod.console_print_left(look_console, 1, 1, libtcod.BKGND_NONE, 'You see:') else: libtcod.console_print_left(look_console, 1, 1, libtcod.BKGND_NONE, 'You recall:') offset = 0 if actor: libtcod.console_put_char_ex(look_console, 1, 3, *clean_symbol(actor)) libtcod.console_print_left(look_console, 3, 3, libtcod.BKGND_NONE, actor.name) offset += 1 if item: libtcod.console_put_char_ex(look_console, 1, 3 + offset, *clean_symbol(item)) libtcod.console_print_left(look_console, 3, 3 + offset, libtcod.BKGND_NONE, item.name) offset += 1 if feature: libtcod.console_put_char_ex(look_console, 1, 3 + offset, *clean_symbol(feature)) libtcod.console_print_left(look_console, 3, 3 + offset, libtcod.BKGND_NONE, feature.name) else: libtcod.console_print_left(look_console, 1, 1, libtcod.BKGND_NONE, 'You cannot see this location.') libtcod.console_blit(look_console, 0, 0, 50, 10, 0, 30, 40) libtcod.console_flush() key = libtcod.console_wait_for_keypress(True) if key.vk == libtcod.KEY_ESCAPE or key.c == ord('l'): break elif key.vk in DIRECTION_KEYS: dx, dy = DIRECTION_KEYS[key.vk] cursor_x += dx cursor_y += dy level = 0 cursor_x %= 80 # mmmm hardcoded cursor_y %= 40 libtcod.console_delete(look_console)
def consoles_delete(self): libtcod.console_delete(self.con_mid) if self.con_top: libtcod.console_delete(self.con_top) if self.con_bot: libtcod.console_delete(self.con_bot)
def __del__(self): dlib.console_delete(self._intern)