def test_delete_game():
headers = {
'Authorization': 'Bearer ' + pytest.users[2]["token"],
'Content-Type': 'text/plain'
}
response = client.delete("/games/100/delete", headers=headers)
assert response.status_code == 404
assert response.json() == {'detail': 'The game does not exist'}
response = client.delete(f"/games/{pytest.info['game']}/delete",
headers=headers)
assert response.status_code == 403
assert response.json() == {
'detail': 'The game does not belong to the current user'
}
headers['Authorization'] = 'Bearer ' + pytest.users[1]["token"]
response = client.delete(f"/games/{pytest.info['game']}/delete",
headers=headers)
assert response.status_code == 200
assert response.json() == {
"message": f"The game {pytest.info['game']} (Partida 1) was deleted"
}
with db_session:
Player.get(id=pytest.info['other_player']).delete()
Game.get(id=pytest.info['other_game']).delete()
for u in list(pytest.users.values())[:-1]:
User.get(id=u["user_id"]).delete()
def create_game(challenger_id, challengee_id, options):
mode, color, time = options["mode"], options["color"], int(options["time"])
logger.info("Check time is valid")
is_time_enabled = time != 0
if is_time_enabled and GAME_MIN_TIME_SECONDS > time > GAME_MAX_TIME_SECONDS:
return (
{},
"Time must be between {} and {}".format(GAME_MIN_TIME_SECONDS,
GAME_MAX_TIME_SECONDS),
)
logger.info("Assign color to players")
white_player_id, black_player_id = assign_player_color(
color, challenger_id, challengee_id)
try:
time_in_milleseconds = time * 1000
game = Game(
id=str(uuid.uuid4()),
mode=GameMode[mode.upper()],
time=time_in_milleseconds,
whitePlayerTimeLeft=time_in_milleseconds,
blackPlayerTimeLeft=time_in_milleseconds,
whitePlayerId=white_player_id,
blackPlayerId=black_player_id,
playerTurn=white_player_id,
)
game.save()
return game, ""
except Exception as e:
logger.error(e)
return {}, "Failed to create game"
def test_board_game():
headers = {
'Authorization': 'Bearer ' + pytest.users[1]["token"],
'Content-Type': 'text/plain'
}
response = client.get(f"/games/{pytest.info['game']}/board",
headers=headers)
with db_session:
current_position = Player.get(
id=pytest.users[1]["player_id"]).current_position
game = Game.get(id=pytest.info['game'])
board = game.board.id
minister = int(game.status["minister"])
assert response.status_code == 200
assert response.json() == {
"id":
board,
"de_proc":
0,
"po_proc":
0,
"spell_fields":
["", "", "divination", "avadakedavra", "avadakedavra", "win"],
"caos":
0,
"game":
pytest.info['game']
}
response = client.get("/games/100/board", headers=headers)
assert response.status_code == 404
assert response.json() == {'detail': 'Game not found'}
def handler(event, context):
connection_id = event["requestContext"].get("connectionId")
logger.info("Leave game request from connectionId {})".format(connection_id))
logger.info("Parse event")
data, err = parse_event(event)
if err:
return create_aws_lambda_response(500, err)
game_id, player_id = data["game_id"], data["player_id"]
game = Game.get(game_id)
logger.info("Check player permissions")
if not game.is_player_in_game(player_id):
return create_aws_lambda_response(403, "Player is not part of the game")
logger.info("Resign player")
err = resign_player(game, player_id)
if err:
return create_aws_lambda_response(500, err)
logger.info("Notify players")
player_ids = [game.whitePlayerId, game.blackPlayerId]
err = notify_players(player_ids, "endGame", {"game": game.to_dict()})
if err:
return create_aws_lambda_response(500, err)
return create_aws_lambda_response(200, "Leave game successful")
async def play(proc: ProcM, game_id: int, user=Depends(manager)):
with db_session:
game = Game.get(id=game_id)
if game is None:
raise HTTPException(status_code=404, detail="Game not found")
current_player = Player.user_player(user, game_id)
if game.status["phase"] == "minister play":
if current_player["current_position"] != "minister":
raise HTTPException(status_code=404,
detail="This player is not the minister")
cards = game.board.deck.split(',')[:3]
if proc.card in cards:
cards = game.board.deck.split(',')
cards.remove(proc.card)
game.board.deck = ','.join(cards)
else:
raise HTTPException(
status_code=400,
detail="The input card was not one of the options")
msg = f'{proc.card} card discarded successfully'
# PASS THE TURN #####################
game.status["phase"] = "headmaster play"
#####################################
elif game.status["phase"] == "headmaster play":
if current_player["current_position"] != "headmaster":
raise HTTPException(status_code=404,
detail="This player is not the headmaster")
cards = game.board.deck.split(',')[:2]
if proc.card in cards:
cards = game.board.deck.split(',')[2:]
game.board.deck = ','.join(cards)
if proc.card == 'phoenix':
game.board.po_proc += 1
else:
game.board.de_proc += 1
# IMPORTANT! HERE GOES THE LOGIC FOR SPELL ACTIVATION
# PASS THE TURN ###########
spell_fields = game.board.spell_fields.split(",")
spells = ["divination", "avadakedavra", "imperius", "crucio"]
if game.board.de_proc != 0 and spell_fields[game.board.de_proc
- 1] in spells:
game.status["phase"] = "spell play"
else:
Player.reassign_minister(game)
#####################################
msg = f'{proc.card} card played successfully'
else:
raise HTTPException(
status_code=400,
detail="The input card was not one of the options")
else:
raise HTTPException(
status_code=400,
detail="It is not a phase for playing a proclamation")
return {"message": msg}
def test_get_crucio():
with db_session:
game = Game.get(id=pytest.info['game'])
player = Player.select(lambda p: p.current_position == "" and p.game.id
== game.id).first()
for i in pytest.users.keys():
if pytest.users[i]["user_id"] == player.user.id:
user = i
break
headers = {
'Authorization': 'Bearer ' + pytest.users[user]["token"],
'Content-Type': 'text/plain'
}
game.status["phase"] = "otro estado"
response = client.get(f"/games/{pytest.info['game']}/crucio/4000",
headers=headers)
assert response.status_code == 400
assert response.json() == {
"detail": "The victim player does not belong to this game"
}
response = client.get(
f"/games/{pytest.info['game']}/crucio/{pytest.users[user]['player_id']}",
headers=headers)
assert response.status_code == 400
assert response.json() == {
"detail": "Its not time for playing spells!"
}
game.status["phase"] = "spell play"
game.started = False
response = client.get(f"/games/{pytest.info['game']}/divination",
headers=headers)
assert response.status_code == 400
assert response.json() == {"detail": "Game is not started"}
game.started = True
async def get_status(game_id: int, user=Depends(manager)):
with db_session:
game = Game.get(id=game_id)
if game is None:
raise HTTPException(status_code=404, detail="Game not found")
status = game.status.copy()
return status
def test_post_avadakedavra():
with db_session:
game = Game.get(id=pytest.info['game'])
player = Player.select(lambda p: p.current_position == "" and p.game.id
== game.id).first()
for i in pytest.users.keys():
if pytest.users[i]["user_id"] == player.user.id:
user = i
break
headers = {
'Authorization': 'Bearer ' + pytest.users[user]["token"],
'Content-Type': 'text/plain'
}
response = client.post(f"/games/{pytest.info['game']}/avadakedavra",
headers=headers,
json={'id': pytest.users[2]["player_id"]})
assert response.status_code == 400
assert response.json() == {
"detail": "Its not time for playing spells!"
}
game.status["phase"] = "spell play"
response = client.post(f"/games/{pytest.info['game']}/avadakedavra",
headers=headers,
json={'id': pytest.users[2]["player_id"]})
assert response.status_code == 400
assert response.json() == {
"detail": "The avadakedavra spell is not available"
}
def test_post_msg():
headers = {
'Authorization': 'Bearer ' + pytest.users[2]["token"],
'Content-Type': 'text/plain'
}
response = client.post(f"/games/{pytest.info['game']}/messages",
headers=headers,
json={"content": "Hola Guachin"})
assert response.status_code == 200
assert response.json() == {
"detail": "the message was recorder successfully"
}
response = client.post(f"/games/1000/messages",
headers=headers,
json={"content": "Hola Guachin"})
assert response.status_code == 404
assert response.json() == {'detail': 'Game not found'}
with db_session:
game = Game.get(id=pytest.info['game'])
game.started = False
response = client.post(f"/games/{pytest.info['game']}/messages",
headers=headers,
json={"content": "Hola Guachin"})
assert response.status_code == 400
assert response.json() == {'detail': "Game is not started"}
game.started = True
def test_get_msg():
headers = {
'Authorization': 'Bearer ' + pytest.users[3]["token"],
'Content-Type': 'text/plain'
}
with db_session:
date = str(
Message.select(
lambda u: u.game.id == pytest.info['game']).first().date)
date = date.replace(" ", "T")
response = client.get(f"/games/{pytest.info['game']}/messages",
headers=headers)
assert response.status_code == 200
assert response.json() == {
"data": [{
"content": "Hola Guachin",
"date": date,
"send_by": {
"id": pytest.users[2]["user_id"],
"username": "******",
"useralias": "andres2"
}
}]
}
with db_session:
game = Game.get(id=pytest.info['game'])
game.started = False
response = client.get(f"/games/{pytest.info['game']}/messages",
headers=headers)
assert response.status_code == 400
assert response.json() == {'detail': "Game is not started"}
game.started = True
async def choose_game(self, member):
mutual_guilds = [x.id for x in self.bot.guilds if x.get_member(member.id) is not None]
games = list(Game.select().where( (Game.guild_id.in_(mutual_guilds)) & ( Game.active == True) ))
if len(games) == 1:
return games[0]
async def get_proclamations(game_id: int, user=Depends(manager)):
with db_session:
game = Game.get(id=game_id)
current_player = Player.user_player(user, game_id)
if game is None:
raise HTTPException(status_code=404, detail="Game not found")
if game.status["phase"] == "minister play":
if current_player["current_position"] != "minister":
raise HTTPException(status_code=404,
detail="This player is not the minister")
cards = game.board.deck.split(',')[:3]
data = {"data": cards}
elif game.status["phase"] == "headmaster play":
if current_player["current_position"] != "headmaster":
raise HTTPException(status_code=404,
detail="This player is not the headmaster")
cards = game.board.deck.split(',')[:2]
data = {"data": cards}
else:
raise HTTPException(
status_code=400,
detail="It is not a phase for geting a proclamation")
return data
def test_get_game():
headers = {
'Authorization': 'Bearer ' + pytest.users[2]["token"],
'Content-Type': 'text/plain'
}
response = client.get(f"/games/{pytest.info['game']}", headers=headers)
with db_session:
game = Game.get(id=pytest.info['game'])
creation_date = str(game.creation_date).replace(" ", "T")
minister = int(game.status["minister"])
created_by = int(game.created_by)
board = game.board.id
assert response.status_code == 200
assert response.json() == {
"id": pytest.info['game'],
"name": "Partida 1",
"creation_date": creation_date,
"created_by": created_by,
"player_amount": 5,
"started": True,
"status": {
"minister": minister,
"phase": "propose",
"round": 1
},
"board": board
}
response = client.get("/games/100", headers=headers)
assert response.status_code == 404
assert response.json() == {'detail': 'Game not found'}
async def start(self, ctx, minutes_to_start : float = 30):
game = Game.create(guild_id = ctx.guild.id)
join_emoji = "⬆️"
message = await game.log(f"React with an {join_emoji} to join. In {minutes_to_start} minutes the game will start.")
await message.add_reaction(join_emoji)
await asyncio.sleep(minutes_to_start * 60)
message = await message.channel.fetch_message(message.id)
join_reaction = None
for reaction in message.reactions:
if str(reaction.emoji) == join_emoji:
join_reaction = reaction
break
members = [x for x in await join_reaction.users().flatten() if not x.bot]
random.shuffle(members)
if len(members) < 1:
await message.edit(content = "Not enough players")
game.delete_instance()
return
players = []
for member in members:
players.append(Player.create(user_id = member.id, game = game))
game.start()
def handler(event, context):
connection_id = event["requestContext"].get("connectionId")
logger.info(
"Reject game request from connectionId {})".format(connection_id))
logger.info("Parse event")
data, err = parse_event(event)
if err:
return create_aws_lambda_response(500, err)
game_id, challengee_id = data["game_id"], data["challengee_id"]
game = Game.get(game_id)
logger.info("Check player permissions")
if not game.is_player_in_game(challengee_id):
return create_aws_lambda_response(403,
"Player is not part of the game")
logger.info("Reject game")
err = reject_game(game, challengee_id)
if err:
return create_aws_lambda_response(500, err)
logger.info("Notify player")
challenger_id = game.get_opponent_id(challengee_id)
err = notify_player(challenger_id, "endGame", {"game": game.to_dict()})
if err:
return create_aws_lambda_response(500, err)
return create_aws_lambda_response(200, "Reject game successful")
def handler(event, context):
connection_id = event["requestContext"].get("connectionId")
logger.info("Send message request from connectionId {})".format(connection_id))
logger.info("Parse event")
data, err = parse_event(event)
if err:
return create_aws_lambda_response(500, err)
game_id, player_id, text = data["game_id"], data["player_id"], data["text"]
game = Game.get(game_id)
logger.info("Check player permissions")
if not game.is_player_in_game(player_id):
return create_aws_lambda_response(403, "Player is not part of the game")
logger.info("Generate message")
sender = Player.get(player_id)
message = generate_message(game.id, sender, text)
logger.info("Save message")
_, err = create_message(game_id, player_id, message["text"])
if err:
return create_aws_lambda_response(500, err)
logger.info("Send message to players")
player_ids = [game.whitePlayerId, game.blackPlayerId]
err = notify_players(player_ids, "sendMessage", {"message": message})
if err:
return create_aws_lambda_response(500, err)
return create_aws_lambda_response(200, "Send message successful")
async def get_specific_game(game_id: int, user=Depends(manager)):
with db_session:
game = Game.get(id=game_id)
if game is None:
raise HTTPException(status_code=404, detail="Game not found")
result = game.to_dict()
return result
async def all_messages(game_id: int, user=Depends(manager)):
with db_session:
def user_data(obj_player):
c_user = obj_player.user
return {
"id": c_user.id,
"username": c_user.username,
"useralias": c_user.useralias
}
game = Game.get(id=game_id)
Player.user_player(user, game_id)
if game is None:
raise HTTPException(status_code=404, detail="Game not found")
if not game.started:
raise HTTPException(status_code=400, detail="Game is not started")
chats = game.chats.order_by(lambda c: desc(c.date))
return {
'data': [{
"content": m.content,
"date": m.date,
"send_by": user_data(m.player)
} for m in chats]
}
async def play_crucio(player_id: int, game_id: int, user=Depends(manager)):
with db_session:
game = Game.get(id=game_id)
current_player = Player.user_player(user, game_id)
victim_player = Player.select(
lambda p: p.id == player_id and p.game.id == game_id).first()
deck = game.board.spell_fields.split(",")
if game is None:
raise HTTPException(status_code=404, detail="Game not found")
if not game.started:
raise HTTPException(status_code=400, detail="Game is not started")
if not victim_player:
raise HTTPException(
status_code=400,
detail="The victim player does not belong to this game")
if game.status["phase"] != "spell play":
raise HTTPException(status_code=400,
detail="Its not time for playing spells!")
if current_player["current_position"] != "minister":
raise HTTPException(status_code=400,
detail=f"This player is not the minister")
if game.board.de_proc == 0 or deck[game.board.de_proc - 1] != "crucio":
raise HTTPException(status_code=400,
detail="The crucio spell is not available")
victim_user = User.select(
lambda u: u.id == victim_player.user.id).first()
role = victim_player.role
return {
"role": role,
"player_id": player_id,
"player_alias": victim_user.useralias
}
async def get_deck(game_id: int, user=Depends(manager)):
with db_session:
game = Game.get(id=game_id)
if game is None:
raise HTTPException(status_code=404, detail="Game not found")
if not game.started:
raise HTTPException(status_code=400, detail="Game is not started")
return game.board.deck
async def get_current_player(game_id: int, user=Depends(manager)):
with db_session:
game = Game.get(id=game_id)
if game is None:
raise HTTPException(status_code=404,
detail="The game does not exist")
return Player.user_player(user, game_id)
async def end_turn(game_id: int, user=Depends(manager)):
with db_session:
game = Game.get(id=game_id)
if game is None:
raise HTTPException(status_code=404, detail="Game not found")
if not game.started:
raise HTTPException(status_code=400, detail="Game is not started")
Player.reassign_minister(game)
return {"message": "Turn ended!"}
def test_get_divination():
with db_session:
headers = {
'Authorization': 'Bearer ' + pytest.users[1]["token"],
'Content-Type': 'text/plain'
}
#response = client.get("/games/100/divination", headers=headers)
game = Game.get(id=pytest.info['game'])
game.status["minister"]
def handler(event, context):
connection_id = event["requestContext"].get("connectionId")
logger.info(
"Move piece request from connectionId {})".format(connection_id))
logger.info("Parse event")
data, err = parse_event(event)
if err:
return create_aws_lambda_response(500, err)
game_id, player_id, move_san = data["game_id"], data["player_id"], data[
"move_san"]
game = Game.get(game_id)
logger.info("Check player permissions")
if not game.is_player_in_game(player_id):
return create_aws_lambda_response(403,
"Player is not part of the game")
if not game.is_player_turn(player_id):
return create_aws_lambda_response(403, "It is not player turn to play")
logger.info("Check move is valid")
game.moves.append(move_san)
board = generate_board_from_moves(game.moves)
if not board.is_valid():
notify_player(player_id, "movePieceFailure",
{"error": str(board.status())})
return create_aws_lambda_response(400, "Invalid move")
status, result = is_game_ended(game, board)
if status:
logger.info("Update game with the final result")
err = end_game(game, status, result)
if err:
return create_aws_lambda_response(500, err)
logger.info("Notify players the game has ended")
player_ids = [game.whitePlayerId, game.blackPlayerId]
err = notify_players(player_ids, "endGame", {"game": game.to_dict()})
if err:
return create_aws_lambda_response(500, err)
return create_aws_lambda_response(200, "End game successful")
logger.info("Move piece")
err = move_piece(game, board.fen())
if err:
return create_aws_lambda_response(500, err)
logger.info("Notify users the move is valid")
player_ids = [game.whitePlayerId, game.blackPlayerId]
err = notify_players(player_ids, "movePieceSuccess",
{"game": game.to_dict()})
if err:
return create_aws_lambda_response(500, "Failed to notify players")
return create_aws_lambda_response(200, "Move piece successful")
async def get_board(game_id: int, user=Depends(manager)):
with db_session:
game = Game.get(id=game_id)
if game is None:
raise HTTPException(status_code=404, detail="Game not found")
if not game.started:
raise HTTPException(status_code=400, detail="Game is not started")
board = game.board.to_dict().copy()
spell_fields = board["spell_fields"]
board["spell_fields"] = spell_fields.split(",")
return board
async def get_games(user=Depends(manager)):
with db_session:
def parseGame(game):
game_dict = game.to_dict()
players = game.players.count()
game_dict["joined_players"] = players
return game_dict
games = Game.select()[:]
result = {'data': [parseGame(g) for g in games if not g.started]}
return result
def test_get_proclamations_game():
with db_session:
game = Game.get(id=pytest.info["game"])
minister = game.status['minister']
headmaster = int(game.status['headmaster'])
for i in pytest.users.keys():
if pytest.users[i]["player_id"] != minister and pytest.users[i][
"player_id"] != headmaster:
acc = i
break
headers = {
'Authorization': 'Bearer ' + pytest.users[acc]["token"],
'Content-Type': 'text/plain'
}
game.status["phase"] = "x"
response = client.get(f"/games/{pytest.info['game']}/proclamations",
headers=headers)
assert response.status_code == 400
assert response.json() == {
'detail': "It is not a phase for geting a proclamation"
}
game.status["phase"] = "minister play"
response = client.get(f"/games/{pytest.info['game']}/proclamations",
headers=headers)
assert response.status_code == 404
assert response.json() == {'detail': "This player is not the minister"}
for i in pytest.users.keys():
if pytest.users[i]["player_id"] == minister:
user_minister = i
break
headers[
'Authorization'] = 'Bearer ' + pytest.users[user_minister]["token"]
response = client.get(f"/games/{pytest.info['game']}/proclamations",
headers=headers)
assert response.status_code == 200
assert response.json() == {"data": game.board.deck.split(',')[:3]}
game.status["phase"] = "headmaster play"
response = client.get(f"/games/{pytest.info['game']}/proclamations",
headers=headers)
assert response.status_code == 404
assert response.json() == {
'detail': "This player is not the headmaster"
}
for i in pytest.users.keys():
if pytest.users[i]["player_id"] == headmaster:
user_headmaster = i
break
headers['Authorization'] = 'Bearer ' + pytest.users[user_headmaster][
"token"]
response = client.get(f"/games/{pytest.info['game']}/proclamations",
headers=headers)
assert response.status_code == 200
assert response.json() == {"data": game.board.deck.split(',')[:2]}
async def poll(self):
for game in Game.select().where(Game.active == True):
if not game.started:
continue
if len(game.players) > 1:
if game.ended:
game.end()
if game.cycle_ended:
game.next_cycle()
async def choose_headmaster(headmaster: PlayerM,
game_id: int,
user=Depends(manager)):
with db_session:
game = Game.get(id=game_id)
if game is None:
raise HTTPException(status_code=404, detail="Game not found")
if not game.started:
raise HTTPException(status_code=400, detail="Game is not started")
status = game.status
player = Player.get(id=status["minister"])
if status["phase"] != "propose":
raise HTTPException(
status_code=400,
detail="The headmaster only can be elected in the propose phase"
)
if player.user.id != user["id"]:
raise HTTPException(
status_code=400,
detail="Only the minister can propose a headmaster")
new_hm = Player.get(id=headmaster.id)
if new_hm is None:
raise HTTPException(status_code=400,
detail="The selected player does not exist")
if new_hm.id == status["minister"]:
raise HTTPException(
status_code=400,
detail="The minister can not be the headmaster")
if not new_hm.choosable:
raise HTTPException(
status_code=400,
detail="The player has been headmaster in the previous round")
if new_hm.game.id != game_id:
raise HTTPException(
status_code=400,
detail="The player does not belong to this game")
if not new_hm.alive:
raise HTTPException(
status_code=400,
detail="The player cannot be headmaster because is dead")
Player.reset_choosable()
status["headmaster"] = int(headmaster.id)
# PASS THE TURN ####################
status["phase"] = "vote"
#####################################
game.status = status
new_hm.current_position = "headmaster"
new_hm.choosable = False
return {
"message":
f'The player number {new_hm.id}: {new_hm.user.username} was proposed as headmaster'
}
def test_get_games():
headers = {
'Authorization': 'Bearer ' + pytest.users[2]["token"],
'Content-Type': 'text/plain'
}
response = client.get("/games/", headers=headers, json={})
with db_session:
def parseGame(game):
game_dict = game.to_dict()
players = game.players.count()
game_dict["joined_players"] = players
return game_dict
creation_date = str(
Game.get(id=pytest.info['game']).creation_date).replace(" ", "T")
games = Game.select()[:]
result = {'data': [parseGame(g) for g in games if not g.started]}
for g in result["data"]:
g["creation_date"] = str(g["creation_date"]).replace(" ", "T")
assert response.status_code == 200
assert response.json() == result
