def test_multi_capture_not_activated_on_regular_move(self):
test_board = CheckerBoardFactory.build_board_from_preset(
BoardPresetDataclass(8, 8, [(1, 1)], [(3, 3), (5, 5)]))
test_game = CheckersGame(test_board)
test_game.make_move(CheckersMove([1, 1, 2, 2]))
self.assertEqual(test_game.current_team, TeamEnum.black)
test_game.make_move((CheckersMove([3, 3, 1, 1])))
def test_potential_capture_added_when_blocking_piece_is_removed(self):
test_board = CheckerBoardFactory.build_board_from_preset(
BoardPresetDataclass(8, 8, [(1, 0), (3, 2)], [(2, 1), (2, 3)]))
test_game = CheckersGame(test_board)
test_game.switch_team_turn()
test_game.make_move(CheckersMove([2, 3, 4, 1]))
self.assertEqual(test_game.current_team, TeamEnum.white)
self.assertIn(CheckersMove([1, 0, 3, 2]),
test_game.possible_capture_moves[TeamEnum.white])
def test_load_moves_from_list(self):
list_of_moves_to_convert = [[1, 2, 2, 3],
[0, 5, 1, 4],
[2, 3, 0, 5],
]
list_of_moves = [CheckersMove([1, 2, 2, 3]),
CheckersMove([0, 5, 1, 4]),
CheckersMove([2, 3, 0, 5]),
]
for ind, move in enumerate(create_move_iterator_from_list_of_lists(list_of_moves_to_convert)):
self.assertEqual(list_of_moves[ind], move)
def test_verify_correct_move_direction(self):
test_board = CheckerBoardFactory.build_board_from_preset(CheckerBoardPresets.standard_8_by_8)
test_game = CheckersGame(test_board, skip_scan_for_pieces_that_can_capture=True)
self.assertTrue(test_game.verify_correct_move_direction(CheckersMove([7, 6, 1, 1]), TeamEnum.black))
self.assertFalse(test_game.verify_correct_move_direction(CheckersMove([7, 6, 1, 1]), TeamEnum.white))
self.assertTrue(test_game.verify_correct_move_direction(CheckersMove([1, 2, 2, 1]), TeamEnum.black))
self.assertFalse(test_game.verify_correct_move_direction(CheckersMove([1, 2, 2, 1]), TeamEnum.white))
self.assertTrue(test_game.verify_correct_move_direction(CheckersMove([1, 2, 0, 1]), TeamEnum.black))
self.assertFalse(test_game.verify_correct_move_direction(CheckersMove([1, 2, 0, 1]), TeamEnum.white))
self.assertTrue(test_game.verify_correct_move_direction(CheckersMove([2, 1, 4, 3]), TeamEnum.white))
self.assertFalse(test_game.verify_correct_move_direction(CheckersMove([2, 1, 4, 3]), TeamEnum.black))
self.assertTrue(test_game.verify_correct_move_direction(CheckersMove([2, 3, 0, 1]), TeamEnum.black))
self.assertFalse(test_game.verify_correct_move_direction(CheckersMove([2, 3, 0, 1]), TeamEnum.white))
def test_multi_capture_possible_with_original_piece_only(self):
test_board = CheckerBoardFactory.build_board_from_preset(
BoardPresetDataclass(8, 8, [(2, 2), (6, 4)], [(3, 3), (5, 5)]))
test_game = CheckersGame(test_board)
test_game.make_move(CheckersMove([2, 2, 4, 4]))
self.assertEqual(test_game.current_team, TeamEnum.white)
self.assertRaises(IllegalMoveException, test_game.make_move,
CheckersMove([6, 4, 4, 6]))
test_board2 = CheckerBoardFactory.build_board_from_preset(
BoardPresetDataclass(8, 8, [(2, 2), (6, 4)], [(3, 3), (5, 5)]))
test_game2 = CheckersGame(test_board2)
test_game2.make_move(CheckersMove([2, 2, 4, 4]))
self.assertEqual(test_game2.current_team, TeamEnum.white)
test_game2.make_move(CheckersMove([4, 4, 6, 6]))
def create_move_iterator_from_list_of_lists(
list_of_moves: List[List[int]]) -> Iterator[CheckersMove]:
for move in list_of_moves:
try:
move = CheckersMove(move)
except ValueError as e:
raise IllegalMoveException(str(e))
yield move
def create_move_iterator_from_move_file(path: str) -> Iterator[CheckersMove]:
with open(path, 'r') as file:
for line in file:
try:
move = CheckersMove([int(coord) for coord in line.split(',')])
except ValueError as e:
raise IllegalMoveException(str(e))
yield move
def test_valid_move(self):
test_board = CheckerBoardFactory.build_board_from_preset(
CheckerBoardPresets.standard_8_by_8)
test_game = CheckersGame(test_board)
test_game.make_move(CheckersMove([1, 2, 2, 3]))
self.assertIsInstance(test_game.board[2, 3], CheckersGamePiece)
self.assertEqual(test_game.board[2, 3].team, TeamEnum.white)
self.assertIsNone(test_game.board[1, 2])
def test_possible_captures(self):
test_game = CheckersGame(
CheckerBoardFactory.build_board_from_preset(
CheckerBoardTestPresets.test_capture_board))
test_game.make_move(CheckersMove([3, 2, 5, 4]))
test_game = CheckersGame(
CheckerBoardFactory.build_board_from_preset(
CheckerBoardTestPresets.test_capture_board))
test_game.make_move(CheckersMove([3, 2, 1, 4]))
test_game = CheckersGame(
CheckerBoardFactory.build_board_from_preset(
CheckerBoardTestPresets.test_capture_board))
test_game.make_move(CheckersMove([7, 0, 5, 2]))
test_game = CheckersGame(
CheckerBoardFactory.build_board_from_preset(
CheckerBoardTestPresets.test_capture_board))
self.assertRaises(IllegalMoveException, test_game.make_move,
CheckersMove([0, 1, 1, 2]))
def test_ignore_capture_move_raises_exception(self):
list_of_setup_moves = [
[1, 2, 2, 3],
[0, 5, 1, 4],
]
illegal_move = [2, 3, 3, 4]
test_game = CheckersGame(
CheckerBoardFactory.build_board_from_preset(
CheckerBoardPresets.standard_8_by_8))
for move in create_move_iterator_from_list_of_lists(
list_of_setup_moves):
test_game.make_move(move)
self.assertRaises(IllegalMoveException, test_game.make_move,
CheckersMove(illegal_move))
def test_verify_move_is_diagonal(self):
test_board = CheckerBoardFactory.build_board_from_preset(CheckerBoardPresets.standard_8_by_8)
test_game = CheckersGame(test_board)
self.assertTrue(test_game.verify_move_is_diagonal(CheckersMove([0, 0, 1, 1])))
self.assertTrue(test_game.verify_move_is_diagonal(CheckersMove([0, 0, 2, 2])))
self.assertFalse(test_game.verify_move_is_diagonal(CheckersMove([0, 0, 4, 2])))
self.assertTrue(test_game.verify_move_is_diagonal(CheckersMove([1, 1, 0, 0])))
self.assertTrue(test_game.verify_move_is_diagonal(CheckersMove([2, 2, 0, 0])))
self.assertFalse(test_game.verify_move_is_diagonal(CheckersMove([4, 2, 0, 0])))
def test_black_cant_move_backwards(self):
test_board = CheckerBoardFactory.build_board_from_preset(
CheckerBoardPresets.standard_8_by_8)
test_game = CheckersGame(test_board)
move_list = [[1, 2, 2, 3], [2, 5, 3, 4], [2, 3, 1, 4]]
team_iterator = self.team_iterator()
for move in create_move_iterator_from_list_of_lists(move_list):
test_game.make_move(move)
self.assertIsInstance(test_game.board[move.target],
CheckersGamePiece)
self.assertEqual(test_game.board[move.target].team,
next(team_iterator))
self.assertIsNone(test_game.board[move.source])
self.assertRaises(IllegalMoveException, test_game.make_move,
CheckersMove([3, 4, 2, 5]))
def test_board_dimensions(self):
test_board = CheckerBoardFactory.build_board_from_preset(
BoardPresetDataclass(8, 100, [(0, 0)], []))
test_board.move_piece(
CheckersMove([0, 0, 2, 2]).source,
CheckersMove([0, 0, 2, 2]).target)
test_board.move_piece(
CheckersMove([2, 2, 4, 11]).source,
CheckersMove([2, 2, 4, 11]).target)
self.assertRaises(OutOfBoardException, test_board.move_piece,
CheckersMove([4, 11, 11, 11]).source,
CheckersMove([4, 11, 11, 11]).target)
def test_extensive_possible_captures(self):
test_board = CheckerBoardFactory.build_board_from_preset(
BoardPresetDataclass(8, 8, [(7, 2), (6, 3), (4, 3), (3, 2),
(2, 3)], [(5, 4), (4, 5), (5, 6),
(6, 5)]))
test_game = CheckersGame(test_board)
test_game.switch_team_turn()
test_game.make_move(CheckersMove([4, 5, 3, 4]))
self.assertEqual(test_game.current_team, TeamEnum.white)
white_potential_captures = [[6, 3, 4, 5], [4, 3, 2, 5], [2, 3, 4, 5]]
black_potential_captures = [[3, 4, 1, 2], [3, 4, 5, 2]]
for move in create_move_iterator_from_list_of_lists(
white_potential_captures):
self.assertIn(move,
test_game.possible_capture_moves[TeamEnum.white])
for move in create_move_iterator_from_list_of_lists(
black_potential_captures):
self.assertIn(move,
test_game.possible_capture_moves[TeamEnum.black])
def test_check_if_there_is_a_piece_to_capture(self):
test_board = CheckerBoardFactory.build_board_from_preset(
CheckerBoardTestPresets.multi_capture_test_board_8_by_8)
test_game = CheckersGame(test_board)
self.assertTrue(
test_game.check_if_there_is_a_piece_to_capture(
CheckersMove([0, 0, 2, 2]), team=TeamEnum.white))
self.assertFalse(
test_game.check_if_there_is_a_piece_to_capture(
CheckersMove([0, 0, 2, 2]), team=TeamEnum.black))
test_game.board.set_up_pieces([(1, 2), (3, 4)], [(2, 3)])
self.assertTrue(
test_game.check_if_there_is_a_piece_to_capture(
CheckersMove([1, 2, 3, 4]), team=TeamEnum.white))
self.assertFalse(
test_game.check_if_there_is_a_piece_to_capture(
CheckersMove([3, 3, 5, 5]), TeamEnum.black))
self.assertFalse(
test_game.check_if_there_is_a_piece_to_capture(
CheckersMove([3, 3, 2, 2]), TeamEnum.black))
test_game.check_if_there_is_a_piece_to_capture(CheckersMove(
[0, 0, 2, 2]),
team=TeamEnum.white)
def test_find_move_type(self):
test_board = CheckerBoardFactory.build_board_from_preset(CheckerBoardPresets.standard_8_by_8)
test_game = CheckersGame(test_board)
self.assertEqual(test_game.find_move_type(CheckersMove([0, 0, 1, 1])), MoveTypeEnum.regular_move)
self.assertEqual(test_game.find_move_type(CheckersMove([0, 0, 2, 2])), MoveTypeEnum.capture)
self.assertEqual(test_game.find_move_type(CheckersMove([0, 0, 4, 2])), MoveTypeEnum.illegal_move)
def test_move_iterator_from_path(self):
move_iterator = create_move_iterator_from_move_file('games/white.txt')
self.assertEqual(next(move_iterator), CheckersMove([1, 2, 0, 3]))
self.assertEqual(next(move_iterator), CheckersMove([4, 5, 3, 4]))
def test_verify_move_is_valid(self):
test_game = CheckersGame(
CheckerBoardFactory.build_board_from_preset(
CheckerBoardPresets.standard_8_by_8))
self.assertRaises(IllegalMoveException, test_game.verify_move_is_valid,
CheckersMove([1, 0, 0, 1]), TeamEnum.white)
self.assertRaises(IllegalMoveException, test_game.verify_move_is_valid,
CheckersMove([0, 1, 2, 3]), TeamEnum.white)
self.assertRaises(IllegalMoveException, test_game.verify_move_is_valid,
CheckersMove([0, 1, 2, 3]), TeamEnum.white)
self.assertRaises(IllegalMoveException, test_game.verify_move_is_valid,
CheckersMove([0, 1, 2, 3]), TeamEnum.black)
self.assertRaises(IllegalMoveException, test_game.verify_move_is_valid,
CheckersMove([1, 2, 0, 3]), TeamEnum.black)
self.assertRaises(IllegalMoveException, test_game.verify_move_is_valid,
CheckersMove([1, 2, -1, 4]), TeamEnum.white)
test_game.board.remove_piece((4, 5))
self.assertRaises(IllegalMoveException, test_game.verify_move_is_valid,
CheckersMove([1, 2, 4, 5]), TeamEnum.white)
self.assertRaises(IllegalMoveException, test_game.verify_move_is_valid,
CheckersMove([7, 2, 5, 3]), TeamEnum.white)
test_game.verify_move_is_valid(CheckersMove([1, 2, 0, 3]),
TeamEnum.white)
test_game.verify_move_is_valid(CheckersMove([3, 2, 2, 3]),
TeamEnum.white)
test_game.verify_move_is_valid(CheckersMove([3, 2, 4, 3]),
TeamEnum.white)
test_game2 = CheckersGame(
CheckerBoardFactory.build_board_from_preset(
CheckerBoardTestPresets.multi_capture_test_board_8_by_8))
test_game2.verify_move_is_valid(CheckersMove([0, 0, 2, 2]),
TeamEnum.white)
test_game2.board.set_up_pieces([(5, 6)], [(4, 5)])
self.assertRaises(IllegalMoveException,
test_game2.verify_move_is_valid,
CheckersMove([5, 6, 6, 5]), TeamEnum.white)
self.assertRaises(IllegalMoveException,
test_game2.verify_move_is_valid,
CheckersMove([5, 6, 3, 4]), TeamEnum.white)
def test_verify_is_on_board(self):
test_board = CheckerBoardFactory.build_board_from_preset(BoardPresetDataclass(8, 100, [(0, 0)], []))
test_game = CheckersGame(test_board)
self.assertTrue(test_game.is_move_inside_board(CheckersMove([0, 0, 2, 2])))
self.assertTrue(test_game.is_move_inside_board(CheckersMove([2, 2, 4, 11])))
self.assertTrue(test_game.is_move_inside_board(CheckersMove([2, 2, 7, 99])))
self.assertFalse(test_game.is_move_inside_board(CheckersMove([4, 11, 11, 11])))
self.assertFalse(test_game.is_move_inside_board(CheckersMove([8, 100, 11, 11])))
self.assertFalse(test_game.is_move_inside_board(CheckersMove([7, 100, 11, 11])))
self.assertFalse(test_game.is_move_inside_board(CheckersMove([8, 99, 11, 11])))
self.assertFalse(test_game.is_move_inside_board(CheckersMove([-1, 99, 11, 11])))
self.assertFalse(test_game.is_move_inside_board(CheckersMove([5, -2, 11, 11])))
self.assertFalse(test_game.is_move_inside_board(CheckersMove([5, 5, 8, 100])))
self.assertFalse(test_game.is_move_inside_board(CheckersMove([5, 5, 7, 100])))
self.assertFalse(test_game.is_move_inside_board(CheckersMove([5, 5, 8, 99])))
self.assertFalse(test_game.is_move_inside_board(CheckersMove([5, 5, 5, -1])))
self.assertFalse(test_game.is_move_inside_board(CheckersMove([5, 5, -5, 55])))
def test_cant_move_to_occupied_space_by_same_team(self):
test_board = CheckerBoardFactory.build_board_from_preset(
CheckerBoardPresets.standard_8_by_8)
test_game = CheckersGame(test_board)
self.assertRaises(IllegalMoveException, test_game.make_move,
CheckersMove([1, 0, 0, 1]))
def test_verify_target_is_empty(self):
test_board = CheckerBoardFactory.build_board_from_preset(CheckerBoardPresets.standard_8_by_8)
test_game = CheckersGame(test_board, skip_scan_for_pieces_that_can_capture=True)
self.assertTrue(test_game.verify_target_is_empty(CheckersMove([2, 1, 1, 1])))
self.assertFalse(test_game.verify_target_is_empty(CheckersMove([1, 1, 2, 1])))