def deploy(remote='origin'):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[production, staging])
if app_config.DEPLOY_TO_SERVERS:
require('branch', provided_by=[stable, master, branch])
if (app_config.DEPLOYMENT_TARGET == 'production' and env.branch != 'stable'):
utils.confirm(
colored("You are trying to deploy the '%s' branch to production.\nYou should really only deploy a stable branch.\nDo you know what you're doing?" % env.branch, "red")
)
servers.checkout_latest(remote)
servers.fabcast('text.update')
servers.fabcast('assets.sync')
servers.fabcast('data.update')
if app_config.DEPLOY_CRONTAB:
servers.install_crontab()
if app_config.DEPLOY_SERVICES:
servers.deploy_confs()
update()
render.render_all()
_gzip('www', '.gzip')
_deploy_to_s3()
def target_tile(max_range=None):
# TODO: replace this completely with the target_tile function below
message("Use the mouse or the keyboard to select a tile...", tcod.blue)
# return the position of a tile left-clicked in player's FOV (optionally
# in a range), or (None,None) if right-clicked.
while True:
# render the screen. this erases the inventory and shows the names of
# objects under the mouse.
render.render_all()
tcod.console_flush()
tcod.sys_check_for_event(tcod.EVENT_MOUSE | tcod.EVENT_KEY_PRESS, key, mouse)
(x, y) = (mouse.cx, mouse.cy)
x += render.camera_width
y += render.camera_height
# accept the target if the player clicked in FOV, and in case a range
# is specified, if it's in that range
if (
mouse.lbutton_pressed
and tcod.map_is_in_fov(terain.map.fov_map, x, y)
and (max_range is None or player.distance(x, y) <= max_range)
):
return (x, y)
elif mouse.rbutton_pressed or key.vk == tcod.KEY_ESCAPE:
message("Targetting cancelled")
return (None, None) # cancel if the player right-clicked or pressed Escape
def deploy(remote='origin'):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[production, staging])
if app_config.DEPLOY_TO_SERVERS:
require('branch', provided_by=[stable, master, branch])
if (app_config.DEPLOYMENT_TARGET == 'production' and env.branch != 'stable'):
utils.confirm("You are trying to deploy the '%s' branch to production.\nYou should really only deploy a stable branch.\nDo you know what you're doing?" % env.branch)
servers.checkout_latest(remote)
servers.fabcast('copytext.update')
servers.fabcast('assets.sync')
servers.fabcast('data.update')
if app_config.DEPLOY_CRONTAB:
servers.install_crontab()
if app_config.DEPLOY_SERVICES:
servers.deploy_confs()
update()
render.render_all()
_gzip('www', '.gzip')
_deploy_to_s3()
def play_game():
global key, mouse
player_action = None
mouse = ltc.Mouse()
key = ltc.Key()
#main loop
while not ltc.console_is_window_closed():
ltc.sys_check_for_event(ltc.EVENT_KEY_PRESS | ltc.EVENT_MOUSE, key, mouse)
#render the screen
r.render_all()
ltc.console_flush()
#level up if needed
check_level_up()
#erase all objects at their old locations, before they move
for object in objects:
object.clear()
#handle keys and exit game if needed
player_action = handle_keys()
if player_action == 'exit':
save_game()
break
#let monsters take their turn
if game_state == 'playing' and player_action != 'didnt-take-turn':
for object in objects:
if object.ai:
object.ai.take_turn()
def update_objects(render_bullets_flying=False):
# update all objects
for list in terrain.map.objectlists[:-1]:
for object in list[:]:
#only update living objects
if not object.dead:
object.update()
if player.dead:
#if player dies, immediately end gameplay
break
for i in range(mob.Bullet.speed):
for bullet in terrain.map.bullets[:]:
if not bullet.dead:
bullet.update()
if bullet.dead:
terrain.map.bullets.remove(bullet)
if render_bullets_flying:
render.render_all()
#also update objects in player inventory
#e.g. passive items may do stuff here
if not player.dead:
for object in player.inventory:
object.update()
purge_dead_objects()
def deploy(remote='origin', reload=False):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[production, staging])
if app_config.DEPLOY_TO_SERVERS:
require('branch', provided_by=[stable, master, branch])
if (app_config.DEPLOYMENT_TARGET == 'production' and env.branch != 'stable'):
utils.confirm(
colored("You are trying to deploy the '%s' branch to production.\nYou should really only deploy a stable branch.\nDo you know what you're doing?" % env.branch, "red")
)
servers.checkout_latest(remote)
if app_config.DEPLOY_CRONTAB:
servers.install_crontab()
if app_config.DEPLOY_SERVICES:
servers.deploy_confs()
update()
render.render_all()
flat.deploy_folder(
app_config.S3_BUCKET,
'www',
app_config.PROJECT_SLUG,
headers={
'Cache-Control': 'max-age=%i' % app_config.DEFAULT_MAX_AGE
},
ignore=[]
)
def deploy(quick=None, remote='origin', reload=False):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[random_prod, production, staging])
if app_config.DEPLOYMENT_TARGET == 'production' or app_config.DEPLOYMENT_TARGET == 'random_prod':
utils.confirm(
colored(
"You are trying to deploy to production this project %s.\nDo you know what you're doing?"
% app_config.PROJECT_SLUG, "red"))
if app_config.DEPLOY_TO_SERVERS:
require('branch', provided_by=[stable, master, branch])
if (app_config.DEPLOYMENT_TARGET == 'production'
and env.branch != 'stable'):
utils.confirm(
colored(
"You are trying to deploy the '%s' branch to production.\nYou should really only deploy a stable branch.\nDo you know what you're doing?"
% env.branch, "red"))
servers.checkout_latest(remote)
servers.fabcast('text.update')
servers.fabcast('data.update')
servers.fabcast('assets.sync')
if app_config.DEPLOY_CRONTAB:
servers.install_crontab()
if app_config.DEPLOY_SERVICES:
servers.deploy_confs()
if quick != 'quick':
update()
render.render_all()
# Clear files that should never be deployed
local('rm -rf www/live-data')
flat.deploy_folder(
app_config.S3_BUCKET,
'www',
app_config.PROJECT_SLUG,
headers={'Cache-Control': 'max-age=%i' % app_config.DEFAULT_MAX_AGE},
ignore=['www/assets/*', 'www/live-data/*'])
flat.deploy_folder(
app_config.S3_BUCKET,
'www/assets',
'%s/assets' % app_config.PROJECT_SLUG,
headers={'Cache-Control': 'max-age=%i' % app_config.ASSETS_MAX_AGE})
if reload:
reset_browsers()
if not check_timestamp():
reset_browsers()
def deploy(remote='origin', reload=False):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[production, staging])
update()
render.render_all()
# Clear files that should never be deployed
local('rm -rf www/live-data')
flat.deploy_folder(
app_config.S3_BUCKET,
'www',
app_config.PROJECT_SLUG,
headers={'Cache-Control': 'max-age=%i' % app_config.DEFAULT_MAX_AGE},
ignore=['www/assets/*', 'www/live-data/*'])
flat.deploy_folder(
app_config.S3_BUCKET,
'www/assets',
'%s/assets' % app_config.PROJECT_SLUG,
headers={'Cache-Control': 'max-age=%i' % app_config.ASSETS_MAX_AGE})
if reload:
reset_browsers()
if not check_timestamp():
reset_browsers()
def build_electron():
require('settings', provided_by=[production, staging])
render.render_all()
if not os.path.exists('electron'):
os.makedirs('electron')
local('npm run-script pack')
def build_electron():
require('settings', provided_by=[production, staging])
render.render_all()
if not os.path.exists('electron'):
os.makedirs('electron')
local('npm run-script pack')
def deploy(quick=None, remote='origin', reload=False):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[production, staging])
if app_config.DEPLOY_TO_SERVERS:
require('branch', provided_by=[stable, master, branch])
if (app_config.DEPLOYMENT_TARGET == 'production' and env.branch != 'stable'):
utils.confirm(
colored("You are trying to deploy the '%s' branch to production.\nYou should really only deploy a stable branch.\nDo you know what you're doing?" % env.branch, "red")
)
servers.checkout_latest(remote)
servers.fabcast('text.update')
servers.fabcast('assets.sync')
servers.fabcast('data.update')
if app_config.DEPLOY_CRONTAB:
servers.install_crontab()
if app_config.DEPLOY_SERVICES:
servers.deploy_confs()
if quick != 'quick':
update()
render.render_all()
# Clear files that should never be deployed
local('rm -rf www/live-data')
flat.deploy_folder(
app_config.S3_BUCKET,
'www',
app_config.PROJECT_SLUG,
headers={
'Cache-Control': 'max-age=%i' % app_config.DEFAULT_MAX_AGE
},
ignore=['www/assets/*', 'www/live-data/*']
)
flat.deploy_folder(
app_config.S3_BUCKET,
'www/assets',
'%s/assets' % app_config.PROJECT_SLUG,
headers={
'Cache-Control': 'max-age=%i' % app_config.ASSETS_MAX_AGE
}
)
if reload:
reset_browsers()
if not check_timestamp():
reset_browsers()
def deploy(remote='origin', reload=False):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[production, staging])
if app_config.DEPLOY_TO_SERVERS:
require('branch', provided_by=[stable, master, branch])
if (app_config.DEPLOYMENT_TARGET == 'production'
and env.branch != 'stable'):
utils.confirm(
colored(
"You are trying to deploy the '%s' branch to production.\nYou should really only deploy a stable branch.\nDo you know what you're doing?"
% env.branch, "red"))
servers.checkout_latest(remote)
# servers.fabcast('text.update')
# servers.fabcast('assets.sync')
# servers.fabcast('data.update')
if app_config.DEPLOY_CRONTAB:
servers.install_crontab()
if app_config.DEPLOY_SERVICES:
servers.deploy_confs()
update()
render.render_all()
# Clear files that should never be deployed
local('rm -rf www/live-data')
flat.deploy_folder(
app_config.S3_BUCKET,
'www',
'%s%s' %
(app_config.DEBATE_DIRECTORY_PREFIX, app_config.CURRENT_DEBATE),
headers={'Cache-Control': 'max-age=%i' % app_config.DEFAULT_MAX_AGE},
ignore=['www/assets/*', 'www/live-data/*'])
flat.deploy_folder(
app_config.S3_BUCKET,
'www/assets',
'%s%s/assets' %
(app_config.DEBATE_DIRECTORY_PREFIX, app_config.CURRENT_DEBATE),
headers={'Cache-Control': 'max-age=%i' % app_config.ASSETS_MAX_AGE})
# DEPLOY STATIC FACTCHECK FROM LOCAL ENVIRONMENT
if app_config.DEPLOY_STATIC_FACTCHECK:
execute('deploy_factcheck')
if reload:
reset_browsers()
if not check_timestamp():
reset_browsers()
def deploy_client(remote='origin'):
"""
Render and deploy app to S3.
"""
require('settings', provided_by=[production, staging])
update()
render.render_all()
utils._gzip('www', '.gzip')
utils._deploy_to_s3()
def deploy(quick=False):
"""
Deploy the latest app to S3
"""
require('settings', provided_by=[production, staging])
if not quick == 'quick':
update()
render.render_all()
_gzip('www', '.gzip')
_deploy_to_s3()
def deploy_client(remote='origin'):
"""
Render and deploy app to S3.
"""
require('settings', provided_by=[production, staging])
update()
render.render_all()
utils._gzip('www', '.gzip')
utils._deploy_to_s3()
def deploy(quick=False):
"""
Deploy the latest app to S3
"""
require('settings', provided_by=[production, staging])
if not quick == 'quick':
update()
render.render_all()
_gzip('www', '.gzip')
_deploy_to_s3()
def deploy_test():
require('settings', provided_by=[production, staging])
render.render_all()
# Clear files that should never be deployed
local('rm -rf www/live-data')
flat.deploy_folder(
'www',
app_config.PROJECT_SLUG,
headers={'Cache-Control': 'max-age=%i' % app_config.DEFAULT_MAX_AGE},
ignore=['www/assets/*'])
def deploy(remote='origin'):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[production, staging])
if app_config.DEPLOY_TO_SERVERS:
require('branch', provided_by=[stable, master, branch])
if (app_config.DEPLOYMENT_TARGET == 'production'
and env.branch != 'stable'):
utils.confirm(
colored(
"You are trying to deploy the '%s' branch to production.\nYou should really only deploy a stable branch.\nDo you know what you're doing?"
% env.branch, "red"))
servers.checkout_latest(remote)
servers.fabcast('text.update')
#servers.fabcast('assets.sync')
servers.fabcast('data.update')
if app_config.DEPLOY_CRONTAB:
# servers.install_crontab()
_servers.install_crontab()
if app_config.DEPLOY_SERVICES:
servers.deploy_confs()
update()
render.render_all()
# # Clear files that should never be deployed
# local('rm -rf www/live-data')
# flat.deploy_folder(
# 'www',
# app_config.PROJECT_SLUG,
# headers={
# 'Cache-Control': 'max-age=%i' % app_config.DEFAULT_MAX_AGE
# },
# ignore=['www/assets/*', 'www/live-data/*']
# )
# flat.deploy_folder(
# 'www/assets',
# '%s/assets' % app_config.PROJECT_SLUG,
# headers={
# 'Cache-Control': 'max-age=%i' % app_config.ASSETS_MAX_AGE
# }
# )
_deploy_to_graphics()
def deploy(remote='origin'):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[production, staging])
update()
render.render_all()
# Clear files that should never be deployed
local('rm -rf www/live-data')
local('rsync -vr www/ ubuntu@%s:~/www/%s' % (app_config.FILE_SERVER, app_config.PROJECT_SLUG))
def target_tile(max_range=None):
# return the position of a tile left-clicked in player's FOV (optionally
# in a range), or (None,None) if right-clicked.
message("Use the mouse or the keyboard to select a tile...", tcod.blue)
prevcolor = tcod.black
mouse_lastx, mouse_lasty = (x, y) = render.prev_mouse_pos
while True:
# render the screen. this erases the inventory and shows the names of
# objects under the mouse.
render.render_all()
tcod.console_flush()
tcod.console_set_char_background(
render.con, x, y, prevcolor, tcod.BKGND_SET
) # set last tile's bg color to normal
tcod.sys_check_for_event(tcod.EVENT_MOUSE | tcod.EVENT_KEY_PRESS, key, mouse)
if mouse.dx or mouse.dy:
(mouse_lastx, mouse_lasty) = (x, y) = (mouse.cx, mouse.cy)
x = mouse.cx
y = mouse.cy
x = x + render.camera_x
y = y + render.camera_y
key_pressed = game.get_key(key)
if key_pressed in direction_keys:
direction = direction_keys[key_pressed]
x += direction[0]
y += direction[1]
if tcod.map_is_in_fov(terrain.map.fov_map, x, y):
prevcolor = tcod.console_get_char_background(render.con, x, y) # for resetting the color later
tcod.console_set_char_background(render.con, x, y, tcod.sky, tcod.BKGND_SET) # visualising the target tile
else:
x, y = game.player.x, game.player.y # if not in fov, reset it to the player coords
if mouse.rbutton_pressed or key.vk == tcod.KEY_ESCAPE:
tcod.console_set_char_background(render.con, x, y, prevcolor, tcod.BKGND_SET)
return (None, None) # cancel if the player right-clicked or pressed Escape
# accept the target if the player clicked in FOV, and in case a range
# is specified, if it's in that range
if (
(mouse.lbutton_pressed or key.vk == tcod.KEY_ENTER)
and tcod.map_is_in_fov(terrain.map.fov_map, x, y)
and (max_range is None or game.player.distance(x, y) <= max_range)
):
tcod.console_set_char_background(render.con, x, y, prevcolor, tcod.BKGND_SET)
return (x, y)
def deploy(remote='origin'):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[production, staging])
if app_config.DEPLOY_TO_SERVERS:
require('branch', provided_by=[stable, master, branch])
if (app_config.DEPLOYMENT_TARGET == 'production' and env.branch != 'stable'):
utils.confirm(
colored("You are trying to deploy the '%s' branch to production.\nYou should really only deploy a stable branch.\nDo you know what you're doing?" % env.branch, "red")
)
servers.checkout_latest(remote)
servers.fabcast('text.update')
#servers.fabcast('assets.sync')
servers.fabcast('data.update')
if app_config.DEPLOY_CRONTAB:
# servers.install_crontab()
_servers.install_crontab()
if app_config.DEPLOY_SERVICES:
servers.deploy_confs()
update()
render.render_all()
# # Clear files that should never be deployed
# local('rm -rf www/live-data')
# flat.deploy_folder(
# 'www',
# app_config.PROJECT_SLUG,
# headers={
# 'Cache-Control': 'max-age=%i' % app_config.DEFAULT_MAX_AGE
# },
# ignore=['www/assets/*', 'www/live-data/*']
# )
# flat.deploy_folder(
# 'www/assets',
# '%s/assets' % app_config.PROJECT_SLUG,
# headers={
# 'Cache-Control': 'max-age=%i' % app_config.ASSETS_MAX_AGE
# }
# )
_deploy_to_graphics()
def run():
global current_turn
while alive and not tcod.console_is_window_closed():
action = handle_keys()
if action:
compute_fov()
update_objects()
randomly_spawn_enemies()
current_turn += 1
if player.x + terrain.map.scroll_amount >= VICTORY_DISTANCE:
ui.message(
'Congratulations, you win! Press escape to exit.', tcod.cyan)
global state
state = 'dead'
render.render_all()
def deploy(remote="origin"):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require("settings", provided_by=[production, staging])
if app_config.DEPLOY_TO_SERVERS:
require("branch", provided_by=[stable, master, branch])
if app_config.DEPLOYMENT_TARGET == "production" and env.branch != "stable":
utils.confirm(
colored(
"You are trying to deploy the '%s' branch to production.\nYou should really only deploy a stable branch.\nDo you know what you're doing?"
% env.branch,
"red",
)
)
servers.checkout_latest(remote)
servers.fabcast("text.update")
servers.fabcast("assets.sync")
servers.fabcast("data.update")
if app_config.DEPLOY_CRONTAB:
servers.install_crontab()
if app_config.DEPLOY_SERVICES:
servers.deploy_confs()
update()
render.render_all()
# Clear files that should never be deployed
local("rm -rf www/live-data")
flat.deploy_folder(
"www",
app_config.PROJECT_SLUG,
headers={"Cache-Control": "max-age=%i" % app_config.DEFAULT_MAX_AGE},
ignore=["www/assets/*", "www/live-data/*"],
)
flat.deploy_folder(
"www/assets",
"%s/assets" % app_config.PROJECT_SLUG,
headers={"Cache-Control": "max-age=%i" % app_config.ASSETS_MAX_AGE},
)
def deploy(remote='origin'):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[production, staging])
if app_config.DEPLOY_TO_SERVERS:
require('branch', provided_by=[stable, master, branch])
if (app_config.DEPLOYMENT_TARGET == 'production' and env.branch != 'stable'):
utils.confirm("You are trying to deploy the '%s' branch to production.\nYou should really only deploy a stable branch.\nDo you know what you're doing?" % env.branch)
if app_config.DEPLOY_TO_SERVERS:
checkout_latest(remote)
fabcast('update_copy')
fabcast('assets_sync')
fabcast('update_data')
if app_config.DEPLOY_CRONTAB:
install_crontab()
if app_config.DEPLOY_SERVICES:
deploy_confs()
compiled_includes = render.render_all()
render.render_dorms(compiled_includes)
sass()
# _gzip('www', '.gzip')
# _deploy_to_s3()
# _gzip('.dorms_html', '.dorms_gzip')
# _deploy_to_s3('.dorms_gzip')
local('rm -rf dist')
local('cp -r .dorms_html dist')
local('cp -r www/ dist/')
def deploy(remote='origin'):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[production, staging])
if app_config.DEPLOY_TO_SERVERS:
require('branch', provided_by=[stable, master, branch])
if (app_config.DEPLOYMENT_TARGET == 'production' and env.branch != 'stable'):
utils.confirm("You are trying to deploy the '%s' branch to production.\nYou should really only deploy a stable branch.\nDo you know what you're doing?" % env.branch)
if app_config.DEPLOY_TO_SERVERS:
checkout_latest(remote)
fabcast('update_copy')
fabcast('assets_sync')
fabcast('update_data')
if app_config.DEPLOY_CRONTAB:
install_crontab()
if app_config.DEPLOY_SERVICES:
deploy_confs()
compiled_includes = render.render_all()
render.render_dorms(compiled_includes)
sass()
# _gzip('www', '.gzip')
# _deploy_to_s3()
# _gzip('.dorms_html', '.dorms_gzip')
# _deploy_to_s3('.dorms_gzip')
local('rm -rf dist')
local('cp -r .dorms_html dist')
local('cp -r www/ dist/')
def play_game(game):
while not libtcod.console_is_window_closed():
render.render_all(game)
if game.state == 'pathing':
if game.player.mover.takepath() == 'empty':
game.state = 'playing'
game.map_movement = True
player_action = input.handle_keys(game)
# If 'tookturn' is added, fov_recompute should be true.
if player_action == "exit":
break
def main():
message_log, key, mouse = init_ui()
show_popup((
"You are a killer robot, sent from the future on a vital mission.\n"
"Your only job -- to defeat the humans who threaten your very existence with their foolish schemes.\n"
"They cannot be allowed to wipe out the peaceful race of killer robots before they're even created!"
), 'THE STORY SO FAR')
turn_state, game_map, map_knowledge = init_game()
while not tcod.console_is_window_closed():
if game_map.los_changed:
compute_los(game_map.los_map, game_map.get_active_player().pos)
game_map.los_changed = False
map_knowledge.update(game_map)
render_all(map_knowledge, game_map.los_map,
game_map.get_active_player(), message_log, turn_state)
turn_state.progress = TurnProgress.Ongoing
for actor in game_map.actors:
actor.energy += 100
active_actors = [
actor for actor in game_map.actors if actor.energy > 0
]
while len(active_actors) != 0:
# sort to always let the player go first
active_actors.sort(
key=lambda act: 0 if act.is_active_player else 1)
for actor in active_actors:
command = actor.ai.next_move(
target=game_map.get_active_player(), game_map=game_map)
results = actor.execute(command, game_map)
end_game = process_results(results, actor, game_map,
message_log,
turn_state.current_turn)
if end_game:
return True
# if only python had do-while
active_actors = [
actor for actor in game_map.actors if actor.energy > 0
]
turn_state.next_turn()
def play_game(game):
while not libtcod.console_is_window_closed():
render.render_all(game)
#In the case of pathing, follow the path or switch back to normal playing when done.
if game.state == 'pathing':
if game.player.mover.takepath(game) == 'empty':
game.state = 'playing'
game.map_movement = True
if game.map_movement:
pass # Here we can check to see if player movement has occurred and see if an event should come up.
player_action = input.handle_keys(game)
# If 'tookturn' is added, fov_recompute should be true.
if player_action == "exit":
break
def play_game():
""" Main Loop """
player_action = None
#Main Loop
while not libtcod.console_is_window_closed():
render.render_all()
libtcod.console_flush()
map = gvar.game.player.currentmap()
for object in map.objects:
object.clear()
if object.fighter is not None and libtcod.map_is_in_fov(
gvar.foh_map, object.x,
object.y) and not gvar.game.ticks.contains(object):
object.fighter.join_battle()
#handle death state
if gvar.game.game_state == 'dead':
player_action = input.handle_keys()
if player_action == 'exit':
save.save_game()
break
else:
continue
else:
actor = gvar.game.ticks.getWithPriority()
if actor[1] == gvar.game.player:
#handle keys and exit game if needed
player_action = input.handle_keys()
if player_action == 'exit':
save.save_game()
main_menu()
break
gvar.game.ticks.put(actor[1], int(player_action + actor[0]))
else:
#let mobs take their turn
if gvar.game.game_state == 'playing':
if actor[1].ai:
speed = actor[1].ai.take_turn()
gvar.game.ticks.put(actor[1], int(speed + actor[0]))
def deploy(slug=''):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[staging, production])
require('slug', provided_by=[post])
update()
render.render_all()
flat.deploy_folder('%s/www' % env.static_path,
'%s/%s' % (env.post_root, env.post_config.DEPLOY_SLUG),
max_age=app_config.DEFAULT_MAX_AGE,
ignore=['%s/www/assets/*' % env.static_path])
flat.deploy_folder('%s/www/assets' % env.static_path,
'%s/%s/assets' %
(env.post_root, env.post_config.DEPLOY_SLUG),
max_age=app_config.ASSETS_MAX_AGE,
warn_threshold=app_config.WARN_THRESHOLD)
def deploy(remote='origin', reload=False):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[production, staging, electron])
render.render_all()
if env.settings == 'electron':
if not os.path.exists('electron'):
os.makedirs('electron')
local('npm run-script pack')
if env.settings == 'fileserver':
local('rsync -vr www/ %s@%s:%s/%s' % (
app_config.FILE_SERVER_USER,
app_config.FILE_SERVER,
app_config.FILE_SERVER_PATH,
app_config.PROJECT_SLUG
))
if env.settings == 'production' or env.settings == 'staging':
flat.deploy_folder(
app_config.S3_BUCKET,
'www',
app_config.PROJECT_SLUG,
headers={
'Cache-Control': 'max-age=%i' % app_config.DEFAULT_MAX_AGE
},
ignore=['www/img/*', 'www/live-data/*']
)
flat.deploy_folder(
app_config.S3_BUCKET,
'www/img',
'%s/img' % app_config.PROJECT_SLUG,
headers={
'Cache-Control': 'max-age=%i' % app_config.ASSETS_MAX_AGE
}
)
def deploy(remote='origin', reload=False):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[production, staging, electron])
render.render_all()
if env.settings == 'electron':
if not os.path.exists('electron'):
os.makedirs('electron')
local('npm run-script pack')
if env.settings == 'fileserver':
local('rsync -vr www/ %s@%s:%s/%s' % (
app_config.FILE_SERVER_USER,
app_config.FILE_SERVER,
app_config.FILE_SERVER_PATH,
app_config.PROJECT_SLUG
))
if env.settings == 'production' or env.settings == 'staging':
flat.deploy_folder(
app_config.S3_BUCKET,
'www',
app_config.PROJECT_SLUG,
headers={
'Cache-Control': 'max-age=%i' % app_config.DEFAULT_MAX_AGE
},
ignore=['www/img/*', 'www/live-data/*']
)
flat.deploy_folder(
app_config.S3_BUCKET,
'www/img',
'%s/img' % app_config.PROJECT_SLUG,
headers={
'Cache-Control': 'max-age=%i' % app_config.ASSETS_MAX_AGE
}
)
def play_game(): """ Main Loop """ player_action = None #Main Loop while not libtcod.console_is_window_closed(): render.render_all() libtcod.console_flush() map = gvar.game.player.currentmap() for object in map.objects: object.clear() if object.fighter is not None and libtcod.map_is_in_fov(gvar.foh_map, object.x, object.y) and not gvar.game.ticks.contains(object): object.fighter.join_battle() #handle death state if gvar.game.game_state == 'dead': player_action = input.handle_keys() if player_action == 'exit': save.save_game() break else: continue else: actor = gvar.game.ticks.getWithPriority() if actor[1] == gvar.game.player: #handle keys and exit game if needed player_action = input.handle_keys() if player_action == 'exit': save.save_game() main_menu() break gvar.game.ticks.put(actor[1], int(player_action + actor[0])) else: #let mobs take their turn if gvar.game.game_state == 'playing': if actor[1].ai: speed = actor[1].ai.take_turn() gvar.game.ticks.put(actor[1], int(speed + actor[0]))
def deploy(remote="origin", reload=False):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require("settings", provided_by=[production, staging, electron])
render.render_all()
if env.settings == "electron":
if not os.path.exists("electron"):
os.makedirs("electron")
local("npm run-script pack")
if env.settings == "fileserver":
local(
"rsync -vr www/ %s@%s:%s/%s"
% (
app_config.FILE_SERVER_USER,
app_config.FILE_SERVER,
app_config.FILE_SERVER_PATH,
app_config.PROJECT_SLUG,
)
)
if env.settings == "production" or env.settings == "staging":
flat.deploy_folder(
app_config.S3_BUCKET,
"www",
app_config.PROJECT_SLUG,
headers={"Cache-Control": "max-age=%i" % app_config.DEFAULT_MAX_AGE},
ignore=["www/img/*", "www/live-data/*"],
)
flat.deploy_folder(
app_config.S3_BUCKET,
"www/img",
"%s/img" % app_config.PROJECT_SLUG,
headers={"Cache-Control": "max-age=%i" % app_config.ASSETS_MAX_AGE},
)
def deploy(slug=''):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[staging, production])
require('slug', provided_by=[post])
update()
render.render_all()
flat.deploy_folder(
'%s/www' % env.static_path,
'%s/%s' % (env.post_root, env.post_config.DEPLOY_SLUG),
max_age=app_config.DEFAULT_MAX_AGE,
ignore=['%s/www/assets/*' % env.static_path]
)
flat.deploy_folder(
'%s/www/assets' % env.static_path,
'%s/%s/assets' % (env.post_root, env.post_config.DEPLOY_SLUG),
max_age=app_config.ASSETS_MAX_AGE,
warn_threshold=app_config.WARN_THRESHOLD
)
def deploy_client(reload=False):
"""
Deploy the latest app to S3.
"""
require('settings', provided_by=[production, staging])
update()
render.render_all()
render.render_current_state(folder='www')
# Clear files that should never be deployed
local('rm -rf www/live-data')
flat.deploy_folder(
app_config.S3_BUCKET,
'www',
'',
headers={
'Cache-Control': 'max-age=%i' % app_config.DEFAULT_MAX_AGE
},
ignore=['www/assets/*', 'www/live-data/*']
)
flat.deploy_folder(
app_config.S3_BUCKET,
'www/assets',
'assets',
headers={
'Cache-Control': 'max-age=%i' % app_config.ASSETS_MAX_AGE
}
)
if reload:
reset_browsers()
if not check_timestamp():
reset_browsers()
def deploy(remote='origin', reload=False):
"""
Deploy the latest app to S3 and, if configured, to our servers.
"""
require('settings', provided_by=[production, staging])
update()
render.render_all()
# Clear files that should never be deployed
local('rm -rf www/live-data')
flat.deploy_folder(
app_config.S3_BUCKET,
'www',
app_config.PROJECT_SLUG,
headers={
'Cache-Control': 'max-age=%i' % app_config.DEFAULT_MAX_AGE
},
ignore=['www/assets/*', 'www/live-data/*']
)
flat.deploy_folder(
app_config.S3_BUCKET,
'www/assets',
'%s/assets' % app_config.PROJECT_SLUG,
headers={
'Cache-Control': 'max-age=%i' % app_config.ASSETS_MAX_AGE
}
)
if reload:
reset_browsers()
if not check_timestamp():
reset_browsers()
def scenemaker():
render.render_all(dot_list=dots, start=start_time)
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, '~//Documents//rogue ', False)
libtcod.sys_set_fps(LIMIT_FPS)
con = libtcod.console_new(SCREEN_WIDTH, SCREEN_HEIGHT)
dongeon = mapGen.Dongeon(80, 45)
player = gameObject.Player(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, "@", libtcod.white, dongeon)
player.x = 25
player.y = 23
npc = gameObject.Object(SCREEN_WIDTH/2 - 5, SCREEN_HEIGHT/2, "@", libtcod.yellow, dongeon) ##change this later
objects = [player, npc]
##main loop
while not libtcod.console_is_window_closed():
render.render_all(objects, dongeon, con)
libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT,0, 0, 0)
libtcod.console_flush() ##redraw the scene
for obj in objects:
obj.clear(con)
def handle_keys():
key = libtcod.console_wait_for_keypress(False)
if key.vk == libtcod.KEY_ENTER and key.lalt:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
elif key.vk == libtcod.KEY_ESCAPE:
return True ## exit function
exit = handle_keys()
if exit:
def play_game(player, entities, game_map, message_log, game_state, con, panel,
constants):
fov_recompute = True
fov_map = initialize_fov(game_map)
key = tcod.Key()
mouse = tcod.Mouse()
game_state = GameStates.PLAYERS_TURN
previous_game_state = game_state
targeting_item = None
while not tcod.console_is_window_closed():
tcod.sys_check_for_event(tcod.EVENT_KEY_PRESS | tcod.EVENT_MOUSE, key,
mouse)
if fov_recompute:
recompute_fov(fov_map, player.x, player.y, constants['fov_radius'],
constants['fov_light_walls'],
constants['fov_algorithm'])
render_all(con, panel, entities, player, game_map, fov_map,
fov_recompute, message_log, constants['screen_width'],
constants['screen_height'], constants['bar_width'],
constants['panel_height'], constants['panel_y'], mouse,
constants['colors'], game_state)
fov_recompute = False
tcod.console_flush()
clear_all(con, entities)
action = handle_keys(key, game_state)
mouse_action = handle_mouse(mouse)
move = action.get('move')
pickup = action.get('pickup')
show_inventory = action.get('show_inventory')
drop_inventory = action.get('drop_inventory')
inventory_index = action.get('inventory_index')
exit = action.get('exit')
fullscreen = action.get('fullscreen')
left_click = mouse_action.get('left_click')
right_click = mouse_action.get('right_click')
player_turn_results = []
if move and game_state == GameStates.PLAYERS_TURN:
dx, dy = move
destination_x = player.x + dx
destination_y = player.y + dy
if not game_map.is_blocked(destination_x, destination_y):
target = get_blocking_entities_at_location(
entities, destination_x, destination_y)
if target:
attack_results = player.fighter.attack(target)
player_turn_results.extend(attack_results)
else:
player.move(dx, dy)
fov_recompute = True
game_state = GameStates.ENEMY_TURN
elif pickup and game_state == GameStates.PLAYERS_TURN:
for entity in entities:
if entity.item and entity.x == player.x and entity.y == player.y:
pickup_results = player.inventory.add_item(entity)
player_turn_results.extend(pickup_results)
break
else:
message_log.add_message(
Message('There is nothing here to pick up.', tcod.yellow))
if show_inventory:
previous_game_state = game_state
game_state = GameStates.SHOW_INVENTORY
if drop_inventory:
previous_game_state = game_state
game_state = GameStates.DROP_INVENTORY
if inventory_index is not None and previous_game_state != GameStates.PLAYER_DEAD and inventory_index < len(
player.inventory.items):
item = player.inventory.items[inventory_index]
if game_state == GameStates.SHOW_INVENTORY:
player_turn_results.extend(
player.inventory.use(item,
entities=entities,
fov_map=fov_map))
elif game_state == GameStates.DROP_INVENTORY:
player_turn_results.extend(player.inventory.drop_item(item))
if game_state == GameStates.TARGETING:
if left_click:
target_x, target_y = left_click
item_use_results = player.inventory.use(targeting_item,
entities=entities,
fov_map=fov_map,
target_x=target_x,
target_y=target_y)
player_turn_results.extend(item_use_results)
elif right_click:
player_turn_results.append({'targeting_cancelled': True})
if exit:
if game_state in (GameStates.SHOW_INVENTORY,
GameStates.DROP_INVENTORY):
game_state = previous_game_state
elif game_state == GameStates.TARGETING:
player_turn_results.append({'targeting_cancelled': True})
else:
save_game(player, entities, game_map, message_log, game_state)
return True
if fullscreen:
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
for player_turn_result in player_turn_results:
message = player_turn_result.get('message')
dead_entity = player_turn_result.get('dead')
item_added = player_turn_result.get('item_added')
item_consumed = player_turn_result.get('consumed')
item_dropped = player_turn_result.get('item_dropped')
targeting = player_turn_result.get('targeting')
targeting_cancelled = player_turn_result.get('targeting_cancelled')
if message:
message_log.add_message(message)
if dead_entity:
if dead_entity == player:
message, game_state = kill_player(dead_entity)
else:
message = kill_monster(dead_entity)
message_log.add_message(message)
if item_added:
entities.remove(item_added)
game_state = GameStates.ENEMY_TURN
if item_consumed:
game_state = GameStates.ENEMY_TURN
if item_dropped:
entities.append(item_dropped)
game_state = GameStates.ENEMY_TURN
if targeting:
previous_game_state = GameStates.PLAYERS_TURN
game_state = GameStates.TARGETING
targeting_item = targeting
message_log.add_message(targeting_item.item.targeting_message)
if targeting_cancelled:
game_state = previous_game_state
message_log.add_message(Message('Targeting cancelled'))
if game_state == GameStates.ENEMY_TURN:
for entity in entities:
if entity.ai:
enemy_turn_results = entity.ai.take_turn(
player, fov_map, game_map, entities)
for enemy_turn_result in enemy_turn_results:
message = enemy_turn_result.get('message')
dead_entity = enemy_turn_result.get('dead')
if message:
message_log.add_message(message)
if dead_entity:
if dead_entity == player:
message, game_state = kill_player(dead_entity)
else:
message = kill_monster(dead_entity)
message_log.add_message(message)
if game_state == GameStates.PLAYER_DEAD:
break
if game_state == GameStates.PLAYER_DEAD:
break
else:
game_state = GameStates.PLAYERS_TURN
app.url_map.strict_slashes = False
# https://flask.palletsprojects.com/en/1.1.x/config/
app.config.from_pyfile("config.py")
try:
with open("raw/config.yml") as yaml_config:
user_config = safe_load(yaml_config)
print(user_config)
app.config.update(user_config)
except:
pass
os.environ.setdefault('PYPANDOC_PANDOC', app.config["PANDOC_PATH"])
notes, tag_set, static_pages = render_all()
@app.route("/")
def index():
return render_template("index.html", notes=notes, tag_set=tag_set)
@app.route("/tags")
def tags():
tag = request.args.get("tag")
matching_articles = [note for note in notes if tag in note.tags]
return render_template("index.html", notes=matching_articles, tag_set=tag_set)
def target_tile(max_range=None, radius=0): """ | Target a distant tile | For Ranged Attacks, like Archery, Thrown | Also Fireballs or similar projectiles with Radius """ from components import Object from mapcreation import Circle from render import render_all # Spawn a Target Object that can be moved with arrow Keys (x, y) = (gvar.game.player.x, gvar.game.player.y) target = Object(x, y, 'X', color=libtcod.red, name='target', blocks=False) gvar.game.objects.append(target) while True: target.send_to_front() render_all() #Render Splash libtcod.console_clear(gvar.overlay) if radius > 0: target.splash = Circle(target.x, target.y, radius) for point in target.splash.circle: libtcod.console_set_char_background(gvar.overlay, point[0], point[1], libtcod.yellow) libtcod.console_blit(gvar.overlay, 0, 0, gvar.SCREEN_WIDTH, gvar.SCREEN_HEIGHT, 0, 0, 0, 1.0, 0.5) libtcod.console_flush() #Move the Target around key = libtcod.Key() mouse = libtcod.Mouse() key_pressed = libtcod.sys_wait_for_event(libtcod.EVENT_KEY_PRESS,key,mouse,True) if not key_pressed: return 'cancelled' if key.vk == libtcod.KEY_UP or key.vk == libtcod.KEY_KP8: if libtcod.map_is_in_fov(gvar.fov_map, target.x, target.y-1): target.y -= 1 elif key.vk == libtcod.KEY_DOWN or key.vk == libtcod.KEY_KP2: if libtcod.map_is_in_fov(gvar.fov_map, target.x, target.y+1): target.y += 1 elif key.vk == libtcod.KEY_LEFT or key.vk == libtcod.KEY_KP4: if libtcod.map_is_in_fov(gvar.fov_map, target.x-1, target.y): target.x -= 1 elif key.vk == libtcod.KEY_RIGHT or key.vk == libtcod.KEY_KP6: if libtcod.map_is_in_fov(gvar.fov_map, target.x+1, target.y): target.x += 1 elif key.vk == libtcod.KEY_KP7: if libtcod.map_is_in_fov(gvar.fov_map, target.x-1, target.y-1): target.x -= 1 target.y -= 1 elif key.vk == libtcod.KEY_KP9: if libtcod.map_is_in_fov(gvar.fov_map, target.x+1, target.y-1): target.x += 1 target.y -= 1 elif key.vk == libtcod.KEY_KP3: if libtcod.map_is_in_fov(gvar.fov_map, target.x+1, target.y+1): target.x += 1 target.y += 1 elif key.vk == libtcod.KEY_KP1: if libtcod.map_is_in_fov(gvar.fov_map, target.x-1, target.y+1): target.x -= 1 target.y += 1 elif key.vk == libtcod.KEY_ENTER: gvar.game.objects.remove(target) return target break elif key.vk == libtcod.KEY_ESCAPE: gvar.game.objects.remove(target) return 'cancelled' break elif chr(key.c) == 's': # Returns String 'closest' for further evaluation by the calling function, e.g. for targeting the closest mob gvar.game.objects.remove(target) return 'closest' break
def main():
# initialise screen dimensions
screen_width = 80
screen_height = 50
# initialise map dimensions
map_width = 80
map_height = 45
# room limits and dimensions
max_room_size = 10
min_room_size = 6
total_room_limit = 30
colours = {
'dark_wall': libtcod.Color(60, 49, 32),
'dark_ground': libtcod.Color(96, 128, 56),
'npc_colour': libtcod.Color(80, 80, 80)
}
# declare player and npcs, put them into a list
player = Entity(int(screen_width / 2), int(screen_height / 2), '@',
libtcod.white)
npc = Entity(int(screen_width - 10 / 2), int(screen_height / 2), '$',
colours.get('npc_colour'))
entities = [player, npc]
# initialise the map
game_map = Map(map_width, map_height)
game_map.create_map(total_room_limit, min_room_size, max_room_size,
map_width, map_height, player)
# choose font for rendering
libtcod.console_set_custom_font(
'arial10x10.png',
libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
# initialise console
libtcod.console_init_root(screen_width, screen_height, 'Omars Roguelike',
False)
con = libtcod.console_new(screen_width, screen_height)
# key and mouse presses
key = libtcod.Key()
mouse = libtcod.Mouse()
while not libtcod.console_is_window_closed():
# checks for mouse or key interrupt
libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS, key, mouse)
# renders all entities
render_all(con, entities, screen_width, screen_height, colours,
game_map)
libtcod.console_flush()
clear_all(con, entities)
# checks what action has to be done
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) and map_width-1 > player.x + dx > 0 and map_height-1 > \
player.y + dy > 0:
player.move(dx, dy)
if exit:
return True
if fullscreen:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
import render
#######################################
# Initialization and main loop
#######################################
tcod.console_set_custom_font(data.font, tcod.FONT_TYPE_GREYSCALE |
tcod.FONT_LAYOUT_TCOD)
tcod.console_init_root(
data.screen_width, data.screen_height, 'frogue!!', False)
maps.make_bsp_dungeon(6, 10, 30)
# maps.build_prefab()
engine.start()
recompute_field_of_view = True
render.initialize_field_of_view()
while not tcod.console_is_window_closed():
# Render the screen...
render.render_all()
tcod.console_flush()
# Clear objects from old location, before they move
for object in data.objects:
object.clear()
exit = control.input()
if exit:
break
def main():
tdl.set_font('terminal16x16.png', greyscale=True,
altLayout=False) # Load the font from a png.
tdl.set_fps(100)
map_width = 20
map_height = 20
room_width = 30
room_height = 30
screen_width = room_width + 22
screen_height = room_height + 22
root_console = tdl.init(screen_width, screen_height, title='7DRL 2019')
top_panel_console = tdl.Console(screen_width, 10)
view_port_console = tdl.Console(room_width, room_height)
bottom_panel_console = tdl.Console(screen_width, 10)
message_log = MessageLog(0, 0, screen_width, 9)
entities = []
game_map = GameMap(map_width, map_height)
sword_stats = Weapon(2, 10)
player_weapon = Item(game_map,
"0x0",
0,
0,
"Sword",
"|", (255, 255, 255),
weapon=sword_stats)
player_stats = Fighter(hits=10, left_hand=player_weapon)
player = Actor(game_map,
"2x2",
15,
10,
"Player",
"@", (255, 255, 255),
fighter=player_stats)
entities.append(player)
generate_map(game_map, entities, player)
all_consoles = [
root_console, view_port_console, bottom_panel_console,
top_panel_console
]
fov_algorithm = "BASIC"
fov_light_walls = True
fov_radius = 50
fov_recompute = True
game_state = GameStates.PLAYER_TURN
while not tdl.event.is_window_closed():
if fov_recompute: # Compute the field of view to show changes.
game_map.rooms[player.map_x][player.map_y]\
.compute_fov(player.room_x, player.room_y,
fov=fov_algorithm, radius=fov_radius, light_walls=fov_light_walls, sphere=True)
render_all(all_consoles, game_map, entities, player, fov_recompute,
message_log)
tdl.flush()
clear_all(view_port_console, entities)
fov_recompute = False
for event in tdl.event.get():
if event.type == 'KEYUP':
user_input = event
break
else:
user_input = None
if not user_input:
continue
action = handle_keys(user_input)
move = action.get('move')
exit_game = action.get('exit_game')
select_hand = action.get('select_hand')
drop_item = action.get('drop_item')
pickup_item = action.get('pickup_item')
shuffle_rooms = action.get('shuffle_rooms')
player_turn_results = []
if shuffle_rooms:
message = game_map.shuffle_rooms(player, entities)
message_log.add_message(message)
fov_recompute = True
# TODO at the moment these functions are doing all the leg work and player_turn_results isn't used. Rectify.
if select_hand and game_state == GameStates.PLAYER_TURN:
player.fighter.selected_hand = select_hand
fov_recompute = True
if drop_item and game_state == GameStates.PLAYER_TURN:
message = player.fighter.drop_item(game_map, entities)
message_log.add_message(message)
game_state = GameStates.ENEMY_TURN
fov_recompute = True
if pickup_item and game_state == GameStates.PLAYER_TURN:
message = player.fighter.pickup_item(entities)
message_log.add_message(message)
game_state = GameStates.ENEMY_TURN
fov_recompute = True
if move and game_state == GameStates.PLAYER_TURN:
dx, dy = move
destination_room_x = player.room_x + dx
destination_room_y = player.room_y + dy
if destination_room_x < 0:
dx = 0
if player.map_x - 1 < 0:
player.map_x = map_width - 1
else:
player.map_x -= 1
player.room_x = room_width - 1
if destination_room_x == room_width:
destination_room_x -= 1
dx = 0
if player.map_x + 1 > map_width - 1:
player.map_x = 0
else:
player.map_x += 1
player.room_x = 0
if destination_room_y < 0:
dy = 0
if player.map_y - 1 < 0:
player.map_y = map_height - 1
else:
player.map_y -= 1
player.room_y = room_height - 1
if destination_room_y == room_height:
destination_room_y -= 1
dy = 0
if player.map_y + 1 > map_height - 1:
player.map_y = 0
else:
player.map_y += 1
player.room_y = 0
if game_map.rooms[player.map_x][player.map_y].walkable[
destination_room_x, destination_room_y]:
target = get_blocking_entities_at_location(
entities, player.map_x, player.map_y, destination_room_x,
destination_room_y)
if target: # Combat here
attack_results = player.fighter.attack(target)
player_turn_results.extend(
attack_results
) # Add the result of the last turn to the list
fov_recompute = True
else:
player.move(dx, dy) # Or just move
player.set_current_room(game_map)
# TODO: Bug with the new room layouts - some cause change of room to break.
print("MapPos: ",
player.map_x,
",",
player.map_y,
end=" / ")
print("RoomPos: ", player.room_x, ",", player.room_y)
fov_recompute = True
game_state = GameStates.ENEMY_TURN # Switch over the enemy's turn.
if exit_game:
return True
for player_turn_result in player_turn_results:
message = player_turn_result.get("message") # Pull any messages
dead_entity = player_turn_result.get(
"dead") # Or anything that died
if message:
message_log.add_message(
message
) # Add the message (if any) to the message log to print on screen.
if dead_entity: # If anything died...
if dead_entity == player:
message, game_state = kill_player(dead_entity) # Game over
else:
message = kill_monster(
dead_entity
) # Print a death message for monster, add exp
message_log.add_message(message) # Print messages to screen.
player_turn_results.clear() # Clear ready for next turn.
if game_state == GameStates.ENEMY_TURN:
for entity in entities:
if entity.map_x == player.map_x and entity.map_y == player.map_y:
if entity.ai: # If the entity has some intelligence (monsters, npc)
enemy_turn_results = entity.ai.take_turn(
player, game_map, entities)
for enemy_turn_result in enemy_turn_results: # Same deal as the player turns
message = enemy_turn_result.get("message")
dead_entity = enemy_turn_result.get("dead")
if message:
message_log.add_message(message)
if dead_entity:
if dead_entity == player:
message, game_state = kill_player(
dead_entity)
else:
message = kill_monster(dead_entity)
message_log.add_message(message)
if game_state == GameStates.PLAYER_DEAD:
break
enemy_turn_results.clear()
if game_state == GameStates.PLAYER_DEAD:
break
else:
game_state = GameStates.PLAYER_TURN
def main(map, entities, player, fov_radius, light_walls, health_boost,
spell_dict):
# defining game display parameters and creating consoles
panel_height = 10
screen_width = max(map.width, 80)
screen_height = map.height + panel_height
map_con = libtcod.console_new(map.width, map.height)
panel_con = libtcod.console_new(screen_width, panel_height)
fov_recompute = True
fov_map = initialize_fov(map)
msg_log = MessageLog(25, 50, panel_height - 1)
gamestate = GameStates.PLAYER
recompute_fov(fov_map, player.x, player.y, fov_radius, light_walls)
while not libtcod.console_is_window_closed():
render_all(map_con, panel_con, map, fov_map, fov_recompute, entities,
player, msg_log, screen_width, screen_height, panel_height)
# Keyboard input
key = libtcod.console_wait_for_keypress(True)
action = handle_keys(key, spell_dict, gamestate)
move = action.get('move')
fullscreen = action.get('fullscreen')
exit = action.get('exit')
display = action.get('display')
spell = action.get('spell')
dirn = action.get('dirn')
turn_results = []
if move and gamestate == GameStates.PLAYER:
dx, dy = move
dest_x, dest_y = player.x + dx, player.y + dy
if not map.is_blocked(dest_x, dest_y):
# attack if a monster is present else just move
target = map.get_entity(dest_x, dest_y, entities[1:-1])
if target:
player.attack(target, turn_results)
else:
player.move(dx, dy, map)
fov_recompute = True
for entity in entities[:-1]:
# get health_boost if standing on a corpse
if entity.behav is None and entity.x == player.x and entity.y == player.y:
player.hp += health_boost
if player.hp > player.max_hp:
player.hp = player.max_hp
entities.remove(entity)
# check if reached stairs
if entities[0].x == player.x and entities[0].y == player.y:
msg_log.add_msg(
Message(
'You\'ve reached the stairs. Setting up new map.'.
format(player.name), 'red'))
render_all(map_con, panel_con, map, fov_map, fov_recompute,
entities, player, msg_log, screen_width,
screen_height, panel_height)
time.sleep(5)
return False
gamestate = GameStates.ENEMY
if spell is not None and gamestate == GameStates.PLAYER:
# Check whether spell is directional
if spell['dirn']:
gamestate = GameStates.DIRECTION
active_spell = spell
turn_results.append({
'message':
Message(
'Targeting active for {}. Choose direction.'.format(
active_spell['name']), 'silver')
})
else:
if player.do_spell(spell, map, fov_map, entities,
turn_results):
gamestate = GameStates.ENEMY
if gamestate == GameStates.DIRECTION and dirn:
if dirn < 5:
# execute only if valid direction selected
if player.do_spell(active_spell, map, fov_map, entities,
turn_results, dirn):
gamestate = GameStates.ENEMY
else:
gamestate = GameStates.PLAYER
else:
turn_results.append(
{'message': Message('Targeting cancelled.', 'silver')})
gamestate = GameStates.PLAYER
if fullscreen:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
if exit:
return True
if display:
render_display(map_con, panel_con, map, fov_map, entities,
screen_width, screen_height, panel_height)
for result in turn_results:
message = result.get('message')
dead = result.get('dead')
if message:
msg_log.add_msg(message)
if dead:
if dead is player:
msg_log.add_msg(dead.die())
gamestate = GameStates.DEAD
else:
msg_log.add_msg(dead.die())
map.tiles[dead.x][dead.y].has_entity = 0
if fov_recompute:
recompute_fov(fov_map, player.x, player.y, fov_radius, light_walls)
render_all(map_con, panel_con, map, fov_map, fov_recompute, entities,
player, msg_log, screen_width, screen_height, panel_height)
time.sleep(0.2)
fov_recompute == False
# enemy turn
if gamestate == GameStates.ENEMY:
for entity in entities[1:-1]:
if libtcod.map_is_in_fov(fov_map, entity.x,
entity.y) and entity.behav:
entity_results = []
entity.take_turn(player, map, entity_results)
for result in entity_results:
message = result.get('message')
dead = result.get('dead')
if message:
msg_log.add_msg(message)
if dead:
if dead is player:
msg_log.add_msg(dead.die())
gamestate = GameStates.DEAD
else:
msg_log.add_msg(dead.die())
if gamestate == GameStates.DEAD:
break
else:
gamestate = GameStates.PLAYER
return True
import os
from git import clone
from prompt import interact
from render import render_all
from helper import schema_path
template = 'https://github.com/deepankarm/pod-template.git'
if __name__ == '__main__':
try:
repo_dir = clone(url=template)
schema = schema_path(repo_dir=repo_dir)
user_context = interact(filepath=schema)
if not user_context:
print('Something wrong')
render_all(context=user_context,
project_directory=os.path.join(repo_dir, user_context['project_dir']))
except KeyboardInterrupt:
print('\nUser interrupted. Nothing to do. Bye!')
def target_tile(max_range=None, radius=0):
""" | Target a distant tile
| For Ranged Attacks, like Archery, Thrown
| Also Fireballs or similar projectiles with Radius
"""
from components import Object
from mapcreation import Circle
from render import render_all
# Spawn a Target Object that can be moved with arrow Keys
(x, y) = (gvar.game.player.x, gvar.game.player.y)
target = Object(x, y, 'X', color=libtcod.red, name='target', blocks=False)
gvar.game.objects.append(target)
while True:
target.send_to_front()
render_all()
#Render Splash
libtcod.console_clear(gvar.overlay)
if radius > 0:
target.splash = Circle(target.x, target.y, radius)
for point in target.splash.circle:
libtcod.console_set_char_background(gvar.overlay, point[0],
point[1], libtcod.yellow)
libtcod.console_blit(gvar.overlay, 0, 0, gvar.SCREEN_WIDTH,
gvar.SCREEN_HEIGHT, 0, 0, 0, 1.0, 0.5)
libtcod.console_flush()
#Move the Target around
key = libtcod.Key()
mouse = libtcod.Mouse()
key_pressed = libtcod.sys_wait_for_event(libtcod.EVENT_KEY_PRESS, key,
mouse, True)
if not key_pressed:
return 'cancelled'
if key.vk == libtcod.KEY_UP or key.vk == libtcod.KEY_KP8:
if libtcod.map_is_in_fov(gvar.fov_map, target.x, target.y - 1):
target.y -= 1
elif key.vk == libtcod.KEY_DOWN or key.vk == libtcod.KEY_KP2:
if libtcod.map_is_in_fov(gvar.fov_map, target.x, target.y + 1):
target.y += 1
elif key.vk == libtcod.KEY_LEFT or key.vk == libtcod.KEY_KP4:
if libtcod.map_is_in_fov(gvar.fov_map, target.x - 1, target.y):
target.x -= 1
elif key.vk == libtcod.KEY_RIGHT or key.vk == libtcod.KEY_KP6:
if libtcod.map_is_in_fov(gvar.fov_map, target.x + 1, target.y):
target.x += 1
elif key.vk == libtcod.KEY_KP7:
if libtcod.map_is_in_fov(gvar.fov_map, target.x - 1, target.y - 1):
target.x -= 1
target.y -= 1
elif key.vk == libtcod.KEY_KP9:
if libtcod.map_is_in_fov(gvar.fov_map, target.x + 1, target.y - 1):
target.x += 1
target.y -= 1
elif key.vk == libtcod.KEY_KP3:
if libtcod.map_is_in_fov(gvar.fov_map, target.x + 1, target.y + 1):
target.x += 1
target.y += 1
elif key.vk == libtcod.KEY_KP1:
if libtcod.map_is_in_fov(gvar.fov_map, target.x - 1, target.y + 1):
target.x -= 1
target.y += 1
elif key.vk == libtcod.KEY_ENTER:
gvar.game.objects.remove(target)
return target
break
elif key.vk == libtcod.KEY_ESCAPE:
gvar.game.objects.remove(target)
return 'cancelled'
break
elif chr(key.c) == 's':
# Returns String 'closest' for further evaluation by the calling function, e.g. for targeting the closest mob
gvar.game.objects.remove(target)
return 'closest'
break
def js_tests():
"""
Run Karma/Jasmine unit tests.
"""
render.render_all()
local('node_modules/karma/bin/karma start www/js/test/karma.conf.js')
