Exemplo n.º 1
0
    def test_restrictions_maze1(self):
        node = Node(None).extend_path(
            [(2, 3), (2, 2), (1, 2), (1, 1), (0, 1), (0, 0), (-1, 0), (0, 0), (1, 0), (2, 0), (2, 1), (2, 2)])
        self.assertEqual(True, restrictions(node, 1))

        node = Node(None).extend_path(
            [(1, 2), (1, 1), (0, 1), (0, 0), (-1, 0), (0, 0), (1, 0), (2, 0), (2, 1), (2, 2)])
        self.assertEqual(False, restrictions(node, 1))

        node = Node(None).extend_path(
            [(2, 2), (1, 2), (1, 1), (0, 1), (0, 0), (-1, 0), (0, 0), (1, 0), (2, 0), (2, 1), (2, 2)])
        self.assertEqual(True, restrictions(node, 1))
Exemplo n.º 2
0
def _find_adjacents(adjacents, current_node, matrix, level):
    if current_node.position[0] > 0:  # adjacent above
        node = Node(((current_node.position[0] - 1),
                     (current_node.position[1]))).extend_path(
                         current_node.path).extend_path([
                             ((current_node.position[0] - 1),
                              (current_node.position[1]))
                         ])
        if matrix[node.position[0]][
                node.position[1]] != 1 and not restrictions(node, level):
            adjacents.append(node)
    if current_node.position[0] < (len(matrix[0]) - 1):  # adjacent below
        node = Node(((current_node.position[0] + 1),
                     (current_node.position[1]))).extend_path(
                         current_node.path).extend_path([
                             ((current_node.position[0] + 1),
                              (current_node.position[1]))
                         ])
        if matrix[node.position[0]][
                node.position[1]] != 1 and not restrictions(node, level):
            adjacents.append(node)
    if current_node.position[1] > 0:  # left adjacent
        node = Node(
            ((current_node.position[0]),
             (current_node.position[1] -
              1))).extend_path(current_node.path).extend_path([
                  ((current_node.position[0]), (current_node.position[1] - 1))
              ])
        if matrix[node.position[0]][
                node.position[1]] != 1 and not restrictions(node, level):
            adjacents.append(node)
    if current_node.position[1] < len(matrix[1]) - 1:  # right adjacent
        node = Node(
            ((current_node.position[0]),
             (current_node.position[1] +
              1))).extend_path(current_node.path).extend_path([
                  ((current_node.position[0]), (current_node.position[1] + 1))
              ])
        if matrix[node.position[0]][
                node.position[1]] != 1 and not restrictions(node, level):
            adjacents.append(node)
    return adjacents
Exemplo n.º 3
0
    def test_restrictions_maze5(self):
        self.assertEqual(False, restrictions(Node((0, 1)).extend_path([(0, 0), (0, 1)]), 5))

        self.assertEqual(True,
                         restrictions(Node((2, 2)).extend_path([(1, 1), (1, 2), (2, 2), (2, 1), (2, 2)]), 5))
        self.assertEqual(True, restrictions(Node((1, 1)).extend_path([(2, 0), (1, 0), (1, 1)]),
                                            5))
        self.assertEqual(False, restrictions(Node((0, 1)).extend_path([(1, 1), (1, 2), (0, 2)]), 5))

        self.assertEqual(True,
                         restrictions(Node((2, 0)).extend_path([(1, 0), (1, 1), (1, 2), (2, 2), (2, 1), (2, 0)]),
                                      5))
        self.assertEqual(True, restrictions(Node((0, 1)).extend_path([(0, 0), (1, 0), (1, 1), (0, 1)]), 5))
Exemplo n.º 4
0
 def test_restrictions_maze3(self):
     node = Node(None).extend_path([(0, 3), (1, 3), (2, 3), (2, 2), (2, 1), (2, 0), (1, 0), (1, 1), (1, 2)])
     self.assertEqual(False, restrictions(node, 3))
     node = Node(None).extend_path([(2, 2), (2, 1), (2, 0), (2, -1), (2, -2), (2, -3)])
     self.assertEqual(False, restrictions(node, 3))
     node = Node(None).extend_path(
         [(0, 0), (1, 0), (1, 1), (2, 1), (2, 2), (2, 1), (3, 1), (3, 0), (2, 0), (2, 1), (3, 1)])
     self.assertEqual(True, restrictions(node, 3))
     node = Node(None).extend_path(
         [(0, 0), (1, 0), (1, 1), (2, 1), (2, 2), (2, 1), (3, 1), (3, 0), (2, 0), (3, 0), (4, 0)])
     self.assertEqual(False, restrictions(node, 3))
     node = Node(None).extend_path(
         [(0, 0), (1, 0), (1, 1), (2, 1), (2, 2), (2, 3), (2, 4), (1, 4), (1, 3), (2, 3), (3, 2), (3, 3)])
     self.assertEqual(False, restrictions(node, 3))
     node = Node(None).extend_path(
         [(0, 0), (1, 0), (1, 1), (2, 1), (2, 2), (2, 3), (2, 4), (1, 4), (1, 3), (2, 3), (3, 2), (3, 3), (2, 3)])
     self.assertEqual(True, restrictions(node, 3))
     node = Node(None).extend_path(
         [(0, 0), (1, 0), (1, 1), (2, 1), (2, 2), (2, 3), (2, 4), (1, 4), (1, 3), (2, 3), (3, 3), (3, 4), (2, 4)])
     self.assertEqual(False, restrictions(node, 3))
     node = Node(None).extend_path(
         [(0, 0), (1, 0), (1, 1), (2, 1), (2, 2), (2, 3), (2, 4), (1, 4), (1, 3), (2, 3), (3, 3), (3, 4), (2, 4),
          (2, 3)])
     self.assertEqual(True, restrictions(node, 3))
