def end_game(game_name, run_id):
# global game
game = manager.get_game(game_name)
if game is None or game.curr_run_id != run_id or game.done:
return
print(f"\n--\nEnding run {game.curr_run_id+1}\n--\n")
with app.test_request_context('/'):
# 1: get current place
(city_name, hint), (lon, lat) = game.current.place
answer = dict(name=city_name, lon=lon, lat=lat)
# 2: end game
records = game.current.records
results, done = game.end()
socketio.emit("run-end",
dict(results=records, answer=answer, leaderboard=game.get_current_leaderboard(), done=done),
json=True, broadcast=True, room=game_name
)
# 3: continue?
if done:
#
timers[game_name] = wait_and_run(game.wait_time, terminate_game, game_name)
# timers[game_name] = threading.Timer(game.wait_time, terminate_game, [game_name]) # run_launcher(game_name))
# timers[game_name].start()
else:
timers[game_name] = wait_and_run(game.wait_time, launch_run, game_name, game.curr_run_id)
def launch_game():
game_name = session["game"]
game = manager.get_game(game_name)
game.launch() # GameRun(players)
emit("game-launched", dict(game=game.map_name, runs=game.n_run, diff=game.difficulty), json=True, broadcast=True, room=game_name)
wait_and_run(3, launch_run, game_name, game.curr_run_id)
def init_game(data):
game_name = session["game"]
player = session.get("player", "unknown")
print(f"Receive <event:connection[to={game_name}> from <player:{player}>")
if not manager.exists(game_name):
print(f"Game <game:{game_name}> doesnt exist")
del session["game"]
emit("redirect", dict(url=url_for("serve_main")), json=True)
# return redirect(url_for("serve_main"))
join_room(game_name)
game = manager.get_game(game_name)
if "pseudo" in data and data["pseudo"]:
pseudo = data["pseudo"]
else:
pseudo = None
if "player" in session:
player = session["player"]
print(f"Receive <event:connection> from existing player <player:{player}>")
if player not in game.players:
game.add_player(player, pseudo)
else:
player, pseudo = game.add_player(pseudo=pseudo)
session["player"] = player
print(f"Player <{player}> connected to game <{game_name}> with pseudo <{pseudo}>")
emit("init", dict(player=player, launched=game.launched, pseudo=pseudo,
game=game.map_name, runs=game.n_run, diff=game.difficulty,
pseudos=game.pseudos))
emit("new-player", dict(
player=player,
pseudo=pseudo,
leaderboard=game.get_current_leaderboard(),
pseudos=game.pseudos),
broadcast=True, room=game_name)
def update_pseudo(data):
game_name = session["game"]
player = session.get("player")
if player is None:
return
game = manager.get_game(game_name)
pseudo = data["name"]
if is_valid_pseudo(pseudo):
game.add_pseudo(player, pseudo)
emit("new-name", dict(change=dict(player=player, pseudo=pseudo), pseudos=game.pseudos),
room=game_name, broadcast=True, json=True)
def terminate_game(game_name):
game = manager.get_game(game_name)
if game is None or not game.done:
return
socketio.emit("game-end",
dict(
leaderboard=game.get_current_leaderboard(),
full=game.get_final_results(),
), json=True, broadcast=True,
room=game_name)
# game = Game(players=set(game.players), n_run=N_RUNS, map=game.map_name)
manager.relaunch_game(game_name)
def serve_game(name):
if not manager.exists(name):
return redirect(url_for("serve_main"))
else:
session["game"] = name
game_name = session["game"]
game = manager.get_game(game_name)
params = dict(
map=game.map_name,
wait_time=game.wait_time,
bbox=game.bbox,
allow_zoom=game.allow_zoom,
duration=game.duration)
return render_template("main.html", game_name=name, params=params, debug=DEBUG or is_local)
def launch_run(game_name, run_id):
# global duration_thread
game = manager.get_game(game_name)
if game is None or game.curr_run_id != run_id:
return
print(f"--\nLaunching run {game.curr_run_id+1} for game <{game_name}>\n--")
with app.test_request_context('/'):
hint = game.current.launch()
print(f"Hint is '{hint}'")
socketio.emit("run-start",
dict(hint=hint, current=game.curr_run_id, total=game.n_run),
json=True,
room=game_name,
broadcast=True)
timers[game_name] = wait_and_run(game.current.duration, end_game, game_name, game.curr_run_id)
def remove_from_game():
if "player" not in session:
return
player = session["player"]
game_name = session["game"]
game = manager.get_game(game_name)
game.remove_player(player)
leave_room(game_name)
emit("player-left", dict(player=player, leaderboard=game.get_current_leaderboard()), broadcast=True, room=game_name)
print(f"<{player}> disconnected!")
if not game.players:
manager.remove_game(game_name)
close_room(game_name)
safe_cancel(timers[game_name])
del timers[game_name]
print(f"Game <{game_name}> was removed!")
def process_guess(data):
# global duration_thread
game_name = session["game"]
game = manager.get_game(game_name)
player = data["player"]
print("Receiving guess from", player)
lon, lat = data["lon"], data["lat"]
res, done = game.current.process_answer((lon, lat), player)
res["total_score"] = game.scores[player] + res["score"] # We need to add res["score"] between game.scores isn't updated yet
emit("log", f"Player <{player}> has scored {res['score']} points", broadcast=True, room=game_name)
emit("new-guess", dict(player=player, dist=res["dist"], delta=res["delta"], score=res["score"]),
broadcast=True, room=game_name)
emit("score", res, json=True)
if done:
try:
print(f"--\nInterrupting run {game.curr_run_id+1}\n--")
safe_cancel(timers[game_name])
except AttributeError:
pass
end_game(game_name, game.curr_run_id)