class GameGenetics:
def __init__(self, player_1, player_2):
self.board = Board()
self.player_1 = player_1
self.player_2 = player_2
self.turn_player_1 = False
def play_game(self):
self.board.created_board()
while (not self.is_winner()):
if (self.board.is_full()):
#print("Empate")
return cf.TIE
self.turn_player_1 = not self.turn_player_1
if (self.turn_player_1):
col = self.player_1.next_action(deepcopy(self.board))
self.board.set_value_cell(col, 1)
else:
col = self.player_2.next_action(deepcopy(self.board))
self.board.set_value_cell(col, 2)
return self.who_is_winner()
def who_is_winner(self):
if (self.turn_player_1):
return cf.WINNER_1
else:
return cf.WINNER_2
def is_winner(self):
last_mov = self.board.get_last_mov()
if (self.turn_player_1):
return self.board.winner(last_mov[0], last_mov[1], 1)
else:
return self.board.winner(last_mov[0], last_mov[1], 2)
def test_get_strategy_0():
""" Check that get_strategy is working correctly
"""
b = [[1, 0, 1, 2, 1, 1, 0],
[2, 0, 0, 2, 1, 2, 0],
[1, 0, 0, 1, 2, 2, 0],
[2, 0, 0, 0, 1, 0, 0],
[2, 0, 0, 0, 1, 0, 0],
[1, 0, 0, 0, 2, 0, 0]]
board = Board()
board.board = b
player_1 = Agent(1, 2, True) # 1 symbol of the agent, 2 symbol of the opponent
player_1.set_strategies([0,0,0,0])
var_action = player_1.get_strategy(board)
array_result = [[0, 1, 1], [1, 2, 2], [2, 2, 2],
[3, 2, 2], [4, 1, 1], [5, 3, 3], [6, 2, 2]]
result = True
for x in var_action:
position = array_result[x.position][0]
amount = array_result[x.position][1]
strategies_number = array_result[x.position][2]
print(x.position,x.amount, x.strategies_number)
if not(x.position == position and x.amount == amount
and strategies_number == x.strategies_number):
result = False
assert(result)
def test_winner_false():
"""Given a cell, check if there is not win from it
"""
array = [[1, 2, 1, 1, 2, 2, 2], [1, 2, 1, 1, 1, 1,
2], [0, 2, 2, 1, 2, 2, 2],
[0, 1, 0, 1, 2, 0, 2], [0, 0, 0, 2, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
board = Board()
board.board = array
test_pos = [[1, 2], [1, 5], [1, 8], [4, 5], [3, 6], [3, 3], [-4, 3],
[2, 11]]
sym_p1 = 1
sym_p2 = 2
sym_p3 = 3
# compare with symbols valid
assert (board.winner(test_pos[0][0], test_pos[0][1], sym_p2) == False)
assert (board.winner(test_pos[1][0], test_pos[1][1], sym_p2) == False)
assert (board.winner(test_pos[3][0], test_pos[3][1], sym_p1) == False)
assert (board.winner(test_pos[4][0], test_pos[4][1], sym_p1) == False)
assert (board.winner(test_pos[5][0], test_pos[5][1], sym_p2) == False)
# compare with symbol not valid
assert (board.winner(test_pos[3][0], test_pos[3][1], sym_p3) == False)
assert (board.winner(test_pos[4][0], test_pos[4][1], sym_p3) == False)
assert (board.winner(test_pos[5][0], test_pos[5][1], sym_p3) == False)
# compare with cell (row, col) not valid
assert (board.winner(test_pos[2][0], test_pos[2][1], sym_p1) == False)
assert (board.winner(test_pos[6][0], test_pos[6][1], sym_p1) == False)
assert (board.winner(test_pos[7][0], test_pos[7][1], sym_p1) == False)
def test_win_vrt_true():
"""Given a cell, check if there is win from it in vertical line
"""
array = [[1, 2, 1, 1, 2, 2, 2], [1, 2, 1, 1, 2, 1,
2], [1, 2, 2, 1, 2, 2, 2],
[1, 1, 0, 1, 2, 0, 2], [0, 0, 0, 1, 2, 0, 0],
[0, 0, 0, 0, 2, 0, 0]]
board = Board()
board.board = array
test_pos_1 = [[3, 0], [4, 3], [3, 3], [5, 4], [4, 4], [3, 4], [3, 6]]
size_line = 3
sym_p1 = 1
sym_p2 = 2
assert (board.win_vrt(test_pos_1[0][0], test_pos_1[0][1], sym_p1) >=
size_line)
assert (board.win_vrt(test_pos_1[1][0], test_pos_1[1][1], sym_p1) >=
size_line)
assert (board.win_vrt(test_pos_1[2][0], test_pos_1[2][1], sym_p1) >=
size_line)
assert (board.win_vrt(test_pos_1[3][0], test_pos_1[3][1], sym_p2) >=
size_line)
assert (board.win_vrt(test_pos_1[4][0], test_pos_1[4][1], sym_p2) >=
size_line)
assert (board.win_vrt(test_pos_1[5][0], test_pos_1[5][1], sym_p2) >=
size_line)
assert (board.win_vrt(test_pos_1[6][0], test_pos_1[6][1], sym_p2) >=
size_line)
def test_get_cols():
""" Check that the number of cols is exactly 7
"""
# default value of cols is 7
board = Board()
cols = 7
assert (board.get_cols() == cols)
def test_get_rows():
""" Check that the number of rows is exactly 6
"""
# default value of rows is 6
board = Board()
rows = 6
assert (board.get_rows() == rows)
def test_is_full_true():
""" Check that the board is really full
"""
array = [[1, 1, 2, 2, 2, 1, 1], [2, 1, 1, 1, 2, 1,
2], [1, 1, 2, 1, 1, 1, 2],
[2, 2, 1, 2, 2, 2, 1], [1, 1, 2, 2, 1, 1, 2],
[2, 1, 2, 1, 1, 2, 2]]
board = Board()
board.board = array
assert (board.is_full() == True)
def test_is_cell_valid_true():
""" Check that the cell (i,j) of board is valid
"""
# default value of dimensions is (6x7)
board = Board()
pos = [[1, 2], [3, 4], [0, 1], [0, 5]]
assert (board.is_cell_valid(pos[0][0], pos[0][1]) == True)
assert (board.is_cell_valid(pos[1][0], pos[1][1]) == True)
assert (board.is_cell_valid(pos[2][0], pos[2][1]) == True)
assert (board.is_cell_valid(pos[3][0], pos[3][1]) == True)
def test_is_full_false():
""" Check that the board is not really full
"""
array = [[1, 1, 2, 0, 0, 1, 1], [2, 1, 1, 1, 2, 1,
2], [1, 1, 2, 1, 1, 1, 2],
[2, 2, 1, 2, 2, 2, 1], [1, 1, 2, 2, 1, 1, 2],
[2, 1, 2, 1, 1, 2, 2]]
board = Board()
board.board = array
assert (board.is_full() == False)
def test_is_cell_valid_false():
""" Check that the cell (i,j) of board is not valid
"""
# default value of dimensions is (6x7)
board = Board()
pos = [[0, -2], [9, 11], [0, 7], [1, 8]]
assert (board.is_cell_valid(pos[0][0], pos[0][1]) == False)
assert (board.is_cell_valid(pos[1][0], pos[1][1]) == False)
assert (board.is_cell_valid(pos[2][0], pos[2][1]) == False)
assert (board.is_cell_valid(pos[3][0], pos[3][1]) == False)
def test_validate_action_False():
""" Check that validate_action is working correctly
"""
array = [[1, 1, 1, 2, 1, 0, 0], [2, 1, 1, 1, 2, 0,
0], [0, 0, 1, 2, 2, 0, 0],
[0, 0, 0, 2, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 2, 0, 0, 0]]
board = Board()
board.set_board(array)
player_1 = Player()
result = player_1.validate_action(board, 9)
assert (not result)
def test_created_board():
""" Check that the board is created and all the cells
contains the null_cell of the board
"""
array = [[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0,
0], [0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
board = Board()
board.created_board()
# compare the array with the new board created
assert (array == board.board)
def test_is_full_column_true():
""" Check that the column of board is really full
"""
array = [[0, 1, 2, 0, 1, 1, 0], [0, 1, 1, 0, 2, 1,
0], [0, 1, 2, 1, 1, 1, 0],
[2, 2, 1, 2, 2, 2, 0], [1, 1, 2, 2, 1, 1, 0],
[2, 1, 2, 1, 1, 2, 0]]
board = Board()
board.board = array
assert (board.is_fill_column(1) == True)
assert (board.is_fill_column(2) == True)
assert (board.is_fill_column(4) == True)
assert (board.is_fill_column(5) == True)
def test_get_column_not_exist():
""" Check there is zero match
"""
array = [[0, 1, 1, 0, 1, 1, 0], [0, 1, 1, 0, 1, 1,
0], [0, 1, 1, 0, 1, 1, 0],
[0, 1, 1, 0, 1, 1, 0], [1, 1, 1, 0, 1, 1, 0],
[1, 1, 1, 1, 1, 1, 0]]
board = Board()
board.board = array
col_7 = []
col_8 = []
col_20 = []
assert (board.get_column(7) == col_7)
assert (board.get_column(8) == col_8)
assert (board.get_column(20) == col_20)
def test_next_action_block():
""" Check that next_action is working correctly
"""
array = [[1, 1, 1, 2, 1, 0, 0],
[2, 1, 1, 1, 2, 0, 0],
[0, 0, 1, 2, 2, 0, 0],
[0, 0, 0, 2, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
board = Board()
board.set_board(array)
player_1 = Agent(1, 2, True) # 1 symbol of the agent, 2 symbol of the opponent
player_2 = Agent(2, 1, True) # 2 symbol of the agent, 1 symbol of the opponent
col_result = player_2.next_action(board)
col = 2
assert(col == col_result)
def test_last_mov():
"""Check that the board save correctly the last position
of last movement
"""
array = [[1, 1, 1, 1, 1, 1, 0], [1, 1, 1, 0, 1, 1,
0], [0, 1, 1, 0, 1, 1, 0],
[0, 1, 0, 0, 1, 1, 0], [0, 1, 0, 0, 1, 1, 0],
[0, 1, 0, 0, 1, 1, 0]]
board = Board()
board.board = array
# insert value in col 2
board.set_value_cell(2, 1)
# position where 1 was insert
last_position = (3, 2)
assert (board.last_mov == last_position)
def test_get_column_exist():
""" Check there is zero match
"""
array = [[0, 1, 1, 0, 1, 1, 0], [0, 1, 1, 0, 1, 1,
0], [0, 1, 1, 0, 1, 1, 0],
[0, 1, 1, 0, 1, 1, 0], [1, 1, 1, 0, 1, 1, 0],
[1, 1, 1, 1, 1, 1, 0]]
board = Board()
board.board = array
col_0 = [0, 0, 0, 0, 1, 1]
col_1 = [1, 1, 1, 1, 1, 1]
col_2 = [1, 1, 1, 1, 1, 1]
col_3 = [0, 0, 0, 0, 0, 1]
col_4 = [1, 1, 1, 1, 1, 1]
col_5 = [1, 1, 1, 1, 1, 1]
col_6 = [0, 0, 0, 0, 0, 0]
assert (board.get_column(0) == col_0)
assert (board.get_column(1) == col_1)
assert (board.get_column(2) == col_2)
assert (board.get_column(3) == col_3)
assert (board.get_column(4) == col_4)
assert (board.get_column(5) == col_5)
assert (board.get_column(6) == col_6)
def test_get_empty_element_available_cell():
""" Check that all the columns are available to insert
"""
array = [[1, 1, 1, 1, 1, 1, 0], [1, 1, 1, 0, 1, 1,
0], [0, 1, 1, 0, 1, 0, 0],
[0, 1, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
board = Board()
board.board = array
col_0 = 2
col_1 = 5
col_2 = 3
col_3 = 1
col_4 = 4
col_5 = 2
col_6 = 0
# compare with all columns of the board
assert (board.get_empty_element(0) == col_0)
assert (board.get_empty_element(1) == col_1)
assert (board.get_empty_element(2) == col_2)
assert (board.get_empty_element(3) == col_3)
assert (board.get_empty_element(4) == col_4)
assert (board.get_empty_element(5) == col_5)
assert (board.get_empty_element(6) == col_6)
def test_win_false():
""" Check that win function is working correctly
"""
array = [[1, 1, 1, 2, 1, 0, 0],
[2, 1, 2, 1, 2, 0, 0],
[0, 0, 1, 2, 2, 0, 0],
[0, 0, 0, 2, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
board = Board()
board.set_board(array)
player_1 = Agent(1, 2, True) # 1 symbol of the agent, 2 symbol of the opponent
player_2 = Agent(2, 1, True) # 2 symbol of the agent, 1 symbol of the opponent
col_to_win_result = player_1.win(board, 1)
col_to_win = -1
col_to_win_result_2 = player_2.win(board, 2)
col_to_win_2 = -1
assert(col_to_win == col_to_win_result)
assert(col_to_win_2 == col_to_win_result_2)
def test_get_cells_symbol_zero():
""" Check there is zero match
"""
array = [[0, 1, 1, 0, 1, 1, 0], [0, 1, 1, 0, 1, 1,
0], [0, 1, 1, 0, 1, 1, 0],
[0, 1, 1, 0, 1, 1, 0], [1, 1, 1, 0, 1, 1, 0],
[1, 1, 1, 1, 1, 1, 0]]
board = Board()
board.board = array
symb_a = 3
symb_b = 2
# positions of the symbol 3 and 2
pos_a = []
pos_b = []
# compare all cells of each symbol with the respective array
assert (board.get_cells_symbol(symb_a) == pos_a)
assert (board.get_cells_symbol(symb_b) == pos_b)
def test_block_true():
""" Check that block function is working correctly
"""
array = [[1, 1, 1, 2, 1, 0, 0],
[2, 1, 1, 1, 2, 0, 0],
[0, 0, 1, 2, 2, 0, 0],
[0, 0, 0, 2, 2, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
board = Board()
board.set_board(array)
player_1 = Agent(1, 2, True) # 1 symbol of the agent, 2 symbol of the opponent
player_2 = Agent(2, 1, True) # 2 symbol of the agent, 1 symbol of the opponent
col_to_block_result = player_1.block(board, 2)
col_to_block = 4
col_to_block_result_2 = player_2.block(board, 1)
col_to_block_2 = 2
assert(col_to_block == col_to_block_result)
assert(col_to_block_2 == col_to_block_result_2)
def test_get_cells_symbol_one_or_more():
""" Check there is at least one or more match
"""
array = [[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0,
0], [0, 1, 0, 0, 0, 0, 0],
[2, 2, 1, 0, 2, 0, 0], [1, 1, 2, 2, 1, 1, 0],
[2, 1, 2, 1, 1, 2, 2]]
board = Board()
board.board = array
symb_a = 1
symb_b = 2
# positions of the symbol 1 and 2
pos_a = [(2, 1), (3, 2), (4, 0), (4, 1), (4, 4), (4, 5), (5, 1), (5, 3),
(5, 4)]
pos_b = [(3, 0), (3, 1), (3, 4), (4, 2), (4, 3), (5, 0), (5, 2), (5, 5),
(5, 6)]
# compare all cells of each symbol with the respective array
assert (board.get_cells_symbol(symb_a) == pos_a)
assert (board.get_cells_symbol(symb_b) == pos_b)
def test_set_value_cell_wrong_col():
"""Check that the board no change with a wrong column
"""
array = [[1, 1, 1, 1, 1, 1, 0], [1, 1, 1, 0, 1, 1,
0], [0, 1, 1, 0, 1, 1, 0],
[0, 1, 0, 0, 1, 1, 0], [0, 1, 0, 0, 1, 1, 0],
[0, 1, 0, 0, 1, 1, 0]]
board = Board()
board.board = array
# insert value in col 10
board.set_value_cell(10, 1)
# insert value in col -1
board.set_value_cell(-1, 1)
# verify that the cols are not update
assert (board.board == array)
def test_set_value_cell_correct_col():
""" Check that a symbol is set correctly in column
"""
array = [[1, 1, 1, 1, 1, 1, 0], [1, 1, 1, 0, 1, 1,
0], [0, 1, 1, 0, 1, 1, 0],
[0, 1, 0, 0, 1, 1, 0], [0, 1, 0, 0, 1, 1, 0],
[0, 1, 0, 0, 1, 1, 0]]
board = Board()
board.board = array
# insert value in col 0
board.set_value_cell(0, 1)
# insert value in col 2
board.set_value_cell(2, 1)
# verify that the cols are update
assert (board.board == array)
def test_is_col_valid_true():
""" Check that the col of board is valid
"""
# default value of dimensions is (6x7)
board = Board()
pos = [0, 1, 2, 3, 4, 5, 6]
assert (board.is_col_valid(pos[0]) == True)
assert (board.is_col_valid(pos[1]) == True)
assert (board.is_col_valid(pos[2]) == True)
assert (board.is_col_valid(pos[3]) == True)
assert (board.is_col_valid(pos[4]) == True)
assert (board.is_col_valid(pos[5]) == True)
assert (board.is_col_valid(pos[6]) == True)
def test_is_col_valid_false():
""" Check that the col of board is not valid
"""
# default value of dimensions is (6x7)
board = Board()
pos = [-1, 7, 8, 9, -2, -4, 10]
assert (board.is_col_valid(pos[0]) == False)
assert (board.is_col_valid(pos[1]) == False)
assert (board.is_col_valid(pos[2]) == False)
assert (board.is_col_valid(pos[3]) == False)
assert (board.is_col_valid(pos[4]) == False)
assert (board.is_col_valid(pos[5]) == False)
assert (board.is_col_valid(pos[6]) == False)
def test_clear_cell_not_exist():
""" Check that the board not change with value out the range
"""
array = [[1, 1, 1, 2, 1, 0, 0], [2, 1, 1, 1, 2, 0,
0], [0, 0, 1, 1, 2, 0, 0],
[0, 0, 2, 2, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
board = Board()
board.set_board(array)
position_test = [9, 9] # out the range of board
# try to clear cell
board.clear_cell(position_test[0], position_test[0])
assert (array == board.board)
def test_clear_cell_exist():
""" Check that cell is clear correctly
"""
array = [[1, 1, 1, 2, 1, 0, 0], [2, 1, 1, 1, 2, 0,
0], [0, 0, 1, 1, 2, 0, 0],
[0, 0, 2, 2, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
board = Board()
board.set_board(array)
position_test = [0, 0] # at the begin of array
# update position in array to compare
array[position_test[0]][position_test[1]] = board.null_cell
board.clear_cell(position_test[0], position_test[0])
assert (array == board.board)
def test_is_full_column_false():
""" Check that the column of board is not really full
"""
array = [[0, 1, 2, 0, 1, 1, 0], [0, 1, 1, 0, 2, 1,
0], [0, 1, 2, 1, 1, 1, 0],
[2, 2, 1, 2, 2, 2, 0], [1, 1, 2, 2, 1, 1, 0],
[2, 1, 2, 1, 1, 2, 0]]
board = Board()
board.board = array
# compare cases with valid column
assert (board.is_fill_column(0) == False)
assert (board.is_fill_column(3) == False)
assert (board.is_fill_column(6) == False)
# compare cases with column out the range
assert (board.is_fill_column(9) == False)
def test_winner_true():
"""Given a cell, check if there is win from it
"""
array = [[1, 2, 1, 1, 2, 2, 2], [1, 2, 1, 1, 1, 1,
2], [0, 2, 2, 1, 2, 2, 2],
[0, 1, 0, 1, 2, 0, 2], [0, 0, 0, 2, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
board = Board()
board.board = array
test_pos = [[1, 2], [1, 5], [1, 6], [4, 3], [3, 6], [3, 3]]
sym_p1 = 1
sym_p2 = 2
assert (board.winner(test_pos[0][0], test_pos[0][1], sym_p1) == True)
assert (board.winner(test_pos[1][0], test_pos[1][1], sym_p1) == True)
assert (board.winner(test_pos[2][0], test_pos[2][1], sym_p2) == True)
assert (board.winner(test_pos[3][0], test_pos[3][1], sym_p2) == True)
assert (board.winner(test_pos[4][0], test_pos[4][1], sym_p2) == True)
assert (board.winner(test_pos[5][0], test_pos[5][1], sym_p1) == True)
