def handle_keys(self):
key = libtcod.console_wait_for_keypress(True)
if key.vk == libtcod.KEY_ESCAPE:
return 'exit'
elif key.vk == libtcod.KEY_ENTER and libtcod.KEY_ALT:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
elif key.vk == libtcod.KEY_CONTROL and ord('s'):
libtcod.sys_save_screenshot()
move = False
if self.mode == 'playing':
if libtcod.console_is_key_pressed(libtcod.KEY_UP):
self.move_player((0, -1))
move = True
return 'move'
elif libtcod.console_is_key_pressed(libtcod.KEY_DOWN):
self.move_player((0, 1))
move = True
return 'move'
elif libtcod.console_is_key_pressed(libtcod.KEY_LEFT):
self.move_player((-1, 0))
move = True
return 'move'
elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
self.move_player((1, 0))
move = True
return 'move'
if move:
return 'move'
else:
return "didnt-take-turn"
def handle_keys():
key = libtcod.Key()
libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS, key, libtcod.Mouse())
key_char = chr(key.c)
if key.vk is not 0:
logg.debug('Key pressed: key_char[%s], key.vk[%s].', key_char, key.vk)
#toggle fullscreen
if key.vk == libtcod.KEY_F11:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
#exit game
elif key.vk == libtcod.KEY_ESCAPE:
return 'exit'
#if the game is playing
if Game.gamestate == 'playing':
#movement keys
#numpad, arrows, vim
if key.vk == libtcod.KEY_KP8 or key.vk == libtcod.KEY_UP or key_char == 'k':
Game.player.move(0, -1)
return True
elif key.vk == libtcod.KEY_KP2 or key.vk == libtcod.KEY_DOWN or key_char == 'j':
Game.player.move(0, 1)
return True
elif key.vk == libtcod.KEY_KP4 or key.vk == libtcod.KEY_LEFT or key_char == 'h':
Game.player.move(-1, 0)
return True
elif key.vk == libtcod.KEY_KP6 or key.vk == libtcod.KEY_RIGHT or key_char == 'l':
Game.player.move(1, 0)
return True
elif key.vk == libtcod.KEY_KP5 or key.vk == libtcod.KEY_SPACE or key_char == '.': #KP_5, SPACE, . - wait a turn
Game.player.move(0, 0)
return True
else:
#test for other keys
if key_char == 'P':
#screenshot, because I can
libtcod.sys_save_screenshot()
if key.vk == libtcod.KEY_F1:
help_screen()
return 'didnt-take-turn' #This makes sure that monsters don't take turn if player did not.
def handle_input(key, mouse):
if key.vk == libtcod.KEY_ENTER and key.lalt:
print 'fullscreen'
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
elif key.vk == libtcod.KEY_PRINTSCREEN or key.c == 'p':
print "screenshot"
if key.lalt :
libtcod.console_save_apf(None,"samples.apf")
print "apf"
else :
libtcod.sys_save_screenshot()
print "png"
elif key.vk == libtcod.KEY_ESCAPE:
return True
if mouse.lbutton_pressed:
x = mouse.x/FONT_WIDTH
y = mouse.y/FONT_HEIGHT
if mouse.rbutton_pressed:
x = mouse.x/FONT_WIDTH
y = mouse.y/FONT_HEIGHT
# key handler
player.control(key.vk)
if key.vk == libtcod.KEY_ENTER and key.lalt:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
elif key.vk == libtcod.KEY_PRINTSCREEN or key.c == 'p':
print ("screenshot")
if key.lalt :
libtcod.console_save_apf(None,"samples.apf")
print ("apf")
else :
libtcod.sys_save_screenshot()
print ("png")
elif key.vk == libtcod.KEY_ESCAPE:
break
elif key.vk == libtcod.KEY_F1:
libtcod.sys_set_renderer(libtcod.RENDERER_GLSL)
elif key.vk == libtcod.KEY_F2:
libtcod.sys_set_renderer(libtcod.RENDERER_OPENGL)
elif key.vk == libtcod.KEY_F3:
libtcod.sys_set_renderer(libtcod.RENDERER_SDL)
libtcod.console_flush()
def print_screen(self):
libtcod.sys_save_screenshot()
def test_sys_screenshot(console, tmpdir):
libtcodpy.sys_save_screenshot(tmpdir.join('test.png').strpath)
def handle_keys():
global player
global fov_recompute
global key
key_char = chr(key.c)
#key = libtcod.console_check_for_keypress() #real-time
#key = libtcod.console_wait_for_keypress(True) #turn-based
if key.vk == libtcod.KEY_ENTER and key.lalt:
# Alt+Enter: toggle fullscreen
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
elif key.vk == libtcod.KEY_ESCAPE:
return 'exit'
if game_state == 'playing':
# movement keys
if key_char == 's':
player_move_or_attack(0,1) # down
elif key_char == 'w':
player_move_or_attack(0,-1) # up
elif key_char == 'd':
player_move_or_attack(1,0) # right
elif key_char=='a':
player_move_or_attack(-1,0) # left
elif key_char=='c':
player_move_or_attack(1,1) # rdown
elif key_char=='e':
player_move_or_attack(1,-1) # rup
elif key_char=='q':
player_move_or_attack(-1,-1) # lup
elif key_char=='z':
player_move_or_attack(-1,1) # ldown
else:
# test for other keys
if key_char == 'g':
# pick up an item
for object in objects: # look for an item in the players tile
if object.item and object.x == player.x and object.y == player.y:
object.item.pick_up(player)
return # end turn even if noting got picked
if key_char == 'i':
# display inventory menu, if an item is selected, use it
chosen_item = inventory_menu('Press the key next to an item to use it, or any other to cancel\n')
if chosen_item is not None:
chosen_item.use(player)
return
if key_char == 'd':
chosen_item = inventory_menu('Press the key next to an item to drop it, or any other to cancel\n')
if chosen_item is not None:
chosen_item.drop(player)
return
if key_char == '<':
# Go down stairs if player is on them
if stairs.x == player.x and stairs.y == player.y:
next_level()
if key_char == 'f':
# Show character information
level_up_xp = LEVEL_UP_BASE + player.level * LEVEL_UP_FACTOR
msgbox('Character information\n\nLevel : ' + str(player.level) +
'\nExperience : ' + str(player.fighter.xp) +
'\nExperience to level up : ' + str(level_up_xp) +
'\nMax HP : ' + str(player.fighter.max_hp) +
'\nAttack : ' + str(player.fighter.power) +
'\nDefense : ' + str(player.fighter.defense), CHARACTER_SCREEN_WIDTH)
if key_char == 'r':
# take screenshot!
libtcod.sys_save_screenshot()
return 'didnt-take-turn'
def screenshot():
tcod.sys_save_screenshot('screenshot-%s.bmp' % time.time())
r, 0,
len(projectiles_double) - 1)], shot_colors[libtcod.random_get_int(
r, 0,
len(shot_colors) - 1)])
for i in range(20):
con = libtcod.console_new(30, 30)
libtcod.console_set_custom_font(
'cp437_10x10.png',
libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_ASCII_INROW)
libtcod.console_init_root(30, 30, 'Spaceship Generator', False)
body = generate_body()
h = len(body.shape)
wing = generate_wing(body)
if len(wing.engines_single) + len(
wing.engines_double
) == 0 and not body.engine_single and not body.engine_double:
body.shape.append([206])
body.engine_double = True
colors = color_schemes[libtcod.random_get_int(r, 0,
len(color_schemes) - 1)]
libtcod.console_set_default_foreground(con, colors[0])
wing.reversed().draw(con, 0, 8)
wing.draw(con, h + 1, 8)
libtcod.console_set_default_foreground(con, colors[1])
body.draw(con, h, 8)
libtcod.console_blit(con, 0, 0, 30, 30, 0, 0, 0)
libtcod.console_flush()
libtcod.sys_save_screenshot(None)
libtcod.console_wait_for_keypress(True)
def screenshot():
tcod.sys_save_screenshot('screenshot-%s.bmp' % time.time())
def input(self):
libtcod.sys_check_for_event(
libtcod.EVENT_KEY_PRESS | libtcod.EVENT_MOUSE, self.key,
self.mouse)
# SYSTEM INPUT -------------------------------------------------
if libtcod.console_is_window_closed():
self.set_state(0)
if self.key == Input.F11: #libtcod.KEY_ENTER and self.key.lalt:
#Alt+Enter: toggle fullscreen
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
# elif self.key == Input.F4:
# self.game_screen.toggle_blink_selected()
#elif self.key == Input.F2:
#self.test_log()
#self.sound_manager.toggle_music()
#self.sound_manager.play_sound(self.sound_manager.sword2)
#self.kill_all_ennemy()
elif self.key == Input.ALT_ESCAPE:
self.state = 0
return
elif self.key.vk == libtcod.KEY_SPACE:
#self.test_ai()
#print 'ai tested'
pass
elif self.key == Input.F12:
print 'screenshot saved'
libtcod.sys_save_screenshot('Ressources/screen.png')
#MOUSE INPUT-------------------------------------------------------
if self.mouse.rbutton_pressed:
print self.window.get_elem_by_mouse()
if self.mouse.lbutton_pressed:
elem = self.window.get_elem_by_mouse()
self.activate(elem)
#Menu INPUT-----------------------------------------------------
if self.selected_window:
if self.key == Input.UP:
print 'up!'
self.selected_window.content.previous_elem()
self.update_menu(self.selected_window)
if self.key == Input.DOWN:
print 'up!'
self.selected_window.content.next_elem()
self.update_menu(self.selected_window)
elif self.key == Input.ESCAPE:
print 'escape'
#self.open_pause_menu()
elif self.key == Input.ENTER:
self.selected_window.content.activate_elem()
#if self.key.vk==libtcod.KEY_CHAR:
# print self.key.c
#keyboard input--------------------------------------------------------
if self.state == 4 or self.state == 5:
if self.key.vk == libtcod.KEY_CHAR:
print chr(self.key.c)
self.print_letter(chr(self.key.c))
elif self.key == Input.BACKSPACE:
self.del_letter()
elif self.key == Input.ENTER:
self.validate_character() #temporary
elif self.key == Input.SPACE:
self.validate_team()
elif self.state == 6:
if self.key == Input.SPACE:
self.new_level()
elif self.key == Input.TAB:
self.level.set_spawns()
elif self.key == Input.ENTER:
self.launch_level()
#Game INPUT----------------------------------------------------------
elif not self.selected_window and self.state == 1:
if self.key == Input.ESCAPE:
#self.open_pause_menu()
#self.selected_unit=None #temporary
if self.selected_unit:
if self.target:
self.select_target(None)
elif self.is_targeting() and len(
self.get_target_list()) > 0:
self.set_targeting(False)
self.select_action(0)
print 'stopped targeting'
# return #Bad
elif self.in_move:
self.cancel_move()
print 'move cancelled'
# return #Bad
else:
self.select_unit(None)
elif self.key == Input.ENTER:
#if self.in_move and self.selected_action==0 and self.selected_tile==self.selected_unit.get_pos():
#self.solve_move()
#self.select()
# solve_action
if self.selected_unit and self.target:
self.solve_action(self.selected_unit, self.selected_action,
self.target)
elif self.selected_tile:
self.select()
if self.selected_unit and self.target:
self.solve_action(self.selected_unit,
self.selected_action, self.target)
else:
print 'empty enter'
if self.selected_unit:
print 'what to do now'
else:
print "this enter input should'tbe"
elif self.key == Input.TAB:
if self.selected_unit and not self.target:
if len(self.get_target_list()) > 0: #self.targeting:
#print self.get_target_list()
self.target = self.get_target_list()[0]
else:
self.next_unit()
elif self.selected_unit and self.target:
self.next_target()
else:
self.next_unit()
elif self.key == Input.SPACE:
self.next_turn()
elif self.key == Input.NUMBER:
a = Input.NUMBER.get_value(self.key)
print 'number input receveid: ', a
if self.selected_unit:
self.select_action(a)
else:
self.select_unit(self.squad.get_unit(a))
elif self.key == Input.UP and not self.targeting:
if self.selected_tile:
self.set_selected_tile(self.selected_tile[0],
self.selected_tile[1] - 1)
elif self.key == Input.DOWN and not self.targeting:
if self.selected_tile:
self.set_selected_tile(self.selected_tile[0],
self.selected_tile[1] + 1)
elif self.key == Input.LEFT and not self.targeting:
if self.selected_tile:
self.set_selected_tile(self.selected_tile[0] - 1,
self.selected_tile[1])
elif self.key == Input.RIGHT:
if self.selected_tile and not self.targeting:
self.set_selected_tile(self.selected_tile[0] + 1,
self.selected_tile[1])
elif self.targeting:
self.next_target()
def handle_keys(self):
if self.key.vk == libtcod.KEY_UP:
self.player_ship.throttle_open = self.key.pressed
if self.key.vk == libtcod.KEY_DOWN:
self.player_ship.reversing = self.key.pressed
if self.key.vk == libtcod.KEY_LEFT:
self.player_ship.turning_left = self.key.pressed
if self.key.vk == libtcod.KEY_RIGHT:
self.player_ship.turning_right = self.key.pressed
if self.key.vk == libtcod.KEY_SPACE:
self.player_ship.laser_firing = self.key.pressed
if self.key.pressed and self.key.vk == libtcod.KEY_ENTER and self.key.lalt:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
elif self.key.pressed and self.key.vk == libtcod.KEY_ESCAPE:
return 1 #exit game
elif self.key.pressed:
key_character = chr(self.key.c)
if key_character == 'l' and self.current_screen == 'flight':
landed, message, planet_index = self.sector.land_at_closest_planet(self.player_ship)
if message:
self.add_message(message)
if landed:
self.landed_loop(planet_index)
elif key_character == 'G':
self.player_ship.ship_value = getrandbits(32)
self.player_ship.load_ship_sprites()
elif self.key.vk == libtcod.KEY_TAB:
if self.current_screen == 'flight':
self.galaxy_map_loop()
else:
return 1 # exit galaxy loop
elif key_character == '\\' and self.current_screen == 'galaxy':
self.galaxy.cycle_sector_target()
elif key_character == 'm':
if self.minimap_width == self.screen_height:
self.set_minimap(20)
elif self.minimap_width == 23:
self.set_minimap(20 + (self.screen_height-20)/2)
else:
self.set_minimap(self.screen_height-3)
elif key_character == 'p':
self.sector.cycle_planet_target(self.player_ship)
elif key_character == 'P':
self.sector.target_nearest_planet(self.player_ship)
elif key_character == 't':
self.sector.cycle_target(self.player_ship)
elif key_character == 'T':
self.sector.target_nearest_asteroid(self.player_ship)
elif key_character == 'j' and self.current_screen == 'flight':
self.new_sector()
elif key_character == 'S':
libtcod.sys_save_screenshot()
self.add_message("Saved screenshot")
def screenshot(name):
tcod.sys_save_screenshot(name)
#handle keys
player_action = handle_keys()
#prints out name of object below player position
walk_names = player.look.walk_names()
if (game_state == 'playing'
and (player_action != 'no-move' and player_action != 'enter-key')):
print player_action
for object in objects:
if object.ai:
object.ai.take_turn()
if object.fighter:
#health regen
object.fighter.health_regen()
if object.needs:
object.needs.hunger_increase()
object.needs.thirst_increase()
if (walk_names and player_action == 'player-move'):
message(walk_names)
if (game_state == 'playing'
or game_state == 'dead') and player_action == 'esc':
break
if (game_state == 'playing'
or game_state == 'dead') and player_action == 'enter-key':
#screenshot
libtcod.sys_save_screenshot()
message('//SCREENSHOT SAVED//')
def screenshot(name): tcod.sys_save_screenshot(name)
if libtcod.random_get_int(r, 0, 1) == 1:
return WeaponComponent([[side_weapons_single[libtcod.random_get_int(r, 0, len(side_weapons_single) - 1)]]], projectiles_single[libtcod.random_get_int(r, 0, len(projectiles_single) - 1)], shot_colors[libtcod.random_get_int(r, 0, len(shot_colors) - 1)])
else:
return WeaponComponent([[side_weapons_double[libtcod.random_get_int(r, 0, len(side_weapons_double) - 1)]]], projectiles_double[libtcod.random_get_int(r, 0, len(projectiles_double) - 1)], shot_colors[libtcod.random_get_int(r, 0, len(shot_colors) - 1)])
def generate_weapon_front():
if libtcod.random_get_int(r, 0, 1) == 1:
return WeaponComponent([[front_weapons_single[libtcod.random_get_int(r, 0, len(front_weapons_single) - 1)]]], projectiles_single[libtcod.random_get_int(r, 0, len(projectiles_single) - 1)], shot_colors[libtcod.random_get_int(r, 0, len(shot_colors) - 1)])
else:
return WeaponComponent([[front_weapons_double[libtcod.random_get_int(r, 0, len(front_weapons_double) - 1)]]], projectiles_double[libtcod.random_get_int(r, 0, len(projectiles_double) - 1)], shot_colors[libtcod.random_get_int(r, 0, len(shot_colors) - 1)])
for i in range(20):
con = libtcod.console_new(30, 30)
libtcod.console_set_custom_font('cp437_10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_ASCII_INROW)
libtcod.console_init_root(30, 30, 'Spaceship Generator', False)
body = generate_body()
h = len(body.shape)
wing = generate_wing(body)
if len(wing.engines_single) + len(wing.engines_double) == 0 and not body.engine_single and not body.engine_double:
body.shape.append([206])
body.engine_double = True
colors = color_schemes[libtcod.random_get_int(r, 0, len(color_schemes) - 1)]
libtcod.console_set_default_foreground(con, colors[0])
wing.reversed().draw(con, 0, 8)
wing.draw(con, h + 1, 8)
libtcod.console_set_default_foreground(con, colors[1])
body.draw(con, h, 8)
libtcod.console_blit(con, 0, 0, 30, 30, 0, 0, 0)
libtcod.console_flush()
libtcod.sys_save_screenshot(None)
libtcod.console_wait_for_keypress(True)
def menu(header, options, width, offset=0):
"""Generic menu function"""
if len(options) > 26: raise ValueError('Cannot have a menu with more than 26 options.')
#calculate total height for the header (auto-wraped), and one line per option
header_height = libtcod.console_get_height_rect(Game.con, 0, 0, width, SCREEN_HEIGHT, header)
if header == '':
header_height = 0
height = len(options) + header_height
highlight = ord('a')
while True:
#creates 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, color_menu_text)
libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header)
libtcod.console_set_default_background(window, color_menu_highlight_b)
#print the menu's options
y = header_height
letter_index = ord('a')
for option_text in options:
text = '(' + chr(letter_index) + ') ' + option_text
if not highlight == letter_index:
libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, text)
else:
libtcod.console_print_ex(window, 0, y, libtcod.BKGND_SET, libtcod.LEFT, text)
y += 1
letter_index +=1
#blit "window" contents to the root console
x = SCREEN_WIDTH/2 - width/2
y = SCREEN_HEIGHT/2 - height/2 + offset
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
#present the console, and wait for a key-press
libtcod.console_flush()
mouse = libtcod.Mouse()
key = libtcod.Key()
libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS | libtcod.EVENT_MOUSE, key, mouse)
mouse_move = abs(mouse.dy) + abs(mouse.dx)
if mouse_move > 2:
if header_height != 0 and mouse.cy > y and mouse.cy < y+height:
highlight = ord('a') + mouse.cy - y - header_height
else:
highlight = ord('a') + mouse.cy - y
if highlight < ord('a'):
highlight = ord('a')
elif highlight > letter_index - 1:
highlight = letter_index -1
if mouse.lbutton_pressed:
index = highlight - ord('a')
if index >= 0 and index < len(options): return index
if chr(key.c) == "P":
libtcod.sys_save_screenshot()
if key.vk == libtcod.KEY_F11:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
if key.vk == libtcod.KEY_ESCAPE:
#XXX WTF I do with that.
pass
if key.vk == libtcod.KEY_ENTER or key.vk == libtcod.KEY_KPENTER or key.vk == libtcod.KEY_SPACE:
index = highlight - ord('a')
if index >= 0 and index < len(options): return index
if key.vk == libtcod.KEY_DOWN or key.vk == libtcod.KEY_KP2 or chr(key.c) == 'k':
if not highlight == letter_index -1:
highlight += 1
elif key.vk == libtcod.KEY_UP or key.vk == libtcod.KEY_KP8 or chr(key.c) == 'j':
if not highlight == ord('a'):
highlight -= 1
#convert ASCII code to an index; if it corresponds to an option - return that
index = key.c - ord('a')
if index >= 0 and index < len(options): return index
print(index)
return index
def handle_keys():
if cfg.key.vk == libtcod.KEY_ENTER and cfg.key.lalt:
#Alt+Enter: toggle fullscreen
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
elif cfg.key.vk == libtcod.KEY_ESCAPE or libtcod.console_is_window_closed(
):
return 'exit' #exit game
elif cfg.key.vk == libtcod.KEY_F12:
#take a screenshot
libtcod.sys_save_screenshot('a')
if cfg.game_state == 'playing':
#movement keys
if cfg.key.vk == libtcod.KEY_UP or cfg.key.vk == libtcod.KEY_KP8:
object.player_move_or_attack(0, -1)
elif cfg.key.vk == libtcod.KEY_DOWN or cfg.key.vk == libtcod.KEY_KP2:
object.player_move_or_attack(0, 1)
elif cfg.key.vk == libtcod.KEY_LEFT or cfg.key.vk == libtcod.KEY_KP4:
object.player_move_or_attack(-1, 0)
elif cfg.key.vk == libtcod.KEY_RIGHT or cfg.key.vk == libtcod.KEY_KP6:
object.player_move_or_attack(1, 0)
elif cfg.key.vk == libtcod.KEY_HOME or cfg.key.vk == libtcod.KEY_KP7:
object.player_move_or_attack(-1, -1)
elif cfg.key.vk == libtcod.KEY_PAGEUP or cfg.key.vk == libtcod.KEY_KP9:
object.player_move_or_attack(1, -1)
elif cfg.key.vk == libtcod.KEY_END or cfg.key.vk == libtcod.KEY_KP1:
object.player_move_or_attack(-1, 1)
elif cfg.key.vk == libtcod.KEY_PAGEDOWN or cfg.key.vk == libtcod.KEY_KP3:
object.player_move_or_attack(1, 1)
elif cfg.key.vk == libtcod.KEY_KP5 or cfg.key.vk == libtcod.KEY_SPACE:
pass #do nothing ie wait for the monster to come to you
elif cfg.key.vk == libtcod.KEY_INSERT or cfg.key.vk == libtcod.KEY_KP0:
#toggle real time mode
cfg.run_realtime = not cfg.run_realtime
else:
#test for other keys
key_char = chr(cfg.key.c) # use for alphabetical keys
# use key.text for symbolic keys
'''
if key_char == 'g':
#pick up an item
for obj in objects: #look for an item in the player's tile
if obj.x == cfg.player.x and obj.y == cfg.player.y and obj.item:
obj.item.pick_up()
break
if key_char == 'i':
#show the inventory; if an item is selected, use it
chosen_item = inventory_menu('Press the key next to an item to use it, or any other to cancel.\n')
if chosen_item is not None:
chosen_item.use()
if key_char == 'd':
#show the inventory; if an item is selected, drop it
chosen_item = inventory_menu('Press the key next to an item to drop it, or any other to cancel.\n')
if chosen_item is not None:
chosen_item.drop()
if key_char == 'c':
#show character information
level_up_xp = cfg.LEVEL_UP_BASE + cfg.player.level * cfg.LEVEL_UP_FACTOR
gui.msgbox('Character Information\n\nLevel: ' + str(cfg.player.level) + '\nExperience: ' + str(cfg.player.fighter.xp) +
'\nExperience to level up: ' + str(level_up_xp) + '\n\nMaximum HP: ' + str(cfg.player.fighter.max_hp) +
'\nAttack: ' + str(cfg.player.fighter.power) + '\nDefense: ' + str(cfg.player.fighter.defense), cfg.CHARACTER_SCREEN_WIDTH)
'''
if key_char == 's':
#show monster stats
gui.display_monster_stats()
if key_char == 'd':
#show monster descriptions
gui.display_description()
if key_char == '/' or key_char == '?':
#show monster descriptions
gui.display_controls()
if key_char == 'r':
#toggle real time mode
cfg.run_realtime = not cfg.run_realtime
if key_char == 'q':
#quit game while running
return 'exit'
'''
if cfg.key.text == '>' or cfg.key.text == '+':
#go down stairs, if the player is on them
if cfg.stairs.x == cfg.player.x and cfg.stairs.y == cfg.player.y:
next_level()
'''
if cfg.run_realtime:
return 'wait'
else:
return 'didnt-take-turn'
