Esempio n. 1
0
def main() -> None:
    """Play multiple rounds of a TIC-TAC-TOE based on user input settings.
    """
    print("=== TIC-TAC-TOE ===\n\n")
    p1 = make_player('player 1', 'X')
    p2 = make_player('player 2', 'O')
    if (isinstance(p1, ComputerPlayer) and isinstance(p2, ComputerPlayer)) or \
        (isinstance(p1, CyborgPlayer) and isinstance(p2, CyborgPlayer)):
        p1.name = p1.name + ' 1'
        p2.name = p2.name + ' 2'

    while True:
        game = TicTacToe((p1, p2))
        winner = game.play()

        if winner is None:
            print('Game tied!')
        else:
            print(f'And the winner is  {winner.name}!!! \n')
            winner.wins += 1
        again = input(
            f'{p1.name} and {p2.name}, would you like to play again? '
            f'(y/n)')
        print('')
        if again != 'y' and again != 'Y':
            print(f'{p1.name} won {p1.wins} times!')
            print(f'{p2.name} won {p2.wins} times!')
            print('GAME OVER!')
            return None
 def testCurrentPlayerIsX(self):
     game = TicTacToe()
     if game.currentPlayer() == 'X':
         result = True
     else:
         result = False
     self.assertEqual(result, True)
Esempio n. 3
0
    def testAddPlayer(self):
        game = TicTacToe()
        game.add_player("playerx")
        game.add_player("playery")

        self.assertTrue("playerx" in game.players)
        self.assertTrue("playery" in game.players)
Esempio n. 4
0
    def test_learn_single(self):
        self.learner = Learner('X')
        self.other_player = Player('O')
        self.tictactoe = TicTacToe()

        fields = [(0, 0), (0, 1), (0, 2)]

        for field in fields:
            self.tictactoe.play(*field, self.learner)

        self.assertEqual(fields, self.tictactoe.is_winner(self.learner))
        self.learner.learn(self.tictactoe, 100, self.learner)
        print(self.learner.rewards)

        self.tictactoe = TicTacToe()
        while (self.tictactoe.available_moves()
               and not self.tictactoe.is_winner(self.learner)
               and not self.tictactoe.is_winner(self.other_player)):
            self.tictactoe.play(*self.learner.next_move(self.tictactoe),
                                self.learner)

        print(self.tictactoe.board)

        self.assertFalse(self.tictactoe.is_winner(self.other_player))
        self.assertEqual(fields, self.tictactoe.is_winner(self.learner))
Esempio n. 5
0
    def __init__(self, host, port, hostLetter, goesFirst):
        print("Server started")

        self.host = host

        self.port = port

        self.hostLetter = hostLetter

        self.goesFirst = goesFirst

        self.finishedServing = False

        # Store player client info
        self.clientList = []

        # Create instance of TTT game
        self.game = TicTacToe()

        # Create socket instance - Creates default TCP
        self.s = socket.socket()

        # Timeout every 0 seconds to listen for key exception and create non blocking socket
        # self.s.settimeout(0)
        # self.s.setblocking(0)

        # Bind host/port to socket
        self.s.bind((host, port))

        # Start server listening for connections
        self.s.listen(2)

        # Start getting connection
        self.startServer()
Esempio n. 6
0
def test_games(games):
    for i in range(games):
        game = TicTacToe(p1, p2)
        game.play_game()
        for thing in test_games_results:
            test_games_results[thing] += game.score[thing]
    print('The results of ' + str(games) + ' games played was ' + str(test_games_results))
