def test_move_basic(self):
board_size = (3, 3)
agent_pos = (1, 1)
tiles_pos = {'A': (0, 0), 'B': (0, 0), 'C': (0, 0)}
board = BoardState(agent_pos, tiles_pos, board_size)
a_pos = tiles_pos['A']
b_pos = tiles_pos['B']
c_pos = tiles_pos['C']
new_board_up = board.move(Action.Up)
new_board_down = board.move(Action.Down)
new_board_left = board.move(Action.Left)
new_board_right = board.move(Action.Right)
self.assertEqual(new_board_up.agent_pos,
(agent_pos[0], agent_pos[1] - 1))
self.assertEqual(new_board_up.get_tile_pos('A'), a_pos)
self.assertEqual(new_board_up.get_tile_pos('B'), b_pos)
self.assertEqual(new_board_up.get_tile_pos('C'), c_pos)
self.assertEqual(new_board_down.agent_pos,
(agent_pos[0], agent_pos[1] + 1))
self.assertEqual(new_board_down.get_tile_pos('A'), a_pos)
self.assertEqual(new_board_down.get_tile_pos('B'), b_pos)
self.assertEqual(new_board_down.get_tile_pos('C'), c_pos)
self.assertEqual(new_board_left.agent_pos,
(agent_pos[0] - 1, agent_pos[1]))
self.assertEqual(new_board_left.get_tile_pos('A'), a_pos)
self.assertEqual(new_board_left.get_tile_pos('B'), b_pos)
self.assertEqual(new_board_left.get_tile_pos('C'), c_pos)
self.assertEqual(new_board_right.agent_pos,
(agent_pos[0] + 1, agent_pos[1]))
self.assertEqual(new_board_right.get_tile_pos('A'), a_pos)
self.assertEqual(new_board_right.get_tile_pos('B'), b_pos)
self.assertEqual(new_board_right.get_tile_pos('C'), c_pos)
def test_move_invalid(self):
board_size = (3, 3)
tiles_pos = {'A': (0, 0), 'B': (0, 0), 'C': (0, 0)}
agent_pos = (0, 0)
agent_pos_2 = (2, 2)
board = BoardState(agent_pos, tiles_pos, board_size)
board_2 = BoardState(agent_pos_2, tiles_pos, board_size)
self.assertIsNone(board.move(Action.Up))
self.assertIsNone(board.move(Action.Left))
self.assertIsNone(board_2.move(Action.Down))
self.assertIsNone(board_2.move(Action.Right))
def test_expand_generate_only_available_moves(self):
board = BoardState((2, 1), {
'A': (0, 0),
'B': (0, 2),
'C': (2, 2)
}, (3, 3))
node = Node(board, 0, 0, Action.Unknown)
tree_search = AbstractTreeSearch(board, board)
successors = tree_search.expand(node)
self.assertTrue(len(successors) == 3)
child_up = Node(board.move(Action.Up), 1, 1, Action.Up)
child_down = Node(board.move(Action.Down), 1, 1, Action.Down)
child_left = Node(board.move(Action.Left), 1, 1, Action.Left)
self.assertTrue(child_up in successors)
self.assertTrue(child_down in successors)
self.assertTrue(child_left in successors)
def test_move_to_tile(self):
"""
- - A
- B ☺
- - C
"""
board_size = (3, 3)
tiles_pos = {'A': (2, 0), 'B': (1, 1), 'C': (2, 2)}
agent_pos = (2, 1)
a_pos = tiles_pos['A']
b_pos = tiles_pos['B']
c_pos = tiles_pos['C']
board = BoardState(agent_pos, tiles_pos, board_size)
new_board_1 = board.move(Action.Up) # Move onto A
new_board_2 = board.move(Action.Left) # Move onto B
new_board_3 = board.move(Action.Down) # Move onto C
self.assertEqual(new_board_1.agent_pos, a_pos)
self.assertEqual(new_board_1.get_tile_pos('A'), agent_pos)
self.assertEqual(new_board_2.agent_pos, b_pos)
self.assertEqual(new_board_2.get_tile_pos('B'), agent_pos)
self.assertEqual(new_board_3.agent_pos, c_pos)
self.assertEqual(new_board_3.get_tile_pos('C'), agent_pos)
