def handle_keys():
global player_x, player_y, fov_recompute
key = get_key_event(TURN_BASED)
if key.vk == tcod.KEY_ENTER and key.lalt:
# Alt+Enter: toggle fullscreen
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
elif key.vk == tcod.KEY_ESCAPE:
return True # exit game
# movement keys
if tcod.console_is_key_pressed(tcod.KEY_UP):
player.move(0, -1)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_DOWN):
player.move(0, 1)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_LEFT):
player.move(-1, 0)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_RIGHT):
player.move(1, 0)
fov_recompute = True
def keyboard_input(player, con):
global fog_of_war
key = tcod.console_wait_for_keypress(True)
if key.vk == tcod.KEY_ESCAPE:
return True
if key.vk == tcod.KEY_SPACE:
fog_of_war = not fog_of_war
eraseMap(con)
if tcod.console_is_key_pressed(tcod.KEY_UP):
player.move(0, 1)
if tcod.console_is_key_pressed(tcod.KEY_DOWN):
player.move(0, -1)
if tcod.console_is_key_pressed(tcod.KEY_LEFT):
player.move(-1, 0)
if tcod.console_is_key_pressed(tcod.KEY_RIGHT):
player.move(1, 0)
return False
def handle_keys():
global fov_recompute
#key = tcod.console_check_for_keypress() #real-time
key = tcod.console_wait_for_keypress(True) #turn-based
if key.vk == tcod.KEY_ENTER and key.lalt:
#Alt+Enter: toggle fullscreen
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
elif key.vk == tcod.KEY_ESCAPE:
return True #exit game
#movement keys
if tcod.console_is_key_pressed(tcod.KEY_UP):
player.move(0, -1)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_DOWN):
player.move(0, 1)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_LEFT):
player.move(-1, 0)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_RIGHT):
player.move(1, 0)
fov_recompute = True
def handle_keys(currPlayer, mapToUse):
global fov_recompute
#key = tcod.console_check_for_keypress() #real-time
key = tcod.console_wait_for_keypress(True) #turn-based
if key.vk == tcod.KEY_ESCAPE:
sys.exit()
# if key.vk == tcod.KEY_ENTER and key.lalt:
# #Alt+Enter: toggle fullscreen
# tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
#movement keys
if tcod.console_is_key_pressed(tcod.KEY_UP):
mapToUse.movePlayer(currPlayer, 0)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_DOWN):
mapToUse.movePlayer(currPlayer, 2)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_LEFT):
mapToUse.movePlayer(currPlayer, 3)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_RIGHT):
mapToUse.movePlayer(currPlayer, 1)
fov_recompute = True
def handle_keys():
#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' #exit game
if game_state == 'playing':
#movement keys
if libtcod.console_is_key_pressed(libtcod.KEY_UP):
player_move_or_attack(0, -1)
elif libtcod.console_is_key_pressed(libtcod.KEY_DOWN):
player_move_or_attack(0, 1)
elif libtcod.console_is_key_pressed(libtcod.KEY_LEFT):
player_move_or_attack(-1, 0)
elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
player_move_or_attack(1, 0)
else:
return 'didnt-take-turn'
def handle_keys():
global fov_recompute
key = get_key_event(TURN_BASED)
if key.vk == tcod.KEY_ENTER and key.lalt:
# Alt+Enter: toggle fullscreen
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
elif key.vk == tcod.KEY_ESCAPE:
return 'exit' # exit game
# movement and combat only possible in playing game state
if game_state == 'playing':
# movement keys
if tcod.console_is_key_pressed(tcod.KEY_UP):
player.move(0,-1)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_DOWN):
player.move(0,1)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_LEFT):
player.move(-1,0)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_RIGHT):
player.move(1,0)
fov_recompute = True
# testing if turn was taken
else:
return 'turn_not_taken'
def handle_keys(self):
#key = libtcod.console_check_for_keypress() #real-time
key = libtcodpy.console_wait_for_keypress(True) #turn-based
#let monsters take their turn
if self.game_state == 'playing' and self.player_action != 'didnt-take-turn':
for obj in self.objects:
if obj.ai:
obj.ai.take_turn(self.game_map, self.player)
if self.game_state == 'playing':
if key.vk == libtcodpy.KEY_ENTER and key.lalt:
#Alt+Enter: toggle fullscreen
libtcodpy.console_set_fullscreen(not libtcodpy.console_is_fullscreen())
elif key.vk == libtcodpy.KEY_ESCAPE:
return 'exit' #exit game
#movement keys
if libtcodpy.console_is_key_pressed(libtcodpy.KEY_UP):
self.game_map.fov_recompute = self.player.move(0, -1, self.is_blocked_and_target)
elif libtcodpy.console_is_key_pressed(libtcodpy.KEY_DOWN):
self.game_map.fov_recompute = self.player.move(0, 1, self.is_blocked_and_target)
elif libtcodpy.console_is_key_pressed(libtcodpy.KEY_LEFT):
self.game_map.fov_recompute = self.player.move(-1, 0, self.is_blocked_and_target)
elif libtcodpy.console_is_key_pressed(libtcodpy.KEY_RIGHT):
self.game_map.fov_recompute = self.player.move(1, 0, self.is_blocked_and_target)
else:
return 'didnt-take-turn'
def handle_keys():
global fov_recompute
#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 True #exit game
#movement keys
if libtcod.console_is_key_pressed(libtcod.KEY_UP):
player.move(0, -1)
fov_recompute = True
elif libtcod.console_is_key_pressed(libtcod.KEY_DOWN):
player.move(0, 1)
fov_recompute = True
elif libtcod.console_is_key_pressed(libtcod.KEY_LEFT):
player.move(-1, 0)
fov_recompute = True
elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
player.move(1, 0)
fov_recompute = True
def handle_keys():
global playerx, playery
#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 True #exit game
#movement keys
if libtcod.console_is_key_pressed(libtcod.KEY_UP):
playery -= 1
elif libtcod.console_is_key_pressed(libtcod.KEY_DOWN):
playery += 1
elif libtcod.console_is_key_pressed(libtcod.KEY_LEFT):
playerx -= 1
elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
playerx += 1
def handle_keys():
# 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' # exit game
if game_state == 'playing':
# movement keys
if libtcod.console_is_key_pressed(libtcod.KEY_UP):
player_move_or_attack(0, -1)
elif libtcod.console_is_key_pressed(libtcod.KEY_DOWN):
player_move_or_attack(0, 1)
elif libtcod.console_is_key_pressed(libtcod.KEY_LEFT):
player_move_or_attack(-1, 0)
elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
player_move_or_attack(1, 0)
else:
return 'didnt-take-turn'
def handle_keys():
global player, fov_recompute, TURN_BASED
key = get_key_event(TURN_BASED)
if key.vk == tcod.KEY_ENTER and key.lalt:
# Alt+Enter: toggle fullscreen
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
elif key.vk == tcod.KEY_ESCAPE:
return 'exit' # exit game
if game_state == 'playing':
if tcod.console_is_key_pressed(tcod.KEY_UP):
player_move_or_attack(0, -1)
elif tcod.console_is_key_pressed(tcod.KEY_DOWN):
player_move_or_attack(0, 1)
elif tcod.console_is_key_pressed(tcod.KEY_LEFT):
player_move_or_attack(-1, 0)
elif tcod.console_is_key_pressed(tcod.KEY_RIGHT):
player_move_or_attack(1, 0)
else:
return 'didnt-take-turn'
def handle_keys():
global fov_recompute
key = tcod.console_check_for_keypress(True)
if game_state == 'playing':
if key.vk == tcod.KEY_ENTER and key.lalt:
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
elif key.vk == tcod.KEY_ESCAPE:
return 'exit'
if tcod.console_is_key_pressed(tcod.KEY_UP):
player_move_atttack(0, -1)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_DOWN):
player_move_atttack(0, 1)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_LEFT):
player_move_atttack(-1, 0)
fov_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_RIGHT):
player_move_atttack(1, 0)
fov_recompute = True
else:
return 'no-turn'
def handle_keys():
global exit_game
player_dx = 0
player_dy = 0
#movement keys
if tcod.console_is_key_pressed(tcod.KEY_UP):
player_dy = -1
elif tcod.console_is_key_pressed(tcod.KEY_DOWN):
player_dy = 1
elif tcod.console_is_key_pressed(tcod.KEY_LEFT):
player_dx = -1
elif tcod.console_is_key_pressed(tcod.KEY_RIGHT):
player_dx = 1
# move the player
player.move(player_dx, player_dy)
# check for specific key presses combos, etc
key = tcod.console_check_for_keypress()
if key.vk == tcod.KEY_ENTER and key.lalt:
# Alt-enter toggle fullscreen
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
elif key.vk == tcod.KEY_ESCAPE:
exit_game = True
def handle_player_turn_keys(key):
key_char = chr(key.c)
# Movement keys
if key.vk == libtcod.KEY_KP8 or key.vk == libtcod.KEY_UP:
return {'move': (0, -1)}
elif key.vk == libtcod.KEY_KP2 or key.vk == libtcod.KEY_DOWN:
return {'move': (0, 1)}
elif key.vk == libtcod.KEY_KP4 or key.vk == libtcod.KEY_LEFT:
return {'move': (-1, 0)}
elif key.vk == libtcod.KEY_KP6 or key.vk == libtcod.KEY_RIGHT:
return {'move': (1, 0)}
elif key.vk == libtcod.KEY_KP7:
return {'move': (-1, -1)}
elif key.vk == libtcod.KEY_KP9:
return {'move': (1, -1)}
elif key.vk == libtcod.KEY_KP1:
return {'move': (-1, 1)}
elif key.vk == libtcod.KEY_KP3:
return {'move': (1, 1)}
if key_char == 'g':
return {'pickup': True}
elif key_char == 'i':
return {'show_inventory': True}
elif key_char == 'd':
return {'drop_inventory': True}
elif key_char == '.' and libtcod.console_is_key_pressed(
libtcod.KEY_SHIFT): #key_char == '>'
return {'take_down_stairs': True}
elif key_char == ',' and libtcod.console_is_key_pressed(
libtcod.KEY_SHIFT): #key_char == '<'
return {'take_up_stairs': True}
elif key_char == '.' or key.vk == libtcod.KEY_KP5:
return {'wait': True}
elif key_char == 'c':
return {'show_character_screen': True}
elif key_char == 'h':
return {'show_help_screen': True}
if key.vk == libtcod.KEY_ENTER and key.lalt:
# Alt+Enter: toggle full screen
return {'fullscreen': True}
elif key.vk == libtcod.KEY_ESCAPE:
# Exit the game
return {'exit': True}
return {}
def handle_keys(player, game_map):
key = tcod.console_wait_for_keypress(True)
if key.vk == tcod.KEY_ENTER and key.lalt:
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
elif key.vk == tcod.KEY_ESCAPE:
return True
if tcod.console_is_key_pressed(tcod.KEY_UP):
player.move(*DIR_NORTH, game_map)
elif tcod.console_is_key_pressed(tcod.KEY_DOWN):
player.move(*DIR_SOUTH, game_map)
elif tcod.console_is_key_pressed(tcod.KEY_LEFT):
player.move(*DIR_WEST, game_map)
elif tcod.console_is_key_pressed(tcod.KEY_RIGHT):
player.move(*DIR_EAST, game_map)
def input_vk(self):
if not libtcod.console_is_key_pressed(self.key.vk):
return
cpos = self.cursor_pos
ans = ord(self.keyInput)
# returning a result
if (ans == K_ENTER): self.set_result(self.text)
if (ans == K_ESCAPE): self.set_result(self.default)
# deleting
if (ans == K_BACKSPACE):
self.render_text = True
self.putCursor(cpos - 1)
self.delete()
elif (ans == K_DELETE):
self.render_text = True
self.delete()
# moving
elif (ans == K_LEFT):
self.move(cpos - 1)
elif (ans == K_RIGHT):
self.move(cpos + 1)
# insert mode
elif (ans == K_INSERT):
self.insert_mode = not self.insert_mode
def handle_keys():
#key = libtcod.console_check_for_keypress() #real-time
key = libtcod.console_wait_for_keypress(True) #turn-based
global toggleDisplay
global map
if key.vk == libtcod.KEY_ALT:
# random value for
mySeed = random.random()
print(mySeed)
seed = generate_seed(mySeed)
map =make_map(seed)
render_all(map)
libtcod.console_flush()
if key.vk == libtcod.KEY_ENTER:
#change color : bi to greys
if toggleDisplay == True:
toggleDisplay = False
else:
toggleDisplay = True
print('toggleDisplay %s' % toggleDisplay)
render_all(map)
libtcod.console_flush()
#data = generate(simple_sine)
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 True #exit game
#movement keys
if libtcod.console_is_key_pressed(libtcod.KEY_UP):
player.move(0, -1)
elif libtcod.console_is_key_pressed(libtcod.KEY_DOWN):
player.move(0, 1)
elif libtcod.console_is_key_pressed(libtcod.KEY_LEFT):
player.move(-1, 0)
elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
player.move(1, 0)
def handleinput(self):
key = super().handleinput()
if tcod.console_is_key_pressed(tcod.KEY_UP):
self.player.move(self.level, 0, -1)
elif tcod.console_is_key_pressed(tcod.KEY_DOWN):
self.player.move(self.level, 0, 1)
elif tcod.console_is_key_pressed(tcod.KEY_LEFT):
self.player.move(self.level, -1, 0)
elif tcod.console_is_key_pressed(tcod.KEY_RIGHT):
self.player.move(self.level, 1, 0)
elif chr(key.c) in self.keydict:
(fn, ex) = self.keydict[chr(key.c)]
fn(key, ex)
return key
def main():
init()
playing = True
wina = Window(0, 0, 10, screenheight)
winb = Window(0, 0, screenwidth, screenheight)
winc = Window(screenwidth // 2, screenheight // 2, 10, 10)
winb.print_(50, 20, "Hello World!")
winb.print_(0, 20, "Here I am!")
wina.print_(0, 0, "Yo Yo Yo")
winc.print_(10, 10, '@@YO@@')
for y in range(winc.height):
for x in range(winc.width):
tcod.console_set_char_background(winc, x, y,
tcod.Color(20, 20,
20), tcod.BKGND_SET)
while not tcod.console_is_window_closed() and playing:
root.clear()
winb.flush()
wina.flush()
winc.flush()
flip()
key = tcod.console_wait_for_keypress(True)
if key.vk == tcod.KEY_ENTER and key.lalt:
# Alt+Enter: toggle fullscreen
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
elif key.vk == tcod.KEY_ESCAPE:
playing = False
return
if tcod.console_is_key_pressed(tcod.KEY_UP):
winc.y -= 1
elif tcod.console_is_key_pressed(tcod.KEY_DOWN):
winc.y += 1
elif tcod.console_is_key_pressed(tcod.KEY_LEFT):
winc.x -= 1
elif tcod.console_is_key_pressed(tcod.KEY_RIGHT):
winc.x += 1
def handle_keys():
global exit_game
global fov_recompute
player_dx = 0
player_dy = 0
# check for specific key presses combos, etc
key = tcod.console_check_for_keypress()
if key.vk == tcod.KEY_ENTER and key.lalt:
# Alt-enter toggle fullscreen
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
elif key.vk == tcod.KEY_ESCAPE:
return 'exit'
if (game_state == 'playing'):
#movement keys
if tcod.console_is_key_pressed(tcod.KEY_UP):
player_dy = -1
# move or attack
player_move_or_attack(player_dx, player_dy)
elif tcod.console_is_key_pressed(tcod.KEY_DOWN):
player_dy = 1
# move or attack
player_move_or_attack(player_dx, player_dy)
elif tcod.console_is_key_pressed(tcod.KEY_LEFT):
player_dx = -1
# move or attack
player_move_or_attack(player_dx, player_dy)
elif tcod.console_is_key_pressed(tcod.KEY_RIGHT):
player_dx = 1
# move or attack
player_move_or_attack(player_dx, player_dy)
else:
return 'didnt-take-turn'
def get_char(self):
reply = ''
if libtcod.console_is_key_pressed(self.key.vk):
reply = VK_TO_CHAR.get(self.key.vk, None)
elif self.key.vk == libtcod.KEY_TEXT:
tx = self.key.text #.decode()
if (ord(tx) >= 128 or tx == '%'):
return '' # Prevent problem-causing input
else:
reply = tx
self.keyInput = reply
def handle_keys():
global player_x, player_y
global exit_game
#movement keys
if tcod.console_is_key_pressed(tcod.KEY_UP):
player_y = player_y - 1
elif tcod.console_is_key_pressed(tcod.KEY_DOWN):
player_y = player_y + 1
elif tcod.console_is_key_pressed(tcod.KEY_LEFT):
player_x = player_x - 1
elif tcod.console_is_key_pressed(tcod.KEY_RIGHT):
player_x = player_x + 1
key = tcod.console_check_for_keypress()
if key.vk == tcod.KEY_ENTER and key.lalt:
# Alt-enter toggle fullscreen
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
elif key.vk == tcod.KEY_ESCAPE:
exit_game = True
def handle_keys():
# global player.x, player.y # Player Position
global FOV_recompute
key = get_key_event(TURN_BASED) # Gather Keyboard Input
if key.vk == tcod.KEY_ENTER and key.lalt: # Key Check For Fullscreen / Exiting
tcod.console_set_fullscreen(not tcod.console_is_fullscreen()) # Alt + Enter : Toggle Fullscreen
elif key.vk == tcod.KEY_ESCAPE: # Esc : Exit Game
return True
#--------------------------------------------------
# Movement Keys
if tcod.console_is_key_pressed(tcod.KEY_UP): # Up Arrow
player.move(0, -1)
FOV_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_DOWN): # Down Arrow
player.move(0, 1)
FOV_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_LEFT): # Left Arrow
player.move(-1, 0)
FOV_recompute = True
elif tcod.console_is_key_pressed(tcod.KEY_RIGHT): # Right Arrow
player.move(1, 0)
FOV_recompute = True
def handle_keys():
global player_x, player_y
key = get_key_event(TURN_BASED)
if key.vk == tcod.KEY_ENTER and key.lalt:
# Alt + enter = toggle fullscreen
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
elif key.vk == tcod.KEY_ESCAPE:
return True # Exit game
# movement keys
if tcod.console_is_key_pressed(tcod.KEY_UP):
player_y -= 1
elif tcod.console_is_key_pressed(tcod.KEY_DOWN):
player_y += 1
elif tcod.console_is_key_pressed(tcod.KEY_LEFT):
player_x -= 1
elif tcod.console_is_key_pressed(tcod.KEY_RIGHT):
player_x += 1
def handle_keys():
key = get_key_event()
if tcod.console_is_key_pressed(tcod.KEY_UP):
make_map()
if key.vk == tcod.KEY_ESCAPE:
return True
# Select Map Mode
while not tcod.console_is_window_closed():
# Simulation
while isRunning == True:
ProcessCivs(World, Civs, Chars, Colors, Month)
# DEBUG Print Mounth
Month += 1
print("Month: ", Month)
# End Simulation
tcod.console_check_for_keypress(True)
if tcod.console_is_key_pressed(tcod.KEY_SPACE):
timer = 0
isRunning = False
print("*PAUSED*")
time.sleep(1)
# Flush Console
if needUpdate:
BiomeMap(Chars, Colors)
needUpdate = False
key = tcod.console_wait_for_keypress(True)
# Start Simulation
if tcod.console_is_key_pressed(tcod.KEY_SPACE):
isRunning = True
def test_console_key_input(console):
libtcodpy.console_check_for_keypress()
libtcodpy.console_is_key_pressed(libtcodpy.KEY_ENTER)
def test_console_key_input(console):
libtcodpy.console_check_for_keypress()
libtcodpy.console_is_key_pressed(libtcodpy.KEY_ENTER)
def key_get_pressed(): # get both vk and text in one variable
k = libtcod.KEY_NONE
if libtcod.console_is_key_pressed(key.vk): k = key.vk
if k == libtcod.KEY_CHAR: k = key_getchar(key.c)
return k
