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)