def test_cell_swap(board_with_1_chain):
# swapping a board's cell with another should only affect the source and target cells
original = board_with_1_chain
swapped_board = Board.copy_board(original)
# swap corners where the two pieces are different
swapped_board.swap(0, 0, 4, 5)
matching = [
swapped_board.cell(r, c)
for c in range(original.columns) for r in range(original.rows)
if isinstance(original.cell(r, c), type(swapped_board.cell(r, c))) and original.cell(r, c).location == swapped_board.cell(r, c).location
]
assert len(matching) == 28, "Swapping upper left corner with lower right corner of board yielded match counts!"
assert swapped_board.cell(0, 0).location == (0, 0), "Swapped piece @ 0,0 has invalid location!"
assert swapped_board.cell(4, 5).location == (4, 5), "Swapped piece @ 4,5 has invalid location!"
assert isinstance(swapped_board.cell(0, 0), type(original.cell(4, 5))), "Swapped piece @ 0,0 does not match original piece @ 4,5!"
assert isinstance(swapped_board.cell(4, 5), type(original.cell(0, 0))), "Swapped piece @ 4,5 does not match original piece @ 0,0!"
# swap multiple times should yield expected results
original = Board.create_randomized_board(5, 6)
swapped_board = Board.copy_board(original)
swapped_board.swap(0, 0, 1, 1)
swapped_board.swap(1, 1, 2, 2)
swapped_board.swap(2, 2, 3, 3)
swapped_board.swap(3, 3, 4, 4)
assert isinstance(swapped_board.cell(0, 0), type(original.cell(1, 1))), "Swapped piece @ 0,0 does not match original @ 1,1"
assert isinstance(swapped_board.cell(1, 1), type(original.cell(2, 2))), "Swapped piece @ 1,1 does not match original @ 2,2"
assert isinstance(swapped_board.cell(2, 2), type(original.cell(3, 3))), "Swapped piece @ 2,2 does not match original @ 3,3"
assert isinstance(swapped_board.cell(3, 3), type(original.cell(4, 4))), "Swapped piece @ 3,3 does not match original @ 4,4"
assert isinstance(swapped_board.cell(4, 4), type(original.cell(0, 0))), "Swapped piece @ 4,4 does not match original @ 0,0"
def test_cell_swap(board_with_1_chain):
# swapping a board's cell with another should only affect the source and target cells
original = board_with_1_chain
swapped_board = Board.copy_board(original)
# swap corners where the two pieces are different
swapped_board.swap(0, 0, 4, 5)
matching = [
swapped_board.cell(r, c) for c in range(original.columns)
for r in range(original.rows)
if isinstance(original.cell(r, c), type(swapped_board.cell(r, c)))
and original.cell(r, c).location == swapped_board.cell(r, c).location
]
assert len(
matching
) == 28, "Swapping upper left corner with lower right corner of board yielded match counts!"
assert swapped_board.cell(
0, 0).location == (0, 0), "Swapped piece @ 0,0 has invalid location!"
assert swapped_board.cell(
4, 5).location == (4, 5), "Swapped piece @ 4,5 has invalid location!"
assert isinstance(swapped_board.cell(0, 0), type(original.cell(
4, 5))), "Swapped piece @ 0,0 does not match original piece @ 4,5!"
assert isinstance(swapped_board.cell(4, 5), type(original.cell(
0, 0))), "Swapped piece @ 4,5 does not match original piece @ 0,0!"
# swap multiple times should yield expected results
original = Board.create_randomized_board(5, 6)
swapped_board = Board.copy_board(original)
swapped_board.swap(0, 0, 1, 1)
swapped_board.swap(1, 1, 2, 2)
swapped_board.swap(2, 2, 3, 3)
swapped_board.swap(3, 3, 4, 4)
assert isinstance(swapped_board.cell(0, 0), type(original.cell(
1, 1))), "Swapped piece @ 0,0 does not match original @ 1,1"
assert isinstance(swapped_board.cell(1, 1), type(original.cell(
2, 2))), "Swapped piece @ 1,1 does not match original @ 2,2"
assert isinstance(swapped_board.cell(2, 2), type(original.cell(
3, 3))), "Swapped piece @ 2,2 does not match original @ 3,3"
assert isinstance(swapped_board.cell(3, 3), type(original.cell(
4, 4))), "Swapped piece @ 3,3 does not match original @ 4,4"
assert isinstance(swapped_board.cell(4, 4), type(original.cell(
0, 0))), "Swapped piece @ 4,4 does not match original @ 0,0"
def test_copy_board():
# copying a board produces another board with same setup as original
original = Board.create_randomized_board(5, 6)
copy = Board.copy_board(original)
assert original.rows == copy.rows, "Copied board's rows do not match original!"
assert original.columns == copy.columns, "Copied board's columns do not match original!"
matching = [copy.cell(r, c)
for c in range(original.columns) for r in range(original.rows)
if isinstance(original.cell(r, c), type(copy.cell(r, c))) and original.cell(r, c).location == copy.cell(r, c).location]
assert len(matching) == 30, "Copied board's board does not match original!"
def test_cell_update():
# updating a board's cell should update that cell only
original = Board.create_randomized_board(5, 6)
updated_board = Board.copy_board(original).update(3, 4, Jammer)
matching = [
updated_board.cell(r, c)
for c in range(original.columns) for r in range(original.rows)
if isinstance(original.cell(r, c), type(updated_board.cell(r, c))) and original.cell(r, c).location == updated_board.cell(r, c).location
]
assert len(matching) == 29, "Updating board did not yield expected matching cells with original board!"
assert isinstance(updated_board.cell(3, 4), Jammer), "Piece @ 3,4 was not updated to correct piece!"
def _step(self, solutions, depth):
if depth == 0:
return solutions
else:
next_solutions = []
for score, moves, board, row, column in solutions:
for delta_r, delta_c in self._swaps(board, row, column):
swapped_board = Board.copy_board(board).swap(row, column, row + delta_r, column + delta_c)
next_solutions.append((score + self._score(swapped_board), (moves + ((delta_r, delta_c),)), swapped_board, row + delta_r, column + delta_c))
# prune solutions down before recursing to next depth
return self._step(self._prune(next_solutions), depth - 1)
def test_copy_board():
# copying a board produces another board with same setup as original
original = Board.create_randomized_board(5, 6)
copy = Board.copy_board(original)
assert original.rows == copy.rows, "Copied board's rows do not match original!"
assert original.columns == copy.columns, "Copied board's columns do not match original!"
matching = [
copy.cell(r, c) for c in range(original.columns)
for r in range(original.rows)
if isinstance(original.cell(r, c), type(copy.cell(r, c)))
and original.cell(r, c).location == copy.cell(r, c).location
]
assert len(matching) == 30, "Copied board's board does not match original!"
def _step(self, score, moves, board, row, column, depth):
if depth == 0:
return (score, moves, board)
else:
# get possible swaps from current row, column position
swaps = self._swaps(board, row, column)
solutions = []
for delta_r, delta_c in swaps:
swapped_board = Board.copy_board(board).swap(row, column, row + delta_r, column + delta_c)
solutions.append((self._score(swapped_board), swapped_board, (delta_r, delta_c)))
# calculate score on all possible swaps and order them from highest to lowest. recurse into the highest one
best = max(solutions, key=lambda x: x[0])
return self._step(score + best[0], (moves + (best[2],)), best[1], row + best[2][0], column + best[2][1], depth - 1)
def test_cell_update():
# updating a board's cell should update that cell only
original = Board.create_randomized_board(5, 6)
updated_board = Board.copy_board(original).update(3, 4, Jammer)
matching = [
updated_board.cell(r, c) for c in range(original.columns)
for r in range(original.rows)
if isinstance(original.cell(r, c), type(updated_board.cell(r, c)))
and original.cell(r, c).location == updated_board.cell(r, c).location
]
assert len(
matching
) == 29, "Updating board did not yield expected matching cells with original board!"
assert isinstance(updated_board.cell(3, 4),
Jammer), "Piece @ 3,4 was not updated to correct piece!"
def _step(self, score, moves, board, row, column, depth):
if depth == 0:
return (score, moves, board)
else:
# get possible swaps from current row, column position
swaps = self._swaps(board, row, column)
solutions = []
for delta_r, delta_c in swaps:
swapped_board = Board.copy_board(board).swap(row, column, row + delta_r, column + delta_c)
if self._remember(swapped_board):
# only add move to solutions if it is a board layout that has not been seen before
solutions.append((self._score(swapped_board), swapped_board, (delta_r, delta_c)))
if solutions:
# calculate score on all possible swaps and order them from highest to lowest. recurse into the highest one
best = max(solutions, key=lambda x: x[0])
return self._step(score + best[0], (moves + (best[2],)), best[1], row + best[2][0], column + best[2][1], depth - 1)
else:
return (score, moves, board)
def _step(self, solutions, depth):
if depth == 0:
return solutions
else:
next_solutions = []
for score, moves, board, row, column in solutions:
for delta_r, delta_c in self._swaps(board, row, column):
swapped_board = Board.copy_board(board).swap(
row, column, row + delta_r, column + delta_c)
if self._remember(swapped_board):
# only add move to solutions if it is a board layout that has not been seen before
next_solutions.append(
(score + self._score(swapped_board),
(moves + ((delta_r, delta_c), )), swapped_board,
row + delta_r, column + delta_c))
if next_solutions:
# prune solutions down before recursing to next depth
return self._step(self._prune(next_solutions), depth - 1)
else:
return solutions
