示例#1
0
 def test_make_valid_move1(self):
     game = Game(self.player1, self.player2)
     gb = game.game_board
     game.who_plays_first()
     gb.update_board(game.who_is_moving(), 1)
     self.assertFalse(gb.is_space_free(1))
     self.assertTrue(gb.is_space_free(3))
示例#2
0
 def create_hosted_game(cls):
     p_name, ai_diff = None, None
     if input("Host as AI? (y/n): ").strip().lower() == "y":
         p_name = "Host"
         ai_diff = cls._prompt_difficulty("AI")
     else:
         p_name = cls._prompt_name("host player", [])
     print("Waiting for opponent...")
     csock = cls._establish_client_conn(cls._default_port)
     if csock is None:
         print("No opponent connected within {} seconds.".format(
             cls._wait_client_timeout))
         print()
         return None, None
     p = None
     if ai_diff is None:
         p = NetworkHumanPlayer(p_name, csock)
     else:
         p = NetworkAIPlayer(p_name, ai_diff, csock)
     csock.send(p.name.encode("utf-8"))
     opp_name = csock.recv(1024).decode("utf-8")
     print("Established connection with opponent {}.".format(opp_name))
     o = NetworkOpponent(opp_name, csock)
     print()
     return Game(p, o), csock
示例#3
0
 def create_p_vs_ai_game(cls):
     p_name = cls._prompt_name("Player", [])
     ai_diff = cls._prompt_difficulty("AI")
     print()
     p = HumanPlayer(p_name)
     ai = AIPlayer("Bot", ai_diff)
     return Game(p, ai)
示例#4
0
 def create_ai_vs_ai_game(cls):
     ai1_diff = cls._prompt_difficulty("AI 1")
     ai2_diff = cls._prompt_difficulty("AI 2")
     print()
     ai1 = AIPlayer("Bot 1", ai1_diff)
     ai2 = AIPlayer("Bot 2", ai2_diff)
     return Game(ai1, ai2)
示例#5
0
 def create_p_vs_p_game(cls):
     p1_name = cls._prompt_name("Player 1", [])
     p2_name = cls._prompt_name("Player 2", [p1_name])
     print()
     p1 = HumanPlayer(p1_name)
     p2 = HumanPlayer(p2_name)
     return Game(p1, p2)
示例#6
0
    def test_draw(self):
        player1 = StrategyPlayer('player1', 'X', [1, 3, 6, 8])
        player2 = StrategyPlayer('player2', 'O', [2, 4, 5, 7, 9])

        game = Game(player1, player2)
        game.current_player = player2
        result = game.enter_game_loop()
        self.assertEqual(result, None)
示例#7
0
    def test_winner(self):
        losing_player = StrategyPlayer('loser', 'X', [1, 4, 7])
        winning_player = StrategyPlayer('winner', 'O', [2, 5, 8])

        game = Game(losing_player, winning_player)
        game.current_player = winning_player
        winner = game.enter_game_loop()
        self.assertEqual(winner, winning_player)
示例#8
0
 def test_make_invalid_move1(self):
     game = Game(self.player1, self.player2)
     gb = game.game_board
     game.current_player = self.player1
     gb.update_board(game.who_is_moving(), 2)
     game.toggle_player()
     gb.update_board(game.who_is_moving(), 2)
     self.assertFalse(gb.is_space_free(2))
示例#9
0
 def _play_brackets(self, players):
     games = [Game(*p) for p in zip(players[::2], players[1::2])]
     winners = []
     for g in games:
         g.start()
         while g.winner is None:
             g.reset()
             g.start()
         winners.append(g.winner)
         self._bp.increment(g.winner.name)
         self._bp.print_bracket()
         self._press_enter_to_continue()
     return winners
示例#10
0
    def test_who_plays_first(self):
        c1 = 0
        c2 = 0
        game = Game(self.player1, self.player2)
        n_samples = 1000
        for i in range(n_samples):
            first = game.who_plays_first()
            if first == self.player1:
                c1 += 1
            elif first == self.player2:
                c2 += 1

        p = c1 / n_samples
        self.assertTrue(0.4 < p and p < 0.6)
示例#11
0
 def _get_games(self, players):
     games, pairs = [], []
     for i in range(0, len(players), 2):
         p1, p2 = players[i], players[i + 1]
         players_data = {p1["name"]: p1, p2["name"]: p2}
         p1, p2 = self._get_player_instances(p1, p2)
         pairs.append((p1, p2) if self._is_hosting else (p2, p1))
         if not self._is_hosting:
             p1, p2 = p2, p1
         games.append((Game(p1, p2), players_data))
     print("For this bracket segment:")
     print()
     print("{0: <23}{1: <23}".format("On host computer:",
                                     "On client computer:"))
     for p1, p2 in pairs:
         print(" - {0: <20} - {1: <20}".format(p1.name, p2.name))
     print()
     return games
示例#12
0
 def create_joined_game(cls):
     print("Connecting to host...")
     lsock, hsock = cls._establish_host_conn(cls._default_port)
     if hsock is None:
         print("Couldn't connect to host.")
         print()
         return None, None, None
     opp_name = hsock.recv(1024).decode("utf-8")
     print("Established connection with opponent {}.".format(opp_name))
     p = None
     if input("Join as AI? (y/n): ").strip().lower() == "y":
         p_name = "Client"
         ai_diff = cls._prompt_difficulty("AI")
         p = NetworkAIPlayer(p_name, ai_diff, hsock)
     else:
         p_name = cls._prompt_name("joining player",
                                   [opp_name.split("AI ").pop()])
         p = NetworkHumanPlayer(p_name, hsock)
     hsock.send(p.name.encode("utf-8"))
     o = NetworkOpponent(opp_name, hsock)
     print()
     return Game(o, p), lsock, hsock
示例#13
0
 def test_make_valid_move2(self):
     game = Game(self.player1, self.player2)
     gb = game.game_board
     game.who_plays_first()
     gb.update_board(game.who_is_moving(), 1)
     game.toggle_player()
     gb.update_board(game.who_is_moving(), 2)
     game.toggle_player()
     gb.update_board(game.who_is_moving(), 3)
     game.toggle_player()
     gb.update_board(game.who_is_moving(), 4)
     game.toggle_player()
     gb.update_board(game.who_is_moving(), 5)
     game.toggle_player()
     gb.update_board(game.who_is_moving(), 6)
     game.toggle_player()
     gb.update_board(game.who_is_moving(), 7)
     game.toggle_player()
     gb.update_board(game.who_is_moving(), 8)
     game.toggle_player()
     self.assertFalse(gb.is_board_full())
     gb.update_board(game.who_is_moving(), 9)
     game.toggle_player()
     self.assertTrue(gb.is_board_full())
示例#14
0
 def test_represent_gameboard_fresh(self):
     game = Game(self.player1, self.player2)
     game.turn = 1
     self.assertEqual(str(game.game_board), fresh_gameboard_string)
示例#15
0
 def test_who_is_playing(self):
     game = Game(self.player1, self.player2)
     game.current_player = self.player1
     self.assertEqual(game.who_is_moving(), self.player1)
示例#16
0
 def test_represent_gameboard_with_pieces(self):
     game = Game(self.player1, self.player2)
     game.game_board.board = ['x', 'o', 'x', 'o', 'x', 'o', 'x', 'o', 'x']
     self.assertTrue(str(game.game_board), full_gameboard_string)
示例#17
0
 def test_toggle_player(self):
     game = Game(self.player1, self.player2)
     previous_player = game.current_player
     game.toggle_player()
     current_player = game.current_player
     self.assertFalse(current_player == previous_player)