def test_playerx():
suite = poc_simpletest.TestSuite()
print "Move PlayerX:"
board = provided.TTTBoard(3, board=[[3, 2, 1], [3, 2, 1], [1, 3, 2]])
print board
suite.run_test(move_wrapper(board, provided.PLAYERX, 1), (2, 0), "Test 1.")
suite.report_results()
def test_suite1():
# create a TestSuite object
suite = poc_simpletest.TestSuite()
#create boards to test
b0=provided.TTTBoard(3) #maschineplayer is X
b0.move(1,1,2)
print "initialboard \n", b0
mc_trials(b0,3)
print "finalboard \n", b0
#print b0.get_dim()
scores =[[0 for dummy in range(b0.get_dim())] for dummy in range(b0.get_dim())]
#scores[0][0]=3
#scores[1][1]=5
print "initial scores", scores
mc_update_scores(scores, b0, 3)
print "final scores:", scores
# test the method
#suite.run_test(mc_trials(b0, provided.PLAYERO), 1, "Test #1:")
#suite.run_test(b1.is_game_won(), False, "Test #2:")
#suite.run_test(b2.is_game_won(), False, "Test #3:")
#suite.run_test(b3.is_game_won(), True, "Test #4:")
#report test results
suite.report_results()
def newgame(self):
""" Start new game. """
self._board = provided.TTTBoard(self._size, self._reverse)
self._inprogress = True
self._wait = False
self._turn = provided.PLAYERX
self._label.set_text("")
def test_playero():
suite = poc_simpletest.TestSuite()
print "Move PlayerO:"
board = provided.TTTBoard(3, board=[[3, 2, 1], [3, 2, 1], [2, 3, 2]])
print board
suite.run_test(move_wrapper(board, provided.PLAYERO, 1), (0, 2), "Test 2.")
suite.report_results()
def initial_board():
"""
Create a Tic Tac Toe game in progress:
X | |
------------
| X | O
------------
| | O
"""
# Create a 3x3 board
board = provided.TTTBoard(DIM)
# Place some pieces on the board
board.move(0, 0, provided.PLAYERX)
#board.move(0, 1, provided.EMPTY)
#board.move(0, 2, provided.EMPTY)
#board.move(1, 0, provided.EMPTY)
board.move(1, 1, provided.PLAYERX)
board.move(1, 2, provided.PLAYERO)
#board.move(2, 0, provided.PLAYERO)
#board.move(2, 1, provided.EMPTY)
board.move(2, 2, provided.PLAYERO)
return board
def test_get_best_move1(self):
"""
Testing init
"""
self.move = get_best_move(
provided.TTTBoard(2, False, [[provided.EMPTY, provided.EMPTY], [provided.EMPTY, provided.EMPTY]]),
[[0, 0], [3, 0]])
self.assertEqual(self.move, (1, 0))
def test_get_best_move3(self):
"""
Testing get_best_move
"""
self.move = get_best_move(
provided.TTTBoard(2, False, [[provided.EMPTY, provided.PLAYERX], [provided.EMPTY, provided.PLAYERO]]),
[[3, 3], [0, 0]])
self.assertEqual(self.move, (0, 0))
def monte_main():
"""
test function
:return:
"""
board_size = 3
current_player = 2
board = provided.TTTBoard(board_size)
def run_test():
"""
Some informal testing code
"""
# Create a TestSuite object
suite = poc_simpletest.TestSuite()
# Test mm_move
board = provided.TTTBoard(3, board=[[2, 3, 3], [2, 2, 3], [2, 1, 1]])
suite.run_test(mm_move(board, provided.PLAYERX), (1, (-1, -1)), "Test 1:")
board = provided.TTTBoard(3, board=[[2, 3, 3], [3, 2, 2], [3, 2, 3]])
suite.run_test(mm_move(board, provided.PLAYERX), (0, (-1, -1)), "Test 2:")
board = provided.TTTBoard(3, board=[[3, 3, 3], [3, 2, 2], [3, 2, 2]])
suite.run_test(mm_move(board, provided.PLAYERX), (-1, (-1, -1)), "Test 3:")
board = provided.TTTBoard(3, board=[[3, 2, 2], [3, 2, 1], [1, 3, 2]])
suite.run_test(mm_move(board, provided.PLAYERO), (-1, (2, 0)), "Test 4:")
board = provided.TTTBoard(3, board=[[3, 2, 1], [3, 2, 1], [2, 3, 2]])
suite.run_test(mm_move(board, provided.PLAYERO), (0, (0, 2)), "Test 5:")
board = provided.TTTBoard(3, board=[[3, 2, 1], [3, 2, 2], [1, 3, 2]])
suite.run_test(mm_move(board, provided.PLAYERO), (-1, (2, 0)), "Test 6:")
board = provided.TTTBoard(3, board=[[3, 2, 1], [3, 2, 1], [1, 3, 2]])
suite.run_test(mm_move(board, provided.PLAYERX), (0, (2, 0)), "Test 7:")
suite.report_results()
def test_get_best_move2(self):
"""
Testing get_best_move
"""
self.move = get_best_move(provided.TTTBoard(3, False, [[provided.EMPTY, provided.EMPTY, provided.EMPTY],
[provided.EMPTY, provided.EMPTY, provided.EMPTY],
[provided.EMPTY, provided.EMPTY, provided.EMPTY]]),
[[1, 2, 3], [7, 8, 9], [4, 5, 6]])
self.assertEqual(self.move, (1, 2))
def manual_scoring(mc_update_scores, mcmatch, mcother, scores, player,
arrangement):
""" Perform one trial of scoring """
my_board = provided.TTTBoard(3, board=arrangement)
mc_update_scores(scores, my_board, player)
print my_board
print "Player =", provided.STRMAP[player], scores
def test_mc_move4(self):
"""
Testing mc_move
"""
self.move = mc_move(provided.TTTBoard(3, False, [[provided.PLAYERX, provided.PLAYERX, provided.PLAYERO],
[provided.EMPTY, provided.PLAYERX, provided.PLAYERX],
[provided.PLAYERO, provided.EMPTY, provided.PLAYERO]]),
provided.PLAYERO, NTRIALS)
self.assertEqual(self.move, (2, 1))
def run_computer_versus_computer(ngames = 10,
first_player = provided.PLAYERX,
draw_board = False,
board_size = 3):
"""
Computer plays ngames against itself, then win, lost, draw
statistics are displayed. Default for ngames is 10.
first_player is either provided.PLAYERX or provided.PLAYERO.
Default is provided.PLAYERX
draw_board can be set to True if you want to see the
play-by-play moves. The default is False.
board_size is the number of squares per row and column.
Default is 3 (standard Tic-Tac-Toe board size).
"""
wins_x = 0
wins_o = 0
draws = 0
for dummy_game_number in xrange(ngames):
if draw_board:
print "GAME #", dummy_game_number + 1
board = provided.TTTBoard(board_size)
player = first_player
while not board.check_win():
move = mc_move(board, player, NTRIALS)
board.move(move[0], move[1], player)
player = provided.switch_player(player)
if draw_board:
print
print str(board)
game_result = board.check_win()
if game_result == provided.PLAYERX:
if draw_board:
print "X wins"
wins_x += 1
elif game_result == provided.PLAYERO:
if draw_board:
print "O wins"
wins_o += 1
else:
if draw_board:
print "It's a draw"
draws += 1
if draw_board:
print
print "X won", wins_x, "out of", ngames, "(", 100.0 * wins_x / ngames, "%)"
print "O won", wins_o, "out of", ngames, "(", 100.0 * wins_o / ngames, "%)"
print "draws", draws, "out of", ngames, "(", 100.0 * draws / ngames, "%)"
def ttt_test_suite():
"""
Test suite for tic tac toe Monte Carlo implementation.
"""
board1 = provided.TTTBoard(3)
print board1.get_dim()
print board1
print mc_trial(board1, provided.PLAYERX)
print board1
print '-----------------'
board2 = provided.TTTBoard(3)
next_move = mc_move(board2, provided.PLAYERX, 10)
print next_move
print board2
board2.move(next_move[0], next_move[1], provided.PLAYERX)
print board2
#ttt_test_suite()
def test_trial(mc_trial):
""" Test for mc_trial() """
print "Testing the mc_trial function."
# Create a TestSuite object
suite = poc_simpletest.TestSuite()
my_board = provided.TTTBoard(3)
mc_trial(my_board, provided.PLAYERO)
suite.run_test(my_board.check_win() is not None, True,
"Test 1: mc_trial completes 3x3 game")
my_board = provided.TTTBoard(4)
mc_trial(my_board, provided.PLAYERO)
suite.run_test(my_board.check_win() is not None, True,
"Test 2: mc_trial completes 4x4 game")
suite.report_results()
def test():
b=provided.TTTBoard(2)
print b
print b.get_dim()
print b.square(0,0)
print b.get_empty_squares()
b.move(1,2,provided.PLAYERX)
print b
b.move(2,0,3)
print b
print b.check_win()
def test_mc_move3(self):
"""
Testing mc_move
"""
self.move = mc_move(provided.TTTBoard(4, False,
[[provided.PLAYERX, provided.PLAYERO, provided.PLAYERO, provided.EMPTY],
[provided.PLAYERO, provided.EMPTY, provided.PLAYERX, provided.PLAYERX],
[provided.EMPTY, provided.PLAYERX, provided.PLAYERX, provided.PLAYERO],
[provided.EMPTY, provided.PLAYERX, provided.PLAYERO, provided.PLAYERO]]),
provided.PLAYERX, NTRIALS)
self.assertIn(self.move, [(0, 3), (3, 0)])
def run_test():
"""
Run the test suite of Tic-Tac-Toe.
"""
suite = TestSuite()
board = provided.TTTBoard(3)
scores = [[0 for dummy_col in range(3)] for dummy_row in range(3)]
mc_trial = tic_tac_toe.mc_trial
mc_update_scores = tic_tac_toe.mc_update_scores
get_best_move = tic_tac_toe.get_best_move
mc_move = tic_tac_toe.mc_move
for dummy in range(3):
board_clone = board.clone()
mc_trial(board_clone, provided.PLAYERX)
suite.run_test(board_clone.check_win() != None, True, \
"Test #1: mc_trial")
print board_clone
mc_update_scores(scores, board_clone, provided.PLAYERX)
print scores
best_move = get_best_move(board, scores)
print best_move
move = mc_move(board, provided.PLAYERX, 3)
print move
board = provided.TTTBoard(3, False, \
[[provided.PLAYERX, provided.EMPTY, provided.EMPTY], \
[provided.PLAYERO, provided.PLAYERO, provided.EMPTY], \
[provided.EMPTY, provided.PLAYERX, provided.EMPTY]])
print board
print mc_move(board, provided.PLAYERX, tic_tac_toe.NTRIALS)
suite.report_results()
def run_mm_move():
board = provided.TTTBoard(
3, False, [[provided.PLAYERO, provided.PLAYERX, provided.PLAYERO],
[provided.PLAYERO, provided.PLAYERX, provided.PLAYERX],
[provided.PLAYERX, provided.PLAYERO, provided.PLAYERX]])
player = provided.PLAYERX
suite.run_test(tttmm.mm_move(board, player), (0, (-1, -1)), "Test #1:")
board = provided.TTTBoard(
3, False, [[provided.PLAYERX, provided.PLAYERO, provided.PLAYERO],
[provided.PLAYERX, provided.PLAYERX, provided.EMPTY],
[provided.PLAYERX, provided.EMPTY, provided.PLAYERO]])
player = provided.PLAYERX
suite.run_test(tttmm.mm_move(board, player), (1, (-1, -1)), "Test #2:")
board = provided.TTTBoard(
3, False, [[provided.PLAYERX, provided.PLAYERO, provided.PLAYERO],
[provided.EMPTY, provided.PLAYERX, provided.EMPTY],
[provided.PLAYERX, provided.EMPTY, provided.PLAYERO]])
player = provided.PLAYERX
suite.run_test(tttmm.mm_move(board, player), (1, (1, 0)), "Test #3:")
board = provided.TTTBoard(
3, False, [[provided.PLAYERX, provided.EMPTY, provided.EMPTY],
[provided.PLAYERO, provided.PLAYERO, provided.EMPTY],
[provided.EMPTY, provided.PLAYERX, provided.EMPTY]])
player = provided.PLAYERX
suite.run_test(tttmm.mm_move(board, player), (0, (1, 2)), "Test #4:")
board = provided.TTTBoard(
3, False, [[provided.EMPTY, provided.EMPTY, provided.PLAYERX],
[provided.EMPTY, provided.EMPTY, provided.EMPTY],
[provided.EMPTY, provided.EMPTY, provided.EMPTY]])
player = provided.PLAYERO
suite.run_test(tttmm.mm_move(board, player), (0, (1, 1)), "Test #5:")
suite.report_results()
def __init__(self):
# create a TestSuite object
self.suite = poc_simpletest.TestSuite()
# create a Tic Tac Toe object
self.board = provided.TTTBoard(3)
print "Actual initial board state:\n", self.board
print "Cloning board for simulation."
self.current_board = self.board.clone()
self.trial = 1
self.num_trials = NTRIALS
# initialize scores_grid
self.scores_grid = [[]]
self.num_setups = 2
self.test_overlord()
def test_mc_trial1(self):
"""
Testing mc_trial
"""
self.board = provided.TTTBoard(4, False, [
[provided.PLAYERX, provided.PLAYERO, provided.PLAYERO, provided.EMPTY],
[provided.PLAYERO, provided.EMPTY, provided.PLAYERX, provided.PLAYERX],
[provided.EMPTY, provided.PLAYERX, provided.PLAYERX, provided.PLAYERO],
[provided.EMPTY, provided.PLAYERX, provided.PLAYERO, provided.PLAYERO]])
self.move = mc_trial(self.board, 2)
self.assertIn(self.board.square(0, 3), [provided.PLAYERX, provided.PLAYERO, provided.EMPTY])
self.assertIn(self.board.square(1, 1), [provided.PLAYERX, provided.PLAYERO, provided.EMPTY])
self.assertIn(self.board.square(2, 0), [provided.PLAYERX, provided.PLAYERO, provided.EMPTY])
self.assertIn(self.board.square(3, 0), [provided.PLAYERX, provided.PLAYERO, provided.EMPTY])
def test_mm_move():
ts = poc_simpletest.TestSuite()
X = provided.PLAYERX
O = provided.PLAYERO
_ = provided.EMPTY
state_1 = [[O, X, X], [O, X, _], [O, O, X]]
board = provided.TTTBoard(len(state_1), False, state_1)
ts.run_test(mm_move(board, X), (-1, (-1, -1)), "mm_move")
state_2 = [[O, X, X], [O, X, O], [_, O, X]]
board = provided.TTTBoard(len(state_2), False, state_2)
ts.run_test(mm_move(board, X), (1, (2, 0)), "mm_move")
state_3 = [[O, X, _], [O, X, _], [X, O, X]]
board = provided.TTTBoard(len(state_3), False, state_3)
ts.run_test(mm_move(board, O), (0, (0, 2)), "mm_move")
state_4 = [[O, X, _], [O, X, _], [_, O, X]]
board = provided.TTTBoard(len(state_4), False, state_4)
ts.run_test(mm_move(board, X), (0, (2, 0)), "mm_move")
ts.report_results()
def test_run_a_trial():
b1=provided.TTTBoard(3)
scores=scores =[[0 for dummy in range(b1.get_dim())] for dummy in range(b1.get_dim())]
#mc_trials(b1,2)
b1.move(0,0,2)
b1.move(1,1,3)
b1.move(1,0,3)
print b1
new_scores= run_a_trial(b1,3,scores) #plaer is =
print new_scores
print run_a_trial(b1,3,new_scores)
print b1
def test_mc_move():
b1=provided.TTTBoard(3)
#b1.move(1,1,2)
b1.move(0,0,3)
#b1.move(0,2,3)
#b1.move(0,1,3)
b1.move(2,0,2)
b1.move(2,2,2)
#b1.move(2,1,2)
#b1.move(2,2,3)
print b1
move=mc_move(b1,3,10000)
b1.move(move[0],move[1],3)
print b1
def test2():
b1=provided.TTTBoard(3)
#mc_trials(b1,2)
b1.move(0,1,2)
b1.move(1,1,3)
b1.move(2,2,3)
print b1
scores =[[dummy for dummy in range(b1.get_dim())] for dummy in range(b1.get_dim())]
scores [2][0]=12
scores [1][1]=30
scores [1][2]=12
scores [2][1]=222
print "scores", scores
#mc_update_scores(scores,b1,2)
print "choce", get_best_move(b1,scores)
def __init__(self):
# create a TestSuite object
self.suite = poc_simpletest.TestSuite()
# create a Tic Tac Toe object
self.board = provided.TTTBoard(3)
print "Setting up an in-game board state:\n"
self.board.move(0, 0, provided.PLAYERX)
self.board.move(1, 1, provided.PLAYERO)
self.board.move(0, 2, provided.PLAYERX)
self.board.move(1, 0, provided.PLAYERO)
print "Actual initial board state:\n", self.board
print "Cloning board for simulation."
self.current_board = self.board.clone()
self.trial = 1
self.num_trials = NTRIALS
# initialize scores_grid
self.scores_grid = [[0 for dummy_col in range(self.current_board.get_dim())
] for dummy_row in range(self.current_board.get_dim())]
self.run_tests()
def mc_trial(board, player):
"""
This function plays a game with the given board and the next player
by making random moves
"""
current_board = provided.TTTBoard(3, False, board)
print current_board
print current_board.check_win()
while current_board.check_win() == None:
empty_squares = current_board.get_empty_squares()
# print empty_squares
random_square = random.choice(empty_squares)
# print random_square
current_board.move(random_square[0], random_square[1], player)
print current_board
player = provided.switch_player(player)
return current_board.clone()
"""
Mini-max Tic-Tac-Toe Player
"""
import poc_ttt_gui
import poc_ttt_provided as provided
# Set timeout, as mini-max can take a long time
import codeskulptor
codeskulptor.set_timeout(200)
# SCORING VALUES - DO NOT MODIFY
SCORES = {provided.PLAYERX: 1, provided.DRAW: 0, provided.PLAYERO: -1}
my_board = provided.TTTBoard(3)
#""" Example 1
my_board.move(0, 0, provided.PLAYERO)
my_board.move(0, 1, provided.PLAYERX)
my_board.move(1, 0, provided.PLAYERO)
my_board.move(1, 1, provided.PLAYERX)
my_board.move(2, 1, provided.PLAYERO)
my_board.move(2, 2, provided.PLAYERX)
#my_board.move(1, 1, provided.PLAYERX)
#my_board.move(0, 1, provided.PLAYERX)
#my_board.move(1, 0, provided.PLAYERX)
#my_board.move(0, 0, provided.PLAYERO)
#my_board.move(0, 2, provided.PLAYERO)
#my_board.move(1, 2, provided.PLAYERO)
#my_board.move(2, 0, provided.PLAYERO)
#my_board.move(2, 2, provided.PLAYERX)
import poc_simpletest
import poc_ttt_provided as provided
board = provided.TTTBoard(3, False, None)
PLAYERX = provided.PLAYERX
def run_suite(mc_move):
"""
run code to test the mc_move function
"""
suite = poc_simpletest.TestSuite()
suite.run_test(mc_move(board, PLAYERX, 1), (0,0), "Test #1:")
# suite.run_test(mc_move(board, PLAYERX, 1), (0,1), "Test #2:")
# suite.run_test(mc_move(board, PLAYERX, 1), (0,2), "Test #3:")
# suite.run_test(mc_move(board, PLAYERX, 1), (1,0), "Test #4:")
# suite.run_test(mc_move(board, PLAYERX, 1), (1,1), "Test #5:")
# suite.run_test(mc_move(board, PLAYERX, 1), (1,2), "Test #6:")
# suite.run_test(mc_move(board, PLAYERX, 1), (2,0), "Test #7:")
# suite.run_test(mc_move(board, PLAYERX, 1), (2,1), "Test #8:")
# suite.run_test(mc_move(board, PLAYERX, 1), (2,2), "Test #9:")
suite.report_results()
"""
Wrapper to allow the use of the same infrastructure that was used
for Monte Carlo Tic-Tac-Toe.
"""
move = mm_move(board, player)
assert move[1] != (-1, -1), "returned illegal move (-1, -1)"
return move[1]
# Test game with the console or the GUI.
# Uncomment whichever you prefer.
# Both should be commented out when you submit for
# testing to save time.
#provided.play_game(move_wrapper, 1, False)
#poc_ttt_gui.run_gui(3, provided.PLAYERO, move_wrapper, 1, False)
# run the testing suite for our format function
#poc_format_testsuite.run_suite(mm_move)
#X = provided.PLAYERX
#O = provided.PLAYERO
#_ = provided.EMPTY
#
#J = [[O, X, X], [O, X, _], [X, O ,X]] #Test #10
#
#print mm_move(provided.TTTBoard(3, False, J), provided.PLAYERX)
print mm_move(
provided.TTTBoard(
2, False,
[[provided.EMPTY, provided.EMPTY], [provided.EMPTY, provided.EMPTY]]),
provided.PLAYERX)
