def start_game(game: ThingsGame, player_id, session_key):
try:
game.start_game(player_id, session_key)
send_update("game_started", game)
logger.info("Game {} started".format(game.id))
except (GameStateError, PlayerError, InputError) as e:
send_error(e)
def submit_answer(game: ThingsGame, player_id, session_key, answer):
if not answer:
send_error("Answer was not provided")
return
try:
game.submit_answer(player_id, session_key, answer)
send_update("answer_submitted", game)
except (GameStateError, PlayerError, InputError) as e:
send_error(e)
def set_topic(game: ThingsGame, player_id, session_key, topic):
if not topic:
send_error("Topic was not set")
return
try:
game.set_topic(player_id, session_key, topic)
send_update("topic_set", game)
except (GameStateError, PlayerError, InputError) as e:
send_error(e)
def leave_game(game: ThingsGame, player_id, session_key):
try:
initial_state = game.info.state
leave_room(game.id)
manager.remove_player_sid(game.id, player_id)
player = game.remove_player(player_id, session_key)
new_state = game.info.state
logger.info("Player '{}' left game {}".format(player.name, game.id))
send_update("player_left", game, player)
except PlayerError:
return
if initial_state == new_state:
return
if new_state == GameState.round_complete:
game.start_round()
send_update("round_started", game)
def change_color(game: ThingsGame, player_id, session_key, color):
try:
if not color:
raise InputError("Failed to set color")
player = game.validate_player(player_id, session_key)
player.color = color
except (GameStateError, PlayerError, InputError) as e:
send_error(e)
def remove_player(game: ThingsGame, player_id, session_key,
player_id_to_remove):
try:
initial_state = game.info.state
player = game.force_remove_player(player_id, session_key,
player_id_to_remove)
new_state = game.info.state
send_update("player_removed", game, player)
player_sid = manager.remove_player_sid(game.id, player_id_to_remove)
if player_sid:
leave_room(game.id, player_sid)
except PlayerError as e:
send_error(e)
return
if initial_state != new_state and new_state == GameState.round_complete:
game.start_round()
send_update("round_started", game)
def join_game(game: ThingsGame, password, player_name, color, observer):
if game.password != password:
send_error("Incorrect password")
return
player = game.add_player(player_name, observer, color)
manager.update_player_sid(game.id, player.id, flask.request.sid)
logger.info("Player '{}' joined game {}".format(player_name, game.id))
join_room(game.id)
send_update("player_joined", game, player)
emit("player_id", {
"player_id": player.id,
"session_key": player.session_key
})
def create_game(self, name, password_hash, password_salt):
with self.lock:
game_id = generate_game_id()
i = 0
while game_id in self.games:
if i < 100:
game_id = generate_game_id()
else:
game_id = generate_id()
if not name:
name = game_id
game = ThingsGame(name, password_hash, password_salt, game_id)
self.games[game_id] = game
return game
def submit_match(game: ThingsGame, player_id, session_key, guessed_player_id,
answer_id):
try:
player, guessed_answer, guessed_player_answer = game.validate_match(
player_id, session_key, answer_id, guessed_player_id)
data = {
"player": player.to_dict(),
"guessed_answer": guessed_answer.to_dict(),
"guessed_player": guessed_player_answer.player.to_dict()
}
emit("match_submitted",
data,
broadcast=True,
room=game.info.game_id,
include_self=True)
except (GameStateError, PlayerError, InputError) as e:
send_error(e)
return
def round_started():
game.start_round()
send_update("round_started", game, context_aware=False)
def round_complete():
round_complete_data = {"winner": player.to_dict()}
socketio.emit("round_complete",
round_complete_data,
broadcast=True,
room=game.info.game_id)
background_scheduler.run_in(6, round_started)
def finalize():
result = game.finalize_match(player, guessed_answer,
guessed_player_answer)
match_result_data = {"game": game.info.to_dict(), "result": result}
socketio.emit("match_result",
match_result_data,
room=game.info.game_id)
if game.info.state == GameState.round_complete:
background_scheduler.run_in(2, round_complete)
background_scheduler.run_in(3, finalize)
def skip_topic_writer(game: ThingsGame, player_id, session_key):
try:
game.skip_topic_writer(player_id, session_key)
send_update("topic_writer_skipped", game)
except (GameStateError, PlayerError, InputError) as e:
send_error(e)
def reset_points(game: ThingsGame, player_id, session_key):
try:
game.reset_points(player_id, session_key)
send_update("points_reset", game)
except (GameStateError, PlayerError, InputError) as e:
send_error(e)