def play_game(game, fps=30):
"""
Asynchronously apply real-time game updates and broadcast state to all clients currently active
in the game. Note that this loop must be initiated by a parallel thread for each active game
game (Game object): Stores relevant game state. Note that the game id is the same as to socketio
room id for all clients connected to this game
fps (int): Number of game ticks that should happen every second
"""
status = Game.Status.ACTIVE
while status != Game.Status.DONE and status != Game.Status.INACTIVE:
with game.lock:
status = game.tick()
if status == Game.Status.RESET:
with game.lock:
data = game.get_data()
socketio.emit('reset_game', { "state" : game.to_json(), "timeout" : game.reset_timeout, "data" : data}, room=game.id)
socketio.sleep(game.reset_timeout/1000)
else:
socketio.emit('state_pong', { "state" : game.get_state() }, room=game.id)
socketio.sleep(1/fps)
with game.lock:
data = game.get_data()
socketio.emit('end_game', { "status" : status, "data" : data }, room=game.id)
if status != Game.Status.INACTIVE:
game.deactivate()
cleanup_game(game)
def update_game(game):
result = db.games.find_one_and_replace({"game_id": game.id},
game.to_json())
if TEST:
logger.debug('after update we get %s', str(result))
def create_new_game(bot, update):
game = Game(bot, update)
result = db.games.insert(game.to_json())
if TEST:
results = db.games.find({"_id": result})
logger.debug('AFter creating Heuston we found %s in db', str(results))
def debug():
resp = {}
games = []
active_games = []
waiting_games = []
users = []
free_ids = []
free_map = {}
for game_id in ACTIVE_GAMES:
game = get_game(game_id)
active_games.append({"id" : game_id, "state" : game.to_json()})
for game_id in list(WAITING_GAMES.queue):
game = get_game(game_id)
game_state = None if FREE_MAP[game_id] else game.to_json()
waiting_games.append({ "id" : game_id, "state" : game_state})
for game_id in GAMES:
games.append(game_id)
for user_id in USER_ROOMS:
users.append({ user_id : get_curr_room(user_id) })
for game_id in list(FREE_IDS.queue):
free_ids.append(game_id)
for game_id in FREE_MAP:
free_map[game_id] = FREE_MAP[game_id]
resp['active_games'] = active_games
resp['waiting_games'] = waiting_games
resp['all_games'] = games
resp['users'] = users
resp['free_ids'] = free_ids
resp['free_map'] = free_map
return jsonify(resp)
def on_join(data):
user_id = request.sid
with USERS[user_id]:
create_if_not_found = data.get("create_if_not_found", True)
# Retrieve current game if one exists
curr_game = get_curr_game(user_id)
if curr_game:
# Cannot join if currently in a game
return
# Retrieve a currently open game if one exists
game = get_waiting_game()
if not game and create_if_not_found:
# No available game was found so create a game
params = data.get('params', {})
game_name = data.get('game_name', 'overcooked')
_create_game(user_id, game_name, params)
return
elif not game:
# No available game was found so start waiting to join one
emit('waiting', { "in_game" : False })
else:
# Game was found so join it
with game.lock:
join_room(game.id)
set_curr_room(user_id, game.id)
game.add_player(user_id)
if game.is_ready():
# Game is ready to begin play
game.activate()
ACTIVE_GAMES.add(game.id)
emit('start_game', { "spectating" : False, "start_info" : game.to_json()}, room=game.id)
socketio.start_background_task(play_game, game)
else:
# Still need to keep waiting for players
WAITING_GAMES.put(game.id)
emit('waiting', { "in_game" : True }, room=game.id)
def _create_game(user_id, game_name, params={}):
game, err = try_create_game(game_name, **params)
if not game:
emit("creation_failed", { "error" : err.__repr__() })
return
spectating = True
with game.lock:
if not game.is_full():
spectating = False
game.add_player(user_id)
else:
spectating = True
game.add_spectator(user_id)
join_room(game.id)
set_curr_room(user_id, game.id)
if game.is_ready():
game.activate()
ACTIVE_GAMES.add(game.id)
emit('start_game', { "spectating" : spectating, "start_info" : game.to_json()}, room=game.id)
socketio.start_background_task(play_game, game, fps=MAX_FPS)
else:
WAITING_GAMES.put(game.id)
emit('waiting', { "in_game" : True }, room=game.id)