Пример #1
0
from tic_tac_toe import io
import sys

# Initialize objects
game = Game(3)
players = [Player('X'), AIPlayer('O')]
playing = True # Main loop control needed to break out of multiple levels
io.init()

# Main game loop
while playing:
  io.print_board(game)
  try:
    for player in players:
      player.make_move(game)
      if game.check_winner(player.symbol):
        io.print_board(game)
        if players.index(player) == 0:
          io.winner()
        else:
          io.loser()
        playing = False
        break

  except InvalidMove:
    io.invalid()

  except GameTied:
    io.print_board(game)
    io.game_tied()
    break
Пример #2
0
class TestGame(unittest.TestCase):
    def setUp(self):
        self.game = Game()

    def testDefaultSize(self):
        self.assertEqual(self.game.size, 3)

    def testValidMovesInit(self):
        self.assertEqual(len(self.game.valid_moves()), self.game.size ** 2)

    def testValidMovesType(self):
        self.assertIs(type(self.game.valid_moves()), list)

    def testValidMovesAfterMove(self):
        self.game.make_move(1, "X")
        self.assertEqual(len(self.game.valid_moves()), self.game.size ** 2 - 1)

    def testCells(self):
        self.assertIs(type(self.game.cells[1]), list)

    def testCheckArrayTrue(self):
        self.assertTrue(self.game._check_array(["X", "X", "X"], "X"))

    def testCheckArrayFalse(self):
        self.assertFalse(self.game._check_array(["O", "X", "X"], "X"))

    def testMakeMove(self):
        self.game.make_move(1, "X")
        with self.assertRaises(InvalidMove):
            self.game.make_move(1, "X")

    def testCheckWinnerWonRow(self):
        self.game.make_move(1, "X")
        self.game.make_move(2, "X")
        self.game.make_move(3, "X")
        self.assertTrue(self.game.check_winner("X"))

    def testCheckWinnerWonCol(self):
        self.game.make_move(1, "X")
        self.game.make_move(4, "X")
        self.game.make_move(7, "X")
        self.assertTrue(self.game.check_winner("X"))

    def testCheckWinnerWonDiag1(self):
        self.game.make_move(1, "X")
        self.game.make_move(5, "X")
        self.game.make_move(9, "X")
        self.assertTrue(self.game.check_winner("X"))

    def testCheckWinnerWonDiag2(self):
        self.game.make_move(3, "X")
        self.game.make_move(5, "X")
        self.game.make_move(7, "X")
        self.assertTrue(self.game.check_winner("X"))

    def testCheckWinnerTied(self):
        self.game.make_move(1, "X")
        self.game.make_move(2, "X")
        self.game.make_move(3, "O")
        self.game.make_move(4, "O")
        self.game.make_move(5, "X")
        self.game.make_move(6, "X")
        self.game.make_move(7, "X")
        self.game.make_move(8, "O")
        self.game.make_move(9, "O")
        with self.assertRaises(GameTied):
            self.game.check_winner("X")
Пример #3
0
from tic_tac_toe import io
import sys

# Initialize objects
game = Game(3)
players = [Player('X'), AIPlayer('O')]
playing = True  # Main loop control needed to break out of multiple levels
io.init()

# Main game loop
while playing:
    io.print_board(game)
    try:
        for player in players:
            player.make_move(game)
            if game.check_winner(player.symbol):
                io.print_board(game)
                if players.index(player) == 0:
                    io.winner()
                else:
                    io.loser()
                playing = False
                break

    except InvalidMove:
        io.invalid()

    except GameTied:
        io.print_board(game)
        io.game_tied()
        break
Пример #4
0
def test_check_winner_draw_or_no_yet_winner(moves, winner_expected):
    game = Game(3, "X", "MEOW", "KOTIK")
    for i in moves:
        x, y, z = i
        game.move(x, y, z)
    assert game.check_winner() == winner_expected