Esempio n. 7
0
    def test_learn_single_starting(self):
        self.learner = Learner()
        self.other_player = Player()
        self.tictactoe = TicTacToe()

        fields = [(0, 0), (0, 1), (0, 2)]
        other_fields = [(1, 0), (1, 1)]

        for field in range(len(fields)):
            self.tictactoe.play(*fields[field], self.learner)
            try:
                self.tictactoe.play(*other_fields[field], self.other_player)
            except (IndexError):
                pass
            self.learner.look(self.tictactoe)

        self.assertEqual(fields, self.tictactoe.is_winner(self.learner))
        self.learner.learn(self.tictactoe, 100, self.learner)
        print(self.learner.rewards)

        self.tictactoe = TicTacToe()
        while (self.tictactoe.available_moves()
               and not self.tictactoe.is_winner(self.learner)
               and not self.tictactoe.is_winner(self.other_player)):
            self.tictactoe.play(*self.learner.next_move(self.tictactoe),
                                self.learner)
            if (other_fields):
                self.tictactoe.play(*other_fields.pop(0), self.other_player)

        print(self.tictactoe.board)

        self.assertFalse(self.tictactoe.is_winner(self.other_player))
        self.assertEqual(fields, self.tictactoe.is_winner(self.learner))
Esempio n. 8
0
    def testAddPlayer(self):
        game = TicTacToe()
        game.add_player("playerx")
        game.add_player("playery")

        self.assertTrue("playerx" in game.players)
        self.assertTrue("playery" in game.players)
Esempio n. 9
0
 def test_set_reward(self):
     reward = 100
     self.learner = Learner()
     tictactoe = TicTacToe()
     action = tictactoe.available_moves()[0]
     self.learner.set_reward(reward, action, tictactoe.board)
     self.assertEqual(reward,
                      self.learner.get_reward(action, tictactoe.board))
Esempio n. 10
0
    def restart(self):
        """
		Handles game restart and reconstruction.
		"""
        self.game = TicTacToe()
        self.win_lose_label.destroy()
        self.canvas.destroy()
        self.draw_board()
Esempio n. 11
0
 def test_look_other_player(self):
     self.learner = Learner()
     self.other_player = RandomPlayer()
     tictactoe = TicTacToe()
     action = tictactoe.available_moves()[0]
     tictactoe.play(action[0], action[1], self.other_player)
     self.learner.look(tictactoe)
     self.assertEqual(1, len(self.learner.history[self.other_player.name]))
     self.assertEqual(action,
                      self.learner.history[self.other_player.name][0])
