def gp_to_game(gpid):
try:
gpdb = db.pull(GP_DB)
gp = GameParameters.from_dict(gpdb[gpid])
except KeyError:
return "GameParameter not found", 404
if not gp.min_players <= len(gp.players) <= gp.max_players:
return "Player count not fulfilled", 409
try:
_dict = request.get_json(force=True)
_dict["parameters"] = gp.to_dict()
game = Game.from_dict(_dict)
except KeyError:
return "Game: Format Error", 400
del gpdb[gpid]
db.push(gpdb, GP_DB)
gdb = db.pull(G_DB)
gdb[gpid] = game.to_dict()
db.push(gdb, G_DB)
gsdb = db.pull(GS_DB)
gs = GameSnapshot.from_game(game)
gsdb[gpid] = gs.to_dict()
db.push(gsdb, GS_DB)
return "Game Successfully Started", 200
async def confirm_game_handler(websocket, gid):
try:
gdb = db.pull(G_DB)
if (gdb[gid]["status"] == "DELETED"):
await websocket.send(
'{"header":"ERROR", "content":"Room has been deleted"}')
return
game = Game.from_dict(gdb[gid])
# Disable for testing
# if len(game.players) < game.min_players:
# await websocket.send('{"header":"ERROR", "content":"Not enough players"}')
# return
game.assignTeam()
game.status = "PREPARE"
gdb[gid] = game.to_dict()
db.push(gdb, G_DB)
game = gdb[gid]
room_info = {"status": game["status"], "players": game["players"]}
await broadcast(gid, "ROOM_INFO", room_info)
except Exception as e:
print(e)
await websocket.send(
'{"header": "ERROR", "content": "Confirmation fail"}')
def gp_delete(gpid):
gpdb = db.pull(GP_DB)
try:
del gpdb[gpid]
except KeyError:
return "GameParameter not found", 404
db.push(gpdb, GP_DB)
async def save_checkpoints_handler(websocket, _dict):
try:
gid = _dict["gid"]
cps = list()
for cp in _dict["checkpoints"]:
cps.append(Checkpoint.from_dict(cp))
except:
await websocket.send(
'{"header":"ERROR", "content":"Save checkpoints- Wrong Format"}')
return
try:
gdb = db.pull(G_DB)
if (gdb[gid]["status"] == "DELETED"):
await websocket.send(
'{"header":"ERROR", "content":"Room has been deleted"}')
return
game = Game.from_dict(gdb[gid])
game.checkpoints = cps
gdb[gid] = game.to_dict()
db.push(gdb, G_DB)
await websocket.send('{"header": "CPS_SAVED", "content":true}')
game = gdb[gid]
room_info = {
"status": game["status"],
"checkpoints": game["checkpoints"]
}
await broadcast(gid, "ROOM_INFO", room_info)
except Exception as e:
print(e)
await websocket.send('{"header": "ERROR", "content": "Game not found"}'
)
async def add_handler(websocket, _dict):
try:
gdb = db.pull(G_DB)
game = Game.from_dict(gdb[_dict["gid"]])
except Exception as e:
print(e)
await websocket.send(
'{"header": "ERROR", "content": "Cannot find game"}')
return
try:
game.incrementLevel(int(_dict["cid"]), _dict["team"])
except Exception as e:
print(e)
await websocket.send('{"header": "ERROR", "content": "Incremnet fail"}'
)
return
try:
await broadcast(_dict["gid"], "GAME_INFO", game.keyInfo)
except Exception as e:
print(e)
await websocket.send('{"header": "ERROR", "content": "Broadcast fail"}'
)
return
try:
gdb[_dict["gid"]] = game.to_dict()
db.push(gdb, G_DB)
except Exception as e:
print(e)
await websocket.send('{"header": "ERROR", "content": "Save game fail"}'
)
async def join_game_handler(websocket, _dict):
try:
gid = _dict["gid"]
player = Player.from_dict(_dict["player"])
except KeyError:
await websocket.send(
'{"header":"ERROR", "content":"Join Game - Wrong Format"}')
return
try:
gdb = db.pull(G_DB)
if (gdb[gid]["status"] == "DELETED"):
await websocket.send(
'{"header":"ERROR", "content":"Room has been deleted"}')
return
game = Game.from_dict(gdb[gid])
if len(game.players) < game.max_players:
game.players.append(player)
gdb[gid] = game.to_dict()
else:
await websocket.send(
'{"header":"ERROR", "content":"Room is fulled"}')
return
db.push(gdb, G_DB)
await websocket.send('{"header": "JOINED", "content":' +
json.dumps(gdb[gid]) + '}')
await register(websocket, gid)
game = gdb[gid]
room_info = {"status": game["status"], "players": game["players"]}
await broadcast(gid, "ROOM_INFO", room_info)
except Exception as e:
print(e)
await websocket.send('{"header": "ERROR", "content": "Game not found"}'
)
def gs_read_time(gsid, time):
gsdb = db.pull(GS_DB)
try:
gs = GameSnapshot.from_dict(gsdb[gsid])
gs.fast_forward(time)
gsdb[gsid] = gs.to_dict()
except KeyError:
return "GameSnapshot not found", 404
db.push(gsdb, GS_DB)
def gp_remove_player(gpid, pid):
try:
gpdb = db.pull(GP_DB)
gp = GameParameters.from_dict(gpdb[gpid])
gp.players = [player for player in gp.players if player.pid != pid]
gpdb[gpid] = gp.to_dict()
db.push(gpdb, GP_DB)
return "Player removed"
except KeyError:
return "GameParameter not found", 404
def g_get_rid_from_pid(gid, pid):
gdb = db.pull(GS_DB)
try:
g = Game.from_dict(gdb[gid])
for role in g.roles:
if role.player.pid == pid:
return role.to_dict()
else:
return "Player not found", 404
except KeyError:
return "Game not found", 404
def gp_create(gpid):
try:
_dict = request.get_json(force=True)
_dict["gpid"] = gpid
gp = GameParameters.from_dict(_dict)
except KeyError:
return "GPID: Wrong Format", 400
gpdb = db.pull(GP_DB)
gpdb[gpid] = gp.to_dict()
db.push(gpdb, GP_DB)
return "GameParameter successfully created", 200
def gs_process_movement(gsid):
gsdb = db.pull(GS_DB)
try:
gs = GameSnapshot.from_dict(gsdb[gsid])
except KeyError:
return "GameSnapshot not found", 404
try:
_dict = request.get_json(force=True)
movement = CheckpointMovement.from_dict(_dict)
except KeyError:
return "CheckpointMovement: Format Error", 400
gs.fast_forward(movement.time, (movement, ))
gsdb[gsid] = gs.to_dict()
db.push(gsdb, GS_DB)
def gp_add_player(gpid):
try:
_dict = request.get_json(force=True)
player = Player.from_dict(_dict)
except KeyError:
return "Player: Format Error", 400
try:
gpdb = db.pull(GP_DB)
gp = GameParameters.from_dict(gpdb[gpid])
if len(gp.players) < gp.max_players:
gp.players.append(player)
gpdb[gpid] = gp.to_dict()
else:
return "Room is full", 409
db.push(gpdb, GP_DB)
except KeyError:
return "GameParameter not found", 404
async def player_stats_handler(websocket, _dict):
try:
gdb = db.pull(G_DB)
game = Game.from_dict(gdb[_dict["gid"]])
except Exception as e:
print(e)
await websocket.send(
'{"header": "ERROR", "content": "Cannot find game"}')
return
try:
flag = game.setPlayerStats(int(_dict["key"]), _dict["points"],
_dict["dist"])
except Exception as e:
print(e)
await websocket.send(
'{"header": "ERROR", "content": "Updatae stats fail"}')
return
try:
gdb[_dict["gid"]] = game.to_dict()
db.push(gdb, G_DB)
except Exception as e:
print(e)
await websocket.send('{"header": "ERROR", "content": "Save game fail"}'
)
try:
if flag:
[distMVP, pointMVP] = game.findMVPs()
game = gdb[_dict["gid"]]
await broadcast(
_dict["gid"], "ACCOUNT_FINISHED", {
"players": game["players"],
"winTeam": game["winTeam"],
"distMVP": distMVP,
"pointMVP": pointMVP,
"startTime": game["startTime"],
"endTime": game["endTime"]
})
except Exception as e:
print(e)
await websocket.send('{"header": "ERROR", "content": "Broadcast fail"}'
)
return
async def create_game_handler(websocket, _dict):
game = None
try:
gid = 0
gdb = db.pull(G_DB)
assigned = False
while (not assigned):
gid = random.randint(100000, 999999)
if gid not in gdb:
_dict["gid"] = gid
assigned = True
game = Game.new_game(_dict)
except Exception as e:
print(e)
await websocket.send(
'{"header": "ERROR", "content": "Create game - Wrong Format"}')
return
gdb[gid] = game.to_dict()
db.push(gdb, G_DB)
await websocket.send('{"header": "CREATED", "content":' +
json.dumps(gdb[gid]) + '}')
await register(websocket, str(gid))
def gp_read(gpid):
try:
gpdb = db.pull(GP_DB)
return gpdb[gpid]
except KeyError:
return "GameParameter not found", 404
def gs_read(gsid):
gsdb = db.pull(GS_DB)
try:
return gsdb[gsid]
except KeyError:
return "GameSnapshot not found", 404
def gp_list():
gpdb = db.pull(GP_DB)
return gpdb
def g_list():
gdb = db.pull(G_DB)
return gdb
def g_read(gid):
gdb = db.pull(GS_DB)
try:
return gdb[gid]
except KeyError:
return "Game not found", 404
def gs_list():
gsdb = db.pull(GS_DB)
return gsdb
