def __init__(self):
global debug, font_width, font_height, con, panel, ps, fov_noise, savefiles, baseitems, prefix, suffix, tiles, monsters
IO.load_settings()
debug = dbg.Debug()
debug.enable = True
for key, value in fonts.items():
if setting_font == key:
libtcod.console_set_custom_font(value['file'], libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_ASCII_INROW)
font_width = value['width']
font_height = value['height']
self.init_root_console()
#libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'Immortal ' + VERSION, False)
con = libtcod.console_new(MAP_WIDTH, MAP_HEIGHT)
panel = libtcod.console_new(MESSAGE_WIDTH, MESSAGE_HEIGHT)
ps = libtcod.console_new(PLAYER_STATS_WIDTH, PLAYER_STATS_HEIGHT)
fov_noise = libtcod.noise_new(1, 1.0, 1.0)
savefiles = [f for f in os.listdir('saves') if os.path.isfile(os.path.join('saves', f))]
IO.load_high_scores()
baseitems = BaseItemList()
baseitems.init_parser()
prefix = PrefixList()
prefix.init_parser()
suffix = SuffixList()
suffix.init_parser()
tiles = mapgen.TileList()
tiles.init_parser()
monsters = MonsterList()
monsters.init_parser()
self.main_menu()
def __init__(self, app_name='test app', screen_width=None, screen_height=None): print '__init__' if screen_width is None: screen_width, screen_height = self.SCREEN_WIDTH, self.SCREEN_HEIGHT libtcod.console_init_root( screen_width, screen_height, app_name, False ) self.game_msgs = [] global message message = self.message self.game_state = 'playing' self.player_action = 'didnt-take-turn' x,y = None,None self.con = libtcod.console_new(self.MAP_WIDTH, self.MAP_HEIGHT) self.panel = libtcod.console_new(self.SCREEN_WIDTH, self.PANEL_HEIGHT) self.cursor = Cursor(self.con, 'X', 0,0) self.key = libtcod.Key() self.mouse = libtcod.Mouse() libtcod.sys_set_fps(self.LIMIT_FPS)
def __init__(self):
logg.info('Main loop initialization.')
logg.debug('Font size set to 8')
libtcod.console_set_custom_font('main/terminal8x8_gs_ro.png',
libtcod.FONT_LAYOUT_ASCII_INROW | libtcod.FONT_TYPE_GRAYSCALE)
logg.debug('Main console initialization.')
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT,
WINDOW_TITLE + ' v.' + VERSION, False,
renderer = libtcod.RENDERER_SDL)
logg.debug('Setting the FPS limit.')
libtcod.sys_set_fps(LIMIT_FPS)
logg.debug('Drawing console initialization.')
self.con = libtcod.console_new(SCREEN_WIDTH, SCREEN_HEIGHT)
#bottom panel console
logg.debug('Panels console initialization.')
self.top_panel = libtcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
self.bottom_panel = libtcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
logg.debug('Gamestate variables initialization')
self.entities=[]
self.player = None
self.gamestate = ""
self.player_action = None
self.map = None
self.random = libtcod.random_new()
self.score = 0
self.gamemode = ''
def __init__(self, mouse=None, key=None):
# initialize the console
# set the font, and consoles
libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(self.SCREEN_WIDTH, self.SCREEN_HEIGHT, 'python/libtcod tutorial', False)
self.con = libtcod.console_new(self.MAP_WIDTH, self.MAP_HEIGHT)
self.panel = libtcod.console_new(self.SCREEN_WIDTH, self.PANEL_HEIGHT)
libtcod.sys_set_fps(self.LIMIT_FPS)
# create the tile colors
self.color_dark_wall = libtcod.Color(0, 0, 100)
self.color_dark_ground = libtcod.Color(50, 50, 100)
self.color_light_wall = libtcod.Color(130, 110, 50)
self.color_light_ground = libtcod.Color(200, 180, 50)
# set the fov initially to None. This will be generated properly when the map is rendered
self.fov_map = None
self.fov_recompute = False
# set the mous and keyboard capture vars
self.mouse = mouse
self.key = key
# set the message console
self.game_msgs = []
def init():
global con, right_panel, bottom_panel, prev_mouse_pos
con = tcod.console_new(MAP_WIDTH, MAP_HEIGHT)
right_panel = tcod.console_new(RIGHT_PANEL_WIDTH,
SCREEN_HEIGHT)
bottom_panel = tcod.console_new(BOTTOM_PANEL_WIDTH,
BOTTOM_PANEL_HEIGHT)
def menu(header, options, width):
#First, make sure the menu has 26 or fewer items (This is due to an alphabetical selection limitation)
if len(options) > 26:
raise ValueError('Cannot have a menu with more than 26 options!')
#implicitly calculate the height of the window, based on the header height (after word wrap) and the number
# of options
header_height = libtcod.console_get_height_rect(con, 0, 0, width, SCREEN_HEIGHT, header)
if header == '':
header_height = 0
height = len(options) + header_height
#Create an offscreen console that represents the menus window, and a slightly larger one to nest the menu inside of
#This will create a border effect for the inner menu, strictly asthetic
outer_window = libtcod.console_new(width + 2, height + 2)
window = libtcod.console_new(width, height)
#Print the header to our offscreen console
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_set_default_background(window, libtcod.darker_sepia)
libtcod.console_clear(window)
libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header)
#Print all the options, with a corresponding ASCII character
y = header_height
#Get the ASCII value of the letter 'a'
letter_index = ord('a')
for option_text in options:
text = '(' + chr(letter_index) + ') ' + option_text
libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, text)
y += 1
letter_index += 1
#Blit the contents of the window to the main game screen, centered
x = SCREEN_WIDTH / 2 - width / 2
y = SCREEN_HEIGHT /2 - height / 2
#Set up the outer window (which only acts as a border for the inner window, strictly graphical)
libtcod.console_set_default_background(outer_window, libtcod.brass)
libtcod.console_clear(outer_window)
#Blit the actual message window onto the outer window, centered and one off from the borders
libtcod.console_blit(window, 0, 0, width, height, outer_window, 1, 1)
#Blit the outer window onto the screen, centered
libtcod.console_blit(outer_window, 0, 0, width + 2, height + 2, 0, x, y)
#Now that the console is presented to the player, wait for them to make a choice before doing anything else
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
#Clear the main console, so no artifacts from the menu appear
libtcod.console_clear(0)
#Check for fullscreen keys
if key.vk == libtcod.KEY_ENTER and key.lalt:
#ALT + Enter, toggle fullscreen
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
#Convert the ASCII code to an index; if it corresponds to a valid menu item, return it
index = key.c - ord('a')
if index >= 0 and index < len(options): return index
return None
def new_game():
# Initialize consoles
lt.console_clear(0)
lt.console_print_ex(0, SCREEN_WIDTH/2, SCREEN_HEIGHT/2, lt.BKGND_NONE, lt.CENTER, 'Loading...')
lt.console_flush()
global panel, log, frame
panel = lt.console_new(PANEL_WIDTH, SCREEN_HEIGHT)
log = lt.console_new(SCREEN_WIDTH - PANEL_WIDTH + 2, LOG_HEIGHT)
frame = lt.console_new(MAP_WIDTH + 2, MAP_HEIGHT + 2)
# Starting cave
global area
area = world.Area("cave", 50, 100)
global game_msgs
game_msgs = []
message(' ') # Ensures log is rendered.
# Create player entity
global player
player = ccreate.create_player(area.area)
player.loc = Mobile(player.loc.col, player.loc.row, player.loc.char, player.loc.f_color)
player.ai = PlayerControl()
player.inv = Inventory(player)
global gamestate
gamestate = "main"
return True
def screen():
global con, panel
libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_ASCII_INROW, 16,16)
libtcod.console_set_custom_font('menu_background1.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_ASCII_INROW, 16,16)
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'Try not to Die!', False)
libtcod.sys_set_fps(LIMIT_FPS)
con = libtcod.console_new(MAP_WIDTH, MAP_HEIGHT)
panel = libtcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
objects = []
def main_game_loop():
global levelmap
global levelmapobjs
global levelmapobjs_coords
global dungeon
global con
global inventory_manager
con = libtcod.console_new(SCREEN_WIDTH, SCREEN_HEIGHT)
panel = libtcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
player = character.Character(5, 5, '@', libtcod.white, "player", blocks=True)
inventory_manager = inventorymanager.InventoryManager(SCREEN_WIDTH, SCREEN_HEIGHT, con)
#char = character.Character(5, 5, '@', libtcod.white, "player")
""" Right now, just demoing a dungeon. """
#levelmap, levelmapobjs = overworldmap.generate_level_map()
levelmap, levelmapobjs = basemap.generate_level_map(player, current_floor)
#saveload.save_map(levelmap, levelmapobjs, "testingmapmain")
#levelmap, levelmapobjs = saveload.load_map("testingmapmain")
""" Initialize fog of war """
for y in xrange(basemap.MAP_HEIGHT):
for x in xrange(basemap.MAP_WIDTH):
libtcod.map_set_properties(fov_map, x, y, not levelmap[x][y].block_sight, not levelmap[x][y].blocked)
""" Coordinates for every object on the overworld map """
for i in levelmapobjs:
levelmapobjs_coords.append((i.x, i.y))
dungeon.append((levelmap, levelmapobjs, levelmapobjs_coords))
levelmapobjs.append(player)
while not libtcod.console_is_window_closed():
render_all(con, panel, player)
libtcod.console_flush()
libtcod.console_put_char(0, player.x, player.y, ' ', libtcod.BKGND_NONE)
""" Results of the player's key actions. """
key_handler_status = handle_keys(player)
move_npcs(player)
check_endgame_conditions(player)
if key_handler_status == "ok":
continue
if key_handler_status == "exit":
break
elif key_handler_status == "down_stairs":
move_down_stairs(player)
def __init__(self):
flags = libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD
libtcod.console_set_custom_font(self.font, flags)
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'mprl', False)
libtcod.sys_set_fps(LIMIT_FPS)
self.con = libtcod.console_new(MAP_WIDTH, MAP_HEIGHT)
self.panel = libtcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
self.inv_window = libtcod.console_new(MAP_WIDTH, MAP_HEIGHT)
self.hp_bar = UIBar('HP', libtcod.darker_red, libtcod.light_red)
def renderer_init():
"""
Initialize libtcod and set up our basic consoles to draw into.
"""
global _con, _panel, _overlay, _last_frame_time
libtcod.console_set_custom_font('arial12x12.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(config.SCREEN_WIDTH, config.SCREEN_HEIGHT, 'python/libtcod tutorial', False)
libtcod.sys_set_fps(LIMIT_FPS)
_con = libtcod.console_new(config.MAP_PANEL_WIDTH, config.MAP_PANEL_HEIGHT)
_overlay = libtcod.console_new(config.MAP_PANEL_WIDTH, config.MAP_PANEL_HEIGHT)
_panel = libtcod.console_new(config.SCREEN_WIDTH, config.PANEL_HEIGHT)
_last_frame_time = time.time() * 1000
def text_input(header): width = len(header) header_height = libtcod.console_get_height_rect(g.con, 0, 0, width, SCREEN_HEIGHT, header) if header == '': header_height = 0 height = 1 + header_height #create an off-screen console that represents the menu's window window = libtcod.console_new(width, height) #print the header, with auto-wrap libtcod.console_set_default_foreground(window, libtcod.white) libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header) #blit the contents of "window" to the root console x = SCREEN_WIDTH/2 - width/2 y = SCREEN_HEIGHT/6 - height/2 libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7) #Now, get key input repeatedly text = "" libtcod.console_flush() key = libtcod.console_wait_for_keypress(True) while key.vk != libtcod.KEY_ENTER and key.vk != libtcod.KEY_ESCAPE: if key.vk == libtcod.KEY_BACKSPACE: if len(text) > 0: text = text[:-1] #Cut off the last one elif key.c >= 32 and key.c <= 127: key_char = chr(key.c) text += key_char #Redraw #render_all() window = libtcod.console_new(width, height) #print the header, with auto-wrap libtcod.console_set_default_foreground(window, libtcod.white) libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header) #libtcod.console_print_ex(window, 0, 1, libtcod.BKGND_NONE, libtcod.LEFT, 'Ravi') libtcod.console_print_ex(window, 0, 1, libtcod.BKGND_NONE, libtcod.LEFT, text) #libtcod.console_print_ex(panel, MSG_X, y, libtcod.BKGND_NONE, libtcod.LEFT,line) #blit the contents of "window" to the root console libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7) libtcod.console_flush() key = libtcod.console_wait_for_keypress(True) return text
def game_initialize():
libtcod.console_set_custom_font('oryx_tiles3.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD, 32, 12)
libtcod.console_init_root(data.SCREEN_WIDTH, data.SCREEN_HEIGHT, 'MeFightRogues!', False, libtcod.RENDERER_SDL)
libtcod.sys_set_fps(data.LIMIT_FPS)
libtcod.console_map_ascii_codes_to_font(256 , 32, 0, 5) #map all characters in 1st row
libtcod.console_map_ascii_codes_to_font(256+32, 32, 0, 6) #map all characters in 2nd row
Game.con = libtcod.console_new(data.MAP_WIDTH,data.MAP_HEIGHT)
Game.panel = libtcod.console_new(data.SCREEN_WIDTH, data.PANEL_HEIGHT)
main_menu()
def __init__(self):
self.screen_width = 80
self.screen_height = 50
self.fps = 20
self.map_width = 80
self.map_height = 45
self.panel = libtcod.console_new(self.screen_width, self.screen_height)
self.console = libtcod.console_new(self.map_width, self.map_height)
self.screens = []
def run_game():
""" Starts the game. """
# Set globals.
global player, objects, turns, depth, game_messages, fov_map, console_gui, console_message
# Create player.
player_alive = Alive(10, 10, 10, 10)
player = Object(20, 10, "Player", "@", [roguelib.white, roguelib.dark_grey], True, False, alive=player_alive)
# Create objects list.
objects = []
# Set global turns.
turns = 0
depth = 1
game_messages = []
create_message("Welcome to the Simple Roguelike.", roguelib.red)
# Generate dungeon.
make_dungeon()
# Create FOV.
compute_fov()
# Create top and bottom gui consoles.
console_gui = roguelib.console_new(SCREEN_WIDTH, CONSOLE_GUI_HEIGHT)
console_message = roguelib.console_new(SCREEN_WIDTH, MESSAGE_CONSOLE_HEIGHT)
# Create loop for the game to run.
while not roguelib.console_is_window_closed():
# Render graphics.
render_all()
# If player is on stairs, descend or ascend.
if player.x == dstairs.x and player.y == dstairs.y:
descend()
if depth > 1:
if player.x == astairs.x and player.y == astairs.y:
ascend()
# If leave_game is raised, exit game.
leave_game = handle_input()
if leave_game:
break
def main_init():
global con, con_char, inf,minmap, message_bar, date, ui, game_msgs
#libtcod.console_set_custom_font("dejavu16x16.png", libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_set_custom_font("data\ont_big.png",libtcod.FONT_LAYOUT_ASCII_INROW)
libtcod.console_init_root(R.SCREEN_WIDTH, R.SCREEN_HEIGHT, "Trader-RL", False)
libtcod.sys_set_fps(R.LIMIT_FPS)
con = R.con = libtcod.console_new(R.MAP_WIDTH, R.MAP_HEIGHT)
con_char = R.con_char = libtcod.console_new(R.MAP_WIDTH, R.MAP_HEIGHT)
inf = R.inf = libtcod.console_new(R.INFO_BAR_WIDTH, R.SCREEN_HEIGHT - R.PANEL_HEIGHT)
minmap = R.minmap = libtcod.console_new(R.INFO_BAR_WIDTH, R.PANEL_HEIGHT)
message_bar = R.message_bar = libtcod.console_new(R.PANEL_WIDTH, R.PANEL_HEIGHT)
game_msgs = R.game_msgs = []
ui = R.ui = UI.UI(con,game_msgs)
date = R.date = [0, [DAYS[0][0], 1, 1], [MONTHS[0][0], 1, 31], 1000];
def initialize(self):
self.overview_con = libtcod.console_new(OVERVIEW_SCREEN_WIDTH, OVERVIEW_SCREEN_HEIGHT)
self.debug_con = libtcod.console_new(OVERVIEW_SCREEN_WIDTH, 10)
self.region_con = libtcod.console_new(REGION_HEIGHT,REGION_WIDTH)
random.seed()
height_map_seed = random.randint(-1000000,1000000)
rain_fall_map_seed = random.randint(-1000000,1000000)
temperature_map_seed = random.randint(-1000000,1000000)
self.cameraX = 0
self.cameraY = 0
self.cursorX = OVERVIEW_SCREEN_WIDTH / 2
self.cursorY = OVERVIEW_SCREEN_HEIGHT / 2
self.region_cursorX = 0
self.region_cursorY = 0
height_map = gen_height_map(height_map_seed, 0.004,10)
rain_fall_map = gen_rainfall_map(rain_fall_map_seed,0.09,10)
temperature_map = gen_temperature_map(temperature_map_seed,0.004,MAP_WIDTH,10)
self.world = []
for x in range(0,MAP_WIDTH):
tilecolumn = []
for y in range(0,MAP_HEIGHT):
tilecolumn.append(Region(height_map,rain_fall_map,temperature_map,x,y,REGION_WIDTH,REGION_HEIGHT))
self.world.append(tilecolumn)
print str(x) + " of " + str(MAP_WIDTH)
i = 0
print "heightmap done"
while i < RIVERLAKES:
x = random.randint(20,MAP_WIDTH*REGION_WIDTH - 20)
y = random.randint(20,MAP_HEIGHT*REGION_HEIGHT - 20)
def gen_river(mapX,mapY,regX,regY,min_height):
try:
height = self.world[mapX][mapY].tiles[regX][regY].height
except IndexError:
return False
self.world[mapX][mapY].tiles[regX][regY].height = RIVERLEVEL
if height > min_height or height < WATER_THRESHOLD:
return False
for x in (-1,1):
realx = mapX * REGION_WIDTH + regX + x
gen_river(realx / REGION_WIDTH, mapY,realx % REGION_WIDTH, regY,height+RIVER_EROSION)
for y in (-1,1):
realy = mapY * REGION_HEIGHT + regY + y
gen_river(mapX, realy / REGION_HEIGHT, regX, realy % REGION_HEIGHT, height+RIVER_EROSION)
return True
if gen_river(x / REGION_WIDTH, y / REGION_HEIGHT,x % REGION_WIDTH, y % REGION_HEIGHT,1):
i += 1
print ("river " + str(i) + " done")
def equipment_menu(con, header, player, equipment_menu_width, screen_width,
screen_height, colors):
"""Show what items the player has equipped on the equipment slots."""
header_height = libtcod.console_get_height_rect(con, 0, 0,
equipment_menu_width,
screen_height, header)
height = header_height + 10
window = libtcod.console_new(equipment_menu_width, height)
libtcod.console_set_default_foreground(window, colors['text_default'])
libtcod.console_set_color_control(libtcod.COLCTRL_1,
colors['text_emphasize'],
colors['background_default'])
libtcod.console_set_color_control(libtcod.COLCTRL_2,
colors['text_desaturate'],
colors['background_default'])
libtcod.console_set_color_control(libtcod.COLCTRL_3, colors['text_info'],
colors['background_default'])
libtcod.console_set_color_control(libtcod.COLCTRL_4,
colors['text_info_alt'],
colors['background_default'])
slots = [(player.equipment.main_hand, 'Main hand'),
(player.equipment.off_hand, 'Off hand'),
(player.equipment.torso, 'Torso'),
(player.equipment.head, 'Head'), (player.equipment.coat, 'Coat'),
(player.equipment.ring_l, 'Ring (left)'),
(player.equipment.ring_r, 'Ring (right)'),
(player.equipment.special, 'Special')]
libtcod.console_print_rect_ex(window, 0, 1, equipment_menu_width, height,
libtcod.BKGND_NONE, libtcod.LEFT, header)
line = header_height + 1
letter_index = ord('a')
for slot, slot_desc in slots:
equippable_name = '%cEmpty.%c' % (libtcod.COLCTRL_2,
libtcod.COLCTRL_STOP)
index_prefix = f'%c({chr(letter_index)})%c' % (libtcod.COLCTRL_1,
libtcod.COLCTRL_STOP)
if slot is not None:
equippable_name = f'%c{slot.name} %c{slot.equippable}%c' % (
libtcod.COLCTRL_3, libtcod.COLCTRL_4, libtcod.COLCTRL_STOP)
equippable_stats = str(slot.equippable)
libtcod.console_print_rect_ex(
window, 0, line, equipment_menu_width, height, libtcod.BKGND_NONE,
libtcod.LEFT, '{0}{1}: {2}'.format(index_prefix, slot_desc,
equippable_name))
line += 1
letter_index += 1
x = int(screen_width / 2 - equipment_menu_width / 2)
y = int(screen_height / 2 - height / 2)
libtcod.console_blit(window, 0, 0, equipment_menu_width, height, 0, x, y,
1.0, 0.7)
def menu(header, options, width):
if len(options) > 26: raise ValueError('Cannot have a menu with more than 26 options')
#calculate total height for the header, 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 off-screen console that represeents menu's window
window = libtcod.console_new(width, height)
#print the header, with auto-wrap
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header)
#print each option
y = header_height
letter_index = ord('a')
for option_text in options:
text = '(' + chr(letter_index) + ')' + option_text
libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, text)
y += 1
letter_index += 1
#blit the contents of window to the root console
x = SCREEN_WIDTH/2 - width/2
y = SCREEN_HEIGHT/2 - height/2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
#present the root console to the player and wait for a key-press
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
index = key.c - ord('a')
if index >= 0 and index < len(options): return index
return None
def menu(header, options, width):
#generic menu function. has automatic height calculation
if len(options) > CARRY_LIMIT:
raise ValueError('Cannot have a menu with more than' +
str(CARRY_LIMIT) + 'options.')
#calculates total height, one line per option
header_height = libtcod.console_get_height_rect(con, 0, 0, width,
SCREEN_HEIGHT, header)
height = len(options) + header_height
#creates an off-screen console, menu window
window = libtcod.console_new(width, height)
#prints header, words wrapped
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 0, width, height,
libtcod.BKGND_NONE, libtcod.LEFT, header)
#prints options
y = header_height
letter_index = ord('a') #gets ascii code from a character
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
#blits content of window console to root console/screen
x = SCREEN_WIDTH / 2 - width / 2
y = SCREEN_HEIGHT / 2 - height / 2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
#shows root console
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
index = key.c - ord('a')
if index >= 0 and index < len(options): return index
return None
def job_screen(player, character_screen_width, character_screen_height,
screen_width, screen_height):
window = libtcod.console_new(character_screen_width,
character_screen_height)
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(
window, 0, 2, character_screen_width, character_screen_height,
libtcod.BKGND_NONE, libtcod.LEFT,
'Level in Fighter: {0}'.format(player.fighter.job.fighter_level))
libtcod.console_print_rect_ex(
window, 0, 3, character_screen_width, character_screen_height,
libtcod.BKGND_NONE, libtcod.LEFT,
'Levels in Magician: {0}'.format(player.fighter.job.magician_level))
libtcod.console_print_rect_ex(
window, 0, 4, character_screen_width, character_screen_height,
libtcod.BKGND_NONE, libtcod.LEFT,
'Levels in Cleric: {0}'.format(player.fighter.job.cleric_level))
libtcod.console_print_rect_ex(
window, 0, 5, character_screen_width, character_screen_height,
libtcod.BKGND_NONE, libtcod.LEFT,
'Levels in Thief: {0}'.format(player.fighter.job.thief_level))
x = screen_width // 2 - character_screen_width // 2
y = screen_height // 2 - character_screen_height // 2
libtcod.console_blit(window, 0, 0, character_screen_width,
character_screen_height, 0, x, y, 1.0, 0.7)
def menu(header, options, width):
if len(options) > 26: raise ValueError('Cannot have a menu with more than 26 options.') #menu cannot have more than 26 options
#calculate total height for the header (after auto-wrap) and one line per option
header_height = libtcod.console_get_height_rect(con, 0, 0, width, SCREEN_HEIGHT, header)
if header == "":
header_height = 0
height = len(options) + header_height
#creating new window to draw menu
window = libtcod.console_new(width, height)
#print header
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header)
#print options
y = header_height
letter_index = ord("a")
for option_text in options:
text = "(" + chr(letter_index) + ") " + option_text
libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, text)
y += 1
letter_index += 1
#blit to main screen
x = SCREEN_WIDTH/2 - width/2
y = SCREEN_HEIGHT/2 - height/2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7) #last two parameters represent foreground and background transparency, respectively
#flush and wait for keypress
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
if key.vk == libtcod.KEY_ENTER and key.lalt:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
#convert the ASCII code to an index; if it corresponds to an option, return it
index = key.c - ord('a')
if index >= 0 and index < len(options): return index
return None
def build(self):
#print 'built!'
libtcod.console_set_default_foreground(self.console,
self.get_palette().LBLUE)
libtcod.console_set_default_background(self.console,
self.get_palette().DGREY)
libtcod.console_print_frame(self.console, 0, 0, self.width,
self.height, True, libtcod.BKGND_SET,
'fenetre1')
temp = libtcod.console_new(self.width - 2, self.height - 2)
libtcod.console_set_default_foreground(temp, self.get_palette().LBLUE)
libtcod.console_set_default_background(temp, self.get_palette().DGREY)
y = 1
for elem in self.content:
libtcod.console_clear(temp)
height = elem.build(temp)
libtcod.console_blit(temp, 0, 0, elem.width, elem.height,
self.console, 1, y)
y += height
def __init__(self, x, y, w, h, default, mode, insert):
# init
self.console = libtcod.console_new(w, h)
self.init_time = time.time()
self.x = x
self.w = w
self.y = y
self.h = h
self.mode = mode
self.text = default
self.default = default
self.keyInput = ''
self.redraw_cursor = True
self.render_text = True
self.flush = False
self.key = key
self.mouse = mouse
self.cursor = Cursor()
self.cursor.set_pos(x, y)
self.insert_mode = insert #replace the character under the cursor or shift it aside?
#ignore buffer
get_raw_input()
def menu(con, header, options, width, screen_width, screen_height):
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_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 0, width, height,
libtcod.BKGND_NONE, libtcod.LEFT, header)
# print all the options
y = header_height
letter_index = ord('a')
for option_text in options:
text = '(' + chr(letter_index) + ') ' + option_text
libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE,
libtcod.LEFT, text)
y += 1
letter_index += 1
# blit the contents of "window" to the root console
x = 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, 0.7)
def menu(header, options, width):
if len(options) > 26:
raise ValueError('More than 26 menu items not currently supported')
header_height = libtcodpy.console_get_height_rect(_console, 0, 0, width,
config.SCREEN_HEIGHT,
header)
height = len(options) + header_height
window = libtcodpy.console_new(width, height)
libtcodpy.console_set_default_foreground(window, libtcodpy.white)
libtcodpy.console_print_rect_ex(window, 0, 0, window, height,
libtcodpy.BKGND_NONE, libtcodpy.LEFT,
header)
y = header_height
letter_index = ord('a')
for option_text in options:
text = '(' + chr(letter_index) + ') ' + option_text
libtcodpy.console_print_ex(window, 0, y, libtcodpy.BKGND_NONE,
libtcodpy.LEFT, text)
y += 1
letter_index += 1
x = config.SCREEN_WIDTH / 2 - width / 2
y = config.SCREEN_HEIGHT / 2 - height / 2
libtcodpy.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
libtcodpy.console_flush()
key = libtcodpy.console_wait_for_keypress(True)
index = key.c - ord('a')
if 0 <= index < len(options):
return index
return None
def init_specialGrids(self):
w=self.w
h=self.h
# init special grids
self.grid_things = [ [ [] for y in range(h)] for x in range(w) ]
self.grid_lights = [ [ [] for y in range(h)] for x in range(w) ]
#self.grid_fluids = [ [ [] for y in range(h)] for x in range(w) ]
# Init root FOVmap
self.fov_map = libtcod.map_new(w,h)
# init lightmap which stores luminosity values for each tile
self.lightmap_init()
# lists of tiles of interest
self.question_marks = []
# init consoles for UI
self.con_memories = libtcod.console_new(w,h)
self.con_map_state = libtcod.console_new(w,h)
def menu(header, options, width):
#add functionality of pages
header_height = libtcod.console_get_height_rect(con, 0, 0, width,
SCREEN_HEIGHT, header)
height = len(options) + header_height
window = libtcod.console_new(width, height)
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 0, width, height,
libtcod.BKGND_NONE, libtcod.LEFT, header)
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
x = SCREEN_WIDTH / 2 - width / 2
y = SCREEN_HEIGHT / 2 - height / 2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
index = key.c - ord('a')
if index >= 0 and index < len(options): return index
return None
def menu(header, options, width):
if len(options) > 26:
raise ValueError('Cannot have menu with more than 26 options.')
header_height = libtcod.console_get_height_rect(con, 0, 0, width,
SCREEN_HEIGHT, header)
if header == '':
header_height = 0
height = len(options) + header_height
window = libtcod.console_new(width, height)
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 0, width, height,
libtcod.BKGND_NONE, libtcod.LEFT, header)
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
x = SCREEN_WIDTH / 2 - width / 2
y = SCREEN_HEIGHT / 2 - height / 2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
if key.vk == libtcod.KEY_ENTER and key.lalt:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
index = key.c - ord('a')
if index >= 0 and index < len(options):
return index
return None
def character_screen(player, character_screen_width, character_screen_height, screen_width, screen_height):
window = libtcod.console_new(character_screen_width, character_screen_height)
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 1, character_screen_width, character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Character Information')
libtcod.console_print_rect_ex(window, 0, 2, character_screen_width, character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Level: {0}'.format(player.level.current_level))
libtcod.console_print_rect_ex(window, 0, 3, character_screen_width, character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Experience: {0}'.format(player.level.current_xp))
libtcod.console_print_rect_ex(window, 0, 4, character_screen_width, character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Experience to Level: {0}'.format(player.level.experience_to_next_level))
libtcod.console_print_rect_ex(window, 0, 6, character_screen_width, character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Maximum HP: {0}'.format(player.fighter.max_hp))
libtcod.console_print_rect_ex(window, 0, 7, character_screen_width, character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Attack: {0}'.format(player.fighter.power))
libtcod.console_print_rect_ex(window, 0, 8, character_screen_width, character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Defense: {0}'.format(player.fighter.defense))
libtcod.console_print_rect_ex(window, 0, 9, character_screen_width, character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Race: {0}'.format(player.fighter.race))
libtcod.console_print_rect_ex(window, 0, 9, character_screen_width, character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, 'Gender: {0}'.format(Gender.male))
x = screen_width // 2 - character_screen_width // 2
y = screen_height // 2 - character_screen_height // 2
libtcod.console_blit(window, 0, 0, character_screen_width, character_screen_height, 0, x, y, 1.0, 0.7)
def menu(con, header, options, width, screen_width, screen_height):
if len(options) > 26:
raise ValueError('Cannot have a menu with more than 26 options')
header_height = libtcod.console_get_height_rect(con, 0, 0, width,
screen_height, header)
height = len(options) + header_height
window = libtcod.console_new(width, height)
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 0, width, height,
libtcod.BKGND_NONE, libtcod.LEFT, header)
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
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, 0.7)
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.render_all()
libtcod.console_blit(box, 0, 0, 1, 1, 0, x, y, 1.0,
0.5) #0.7 is the transparency
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
key = libtcod.console_wait_for_keypress(True)
if key.vk == libtcod.KEY_ESCAPE:
return (None, None)
direction = Game.getDirection(key)
if direction is not None:
x += direction[0]
y += direction[1]
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 menu(con, header, options, width, screenWidth, screenHeight):
if len(options) > 28: raise ValueError('Cannot have a menu with more than 26 options.')
# calculate height of header (post auto-wrap) and one line per option
headerHeight = libtcod.console_get_height_rect(con,0,0,width,
screenHeight, header)
height = len(options) + headerHeight
# create off-screen console that reps the menu's window
window = libtcod.console_new(width,height)
# print header w/ auto-wrap
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window,0,0,width,height,
libtcod.BKGND_NONE,libtcod.LEFT,header)
# print options
y = headerHeight
letterIndex = ord('a')
for optionText in options:
text = '(' + chr(letterIndex) + ') ' + optionText
libtcod.console_print_ex(window,0,y,libtcod.BKGND_NONE,
libtcod.LEFT, text)
y += 1
letterIndex += 1
# blit contents of window to root console
x = int(screenWidth/2 - width/2)
y = int(screenHeight/2 - height/2)
libtcod.console_blit(window,0,0,width,height,0,x,y,1.0,0.7)
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 menu(header, options, width):
if len(options) > 26: raise ValueError('Cannot have a menu with more than 26 options')
# get geometry
header_height = libtcod.console_get_height_rect(con, 0, 0, width, SCREEN_HEIGHT, header)
height = len(options) + header_height
# create an off screen window
window = libtcod.console_new(width, height)
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header)
#print all the options
y = header_height
letter_index = ord('a')
for option_text in options:
text = '(' + chr(letter_index) + ') ' + option_text
libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, text)
y += 1
letter_index += 1
x = SCREEN_WIDTH/2 - width/2
y = SCREEN_HEIGHT/2 - height/2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
index = key.c - ord('a')
if index >= 0 and index < len(options): return index
return None
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 showDebugScreen(self):
# store the current view
behind_window = libtcod.console_new(SCREEN_WIDTH, SCREEN_HEIGHT)
libtcod.console_blit(0, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, behind_window, 0, 0, 1.0, 1.0)
# show the background image, at twice the regular console resolution
img = libtcod.image_load("./media/menu_debug.png")
libtcod.image_blit_2x(img, 0, 0, 0)
while not libtcod.console_is_window_closed():
# show options and wait for the player's choice
choice = self.showMenu(
"Select debug option:",
["Run some test code!", "Show me some game stuff!", "Back"], # Choice 0 # Choice 1 # Choice 2
36,
)
# interpret choice
if choice is None:
continue
if choice == 0:
print "Running some test code!"
self.runTestCode()
self.showMessage("Test code complete!", "There might be some output in the console...", 36)
continue
elif choice == 1:
print "Showing some game stuff!"
self.newGame()
self.showGameScreen()
elif choice == 2: # quit
print "Back"
break
# Clean up (restore whatever was behind this window)
libtcod.console_blit(behind_window, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0, 1.0, 1.0)
libtcod.console_flush()
def menu(header, options, width):
if len(options) > 26: raise ValueError("Cannot have a menu with more than 26 options.") #TODO: expand inventory.
header_height = libtcod.console_get_height_rect(con, 0, 0, width, SCREEN_HEIGHT, header)
height = len(options) + header_height
window = libtcod.console_new(width, height)
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header)
y = header_height
letter_index = ord("a") #can be replaced with a list i'll iterate over when i want more positions
for option_text in options:
text = "({0}) {1}".format(chr(letter_index), option_text)
libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, text)
y += 1
letter_index += 1
#center and show menu
x = SCREEN_WIDTH/2 - width/2
y = SCREEN_HEIGHT/2 - height/2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
index = key.c - ord("a")
if index >= 0 and index < len(options):
return index
else:
return None
def init(): global SYMBOL_MAP, KEYBOARD_MAP, CON, UI, MOUSE, KEY w = config.SCREEN_WIDTH h = config.SCREEN_HEIGHT ltc.sys_set_fps(config.FPS) #ltc.console_set_custom_font(config.TILE_SET, ltc.FONT_LAYOUT_ASCII_INROW | ltc.FONT_TYPE_GREYSCALE, 16, 16) ltc.console_set_custom_font(config.TILE_SET, ltc.FONT_LAYOUT_TCOD | ltc.FONT_TYPE_GREYSCALE, 32, 8) ltc.console_init_root(w, h, config.TITLE, False) KEYBOARD_MAP = dict([[v, k] for k, v in KEYBOARD_MAP.items()]) CON = ltc.console_new(w, h) UI = ltc.console_new(w, h) ltc.console_set_key_color(UI, ltc.purple) MOUSE = ltc.Mouse() KEY = ltc.Key()
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 menu(header, options, width):
if len(options) > 26: raise ValueError('Cannot have a menu with more than 26 options.')
#calculate the total height for the header and one line per option
header_height = libtcod.console_get_height_rect(con, 0, 0, width, SCREEN_HEIGHT, header)
if header == '':
header_height = 0
height = len(options) + header_height
#create an off-screen console that represent the menu's window
window = libtcod.console_new(width, height)
#print the header, with auto-wrap
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header)
#print all the option
y = header_height
letter_index = ord('a')
for option_text in options:
text = '(' + chr(letter_index) + ')' + option_text
libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, text)
y += 1
letter_index += 1
#blit the contents of 'window' to the root console
x = SCREEN_WIDTH / 2 - width / 2
y = SCREEN_HEIGHT / 2 - height / 2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
#present the root console to the player and wait for a key press
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
#convert the ASCII code to an index; if it corresponds to an option, return it
index = key.c - ord('a')
if index >= 0 and index < len(options): return index
return None
def menu(header, options, width):
if len(options) > 26: raise ValueError('Cannot have a menu with more than 26 options.')
header_height = libtcod.console_get_height_rect(con, 0, 0, width, SCREEN_HEIGHT, header)
if header == '':
header_height = 0
height = len(options) + header_height
window = libtcod.console_new(width, height)
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header)
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
x = SCREEN_WIDTH / 2 - width/2
y = SCREEN_HEIGHT / 2 - height/2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
if key.vk == libtcod.KEY_ENTER and key.lalt: #(special case) Alt+Enter: toggle fullscreen
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
index = key.c - ord('a')
if index >= 0 and index < len(options): return index
return None
def create_menu(menu=[], position=[0,0], title='Untitled', format_str='$k: $v', padding=MENU_PADDING,
on_select=None, on_change=None, on_close=None, on_move=None, dim=True, alignment='', action=None,
close_on_select=False):
_menu = {'settings': {'position': list(position),'title': title,'padding': padding,'dim': dim,'format': format_str},
'on_select': on_select,
'on_change': on_change,
'on_move': on_move,
'on_close': on_close,
'close_on_select': close_on_select,
'alignment': alignment,
'index': 0,
'values':{},
'action':action}
#TODO: Does this need to be copied?
_menu['menu'] = menu[:]
_size = [len(title),len(_menu['menu'])+2+(_menu['settings']['padding'][1]*2)]
_uid = 0
for entry in _menu['menu']:
entry['uid'] = _uid
_uid+=1
for value in range(len(entry['values'])):
_line = format_entry(_menu['settings']['format'], entry, value=value)
if len(_line) > _size[0]:
_size[0] = len(_line)
_menu['settings']['size'] = (_size[0]+(_menu['settings']['padding'][0]*2),_size[1])
_menu['settings']['console'] = tcod.console_new(_menu['settings']['size'][0],_menu['settings']['size'][1])
MENUS.append(_menu)
return MENUS.index(_menu)
def player_card(): #create an off-screen console that represents the card's window window = libtcod.console_new(30, 20) #print player stats libtcod.console_set_foreground_color(window, libtcod.white) libtcod.console_print_left(window, 1, 1, libtcod.BKGND_NONE, 'Player') libtcod.console_print_left(window, 1, 2, libtcod.BKGND_NONE, 'Class: ' + player.stats.plclass) libtcod.console_print_left(window, 1, 3, libtcod.BKGND_NONE, 'STR:' + str(player.stats.str)) libtcod.console_print_left(window, 1, 4, libtcod.BKGND_NONE, 'DEX:' + str(player.stats.dex)) libtcod.console_print_left(window, 1, 5, libtcod.BKGND_NONE, 'CON:' + str(player.stats.con)) libtcod.console_print_left(window, 1, 6, libtcod.BKGND_NONE, 'INT:' + str(player.stats.int)) libtcod.console_print_left(window, 1, 7, libtcod.BKGND_NONE, 'FTH:' + str(player.stats.fth)) libtcod.console_print_left(window, 1, 8, libtcod.BKGND_NONE, 'PER:' + str(player.stats.per)) libtcod.console_print_left(window, 1, 10, libtcod.BKGND_NONE, 'AC: ' + str(player.stats.ac)) libtcod.console_print_left(window, 1, 11, libtcod.BKGND_NONE, 'Encumbrance: ') libtcod.console_print_left(window, 1, 13, libtcod.BKGND_NONE, 'Hit %: ' + str((20-player.stats.hitdie)*5)) libtcod.console_print_left(window, 1, 14, libtcod.BKGND_NONE, 'Damage: ' + str(player.stats.mindmg) + ' - ' + str(player.stats.maxdmg)) #blit the contents of "window" to the root console libtcod.console_blit(window, 0, 0, 30, 20, 0, 1, 1, 1.0, 0.7) #present the root console to the player and wait for a key-press libtcod.console_flush() key = libtcod.console_wait_for_keypress(True) if key.vk == libtcod.KEY_ENTER and key.lalt: #(special case) Alt+Enter: toggle fullscreen libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen()) return None
def createPanels(self, width, height):
self.mainconsole = libtcod.console_new(SCREEN_WIDTH, SCREEN_HEIGHT)
self.mainconsolewidth = SCREEN_WIDTH - 11
self.mainconsoleheight = SCREEN_HEIGHT - 15
self.msgpanel = MessagePanel(0, height-15, width/2, 10)
self.combatlog = MessagePanel(width/2+1, height-15, width/2, 20)
self.typingpanel = TypingPanel(width, height-2)
def menu(header, options, width):
if len(options) > 26: raise ValueError('Cannot have a menu with more than 26 options.')
#calculate total height for the header after autowrap 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 another offscreen console for the menu's window
window = libtcod.console_new(width, height)
#print the header, with autowrap
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header)
y = header_height
letter_index = ord('a') #start the list of inventory items with ordinal letter a
for option_text in options:
text = '(' + chr(letter_index) + ') ' + option_text #converts ordinal to a string for selection
libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, text)
y += 1
letter_index += 1
#blit the contents of the inventory window to the root console in the middle of the screen
x = SCREEN_WIDTH/2 - width/2
y = SCREEN_HEIGHT/2 - height/2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7) #last two values transparency%
#present to the root console to the player and wait for key-press
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
def menu(header, options, width):
if len(options) > 26: raise ValueError('Cannot have a menu with more than 26 options')
# Calc the header height after auto-wrap, one line per option
header_height = libtcod.console_get_height_rect(con, 0, 0, width, opt.SCREEN_HEIGHT, header)
if header == '':
header_height = 0
height = len(options) + header_height
# Create new offscreen window
window = libtcod.console_new(width, height)
# Print header with auto-wrap
libtcod.console_set_default_foreground(window, libtcod.Color(230,230,230))
libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header)
# Print options
y = header_height
letter_index = ord('a')
for option_text in options:
# Print options in format a) Option
text = chr(letter_index) + ') ' + option_text
libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, text)
y += 1
letter_index += 1
x = opt.SCREEN_WIDTH/2 - width/2
y = opt.SCREEN_HEIGHT/2 - height/2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
if key.vk == libtcod.KEY_ENTER and key.lalt:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
# If an item was chosen, return it
index = key.c - ord('a')
if index >= 0 and index < len(options): return index
return None
def __init__(self):
#GUI and map variables
self.SCREEN_WIDTH = 80
self.SCREEN_HEIGHT = 50
#MAP_X_SIZE and _Y_SIZE are the size of the map in chunks
self.MAP_X_SIZE = 200
self.MAP_Y_SIZE = 400
self.CHUNK_SIZE = 128
self.MAP_WIDTH = self.MAP_X_SIZE*self.CHUNK_SIZE
self.MAP_HEIGHT = self.MAP_Y_SIZE*self.CHUNK_SIZE
self.CAMERA_WIDTH = 80
self.CAMERA_HEIGHT = 49
self.LIMIT_FPS = 20
self.INFOBAR_HEIGHT = 1
self.ACTIONPANEL_WIDTH = 15
self.MENU_WIDTH = 20
self.GAME_FONT = 'arial10x10.png'
#We begin in the center of this chunk
self.PLAYER_START_X = 100
self.PLAYER_START_Y = 200
#Variable controlling frame interval for certain events
self.GAMESPEED = 5
#Minimum number of frames between player movements/actions
self.MAX_MOVESPEED = self.GAMESPEED/2
libtcod.console_set_custom_font(self.GAME_FONT, libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(self.SCREEN_WIDTH, self.SCREEN_HEIGHT, 'python/libtcod tutorial', False)
libtcod.sys_set_fps(self.LIMIT_FPS)
self.con = libtcod.console_new(self.SCREEN_WIDTH, self.SCREEN_HEIGHT)
#Game state and GUI control variables
self.show_menu = False
self.mode = "move"
self.cursor = None
self.time = "free"
self.player_wait = 0
self.npcs = []
self.player = None
self.camera = None
self.objects = []
self.map = None
self.infobar = libtcod.console_new(self.SCREEN_WIDTH, self.INFOBAR_HEIGHT)
self.menu = libtcod.console_new(self.MENU_WIDTH, self.SCREEN_HEIGHT)
def character_screen(player, character_screen_width, character_screen_height,
screen_width, screen_height, colors):
"""Show character_screen with basic information."""
window = libtcod.console_new(character_screen_width,
character_screen_height)
libtcod.console_set_default_foreground(window, colors['text_default'])
libtcod.console_set_color_control(libtcod.COLCTRL_1,
colors['text_info_alt'], libtcod.black)
libtcod.console_set_color_control(libtcod.COLCTRL_2,
colors['text_emphasize'], libtcod.black)
heading = f'%cCharacter Information%c' % (libtcod.COLCTRL_2,
libtcod.COLCTRL_STOP)
libtcod.console_print_rect_ex(window, 0, 1, character_screen_width,
character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, heading)
player_level = f'Level: %c{player.level.current_level}%c' % (
libtcod.COLCTRL_1, libtcod.COLCTRL_STOP)
libtcod.console_print_rect_ex(window, 0, 2, character_screen_width,
character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, player_level)
player_experience = f'Experience: %c{player.level.current_xp}%c' % (
libtcod.COLCTRL_1, libtcod.COLCTRL_STOP)
libtcod.console_print_rect_ex(window, 0, 3, character_screen_width,
character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, player_experience)
player_experience_to_next_level = f'Experience to level: %c{player.level.experience_to_next_level}%c' % (
libtcod.COLCTRL_1, libtcod.COLCTRL_STOP)
libtcod.console_print_rect_ex(window, 0, 4, character_screen_width,
character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT,
player_experience_to_next_level)
player_maximum_hp = f'Maximum HP: %c{player.fighter.max_hp}%c' % (
libtcod.COLCTRL_1, libtcod.COLCTRL_STOP)
libtcod.console_print_rect_ex(window, 0, 6, character_screen_width,
character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, player_maximum_hp)
player_attack = f'Attack: %c{player.fighter.power}%c' % (
libtcod.COLCTRL_1, libtcod.COLCTRL_STOP)
libtcod.console_print_rect_ex(window, 0, 7, character_screen_width,
character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, player_attack)
player_defense = f'Defense: %c{player.fighter.defense}%c' % (
libtcod.COLCTRL_1, libtcod.COLCTRL_STOP)
libtcod.console_print_rect_ex(window, 0, 8, character_screen_width,
character_screen_height, libtcod.BKGND_NONE,
libtcod.LEFT, player_defense)
x = int(screen_width / 2 - character_screen_width / 2)
y = int(screen_height / 2 - character_screen_height / 2)
libtcod.console_blit(window, 0, 0, character_screen_width,
character_screen_height, 0, x, y, 1.0, 0.7)
def main():
screen_width = 80
screen_height = 80
map_width = 80
map_height = 70
colors = {
'dark_wall': libtcod.Color(45, 65, 100),
'dark_ground': libtcod.Color(13, 23, 15)
}
player = Entity(int(screen_width / 2), int(screen_height / 2), '@', libtcod.white)
entities = [player]
libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(screen_width, screen_height, 'table tosser', False)
con = libtcod.console_new(screen_width, screen_height)
game_map = GameMap(map_width, map_height)
key = libtcod.Key()
mouse = libtcod.Mouse()
while not libtcod.console_is_window_closed():
libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS, key, mouse)
render_all(con, entities, game_map, screen_width, screen_height, colors)
libtcod.console_flush()
clear_all(con, entities)
action = handle_keys(key)
move = action.get('move')
exit = action.get('exit')
fullscreen = action.get('fullscreen')
if move:
dx, dy = move
if not game_map.is_blocked(player.x + dx, player.y +dy):
player.move(dx, dy)
if exit:
return True
if fullscreen:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
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 setup_ingame_ui(self):
self.game_view = GameView(self.max_camera_width,
self.max_camera_height)
self.infobar = Infobar(self.max_camera_width, self.infobar_height)
self.sidemenu = SideMenu(self.sidemenu_width, self.max_camera_height)
self.gui_background = libtcod.console_new(self.screen_width,
self.screen_height)
self.current_menu = None
def initDisplay(self, displayWidth, displayHeight):
self._displayWidth = displayWidth
self._displayHeight = displayHeight
#libtcod consoles to draw to
self._displayCon = tcod.console_new(displayWidth, displayHeight)
self._overlay = tcod.console_new(displayWidth, displayHeight)
#position of the "crosshair" within the console
self._hudX = self._displayWidth / 2
self._hudY = self._displayHeight / 2
#the map coord where the "Crosshair" is currently located
self._selectedX = self._offsetX + self._hudX
self._selectedY = self._offsetY + self._hudY
self.showCrosshair = True
def __init__(self):
self.width = constants.WINDOW_WIDTH
self.height = constants.WINDOW_HEIGHT
self.console = libtcod.console_new(self.width, self.height)
libtcod.console_set_custom_font(b'arial10x10.png',
libtcod.FONT_TYPE_GREYSCALE |
libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(self.width, self.height, b'Pyrogue', False)
def render(self):
con = libtcod.console_new(self.width, self.height)
y = 1
for (line, color) in self.lines:
libtcod.console_set_default_foreground(con, color)
libtcod.console_print_ex(con, 0, y, libtcod.BKGND_NONE,
libtcod.LEFT, line)
y += 1
return con
def __init__(self, width=20, height=10, console_id=None):
if console_id is None:
self.console_id = libtcod.console_new(width, height)
self.width = width
self.height = height
else:
self.console_id = console_id
self.width = libtcod.console_get_width(console_id)
self.height = libtcod.console_get_height(console_id)
def __init__(self, x: int, y: int, width: int, height: int, fore_fade: float, back_fade: float, parent=None):
self.con_id: int = libtcod.console_new(width, height)
self.parent: GameConsole = parent # If None, it prints to root
self.x: int = x # The console's starting top left coordinates on it's parent interface
self.y: int = y
self.width: int = width
self.height: int = height
self.fore_fade: float = fore_fade
self.back_fade: float = back_fade
def main():
screen_width = 80
screen_height = 50
map_width = 80
map_height = 45
colors = {
"dark_wall": libtcod.Color(0, 0, 100),
"dark_ground": libtcod.Color(50, 50, 150)
}
player = Entity(int(screen_width / 2), int(screen_height / 2), "@",
libtcod.fuchsia)
npc = Entity(int(screen_width / 2 - 5), int(screen_height / 2), "@",
libtcod.yellow)
entities = [npc, player]
# http://roguecentral.org/doryen/data/libtcod/doc/1.5.1/html2/console_set_custom_font.html?c=false&cpp=false&cs=false&py=true&lua=false
libtcod.console_set_custom_font(
"arial10x10.png",
libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
# Creates the window, title, and fullscreen
libtcod.console_init_root(screen_width, screen_height, "B@rd", False)
# Draw a new console
con = libtcod.console_new(screen_width, screen_height)
game_map = GameMap(map_width, map_height)
# Holds keyboard and mouse input
key = libtcod.Key()
mouse = libtcod.Mouse()
# Game loop (until screen is closed)
while not libtcod.console_is_window_closed():
libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS, key, mouse)
render_all(con, entities, game_map, screen_width, screen_height,
colors)
libtcod.console_flush()
clear_all(con, entities)
action = handle_keys(key)
move = action.get("move")
exit = action.get("exit")
fullscreen = action.get("fullscreen")
if move:
dx, dy = move
if not game_map.is_blocked(player.x + dx, player.y + dy):
player.move(dx, dy)
if exit:
return True
if fullscreen:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
def init():
global SYMBOL_MAP, KEYBOARD_MAP, CON, UI, MOUSE, KEY
w = config.SCREEN_WIDTH
h = config.SCREEN_HEIGHT
ltc.sys_set_fps(config.FPS)
#ltc.console_set_custom_font(config.TILE_SET, ltc.FONT_LAYOUT_ASCII_INROW | ltc.FONT_TYPE_GREYSCALE, 16, 16)
ltc.console_set_custom_font(config.TILE_SET,
ltc.FONT_LAYOUT_TCOD | ltc.FONT_TYPE_GREYSCALE,
32, 8)
ltc.console_init_root(w, h, config.TITLE, False)
KEYBOARD_MAP = dict([[v, k] for k, v in KEYBOARD_MAP.items()])
CON = ltc.console_new(w, h)
UI = ltc.console_new(w, h)
ltc.console_set_key_color(UI, ltc.purple)
MOUSE = ltc.Mouse()
KEY = ltc.Key()
def main():
screen_width = 80
screen_height = 50
map_width = 80
map_height = 45
room_max_size = 10
room_min_size = 6
max_rooms = 30
colors = {
'dark_wall': libtcod.Color(0, 0, 100),
'dark_ground': libtcod.Color(50, 50, 150)
}
player = Entity(int(screen_width / 2), int(screen_height / 2), '@', libtcod.white)
npc = Entity(int(screen_width / 2), int(screen_height / 2), '@', libtcod.yellow)
entities = [npc, player]
libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(screen_width, screen_height, 'libtcod tutorial revised', False)
con = libtcod.console_new(screen_width, screen_height)
game_map = GameMap(map_width, map_height)
game_map.make_map(max_rooms, room_min_size, room_max_size, map_width, map_height, player)
key = libtcod.Key()
mouse = libtcod.Mouse()
while not libtcod.console_is_window_closed():
libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS, key, mouse)
render_all(con, entities, game_map, screen_width, screen_height, colors)
libtcod.console_flush()
clear_all(con, entities)
action = handle_keys(key)
move = action.get('move')
exit = action.get('exit')
fullscreen = action.get('fullscreen')
if move:
dx, dy = move
if not game_map.is_blocked(player.x + dx, player.y + dy):
player.move(dx, dy)
if exit:
return True
if fullscreen:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