Esempio n. 12
0
def test_restart():
    game = TicTacToe()
    game.place_marker(0, 0)
    game.place_marker(0, 2)
    game.place_marker(0, 1)
    game.place_marker(1, 1)
    game.place_marker(1, 0)
    game.place_marker(2, 0)
    game.restart()
    assert game.board == [[' ', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']]
Esempio n. 13
0
class GameManager_GUI:
    def __init__(self):
        self.ttt = TicTacToe()
        CAMVAS_SIZE = 300
        self.TILE_SIZE = CAMVAS_SIZE / 3

        self.root = tkinter.Tk()
        self.root.title("틱 택 토")
        self.root.geometry(str(CAMVAS_SIZE) + "x" + str(CAMVAS_SIZE))
        # geometry("300 x 300")
        self.root.resizable(width=False, height=False)
        self.canvas = tkinter.Canvas(self.root,
                                     bg="white",
                                     width=CAMVAS_SIZE,
                                     height=CAMVAS_SIZE)
        self.canvas.pack()

        self.images = dict()
        self.images["O"] = tkinter.PhotoImage(file="Image/O.gif")
        self.images["X"] = tkinter.PhotoImage(file="Image/O.gif")
        self.canvas.bind("<Button-1>", self.click_handler)

    def click_handler(self, event):
        row = math.floor(event.y / self.TILE_SIZE)
        col = math.floor(event.x / self.TILE_SIZE)
        self.ttt.set(row, col)
        self.draw_board()

    def draw_board(self):
        self.canvas.delete("all")

        x = 0
        y = 0

        for i, v in enumerate(self.ttt.board):
            if v == ".":
                pass
            elif v == "O":
                self.canvas.create_image(x,
                                         y,
                                         anchor="nw",
                                         image=self.images["O"])
            elif v == "X":
                self.canvas.create_image(x,
                                         y,
                                         anchor="nw",
                                         image=self.images["X"])
            x += self.TILE_SIZE
            if i % 3 == 2:
                x = 0
                y += self.TILE_SIZE

    def play(self):
        self.root.mainloop()
Esempio n. 14
0
def play_game(player_token):
    agent = Agent(switch_token(player_token))
    game = TicTacToe([' '] * 9)
    while not game.over():
        play_turn(agent, game)
    print(game)
    if game.won():
        winner = game.winner()
        print(f"Better luck next time! {winner} wins!\n")
    else:
        print("Game ends in a draw!\n")
Esempio n. 15
0
class Client:
    def __init__(self, host, port):
        # Server host/port
        self.host = host
        self.port = port

        # Client game instance
        self.clientGame = TicTacToe()

        # Initialize socket object
        self.sock = socket.socket()

        # Connect to game server
        self.sock.connect((self.host, self.port))

        # Start getting connection
        self.startClient()

    def startClient(self):
        print("Connected to game server")

        sendThread = threading.Thread(target=self.sendMessage)
        sendThread.daemon = True
        sendThread.start()

        while True:

            data = self.sock.recv(1024)
            data = pickle.loads(data)

            self.clientGame.setGameState(data)
            self.clientGame.renderAll()

            # for stuff in data:
            #     print(stuff)
            # print("Recieved from server: " + str(data))

            # Set game data and render game
            # self.clientGame.setGameState(data)
            # self.clientGame.renderAll()

            print("->", end="")
            message = input()
            # print("message")
            print(message)
            # message = pickle.dumps(message)
            # maybe send all
            self.sock.send(message.encode("utf-8"))

    def sendMessage(self):
        while True:
            print("->", end="")
            msg = input()
            self.sock.send(msg.encode("utf-8"))
Esempio n. 16
0
    def run(self):
        while (True):
            self.View = MenuView(3, self.players)
            buttons1, buttons2, PlayButton, GRID3, GRID10 = self.View.draw_Menu(
                self.players)

            flag = 0
            p1 = None
            p2 = None
            p3 = None

            while (flag == 0):
                for event in pygame.event.get():
                    if (event.type == pygame.QUIT):
                        sys.exit()
                    if (event.type == pygame.MOUSEBUTTONDOWN):
                        if (p1 != None and p2 != None and p3 != None):
                            if (PlayButton.isClicked(event) == 1):
                                flag = 1
                                p3 = 2

                        if (GRID3.isClicked(event) == 1 and p3 != 2):
                            GRID3.Toggle()
                            GRID10.UnToggle()
                            GRID_SIZE = 3
                            p3 = 1

                        if (GRID10.isClicked(event) == 1 and p3 != 2):
                            GRID10.Toggle()
                            GRID3.UnToggle()
                            GRID_SIZE = 10
                            p3 = 1

                        for i, b in enumerate(buttons1):
                            if (b.isClicked(event) > 0):
                                p1 = deepcopy(self.players[i])
                                for bb in buttons1:
                                    bb.UnToggle()
                                b.Toggle()
                        for i, b in enumerate(buttons2):
                            if (b.isClicked(event) > 0):
                                p2 = deepcopy(self.players[i])
                                for bb in buttons2:
                                    bb.UnToggle()
                                b.Toggle()

            print("!!!")

            #             TicTacToe(needToWin, GRID_SIZE,player1,player2)
            A_TicTacToe = TicTacToe(needToWinDict[GRID_SIZE], GRID_SIZE, p1,
                                    p2, False)
            A_TicTacToe.run()

        pygame.time.wait(30000)
Esempio n. 17
0
 def test_game3(self):
     game = TicTacToe()
     game.put_choice(2, 1)
     game.put_choice(2, 4)
     game.put_choice(1, 10)
     game.put_choice(1, 3)
     game.put_choice(2, 7)
     self.assertEqual(game.status_of_the_match(), 2)
Esempio n. 18
0
    def __init__(self):
        game_number = self.chosen_game_mode(self.args_parser())

        if game_number == 1:
            print("Welcome to The TicTacToe game.")
            ttt = TicTacToe("Tic Tac Toe Game", "190x210",
                            self.board_size_tic_tac_toe_game)
            ttt.run_game()

        elif game_number == 2:
            print("Welcome to The Checkers game.")
            print("In the building process.")
Esempio n. 19
0
 def test_game1(self):
     game = TicTacToe()
     game.put_choice(1, 1)
     game.put_choice(2, 2)
     game.put_choice(1, 5)
     game.put_choice(2, 7)
     game.put_choice(1, 9)
     game.put_choice(2, 4)
     self.assertEqual(game.status_of_the_match(), 1)
 def test_second_case(self):
     game = TicTacToe()
     game.playX(0, 0)
     game.playO(1, 1)
     game.playX(2, 2)
     board_as_x = game.board_for_learning()
     expected_as_x = numpy.array(
         [1.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 1.0])
     self.assertTrue((board_as_x == expected_as_x).all())
     board_as_o = game.board_for_learning_as_O()
     expected_as_o = numpy.array(
         [2.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 2.0])
     self.assertTrue((board_as_o == expected_as_o).all())
Esempio n. 21
0
def train(games):
	# Set timer
	startTime = clock()

	# Train computer
	for i in range(1, games + 1):
		if i % 1000 == 0: print(i)
		game = TicTacToe(p1, p2)
		game.play_game()

	deltaTime = clock() - startTime
	m, s = divmod(deltaTime, 60)
	print("It took " + str(int(m)) + " minutes and " + str(s) + " seconds to play " + str(games) + " games")
Esempio n. 22
0
File: main.py Progetto: abelo98/AI
def Main():

    humanChoice = ''
    aiChoice = ''
    turn = ''

    while 1 :
        humanChoice = input('Select symbol X or O: ').lower()
        if humanChoice == 'x':
            aiChoice = 'o'
            break
        elif humanChoice == 'o':
            aiChoice = 'x'
            break
        print('')
        print('wrong choice')
        print('')

    while 1:
        turn = input('Would you like to play first (y/n): ').lower()
        if turn == 'y':
            turn = 'human'
            break
        elif turn == 'n':
            turn = 'ai'
            break
        print('')
        print('wrong choice')
        print('')

    game = TicTacToe(humanChoice,aiChoice)

    while not game.CheckFinalState() and len(game.GetEmptyCells()) > 0:
        if turn == 'human':
            game.HumanTime()
            turn = 'ai'
        else:
            game.AiTime()
            turn = 'human'

    game.Clear()
    game.Render()

    if game.Winner(-1):
        print('The human wins')
    elif game.Winner(1):
        print('The AI wins')
    else:
        print('tie')
Esempio n. 23
0
def test_cross_win():
    game = TicTacToe()
    game.place_marker(0, 0)
    game.place_marker(0, 1)
    game.place_marker(1, 1)
    game.place_marker(0, 2)
    game.place_marker(2, 2)
    assert game.state == STATES.CROSS_WON
Esempio n. 24
0
def main():
    game = TicTacToe()
    currentInput = ' '

    if random.randint(0, 1) == 0:
        game.nextAIMove()

    game.printField()

    while (currentInput != 'q' and game.gameIsRunning):
        currentInput = input()
        game.performMoves(currentInput)
        game.printField()

    print()
Esempio n. 25
0
 def test_2_random_players_cl(self):
     player1 = RandomPlayer('R1')
     player2 = RandomPlayer('R2')
     game = TicTacToe()
     gui = CommandlineGui(game)
     match = Match(gui, game, players=[player1, player2])
     match.play()
Esempio n. 26
0
 def test_learner_random_players(self):
     player1 = Learner()
     player2 = RandomPlayer()
     game = TicTacToe()
     gui = KtinterGui(game)
     match = Match(gui, game, players=[player1, player2])
     match.play()
Esempio n. 27
0
 def __init__(self):
     self.mainGrid = [[TicTacToe() for j in range(3)] for i in range(3)]
     self.currentBoard = [1, 1]
     self.hasWon = False
     self.wonBy = ' '
     self.currentPlayer = 'X'
     self.verbose = 1
Esempio n. 28
0
 def test_random_human_players_cl(self):
     player1 = RandomPlayer()
     player2 = HumanPlayer()
     game = TicTacToe()
     gui = CommandlineGui(game)
     match = Match(gui, game, players=[player1, player2])
     match.play()
Esempio n. 29
0
 def test_2_human_players_cl(self):
     player1 = HumanPlayer('H1')
     player2 = HumanPlayer('H2')
     game = TicTacToe()
     gui = CommandlineGui(game)
     match = Match(gui, game, players=[player1, player2])
     match.play()
Esempio n. 30
0
 def test_human_learner_players(self):
     player1 = HumanPlayer()
     player2 = Learner()
     game = TicTacToe()
     gui = KtinterGui(game)
     match = Match(gui, game, players=[player1, player2])
     match.play()
Esempio n. 31
0
    def __init__(self, host, port):
        # Server host/port
        self.host = host
        self.port = port

        # Client game instance
        self.clientGame = TicTacToe()

        # Initialize socket object
        self.sock = socket.socket()

        # Connect to game server
        self.sock.connect((self.host, self.port))

        # Start getting connection
        self.startClient()
Esempio n. 32
0
# Define the size of the board
board_rows = 3
board_cols = 3

# Define win condition (# of symbols in a row)
k_to_win = 3

# Define how many games to play
n_games = 100000

# Define how many hidden layer nodes for the NN to have
num_nodes = 100

boardlist_size = board_rows*board_cols
game = TicTacToe(board_rows, board_cols, k_to_win)

Bot1 = {'win':0, 'lose':0, 'tie':0}
Bot2 = {'win':0, 'lose':0, 'tie':0}

for game_num in range(0,n_games):
    print("Playing game " + repr(game_num) + "...")

    playerturn = random.randint(0,1)

    turn = 0

    while not game.won:
        boardlist = game.boardlist

        if turn%2 == playerturn:
Esempio n. 33
0
 def setUp(self):
     self.ttt = TicTacToe()
Esempio n. 34
0
from TicTacToe import TicTacToe

tb = TicTacToe()
tb.simulateGame()
Esempio n. 35
0
class test_TicTacToe(unittest.TestCase):
    def setUp(self):
        self.ttt = TicTacToe()
        
    def test_reset(self):
        board = ["."] * 9
        squares = [[],[]]
        free_squares = [x for x in range(9)]
        game_over = False
        turns = 0
        self.ttt.reset_board()
        self.assertEqual(self.ttt.board, board)
        self.assertEqual(self.ttt.squares, squares)
        self.assertEqual(self.ttt.free_squares, free_squares)
        self.assertEqual(self.ttt.game_over, game_over)
        self.assertEqual(self.ttt.turns, turns)
        
    def test_move_possible(self):
        self.assertTrue(self.ttt.move_possible(3))
        self.ttt.make_move(self.ttt.COMPUTER, 3)
        self.assertFalse(self.ttt.move_possible(3))
    
    def test_make_move(self):
        self.ttt.make_move(self.ttt.COMPUTER, 0)
        self.ttt.make_move(self.ttt.HUMAN, 4)
        
        board = ["."] * 9
        board[0] = "x"
        board[4] = "o"
        self.assertEqual(self.ttt.board, board)
        
        human = [4]
        computer = [0]
        self.assertEqual(human, self.ttt.squares[self.ttt.HUMAN])
        self.assertEqual(computer, self.ttt.squares[self.ttt.COMPUTER])
        
        free_squares = [x for x in range(9)]
        free_squares.remove(0)
        free_squares.remove(4)
        self.assertEqual(free_squares, self.ttt.free_squares)
        
        self.assertEqual(2, self.ttt.turns)
        
    def test_undo_move(self):
        self.ttt.make_move(self.ttt.COMPUTER, 0)
        self.ttt.make_move(self.ttt.HUMAN, 8)
        board = ["."] * 9
        board[0] = "x"
        self.assertTrue(self.ttt.undo_move(self.ttt.HUMAN, 8))
        self.assertEqual(board, self.ttt.board)
        self.assertEqual([], self.ttt.squares[self.ttt.HUMAN])
        self.assertFalse(self.ttt.undo_move(self.ttt.HUMAN, 0))
        
        free_squares = [x for x in range(1, 9)]
        self.assertEqual(set(self.ttt.free_squares), set(free_squares))
        self.assertEqual(self.ttt.turns, 1)
        
    def test_check_game_over(self):
        #test computer victory
        self.ttt.squares = [[0,1,2],[]]
        self.assertEqual(self.ttt.check_game_over(), (True, 1))
        
        #test human victory
        self.ttt.squares = [[],[2,5,8]]
        self.assertEqual(self.ttt.check_game_over(), (True, -1))
        
        #test tie
        #squares = [[4,1,8,6,5],[0,7,3,2]]
        self.ttt.reset_board()
        self.ttt.make_move(self.ttt.COMPUTER,4)
        self.ttt.make_move(self.ttt.HUMAN,0)
        self.ttt.make_move(self.ttt.COMPUTER,1)
        self.ttt.make_move(self.ttt.HUMAN,7)
        self.ttt.make_move(self.ttt.COMPUTER,8)
        self.ttt.make_move(self.ttt.HUMAN,3)
        self.ttt.make_move(self.ttt.COMPUTER,6)
        self.ttt.make_move(self.ttt.HUMAN,2)
        self.ttt.make_move(self.ttt.COMPUTER,5)
        self.assertEqual(self.ttt.check_game_over(), (True, 0))

        #test no winner, no tie
        self.ttt.undo_move(self.ttt.COMPUTER, 5)
        self.assertEqual(self.ttt.check_game_over(), (False, None))
        
    def test_do_computer_turn(self):
        self.ttt.do_computer_turn()
        self.assertEqual(self.ttt.squares[self.ttt.COMPUTER], [4])
        
        self.ttt.do_computer_turn()
        self.assertEqual(len(self.ttt.squares[self.ttt.COMPUTER]), 2)
        self.assertEqual(self.ttt.board_control, self.ttt.HUMAN)
        self.assertEqual(self.ttt.turns, 2)
        
    def test_find_good_move(self):
        #check that all initial moves are neutral (expected to tie)
        score, pos = self.ttt.find_good_move(self.ttt.COMPUTER)
        self.assertEqual(score, 0)
        for i in range(9):
            self.ttt.make_move(self.ttt.HUMAN, i)
            score, pos = self.ttt.find_good_move(self.ttt.COMPUTER)
            self.ttt.undo_move(self.ttt.HUMAN, i)
            self.assertEqual(score, 0)
        
        self.ttt.reset_board()
        
        #set up a cpu wins situation and make sure cpu finds it
        self.ttt.make_move(self.ttt.COMPUTER, 0)
        self.ttt.make_move(self.ttt.HUMAN, 3)
        self.ttt.make_move(self.ttt.COMPUTER, 1)
        self.ttt.make_move(self.ttt.HUMAN, 4)
        score, pos = self.ttt.find_good_move(self.ttt.COMPUTER)
        self.assertEqual(score, 1)
        
        #set up a human wins situation and make sure human finds it
        self.ttt.make_move(self.ttt.COMPUTER, 8)
        score, pos = self.ttt.find_good_move(self.ttt.HUMAN)
        self.assertEqual(score, -1)
        
        #play a game, both players make best moves.  ensure a tie
        self.ttt.reset_board()
        while not self.ttt.game_over:
            if self.ttt.board_control == self.ttt.COMPUTER:
                self.ttt.do_computer_turn()
            else:
                score, pos = self.ttt.find_good_move(self.ttt.HUMAN)
                self.ttt.make_move(self.ttt.HUMAN, pos)
                self.ttt.board_control = self.ttt.COMPUTER
            self.ttt.game_over, winner = self.ttt.check_game_over()
            if self.ttt.game_over:
                self.assertEqual(winner, 0)
Esempio n. 36
0
for arg in sys.argv:
   args.append(arg)

if len(args) != 6:
    print("Must have exactly 5 commandline arguments: <board rows> <board columns> <k-in-a-row to win> <Monte Carlo bot passes> <# games>")
    sys.exit()
else:
    board_rows = int(args[1])
    board_cols = int(args[2])
    k_to_win = int(args[3])
    bot_passes = int(args[4])
    n_games = int(args[5])

boardlist_size = board_rows*board_cols
game = TicTacToe(board_rows, board_cols, k_to_win)
clf = MCbot(bot_passes)
MCmemory = {}

Bot1 = {'win':0, 'lose':0, 'tie':0}
Bot2 = {'win':0, 'lose':0, 'tie':0}

train_X_large = []
train_Y_large = []

for game_num in range(0,n_games):
    playerA_X = [] # X symbol
    playerB_X = [] # @ symbol

    playerA_Y = [] # X symbol
    playerB_Y = [] # @ symbol
Esempio n. 37
0
    def testGame(self):
        #setup
        game = TicTacToe()
        game.add_player("playerx")
        game.add_player("playery")
        game.begin()

        self.assertTrue(game.validate("playerx", {"x" : 0, "y" : 0}))
        game.execute("playerx", {"x" : 0, "y" : 0})

        self.assertTrue(game.validate("playery", {"x" : 1, "y" : 0}))
        game.execute("playery", {"x" : 1, "y" : 0})

        self.assertTrue(game.validate("playerx", {"x" : 2, "y" : 0}))
        game.execute("playerx", {"x" : 2, "y" : 0})

        self.assertTrue(game.validate("playery", {"x" : 0, "y" : 1}))
        game.execute("playery", {"x" : 0, "y" : 1})

        self.assertTrue(game.validate("playerx", {"x" : 1, "y" : 1}))
        game.execute("playerx", {"x" : 1, "y" : 1})

        self.assertTrue(game.validate("playery", {"x" : 1, "y" : 2}))
        game.execute("playery", {"x" : 1, "y" : 2})

        self.assertTrue(game.validate("playerx", {"x" : 2, "y" : 1}))
        game.execute("playerx", {"x" : 2, "y" : 1})

        self.assertTrue(game.validate("playery", {"x" : 2, "y" : 2}))
        game.execute("playery", {"x" : 2, "y" : 2})
 def __init__(self, h=7, v=6, k=4):
     TicTacToe.__init__(self, h, v, k)
Esempio n. 39
0
   args.append(arg)

if len(args) != 5:
	print("Must have exactly 4 commandline arguments: <board rows> <board columns> <k-in-a-row to win> <Monte Carlo bot passes>")
	sys.exit()
else:
	board_rows = int(args[1])
	board_cols = int(args[2])
	k_to_win = int(args[3])
	bot_passes = int(args[4])

boardlist_size = board_rows*board_cols

clf = MCbot(bot_passes)

game = TicTacToe(board_rows, board_cols, k_to_win)

playerturn = 0

while True:
	print("")
	print("Starting new game!")

	turn = 0

	game.printboard()

	while not game.won:
		if turn%2 == playerturn:
			print("Player taking turn...")
			val = int(raw_input("Please select a cell number: "))