def validate(db: StandardDatabase, token, email=None): """ validate player token :param db: connection :param token: jwt token :param email: mail :return Player or None """ if not db.has_collection('players'): logger.error('cannot validate token if players do not exist') raise PlayerStateException('players collection does not exist') col = db.collection('players') if email: db_player = next(col.find({'mail': email}), None) if not db_player: logger.error(f'could not resolve player {email}') raise PlayerStateException(f'player {email} does not exist') if token in db_player['tokens']: player = Player(db_player['mail'], '') player.id = UUID(db_player['_key']) player.password = db_player['password'] return player else: for db_player in col.all(): if 'tokens' in db_player and token in db_player['tokens']: player = Player(db_player['mail'], '') player.id = UUID(db_player['_key']) player.password = db_player['password'] return player return None
def test_player_at_game_change(mocker): ps = Playerset() gs = Gameset(ps) p = Player(**{"id_": 1, "login": "******"}) ps[p.id] = p p = Player(**{"id_": 2, "login": "******"}) ps[p.id] = p p = Player(**{"id_": 3, "login": "******"}) ps[p.id] = p data = copy.deepcopy(GAME_DICT) g1 = Game(playerset=ps, **data) gUpd = mocker.Mock() ps[1].newCurrentGame.connect(gUpd) gs[1] = g1 gUpd.assert_called_with(ps[1], g1, None) gUpd.reset_mock() data["state"] = GameState.PLAYING gs[1].update(**data) assert not gUpd.called data["state"] = GameState.CLOSED gs[1].update(**data) gUpd.assert_called_with(ps[1], None, g1)
def test_game_at_missing_player(mocker): ps = Playerset() gs = Gameset(ps) p = Player(**{"id_": 1, "login": "******"}) ps[p.id] = p p = Player(**{"id_": 2, "login": "******"}) ps[p.id] = p data = copy.deepcopy(GAME_DICT) g1 = Game(playerset=ps, **data) pAdd = mocker.Mock() g1.connectedPlayerAdded.connect(pAdd) gs[1] = g1 assert len(g1.players) == 3 gps = [g1.to_player(n) for n in g1.players if g1.is_connected(n)] assert len(gps) == 2 assert ps[1] in gps assert ps[2] in gps assert not pAdd.called p = Player(**{"id_": 3, "login": "******"}) ps[p.id] = p pAdd.assert_called_with(g1, ps[3]) gps = [g1.to_player(n) for n in g1.players if g1.is_connected(n)] assert len(gps) == 3 assert ps[3] in gps assert g1.is_ingame(ps[3].login) assert ps[3].currentGame is g1
def menu(): fast = False if fast: board = generate_board(3) return Game([Player("p1"), Player("p2")], board) players = [] print( '''Entre respectivamente o tamanho da quadra que voce quer usar, um valor de 3 a 10, e o qantidade de jogadores que vao jogar. Minimo 2, maximo 5, para sair digite sair a qualquer momento''' ) while True: board_size = int(input('Tamanho do tabuleiro: ')) if 2 < board_size <= 10: break while True: pos = len(players) player_name = input('Nome do jogador ' + (pos + 1).__str__() + ": ") players.append(Player(player_name)) # verifica se o tamanho do tabuleiro é 3 e se tem 2 jogadores e continua o jogo, fica impossivel # jogar com mais de dois jogadores no mesmo tabuleiro if board_size.__eq__(3) and len(players).__eq__(2): break if board_size > 3 and len(players) >= 2: more = input('Continuar(S/N)? ') if more.upper().__eq__("N"): break board = generate_board(board_size) return Game(players, board)
def create_players(tournament): """Fonction Permetant de creer huits joueurs a un tournoi""" enter_player = 1 while enter_player <= 8: player_list = select_players() selection = view.menu_create_player(player_list) if selection == 1: # --------------------------------------------------------------------------------- # Joueur existant view.print_actors(player_list) data = create_existing_player() player_db = Player(data['Nom'], data['Prenom'], data['Date de Naissance'], data['Sexe'], data['Classement']) # add the player id to the list of tournament players_id tournament.players_index_list.append(data.doc_id) # add the player to the list of tournament players with the tournament method tournament.add_player(player_db) # --------------------------------------------------------------------------------- elif selection == 2: # --------------------------------------------------------------------------------- # Nouveau joueur data = view.create_player_view(enter_player) player = Player(data['name'], data['first_name'], data['birth_day'], data['sex'], data['ranking']) # add the player to the list of tournament players with the tournament method tournament.add_player(player) # players are registered in the database save_player(player) # prendre l'identifiantiant du joueur for id_player in get_players_id(1): tournament.players_index_list.append(id_player) # --------------------------------------------------------------------------------- enter_player += 1
def initial_state(self): """ Change the state into initial state """ # init player self.player_list.append(Player(5, 0)) self.player_list.append(Player(5, 1)) # init King self.white_king = King(self.KING_HP_DEFAULT, self.KING_ATK_DEFAULT, 4, 8, self.player_list[0]) self.board[4][8] = self.white_king self.black_king = King(self.KING_HP_DEFAULT, self.KING_ATK_DEFAULT, 4, 0, self.player_list[1]) self.board[4][0] = self.black_king init_pawn_spawn = int(9 / 2) + 1 for i in range(init_pawn_spawn): self.white_pawn_list.append( SoldierPawn(i, self.PAWN_HP_DEFAULT, self.PAWN_ATK_DEFAULT, i * 2, 7, False, self.player_list[0], self.PAWN_STEP_DEFAULT)) self.board[i * 2][7] = self.white_pawn_list[i] self.black_pawn_list.append( SoldierPawn(i, self.PAWN_HP_DEFAULT, self.PAWN_ATK_DEFAULT, i * 2, 1, False, self.player_list[1], self.PAWN_STEP_DEFAULT)) self.board[i * 2][1] = self.black_pawn_list[i]
def test_game_fire(self, MockShip): ship = MockShip() ship.is_dead.return_value = False rules = Rules(mode='standard', opponent='human') player1 = Player('p1') player2 = Player('p2') player2.ships.append(ship) g = Game(1, player1, player2, rules) ship.is_hit.return_value = True expected = True actual = g.fire(Coordinates('a', 1)) self.assertEqual(expected, actual) g = Game(1, player1, player2, rules) ship.is_hit.return_value = False expected = False actual = g.fire(Coordinates('b', 3)) self.assertEqual(expected, actual) expected = False actual = g.fire(Coordinates('i', 10)) self.assertEqual(expected, actual)
def __init__(self): super().__init__() self.ui_manager = UIManager() self.controlador = controller.Controller() self.player_1 = Player('assets/blue') self.player_2 = Player('assets/yellow') self.cards_list = None self.text = "Jogador azul escolha carta 0/2"
def on_mouse_press(self, x, y, _button, _modifiers): choice = arcade.get_sprites_at_point((x, y), self.personagem_list) if len(choice) > 0: if choice[0].tipo == 1: self.window.show_view( self.controlador.card_view(Player('assets/yellow'))) else: self.window.show_view( self.controlador.card_view(Player('assets/blue')))
def set_up(): global game global player_1 global player_2 player_1 = Player(name="Pascal") player_2 = Player(name="Alina") game = Game([player_1, player_2]) game.word = ['n', 'a', 'm', 'e']
def setUp(self): self.game = Game([Player(1, "P1"), Player(2, "P2"), Player(3, "P3")]) self.game.game_variant = GameVariantGrand() self.game.players[0].type = Player.Type.DEFENDER self.game.players[1].type = Player.Type.DECLARER self.game.players[2].type = Player.Type.DEFENDER self.game.trick.leader = self.game.players[1] self.state = GameStatePlay(self.game) self.state_machine = GameStateMachine(self.state)
def test_game_next_player(self): rules = Rules(mode='standard', opponent='human') p1 = Player('p1') p2 = Player('p2') g = Game(1, p1, p2, rules) expected = p2 actual = g.next_player() self.assertEqual(expected, actual)
def deserializer(name): db = TinyDB("db_tournament.json", indent=4) tournaments = db.table("Tournaments") tournament = Query() tournament = tournaments.search(tournament.name == name)[0] reload_tournament = Tournament( tournament["name"], tournament["time control"], tournament["place"], tournament["date"], tournament["description"], ) for player in tournament["players"]: reload_player = Player( player["first name"], player["last name"], player["elo"], player["date of birth"], player["player's gender"], player["score"], player["opponent list"], ) reload_tournament.add_player(reload_player) for round in tournament["rounds"]: reload_round = Round(round["number"]) for match in round["matchs"]: player1 = Player( match["player1"]["first name"], match["player1"]["last name"], match["player1"]["elo"], match["player1"]["date of birth"], match["player1"]["player's gender"], match["player1"]["score"], match["player1"]["opponent list"], ) player2 = Player( match["player2"]["first name"], match["player2"]["last name"], match["player2"]["elo"], match["player2"]["date of birth"], match["player2"]["player's gender"], match["player2"]["score"], match["player2"]["opponent list"], ) reload_match = Match(player1, player2, match["score player 1"], match["Score player 2"]) reload_round.add_reload_match(reload_match) reload_tournament.add_round(reload_round) return reload_tournament
def test_next_guessing_player_current_not_none(): global game start_test('test_next_guessing_player_current_not_none') game.current_player = game.players[0] next_player_1 = game.next_guessing_player(game.players[1]) next_player_2 = game.next_guessing_player(next_player_1) current_correct = game.current_player == Player(name="Pascal") player_1_correct = next_player_1 == Player(name="Alina") player_2_correct = next_player_2 == Player(name="Alina") return current_correct and player_1_correct and player_2_correct
def setup(): ps = Playerset() gs = Gameset(ps) p = Player(**{"id_": 1, "login": "******"}) ps[p.id] = p p = Player(**{"id_": 2, "login": "******"}) ps[p.id] = p p = Player(**{"id_": 3, "login": "******"}) ps[p.id] = p g = Game(playerset=ps, **GAME_DICT) gs[g.uid] = g return ps, gs
def test_instance_crud(create_clean_db, game): create(create_clean_db, game) gm = Player('*****@*****.**', '') instance = game.create_new_game('our multiplayer game', gm, datetime.utcnow() - timedelta(days=1), datetime.utcnow() + timedelta(days=1)) player = Player('*****@*****.**', '') instance.add_player(player, 'pseudonym', 'one') save(create_clean_db, instance) assert instance.name in [f[1] for f in saves(create_clean_db, player)] assert instance.name not in [f[1] for f in hosts(create_clean_db, player)] assert instance.name in [f[1] for f in hosts(create_clean_db, gm)] db_instance = load(create_clean_db, instance.id.hex) assert db_instance.id == instance.id assert db_instance.player_states[0].first_name == 'pseudonym'
def test_next_player(): global game start_test('test_next_player') first = game.next_player() game.current_player = first first_correct = first == Player(name="Pascal") second = game.next_player() game.current_player = second second_correct = second == Player(name="Alina") last = game.next_player() == Player(name="Pascal") return first_correct and second_correct and last
def test_high_score(self): high_score=HighScore() player_first = Player('first') player_first.score = 100; player_second = Player('second') player_second.score = 50; high_score.add_player(player_second) expected = player_second actual = high_score.best_player self.assertEqual(expected, actual) high_score.add_player(player_first) expected = player_first actual = high_score.best_player self.assertEqual(expected, actual)
def new_tournament(self): name = self.check_tournament_name() time_control = self.check_tournament_time_control() tournament_date = self.check_tournament_date() tournament_place = self.check_tournament_place() tournament_description = self.check_tournament_description() self.tournament = Tournament( name, time_control, tournament_date, tournament_place, tournament_description, ) for i in range(8): first_name = get_player_first_name() last_name = get_player_last_name() elo = get_player_elo() date_of_birth = get_date_of_birth() player_gender = get_player_gender() player = Player(first_name, last_name, elo, date_of_birth, player_gender) self.tournament.players.append(player) player.save_player() """self.tournament.players = players
def test_npc_interaction(): """ start | w1 <- dialog becomes available | end """ game = Game('test') start = Waypoint(game.graph, 'start') w1 = Waypoint(game.graph, 'w1') end = Waypoint(game.graph, 'end') start.add_destination(w1) w1.add_destination(end) game.set_start(start) npc_dialog = Dialog() ds = Mail(npc_dialog.graph, 'test subject', 'test body') with pytest.raises(PlayerStateException): NonPlayableCharacter('test', 'npc', npc_dialog) npc_dialog.set_start(ds) npc_dialog.start.waypoints.append(w1) game.add_non_playable_character(NonPlayableCharacter('test', 'npc', npc_dialog)) instance = game.create_new_game() instance.add_player(Player('test', 'player'), 'testy', 'mctestpants') assert len(instance.npc_states) == 1 assert ds not in [k for k, _ in instance.player_states[0].inventory.values()] interactions = instance.player_states[0].move_to(w1) assert len(interactions.keys()) == 1 and len(interactions.values()) == 1
def set_lanes_players_positions(self, lanes): lanes_x_positions = [] players = [] lane_center_y_position = self.real_height / 2 for lane in lanes: lanes_x_positions.append(lane['xPosition']) lane_players = [] for player_index in range(lane['playerCount']): y_position_adjust_list = None if lane['playerCount'] % 2 == 0: y_position_adjust_list = [0.5, -0.5, 1.5, -1.5] elif lane['playerCount'] % 2 == 1: y_position_adjust_list = [0, 1, -1, 2, -2] else: pass y_center_position = lane_center_y_position + y_position_adjust_list[ player_index] * lane['playerDistance'] new_player = Player(lane['laneID'], lane['xPosition'], y_center_position, lane['movementLimit']) lane_players.append(new_player) players.extend(lane_players) self.players_in_lane[lane['laneID']] = lane_players self.lanes_real_x_positions = lanes_x_positions self.players = players
def start(self): """ Start the server. :return: None """ self.logger_file.info(f"Starting server... src={SRC}/main:40") sock = self.setup_socket() lock = Lock() input_thread = ServerInput(sock, self.events) input_thread.start() queue_managing_thread = GroupManager(self.groups, lock, self.add_terminal_event) queue_managing_thread.start() self.logger_file.info('Server ready... src={SRC}/main:53') self.logger_info.info("Ready...") while True: try: connection, address = sock.accept() self.logger_file.info(f'{address[0]}:{address[1]} just connected. src={SRC}/main:59') self.logger_info.info(f"{address[0]}:{address[1]} just connected.") with lock: connection_handler = ConnectionHandler(Player(connection=connection), lock, self.groups) connection_handler.start() except socket.error: self.logger_file.critical("Socket closed... Terminating server... src={SRC}/main:67") break
def parse(cls, raw_message: str) -> UpdatePlayer: player_name = cls.__get_id(cls.__get_player_name(raw_message)) role = cls.__get_player_role(raw_message) if role not in RoleEnum._value2member_map_: raise RoleDoesNotExistException() return UpdatePlayer(Player(player_name, ''), RoleEnum._value2member_map_[role])
def get_player(self, player_name: str) -> Player: # todo: add named tuple self.__api.execute_query("select * from {} where name = '{}'".format( self.__table_name, str(player_name).replace("'", "''"))) result = self.__api.get_result()[0] return Player(name=result[0], role=result[1], team_name=result[2])
def test_add_remove(mocker): ps = Playerset() p = Player(**DEFAULT_DICT) def test_player_signal(sp): assert sp is p newplayer = mocker.Mock() goneplayer = mocker.Mock() ps.playerAdded.connect(newplayer) ps.playerAdded.connect(test_player_signal) ps.playerRemoved.connect(goneplayer) ps.playerRemoved.connect(test_player_signal) ps[p.id] = p assert newplayer.called assert ps[p.id] is p assert ps[p.login] is p del ps[p.id] assert goneplayer.called assert p.id not in ps assert p.login not in ps with pytest.raises(KeyError): ps[p.id] with pytest.raises(KeyError): ps[p.login]
def __execute_ai_creation(self): ai_names = [ "amiga", "commodore", "atari", "zx spectrum", "schneider", "amstrad", "mikrosza" ] name = random.choice(ai_names) return AiCtrl(Player(name), self.board, self.difficulty_level)
def make_a_player(player_dict, new=True, tournament_id=0): """ :param player_dict: ictionary, with your player caract :param new: true if it's a new player, else False :param tournament_id: interger, identity of your tournament :return: player instance """ if len(players) < 8: current_player = Player() current_player.edit_lastname(player_dict["lastname"]) current_player.edit_firstname(player_dict["firstname"]) current_player.edit_date_of_birth(player_dict["date_of_birth"]) current_player.edit_gender(player_dict["gender"]) current_player.edit_ranking(player_dict["ranking"]) if new: current_player.edit_identity(get_identity("players")) saving_player(current_player) else: try: t_id = str(tournament_id) current_player.add_tournament_point( tournament_id, player_dict["tournament_point"][t_id]) except KeyError: pass except TypeError: pass current_player.edit_identity(scooting_player_id(current_player)) players.append(current_player) return True else: return False
def init_players(self, tournament_table, actors_db): """ Fonction qui instancie les joueurs du tournoi """ for i in range(8): input(f"\nEnter player{i+1} informations [ENTER]\n") name = vp.get_player_name() surname = vp.get_player_surname() birthday = vp.get_player_birthday() sexe = vp.get_player_sexe() elo = vp.get_player_elo() score = 0 player = Player(name, surname, birthday, sexe, elo, score) self.tournament_progress.add_player(player) serialized_player = player.serialize() actor_table = actors_db.table(f"{name}") User = Query() actor_table.upsert(serialized_player, User.name == name) self.tournament_progress.serialized_players.append( serialized_player) self.tournament_progress.serialized_tournament = ( self.tournament_progress.serialize()) tournament_table.truncate() tournament_table.insert(self.tournament_progress.serialized_tournament)
def setUp(self): """ Creates a test fixture before each test method is run """ self.logPoint() self.test_player = Player(self.NO_ID, self.TEST_F_NAME, self.TEST_L_NAME, self.TEST_ADDRESS, self.TEST_PHONE, self.TEST_PLYR_POSITION, self.TEST_JERSEY_NUMBER, self.TEST_HOURLY_WAGE)
def _construct_player(self, command): result = P.decode_player(command) if not result.success: return Result.get_negative() name, number_of_players = result.result return Result.get_positive(Player(self.player.get_connection, name, number_of_players))