Exemplo n.º 5
0
    def test_restrictions_maze4(self):
        node = Node(None).extend_path([]).extend_path([(0, 1)])
        self.assertEqual(False, restrictions(node, 4))

        node = Node(None).extend_path([(0, 0), (0, 1), (1, 1), (1, 2), (2, 2)])
        self.assertEqual(False, restrictions(node, 4))

        node = Node(None).extend_path([(0, 0), (0, 1), (1, 1), (1, 2), (2, 2), (2, 1)])
        self.assertEqual(False, restrictions(node, 4))

        node = Node(None).extend_path(
            [(0, 0), (0, 1), (1, 1), (1, 2), (2, 2), (2, 1), (2, 0), (1, 0), (1, 1), (0, 1)])
        self.assertEqual(False, restrictions(node, 4))

        node = Node(None).extend_path(
            [(0, 0), (1, 0), (2, 0), (2, 1), (1, 1), (1, 2), (0, 2), (1, 2), (1, 3)])
        self.assertEqual(False, restrictions(node, 4))

        node = Node(None).extend_path(
            [(0, 0), (1, 0), (2, 0), (2, 1), (1, 1), (1, 2), (0, 2), (1, 2), (1, 3), (2, 3)])
        self.assertEqual(False, restrictions(node, 4))

        node = Node(None).extend_path(
            [(2, 3), (2, 2), (2, 1), (2, 0), (1, 0), (0, 0), (1, 0), (2, 0), (2, 1), (2, 2)])
        self.assertEqual(True, restrictions(node, 4))

        node = Node(None).extend_path(
            [(2, 3), (2, 2), (1, 2), (1, 1), (0, 1), (0, 0), (-1, 0), (0, 0), (1, 0), (2, 0), (2, 1), (2, 2)])
        self.assertEqual(True, restrictions(node, 4))

        node = Node(None).extend_path(
            [(2, 3), (2, 2), (1, 2), (1, 1), (0, 1), (0, 0), (-1, 0), (-1, -1), (-2, -1)])
        self.assertEqual(False, restrictions(node, 4))

        node = Node(None).extend_path(
            [(2, 3), (2, 2), (1, 2), (1, 1), (0, 1), (0, 0), (-1, 0), (-1, -1), (-2, -1), (-2, -2), (-3, -2)])
        self.assertEqual(False, restrictions(node, 4))

        node = Node(None).extend_path(
            [(3, 4), (3, 3), (2, 3), (2, 2), (1, 2), (1, 1), (0, 1), (0, 0), (-1, 0), (-1, -1), (-2, -1), (-2, -2),
             (-3, -2)])
        self.assertEqual(False, restrictions(node, 4))

        node = Node(None).extend_path(
            [(3, 4), (3, 3), (2, 3), (2, 2), (1, 2), (1, 1), (0, 1), (0, 0), (-1, 0), (-1, -1), (-2, -1), (-2, -2),
             (-3, -2), (-2, -2), (-2, -1)])
        self.assertEqual(False, restrictions(node, 4))

        node = Node(None).extend_path(
            [(3, 4), (3, 3), (2, 3), (2, 2), (1, 2), (1, 1), (0, 1), (0, 0), (-1, 0), (-1, -1), (-2, -1), (-2, -2),
             (-3, -2), (-2, -2), (-2, -1), (-2, 0)])
        self.assertEqual(True, restrictions(node, 4))

        node = Node(None).extend_path([(3, 2), (2, 2), (1, 2), (1, 1), (1, 0), (0, 0), (0, -1), (0, 0)])
        self.assertEqual(True, restrictions(node, 4))

        node = Node(None).extend_path(
            [(2, 3), (3, 3), (3, 2), (2, 2), (1, 2), (1, 1), (1, 0), (0, 0), (0, -1), (0, 0)])
        self.assertEqual(True, restrictions(node, 4))

        node = Node(None).extend_path(
            [(3, 2), (2, 2), (1, 2), (1, 1), (1, 0), (1, 1), (0, 1), (0, 2), (-1, 2), (0, 2), (1, 2), (2, 2), (3, 2),
             (3, 3)])
        self.assertEqual(True, restrictions(node, 4))

        node = Node(None).extend_path(
            [(3, 2), (2, 2), (1, 2), (1, 1), (1, 0), (0, 0), (0, 1), (0, 2), (1, 2), (2, 2), (2, 3), (3, 3)])
        self.assertEqual(True, restrictions(node, 4))

        node = Node(None).extend_path(
            [(3, 2), (2, 2), (1, 2), (1, 1), (1, 0), (1, 1), (1, 2), (0, 2), (1, 2), (2, 2), (2, 3), (3, 3)])
        self.assertEqual(True, restrictions(node, 4))