def test_player_interface_can_display_winner(self):
pi = PlayersInterface()
x = Player('test')
o = Player('test')
g = Grid()
with self.assertRaises(NotImplementedError):
pi.display_winner(x, x, o, g)
def test_player_interface_can_ask_for_player_to_fill_a_cell(self):
pi = PlayersInterface()
x = Player('test')
o = Player('test')
g = Grid()
with self.assertRaises(NotImplementedError):
pi.choose_cell(x, x, o, g)
async def phase1(self, p: Player) -> bool:
"""
Фаза взятия карты и игры паники
Возвращает необходимость продолжать код
"""
# p.global_log = "тянет карту с колоды..."
# await self.show_table_to_all()
# await self.show_log_to_all(f"Фаза 1. {p.user_fullname} тянет карту с колоды")
card = p.pull_deck()
assert type(card) == Card
if not card.is_panic():
p.take_on_hand(card)
p.local_log.append(f"🎲 событие `{card.name}` c колоды")
p.global_log.append(f"🎲 Вытянул событие из колоды")
await self.show_cards(p)
return True
else:
p.local_log.append(
f"🔥 паника `{card.name}` с колоды, ход завершён.")
p.global_log.append(
f"🔥 Вытянул панику `{card.name}` с колоды. Ход завершён.")
p.play_panic(card)
self.board.deck.append(card) # карта паники ушла в колоду
return False
return True
class PlayerSetupTests(unittest.TestCase):
def setUp(self):
self.player = Player(1, 'Player 1', 2)
self.player2 = Player(2, 'Player 2', 2)
def test_player_has_a_name(self):
self.assertNotEqual(self.player.name, '')
def test_player_game_board_generated(self):
self.assertNotEqual(self.player.board, None)
def test_player_has_ships_generated(self):
self.assertNotEqual(self.player, None)
def test_player_has_correct_number_of_ships(self):
self.assertEqual(len(self.player.ships), 2)
def test_both_players_have_the_same_ships_loaded(self):
player1_ships = [self.player.ships[i].name for i in range(len(self.player.ships))]
player2_ships = [self.player2.ships[i].name for i in range(len(self.player2.ships))]
self.assertListEqual(player1_ships, player2_ships)
def test_player_has_ships_remaining(self):
self.assertTrue(self.player.has_remaining_ships())
def test_player_has_no_ships_remaining(self):
self.player.remaining_ships = 0
self.assertFalse(self.player.has_remaining_ships())
def test_get_ship_at_selected_position(self):
ship_position = self.player.ships[0].positions[0]
self.assertNotEqual(self.player.get_ship(ship_position[0], ship_position[1]), None)
async def show_cards(self, p: Player):
# if not p.title_message_id:
# r1 = await self.app["telebot"].sendMessage(p.user_id, f"Ваше имя: *{p.user_fullname}* -------------------------------- ")
# p.title_message_id = r1["result"]["message_id"]
if not p.table_message_id:
r2 = await self.app["telebot"].sendMessage(p.user_id, self.table)
p.table_message_id = r2["result"]["message_id"]
if not p.hand_slots or len(p.hand_slots) == 0:
await self.create_image_slots(p)
else:
await self.update_image_slots(p)
if not p.panel_message_id:
r3 = await self.app["telebot"].sendMessage(
p.user_id,
f"`[Это сообщение обновится, и вы выберете ваше действие с картами]`"
)
p.panel_message_id = r3["result"]["message_id"]
else:
await self.app["telebot"].editMessageText(p.user_id,
p.panel_message_id,
"\r\n".join(p.local_log))
if not p.log_message_id:
r4 = await self.app["telebot"].sendMessage(p.user_id,
"\n".join(self.log))
p.log_message_id = r4["result"]["message_id"]
return
class TestHigscore(unittest.TestCase):
"""Test Higscore Class."""
def setUp(self):
"""Run at the beginning of the test."""
self.game = Game()
self.mock_player1 = Mock(spec=Player,
name="player1",
score=42,
decision=False)
self.mock_player2 = Mock(spec=Player,
name="Computer",
score=65,
decision=True)
self.assertIsInstance(self.mock_player1, Player)
self.assertIsInstance(self.mock_player2, Player)
self.score = Highscore(self.mock_player1, self.mock_player2)
def test_write_file(self):
"""Test write_file."""
self.player1 = Player("score1", False)
self.game.set_playing_now(self.game.player1)
self.player1.change_score(5)
self.score.write_file()
self.player2_name = Player("score2", False)
self.game.set_playing_now(self.game.player2)
self.player1.change_score(4)
def test_get_path(self):
"""Test get_path."""
exp = self.score.get_path()
self.assertTrue(exp, 'score.txt')
def update( self, frameTime, lifeTime ): Player.update( self, frameTime, lifeTime ) if self.isFiringGuns and self.gunCoolDown == 0: self.gunCoolDown = self.gunFireRate y = self.sprite.rect.y + ( self.sprite.rect.height / 2 ) Bullet( Vector( self.sprite.rect.centerx - 16, y ), Vector( -12, -self.gunBulletSpeed ) ) Bullet( Vector( self.sprite.rect.centerx - 8, y ), Vector( -6, -self.gunBulletSpeed ) ) Bullet( Vector( self.sprite.rect.centerx, y ), Vector( 0, -self.gunBulletSpeed ) ) Bullet( Vector( self.sprite.rect.centerx + 8, y ), Vector( 6, -self.gunBulletSpeed ) ) Bullet( Vector( self.sprite.rect.centerx + 16, y ), Vector( 12, -self.gunBulletSpeed ) ) elif self.gunCoolDown > 0: self.gunCoolDown -= 1
def test_player_figures_out_own_best_hand(self):
mock_hand = MagicMock()
mock_hand.best_rank.return_value = 'Straight Flush'
player = Player(name='M', hand=mock_hand)
assert player.best_hand() == 'Straight Flush'
assert mock_hand.best_rank.called
def setUp(self):
"""Create instances at the beginning of tests cases."""
self.game = Game()
self.player = Player(str, bool)
self.score_list = []
self.dice = Dice()
self.fake_die = random.randint(1, 6)
class TestPlayer(unittest.TestCase):
def setUp(self):
self.player = Player()
self.player.set_name("John")
self.player.set_marker("X")
def test_get_name_returns_name(self):
self.assertEqual(self.player.get_name(), "John")
def __init__(self, num_decks):
self.deck = Deck()
std_deck = list(self.deck.cards)
for i in range(1, num_decks):
self.deck.cards += std_deck
self.player = Player()
self.dealer = Player()
def test_write_file(self):
"""Test write_file."""
self.player1 = Player("score1", False)
self.game.set_playing_now(self.game.player1)
self.player1.change_score(5)
self.score.write_file()
self.player2_name = Player("score2", False)
self.game.set_playing_now(self.game.player2)
self.player1.change_score(4)
def setUp(self):
"""Run at the beginning of the test."""
self.game = Game()
self.game.set_game_status(True)
self.dice = Dice()
self.player1 = Player(str, bool)
self.player2 = Player(str, bool)
self.computer_player = Player(str, bool)
self.highscore = Highscore(self.player1, self.player2)
def joinRoom(data):
"""On refresh, need to re-join the socket io room"""
room = data['room']
app.logger.info("sid " + request.sid + " is joining room " + room)
if room in ROOMS and is_new_sid(request.sid):
join_room(room)
player = Player(data['userData']['name'], ROOMS[room], request.sid)
ROOMS[room].add_player(player)
USERS[player.sid] = player
emit('set_username', data['userData']['name'])
emit('user_data', player.to_json())
emit('join_room', {'room': ROOMS[room].to_json()}, room=room)
def infection____on_accepted(self, p: Player, sender: Player):
assert self.is_infection(), "Текущая карта - заражение"
assert sender.is_evil() or p.is_evil() and sender.is_infected(
), "Либо нечто передаёт, либо мы сами нечто и нам передаёт заражённый"
assert not sender.is_good(), "Люди не могут передавать заражение"
assert not (
sender.is_infected() and (p.is_good() or p.is_infected())
), "Зараженный не может передавать человеку или зараженному (только Нечто может)"
p.become_infected()
def on_create(data):
"""Create a game lobby"""
app.logger.info("Creating a new game!")
curr_game = Game()
# TODO: check for duplicate names
player = Player(data['name'], curr_game, request.sid)
curr_game.players[data['name']] = player
ROOMS[curr_game.id] = curr_game
USERS[player.sid] = player
join_room(curr_game.id)
emit('set_username', data['name'])
emit('user_data', player.to_json())
emit('join_room', {'room': curr_game.to_json()})
def play_game(prediction_request, simulation_depth):
startTime = datetime.now()
global game, player1, player2
game = Game()
player1 = Player(1, game, MultiprocessModel(prediction_request))
player2 = Player(2, game, MultiprocessModel(prediction_request))
while not game.is_over():
play_turn(simulation_depth)
finalize_lessons()
print('game over', datetime.now() - startTime, len(game.moves), 'moves')
def predict(moves):
game, prior_boards = initialize_game(moves)
if game.is_over():
raise ValueError('The game is already over.')
possible_moves = game.get_possible_moves()
if len(possible_moves) == 1:
return possible_moves[0]
model = checkers_model.build()
player = Player(game.whose_turn(), game, model, prior_boards)
return player.simulate(10).get_next_move()
def __init__(self):
self.is_playing = False
self.players = pygame.sprite.Group()
self.player = Player(self)
self.players.add(self.player)
self.sound_manager = SoundManager()
self.comet_event = CometFallEvent(self)
self.monsters = pygame.sprite.Group()
self.score_font = pygame.font.Font("src/fonts/permanent_marker_regular.ttf", 30)
self.score = 0
self.pressed = {}
def reset_round(self):
d = Deck()
if self.p is None:
self.p = Learner()
else:
self.p.reset_hand()
p = self.p
p2 = Player()
winner = None
p.hit(d)
p2.hit(d)
p.hit(d)
p2.hit(d)
return d, p, p2, winner
def read_data():
with codecs.open('/root/WeiXinPublic/data.txt', 'r', 'utf-8') as f:
global g_listPlayers, g_listOrderNums, g_dictOrderToPlayer
g_listPlayers = []
g_listOrderNums = []
for line in f.readlines():
# 数据格式：[strOrderNum] [strName] [intVotes]
strProcess = line.split(":")
strOrderNum = strProcess[0]
strName = strProcess[1]
intVotes = int(strProcess[2])
newPlayer = Player()
newPlayer.strName = strName
newPlayer.intVotes = intVotes
g_listPlayers.append(newPlayer)
g_listOrderNums.append(strOrderNum)
g_dictOrderToPlayer = dict(zip(g_listOrderNums, g_listPlayers))
return "read_ok"
def on_join(data):
"""Join a game lobby"""
app.logger.info("Joining game! code: " + data['room'])
room = data['room'].upper()
if room in ROOMS and ROOMS[room].is_valid_username(data['name']):
join_room(room)
player = Player(data['name'], ROOMS[room], request.sid)
ROOMS[room].add_player(player)
USERS[player.sid] = player
emit('set_username', data['name'])
emit('user_data', player.to_json())
emit('join_room', {'room': ROOMS[room].to_json()}, room=room)
elif room in ROOMS:
emit('error', {
'error': "That username is already taken!",
'errorField': "username"
})
else:
emit('error', {'error': "Game not found :(", 'errorField': "code"})
def test_right_left_diagonal_is_a_winning_pattern(self):
player = Player('test')
grid = Grid()
self.assertIsNone(grid.get_winner())
self.draw_winning_pattern(player,
grid,
row=0,
col=2,
vertical=True,
horizontal=True)
self.assertEqual(player, grid.get_winner())
def test_3_vertical_fill_on_last_col_is_a_winning_pattern(self):
player = Player('test')
grid = Grid()
self.assertIsNone(grid.get_winner())
self.draw_winning_pattern(player,
grid,
row=0,
col=1,
vertical=True,
horizontal=False)
self.assertEqual(player, grid.get_winner())
def add_player(self, name, color):
if not self.players:
player_id = 1
else:
player_id = max(list(self.players.keys())) + 1
player = Player(player_id, name, color)
self.players[player_id] = player
for name in base_deck:
card = self.cards.get_by_name(name)
for x in range(base_deck[name]):
player.add_card_to_deck(card)
player.shuffle_deck()
player.draw_hand()
self.current_player = random.choice(list(self.players.keys()))
return player_id
def __init__(self, list_players: list):
n = len(list_players)
assert n >= 4
self.n = n
self.players = []
self._cards = self.load_cards(card_deck_struct, n)
init_hands, self.deck = self.split_deck(self._cards, n)
for i, hand in enumerate(init_hands):
self.players.append(Player(hand, self, list_players[i]))
random.shuffle(self.players)
self.turn = -1 # Чья очередь. Пока ничья
self.move = 0 # Номер ходя по порядку
self.is_end = False
self.turn_sequence = 1 # -1
def __init__( self, vector=Vector(0,0) ): Player.__init__( self ) # Sprite sprite = AnimatedSprite( 'player/pluto.png', vector ) sprite.addAnimationState( 'idle', 0, 0, 100 ) sprite.setAnimationState( 'idle' ) self.setSprite( sprite ) self.sprite.add( config.spriteGroups['player'] ) config.player_vector = self.vector # Controls self.addControlDown( pygame.K_LEFT, self.moveLeft ) self.addControlDown( pygame.K_RIGHT, self.moveRight ) self.addControlDown( pygame.K_UP, self.moveUp ) self.addControlDown( pygame.K_DOWN, self.moveDown ) self.addControlUp( pygame.K_LEFT, self.stopLeft ) self.addControlUp( pygame.K_RIGHT, self.stopRight ) self.addControlUp( pygame.K_UP, self.stopUp ) self.addControlUp( pygame.K_DOWN, self.stopDown ) self.addControlDown( pygame.K_z, self.shootGuns ) self.addControlUp( pygame.K_z, self.stopShootingGuns ) # Set default speed self.speed = 7 self.isFiringGuns = False self.gunFireRate = 5 self.gunCoolDown = 0 self.gunBulletSpeed = 40 self.isFiringBeam = False
async def phase2(self, p: Player):
"""
Фаза сброса или игры карты с руки
"""
# Обновили карты на руке игрока и ждём от него хода
# await self.show_cards(p)
p.local_log.append(f"❗️ Сыграйте ▶️ или сбросьте 🗑 карту...")
p.global_log.append(f"🃏 Играет или сбрасывает...")
await asyncio.gather(*[
self.show_play_drop_options(p),
self.show_table_to_all(self.print_hands())
])
cmd = None
# while cmd not in ["phase2:play_card", "phase2:drop_card"]:
# await asyncio.sleep(0)
full_input, triggered_player = await self.listen_input(p)
cmd, card_uuid = full_input.split(" ")
assert cmd == "phase2:play_card" or cmd == "phase2:drop_card"
assert triggered_player == p
card = p.pop_card_by_uuid(int(card_uuid)) # выбранная карта
assert type(card) == Card
if cmd == "phase2:play_card":
p.play_card(card, target=None)
p.local_log[-1] = f"▶️ сыграна `{card.name}`"
p.global_log[-1] = f"▶️ Сыграл карту `{card.name}`"
else:
p.local_log[-1] = f"🗑 сброшена `{card.name}`"
p.global_log[-1] = f"🗑 Сбросил карту"
await self.clear_input(p)
p.drop_card(card) # в любом случае в колоду
await asyncio.gather(
*[self.show_cards(p),
self.show_table_to_all(self.print_hands())])
return
def handle(self):
# set_player_queue 元素 data: (nickname, )
param = self.queue.get()
nickname, = param
new_player_id = get_player_id()
if nickname in [i.name for i in manager.gg.player_info.values()]:
pass
else:
new_player = Player()
new_player.set_name(nickname)
new_player.set_id(new_player_id)
manager.gg.add_player(new_player)
def test_print_histogram(self):
"""Test print_histogram by catching output and comparing it."""
histogram = Histogram()
player1 = Player("name1", False)
player2 = Player("name2", False)
res = player1.get_name()
catch_output = io.StringIO()
sys.stdout = catch_output
histogram.print_histogram(player1, player2)
sys.stdout = sys.__stdout__
output = catch_output.getvalue()
self.assertIn(str(res), output)
# check both names
self.assertIn(player1.get_name(), output)
self.assertIn(player2.get_name(), output)
def reset_round(self):
d = Deck()
if self.p is None:
self.p = Learner()
else:
self.p.reset_hand()
p = self.p
p2 = Player()
winner = None
p.hit(d)
p2.hit(d)
p.hit(d)
p2.hit(d)
return d, p, p2, winner
def __init__(self):
"""Initialize instances from other classes."""
self.computer_controlar = False
self.dice = Dice()
# Changable value
self.forbidden_face = 1
self.player1 = Player(str, bool)
self.player2 = Player(str, bool)
self.set_playing_now(self.player1)
# Basically, player2 may be computer in case user decided.
# However, computer_player object has been added to make the
# code easier to read. Since computer controlled by another class.
self.computer_player = Player("Computer", bool)
self.computer_player.set_level("easy")
self.score = Highscore(self.player1, self.player2)
self.histogram = Histogram()
class Game:
round_counter = 0
def __init__(self, num_decks):
self.deck = Deck()
std_deck = list(self.deck.cards)
for i in range(1, num_decks):
self.deck.cards += std_deck
self.player = Player()
self.dealer = Player()
def round(self):
self.round_counter += 1
if self.round_counter > 1:
input("Press Enter to start next round...")
print("Round {} started".format(self.round_counter))
if not self.deck.get_cards():
self.deck = Deck()
self.deck.shuffle()
self.player.hit(self.deck.deal())
self.dealer.hit(self.deck.deal())
self.print_state()
while self.player.playing:
if self.player.calc_hand() > 21:
print("You have too much :(")
self.player.playing = False
break
if self.player.calc_hand() == 21:
print("You have 21!")
self.player.playing = False
break
choice = input("Want to [hit] or [stop]? ")
while choice not in {"hit", "stop"}:
choice = input("Wrong command. Want to [hit] or [stop]? ")
if choice == "hit":
self.player.hit(self.deck.deal())
if choice == "stop":
self.player.playing = False
self.print_state()
if not self.player.calc_hand() > 21:
while self.dealer.calc_hand() < 17:
self.dealer.hit(self.deck.deal())
self.print_state()
self.dealer.playing = False
winner = self.get_winner()
if winner == self.player:
self.player.wins += 1
print("Player won!")
elif winner == self.dealer:
self.dealer.wins += 1
print("Dealer won")
else:
self.player.wins += 1
self.dealer.wins += 1
print("Push")
print("Current win rate is: {:.1%}\n".format(self.player.wins /
self.round_counter))
self.reset()
def reset(self):
self.player.playing = True
self.dealer.playing = True
self.player.reset_hand()
self.dealer.reset_hand()
def print_state(self):
print("Player's hand is:")
self.player.print_hand()
print("Dealer's hand is:")
self.dealer.print_hand()
print("Actual score is: {}:{}\n".format(self.player.calc_hand(),
self.dealer.calc_hand()))
def get_winner(self):
if (self.player.calc_hand() > self.dealer.calc_hand() or self.dealer.calc_hand() > 21)\
and not self.player.calc_hand() > 21:
return self.player
elif self.player.calc_hand() < self.dealer.calc_hand(
) or self.player.calc_hand() > 21:
return self.dealer
else:
return None
class TestGame(unittest.TestCase):
class MockPlayerInterface(PlayersInterface):
def init_players(self):
pass
def choose_cell(self, player, player_x, player_y, grid):
pass
def display_grid(self, player_x, player_o, grid):
pass
def display_player(self, player):
pass
def display_winner(self, winner, player_x, player_y, grid):
pass
def clear(self):
pass
pi = MockPlayerInterface()
player1 = Player('romain')
player2 = Player('tristan')
def test_game_init_an_empty_grid(self):
game = Game(self.player1, self.player2, self.pi)
self.assertIsNotNone(game.grid)
self.assertTrue(game.grid.is_empty())
def test_playing_may_fill_an_empty_cell_with_first_player_on_first_play(self):
self.pi.choose_cell = MagicMock(return_value=(0, 1))
game = Game(self.player1, self.player2, self.pi)
game.play()
self.assertFalse(game.grid.is_empty())
self.assertEqual('romain', game.grid.cells[0][1].player.name)
def test_playing_change_the_current_user(self):
game = Game(self.player1, self.player2, self.pi)
self.pi.choose_cell = MagicMock(return_value=(0, 1))
game.play()
self.pi.choose_cell = MagicMock(return_value=(0, 2))
game.play()
self.assertFalse(game.grid.is_empty())
self.assertEqual('romain', game.grid.cells[0][1].player.name)
self.assertEqual('tristan', game.grid.cells[0][2].player.name)
def test_playing_a_filled_cell_raise_a_bad_cell_error(self):
game = Game(self.player1, self.player2, self.pi)
self.pi.choose_cell = MagicMock(return_value=(0, 1))
game.play()
with self.assertRaises(BadCellError):
game.play()
def test_is_won_return_the_winning_state(self):
game = Game(self.player1, self.player2, self.pi)
game.grid.fill(self.player1, 0, 0)
game.grid.fill(self.player1, 0, 1)
game.grid.fill(self.player1, 0, 2)
self.assertTrue(game.is_won())
def test_get_winner_return_the_winner(self):
game = Game(self.player1, self.player2, self.pi)
game.grid.fill(self.player2, 0, 1)
game.grid.fill(self.player2, 1, 1)
game.grid.fill(self.player2, 2, 1)
self.assertEqual(self.player2, game.get_winner())
def setUp(self):
self.player = Player(1, 'Player 1', 2)
self.player2 = Player(2, 'Player 2', 2)
