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))
