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 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] }
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()
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 create_player(player_id): try: player = Player.get(player_id) except Player.DoesNotExist: logger.info("New player connecting, using defaults") player = Player(id=player_id) finally: return player
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!"}
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' }
async def left_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") if game.started: raise HTTPException(status_code=400, detail="The Game is already started") current_player = Player.user_player(user, game_id) player_obj = Player.get(id=current_player["id"]) player_obj.delete() return {"message": 'game left successfully'}
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 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_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
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_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
async def join_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") if game.players.count() == game.player_amount: raise HTTPException(status_code=403, detail="The game is full") new_player = Player(choosable=True, current_position='', role='', is_voldemort=False, alive=True, user=User[user["id"]]) new_player.game = game game.players.add(new_player) return {"message": 'joined successfully'}
def get_authorizer_principal_id(event): if os.environ.get("IS_OFFLINE") == "true": connection_id = event["requestContext"].get("connectionId") for player in Player.scan(): if player.connectionId == connection_id: return player.id return event["requestContext"]["authorizer"]["principalId"]
def create_players(players: list[str]) -> list[Player]: """Create list of player objects with assigned Trail Objects and Supplies.""" player_list: list[Player] = [] for i in enumerate(players): supply_options: list[str] = [] trail_options: list[Trail] = [] calamities: dict[str, str] = [] for j in range(5): choic: str = choice(trails) trail = Trail(choic[0], choic[1], i[1], choic[2], choic[3], choic[4]) trail_options.append(trail) choi: str = choice(supplies) supply_options.append(choi) player_num: int = i[0] + 1 player = Player(player_num, players[i[0]], supply_options, trail_options, calamities) player_list.append(player) return player_list
def handler(event, context): connection_id = event["requestContext"].get("connectionId") logger.info("Create 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) challenger_id, challengee_id = data["challenger_id"], data["challengee_id"] game_options = data["game_options"] logger.info("Create game") game, err = create_game(challenger_id, challengee_id, game_options) if err: return create_aws_lambda_response(500, err) logger.info("Notify player") challenger = Player.get(challenger_id) content = { "challenger": { "id": challenger.id, "name": challenger.name, "nickname": challenger.nickname, "picture": challenger.picture, }, "game": game.to_dict(), } err = notify_player(challengee_id, "createGame", content) if err: return create_aws_lambda_response(500, "Failed to notify player") return create_aws_lambda_response(200, "Create game successful")
def test_me_game(): headers = { 'Authorization': 'Bearer ' + pytest.users[1]["token"], 'Content-Type': 'text/plain' } response = client.get(f"/games/{pytest.info['game']}/me", headers=headers) with db_session: player = Player.get(id=pytest.users[1]["player_id"]) current_position = player.current_position role = player.role voldemort = player.is_voldemort assert response.status_code == 200 assert response.json() == { "id": pytest.users[1]["player_id"], "choosable": True, "current_position": current_position, "role": role, "is_voldemort": voldemort, "alive": True, "user": pytest.users[1]["user_id"], "game": pytest.info['game'] } response = client.get("/games/100/me", headers=headers) assert response.status_code == 404 assert response.json() == {'detail': "The game does not exist"}
def get_player(player_id): try: player = Player.get(player_id) return player, "" except Exception as e: logger.error(e) return {}, "Failed to get player"
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'}
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 share(self, ctx, member : discord.Member): game = await self.choose_game(ctx.author) if game is None: return await ctx.send("No game running for you.") player = Player.get(game = game, user_id = ctx.author.id, alive = True) player_to_share_with = Player.get(game = game, user_id = member.id, alive = True) if player.id == player_to_share_with.id: return await ctx.send("Nice try.") player.cycle_immunity = True player.save() await member.send(f"{ctx.author} has shared their code with you. The code: {player.code}") await ctx.send("Okay. You are now immune to code leaks when this cycle ends.")
def notify_players(player_ids, action, content): try: data = {"action": action, "content": content} for player in Player.batch_get(player_ids, attributes_to_get=["connectionId"]): send_to_connection(player.connectionId, data) except Exception as e: logger.error(e) return "Failed to notify players"
async def expelliarmus(in_vote: VoteM, game_id: int, user=Depends(manager)): with db_session: game = Game.get(id=game_id) current_player = Player.user_player(user, game_id) username = User.get(id=current_player["user"]).username detail = f"The player {username} has played expelliarmus!" 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 current_player["current_position"] != "minister" and current_player[ "current_position"] != "headmaster": raise HTTPException( status_code=400, detail="this player is not the minister nor the headmaster") if game.board.de_proc < 5 or game.status["phase"] != "headmaster play": raise HTTPException(status_code=400, detail="It is not time for expelliarmus!!!") if "headmaster_expelliarmus" not in game.status.keys(): if current_player["current_position"] == 'headmaster': game.status["headmaster_expelliarmus"] = in_vote.vote else: raise HTTPException( status_code=400, detail="The headmaster must play the expelliarmus first!") else: if current_player["current_position"] == 'minister': game.status["minister_expelliarmus"] = in_vote.vote else: raise HTTPException( status_code=400, detail="The minister must confirm the expelliarmus!") detail = "The expelliarmus has failed!" if game.status["minister_expelliarmus"] and game.status[ "headmaster_expelliarmus"]: cards = game.board.deck.split(',')[2:] game.board.deck = ','.join(cards) detail = "the expelliarmus was played succesfully!, cards discarded" Player.reassign_minister(game) return {detail}
async def create_game(input_game: GameM, user=Depends(manager)): with db_session: new_game = Game(name=input_game.name, created_by=user["id"], started=False, creation_date=datetime.datetime.now(), player_amount=input_game.player_amount, status={}) new_player = Player(choosable=True, current_position='', role='', is_voldemort=False, alive=True, user=User[user["id"]]) new_game.players.add(new_player) new_player.game = new_game commit() status = {'id': new_game.id, 'message': 'Game created successfully'} return status
def get_players(): try: players = [] for player in Player.scan(attributes_to_get=GET_PLAYER_FIELDS, limit=MAX_RECORD_LIMIT): players.append(player.to_dict()) return players, "" except Exception as e: logger.error(e) return {}, "Failed to get players"
async def kill_player(player_id: PlayerM, 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.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 game.status["phase"] != "spell play": raise HTTPException(status_code=400, detail="Its not time for playing spells!") if not game.board.de_proc or deck[game.board.de_proc - 1] != 'avadakedavra': raise HTTPException( status_code=400, detail="The avadakedavra spell is not available") if not victim_player: raise HTTPException( status_code=400, detail="The victim player does not belong to this game") if current_player["current_position"] != "minister": raise HTTPException(status_code=404, detail="This player is not the minister") victim_player.alive = False if victim_player.is_voldemort: game.status = { "info": "game ended", "winner": "Phoenix Order", "detail": "voldemort killed" } else: Player.reassign_minister(game) victim_user = User.select( lambda u: u.id == victim_player.user.id).first() return { "avadakedavra": "succeed!", "dead_player_id": player_id.id, "dead_player_alias": victim_user.useralias }
async def write_message(msg_content: MessageM, game_id: int, user=Depends(manager)): with db_session: game = Game.get(id=game_id) current_player = Player.select(lambda p: user["id"] == p.user.id and p. game.id == game_id).first() 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") Message(date=datetime.datetime.now(), content=msg_content.content, game=game_id, player=current_player) return {"detail": "the message was recorder successfully"}
async def start_game(game_id: int, user=Depends(manager)): status = {} with db_session: current_game = Game.get(id=game_id) # IMPORTANT!!!: # Currently this is not checking that the game is full before continue (for testing purposes) if current_game is None: raise HTTPException(status_code=404, detail="The game does not exist") if current_game.started: raise HTTPException(status_code=400, detail="The game was already started") if current_game.created_by != user["id"]: raise HTTPException( status_code=403, detail="The game does not belong to the current user") # spell board and random deck spell_fields = ','.join(Board.define_board(current_game.player_amount)) random_deck = ','.join(Board.new_deck(50)) new_board = Board(de_proc=0, po_proc=0, spell_fields=spell_fields, caos=0, game=current_game, deck=random_deck) current_game.started = True current_game.board = new_board # Role choosing role_info = Player.assign_roles(current_game.players) current_game.status = { "round": 1, "phase": 'propose', "minister": role_info, } commit() status = { 'board_id': new_board.id, 'message': 'Game started successfully' } return status
def test_player_factory(self): number = 1 name = 'Miss Garbanzo' trail_options = [ 'Active Volcano to the Left', 'Inactive Void of Once-Active Volcano to the Right' ] supplies = ['Vicodin', 'Revolver', 'Single Bullet', 'Garlic'] calamities = ['Yellowstone explodes', 'Your gallstones explode'] p: Player = Player.create(number, name, supplies, trail_options, calamities) self.assertEqual(number, p.number) self.assertEqual(name, p.name) for trail, supply in zip(trail_options, supplies): self.assertEqual(1, p.trail_options.get(trail)) self.assertEqual(1, p.supplies.get(supply))