Пример #5
0
def make_step(sock: socket.socket, game: Game) -> bool:
    game_over = False

    def make_move(is_move_success: bool = False) -> str:
        cell = input("Ваш ход: ")
        while not re.match(r"^[A-Z] \d$", cell) or ord(
                cell.split(" ")[0]) - 65 >= game.field_size:
            print(
                "Введите клетку в формате: Буква Цифра. Клетка не должна выходить за пределы игрового поля."
            )
            cell = input("Ваш ход: ")
        own_x, own_y = cell.split(" ")
        while not is_move_success:
            try:
                game.move(ord(own_x) - 65, int(own_y) - 1)
            except Exception as e:
                print(e)
                cell = make_move(is_move_success)
            is_move_success = True

        return cell

    cell = make_move(False)
    print(game.draw())
    winner = game.check_winner()

    if winner:
        game_over = True
        if winner == "DRAW":
            print("Результат игры - ничья")
        else:
            print(
                f"Выиграл игрок {game.gamer_name if winner == OWN_SIDE else game.enemy_name}"
            )

        sock.sendall(f"MOVE {cell} STOP {winner}".encode("utf-8"))
        sock.close()

        return game_over
    else:
        sock.sendall(f"MOVE {cell}".encode("utf-8"))

    print(f"Ожидание хода игрока {game.enemy_name}")

    data = sock.recv(BUFFER_SIZE)
    command, *arguments = data.decode("utf-8").split(" ")

    if command == "MOVE":
        enemy_x, enemy_y = arguments
        try:
            game.move(ord(enemy_x) - 65, int(enemy_y) - 1, ENEMY_SIDE)
        except Exception as e:
            print(e)
    else:
        raise WrongCommand

    winner = game.check_winner()
    print(game.draw())

    if winner:
        sock.sendall(f"STOP {winner}".encode("utf-8"))
        if winner == "DRAW":
            print("Результат игры - ничья")
        else:
            print(
                f"Выиграл игрок {game.gamer_name if winner == OWN_SIDE else game.enemy_name}"
            )
        game_over = True
        sock.close()

    return game_over
Пример #6
0
class TestGame(unittest.TestCase):
    def setUp(self):
        self.game = Game()

    def testDefaultSize(self):
        self.assertEqual(self.game.size, 3)

    def testValidMovesInit(self):
        self.assertEqual(len(self.game.valid_moves()), self.game.size**2)

    def testValidMovesType(self):
        self.assertIs(type(self.game.valid_moves()), list)

    def testValidMovesAfterMove(self):
        self.game.make_move(1, 'X')
        self.assertEqual(len(self.game.valid_moves()), self.game.size**2 - 1)

    def testCells(self):
        self.assertIs(type(self.game.cells[1]), list)

    def testCheckArrayTrue(self):
        self.assertTrue(self.game._check_array(['X', 'X', 'X'], 'X'))

    def testCheckArrayFalse(self):
        self.assertFalse(self.game._check_array(['O', 'X', 'X'], 'X'))

    def testMakeMove(self):
        self.game.make_move(1, 'X')
        with self.assertRaises(InvalidMove):
            self.game.make_move(1, 'X')

    def testCheckWinnerWonRow(self):
        self.game.make_move(1, 'X')
        self.game.make_move(2, 'X')
        self.game.make_move(3, 'X')
        self.assertTrue(self.game.check_winner('X'))

    def testCheckWinnerWonCol(self):
        self.game.make_move(1, 'X')
        self.game.make_move(4, 'X')
        self.game.make_move(7, 'X')
        self.assertTrue(self.game.check_winner('X'))

    def testCheckWinnerWonDiag1(self):
        self.game.make_move(1, 'X')
        self.game.make_move(5, 'X')
        self.game.make_move(9, 'X')
        self.assertTrue(self.game.check_winner('X'))

    def testCheckWinnerWonDiag2(self):
        self.game.make_move(3, 'X')
        self.game.make_move(5, 'X')
        self.game.make_move(7, 'X')
        self.assertTrue(self.game.check_winner('X'))

    def testCheckWinnerTied(self):
        self.game.make_move(1, 'X')
        self.game.make_move(2, 'X')
        self.game.make_move(3, 'O')
        self.game.make_move(4, 'O')
        self.game.make_move(5, 'X')
        self.game.make_move(6, 'X')
        self.game.make_move(7, 'X')
        self.game.make_move(8, 'O')
        self.game.make_move(9, 'O')
        with self.assertRaises(GameTied):
            self.game.check_winner('X')