def test_translate_error(self):
with self.assertRaises(ForbiddenCoordinates):
Board(3, 3).coordinates_to_index(-1, 0)
with self.assertRaises(ForbiddenCoordinates):
Board(3, 3).coordinates_to_index(0, -1)
with self.assertRaises(ForbiddenCoordinates):
Board(3, 3).coordinates_to_index(0, 3)
with self.assertRaises(ForbiddenCoordinates):
Board(3, 3).coordinates_to_index(3, 0)
def test_index_to_coord(self):
self.assertEquals(Board(3, 3).index_to_coordinates(0), (0, 0))
self.assertEquals(Board(3, 3).index_to_coordinates(1), (1, 0))
self.assertEquals(Board(3, 3).index_to_coordinates(2), (2, 0))
self.assertEquals(Board(3, 3).index_to_coordinates(3), (0, 1))
self.assertEquals(Board(3, 3).index_to_coordinates(4), (1, 1))
self.assertEquals(Board(3, 3).index_to_coordinates(5), (2, 1))
self.assertEquals(Board(3, 3).index_to_coordinates(6), (0, 2))
self.assertEquals(Board(3, 3).index_to_coordinates(7), (1, 2))
self.assertEquals(Board(3, 3).index_to_coordinates(8), (2, 2))
def solve(self):
""" Solve all possible positions of pieces within the context.
Depth-first, tree-traversal of the product space.
"""
# Create a new, empty board.
board = Board(self.length, self.height)
# Iterate through all combinations of positions.
permutations = Permutations(self.pieces, self.vector_size)
for positions in permutations:
# Reuse board but flush all pieces.
board.reset()
for level, (piece_uid, linear_position) in enumerate(positions):
# Try to place the piece on the board.
try:
board.add(piece_uid, linear_position)
# If one of the piece can't be added, throw the whole set, skip
# the rotten branch and proceed to the next.
except (OccupiedPosition, VulnerablePosition, AttackablePiece):
permutations.skip_branch(level)
break
else:
# All pieces fits, save solution and proceeed to the next
# permutation.
self.result_counter += 1
yield board
def __init__(self, agent, playercolour="Black"):
self.board = Board()
self.playercolour = playercolour
# Get Chess agent
self.chess_agent = agent
# set up parameters
self.gamma = 0.9 # E [0,1]
self.memsize = 2000
self.batch_size = 256
# set up arrays for estimation
self.reward_trace = []
self.balance_trace = []
# set up arrays for neural network learning
self.mem_state = np.zeros(shape=(1, 8, 8, 8))
self.mem_sucstate = np.zeros(shape=(1, 8, 8, 8))
self.mem_reward = np.zeros(shape=(1))
self.mem_error = np.zeros(shape=(1))
self.mem_episode_active = np.ones(shape=(1))
def test_territory(self):
""" Test computation of territory at each positions of a 3x3 board. """
board = Board(3, 3)
c2i = board.coordinates_to_index
self.assertEquals(
Knight(board, c2i(1, 1)).territory, [
False,
False,
False,
False,
True,
False,
False,
False,
False,
])
self.assertEquals(
Knight(board, c2i(0, 0)).territory, [
True,
False,
False,
False,
False,
True,
False,
True,
False,
])
self.assertEquals(
Knight(board, c2i(1, 0)).territory, [
False,
True,
False,
False,
False,
False,
True,
False,
True,
])
self.assertEquals(
Knight(board, c2i(2, 0)).territory, [
False,
False,
True,
True,
False,
False,
False,
True,
False,
])
self.assertEquals(
Knight(board, c2i(2, 1)).territory, [
True,
False,
False,
False,
False,
True,
True,
False,
False,
])
self.assertEquals(
Knight(board, c2i(2, 2)).territory, [
False,
True,
False,
True,
False,
False,
False,
False,
True,
])
self.assertEquals(
Knight(board, c2i(1, 2)).territory, [
True,
False,
True,
False,
False,
False,
False,
True,
False,
])
self.assertEquals(
Knight(board, c2i(0, 2)).territory, [
False,
True,
False,
False,
False,
True,
True,
False,
False,
])
self.assertEquals(
Knight(board, c2i(0, 1)).territory, [
False,
False,
True,
True,
False,
False,
False,
False,
True,
])
def test_index_to_coord_error(self):
with self.assertRaises(ForbiddenIndex):
Board(3, 3).index_to_coordinates(-1)
with self.assertRaises(ForbiddenIndex):
Board(3, 3).index_to_coordinates(9)
def test_long_index_to_coord(self):
self.assertEquals(Board(4, 1).index_to_coordinates(0), (0, 0))
self.assertEquals(Board(4, 1).index_to_coordinates(1), (1, 0))
self.assertEquals(Board(4, 1).index_to_coordinates(2), (2, 0))
self.assertEquals(Board(4, 1).index_to_coordinates(3), (3, 0))
def test_wide_index_to_coord(self):
self.assertEquals(Board(1, 4).index_to_coordinates(0), (0, 0))
self.assertEquals(Board(1, 4).index_to_coordinates(1), (0, 1))
self.assertEquals(Board(1, 4).index_to_coordinates(2), (0, 2))
self.assertEquals(Board(1, 4).index_to_coordinates(3), (0, 3))
def test_coord_to_index(self):
self.assertEquals(Board(3, 3).coordinates_to_index(0, 0), 0)
self.assertEquals(Board(3, 3).coordinates_to_index(1, 1), 4)
self.assertEquals(Board(3, 3).coordinates_to_index(2, 2), 8)
def test_all_positions(self):
self.assertEquals(list(Board(3, 3).positions), [
(0, 0), (1, 0), (2, 0),
(0, 1), (1, 1), (2, 1),
(0, 2), (1, 2), (2, 2)])
def listen(self, data):
if data.startswith(b"MATCH"):
self.board = Board(*self.args, b"WHITE" in data, self.finnish)
def __init__(self, playerW, playerB, display=True):
self._b = Board()
self._turn = WHITE
self._players = [playerW, playerB] #just so we can index to each player
self._display = display