Implement method add_loops along with tests

squirrelbattle/mapgeneration/broguelike.py

@@ -6,7 +6,6 @@ from typing import List, Tuple
 
 from ..interfaces import Map, Tile
 
-
 DEFAULT_PARAMS = {
     "width": 120,
     "height": 35,
@@ -21,8 +20,28 @@ DEFAULT_PARAMS = {
     "max_h_corr": 12,
     "large_circular_room": .10,
     "circular_holes": .5,
+    "loop_tries" : 40,
+    "loop_max" : 5,
+    "loop_threshold" : 15,
 }
 
+def dist(level, y1, x1, y2, x2):
+    copy = [[t for t in l] for l in level]
+    dist = -1
+    queue, next_queue = [[y1, x1]], [0]
+    while next_queue:
+        next_queue = []
+        dist += 1
+        while queue:
+            y, x = queue.pop()
+            copy[y][x] = Tile.EMPTY
+            if y == y2 and x == x2: 
+                return dist
+            for y, x in Map.neighbourhood(copy, y, x):
+                if copy[y][x].can_walk():
+                    next_queue.append([y, x])
+        queue = next_queue
+    return -1
 
 class Generator:
     def __init__(self, params: dict = None):
@@ -66,6 +85,39 @@ class Generator:
                 if room[ry][rx] == Tile.FLOOR:
                     level[y - door_y + ry][x - door_x + rx] = Tile.FLOOR
 
+    @staticmethod
+    def add_loop(level: List[List[Tile]], y: int, x: int) -> None:
+        h, w = len(level), len(level[0])
+        if level[y][x] != Tile.EMPTY:
+            return False
+        # loop over both axis
+        for dx, dy in [[0, 1], [1, 0]]:
+            # then we find two floor tiles, exiting if we ever move oob
+            y1, x1, y2, x2 = y, x, y, x
+            while x1 >= 0 and y1 >= 0 and level[y1][x1] == Tile.EMPTY:
+                y1, x1 = y1 - dy, x1 - dx
+            while x2 < w and y2 < h and level[y2][x2] == Tile.EMPTY:
+                y2, x2 = y2 + dy, x2 + dx
+            if not(0 <= x1 <= x2 < w and 0 <= y1 <= y2 < h):
+                continue
+
+            # if adding the path would make the two tiles significantly closer
+            # and its sides don't touch already placed terrain, build it
+            def verify_sides():
+                for Dx, Dy in [[dy, dx], [-dy, -dx]]:
+                    for i in range(1, y2-y1+x2-x1):
+                        if not(0<= y1+Dy+i*dy < h and 0 <= x1+Dx+i*dx < w) or \
+                                level[y1+Dy+i*dy][x1+Dx+i*dx].can_walk():
+                            return False
+                return True
+            if dist(level, y1, x1, y2, x2) < 20 and verify_sides():
+                y, x = y1+dy, x1+dx
+                while level[y][x] == Tile.EMPTY:
+                    level[y][x] = Tile.FLOOR
+                    y, x = y+dy, x+dx
+                return True
+        return False
+
     @staticmethod
     def place_walls(level: List[List[Tile]]) -> None:
         h, w = len(level), len(level[0])
@@ -87,9 +139,29 @@ class Generator:
             return h_sup, w_sup, h_off, w_off
         return 0, 0, 0, 0
 
-    def attach_door(self, room: List[List[Tile]], h_sup: int, w_sup: int,
+    @staticmethod
-                    h_off: int, w_off: int) \
+    def build_door(room, y, x, dy, dx, length):
-            -> Tuple[int, int, int, int]:
+        rh, rw = len(room), len(room[0])
+        # verify we are pointing away from a floor tile
+        if not(0 <= y - dy < rh and 0 <= x - dx < rw) \
+                or room[y - dy][x - dx] != Tile.FLOOR:
+            return False
+        # verify there's no other floor tile around us
+        for ny, nx in [[y + dy, x + dx], [y - dx, x - dy],
+                       [y + dx, x + dy]]:
+            if 0 <= ny < rh and 0 <= nx < rw \
+                    and room[ny][nx] != Tile.EMPTY:
+                return False
+        for i in range(length):
+            if room[y + i * dy][x + i * dx] != Tile.EMPTY:
+                return False
+        for i in range(length):
+            room[y + i * dy][x + i * dx] = Tile.FLOOR
+        return True
+
+    @staticmethod
+    def attach_door(room: List[List[Tile]], h_sup: int, w_sup: int, 
+            h_off: int, w_off: int) -> Tuple[int, int, int, int]:
         length = h_sup + w_sup
         dy, dx = 0, 0
         if length > 0:
@@ -108,25 +180,10 @@ class Generator:
         shuffle(yxs)
         for pos in yxs:
             y, x = pos // rw, pos % rw
-            if room[y][x] == Tile.EMPTY:
+            if room[y][x] == Tile.EMPTY and \
-                # verify we are pointing away from a floor tile
+                    Generator.build_door(room, y, x, dy, dx, length):
-                if not(0 <= y - dy < rh and 0 <= x - dx < rw) \
-                        or room[y - dy][x - dx] != Tile.FLOOR:
-                    continue
-                # verify there's no other floor tile around us
-                for ny, nx in [[y + dy, x + dx], [y - dx, x - dy],
-                               [y + dx, x + dy]]:
-                    if 0 <= ny < rh and 0 <= nx < rw \
-                            and room[ny][nx] != Tile.EMPTY:
-                        break
-                else:
-                    for i in range(length):
-                        if room[y + i * dy][x + i * dx] != Tile.EMPTY:
-                            break
-                    else:
-                        for i in range(length):
-                            room[y + i * dy][x + i * dx] = Tile.FLOOR
                 break
+
         return y + length * dy, x + length * dx, dy, dx
 
     def create_circular_room(self) -> Tuple[List[List[Tile]], int, int,
@@ -204,6 +261,12 @@ class Generator:
 
         # post-processing
         self.place_walls(level)
+        tries, loops = 0, 0
+        while tries < self.params["loop_tries"] and \
+                loops < self.params["loop_max"]:
+            tries += 1
+            y, x = randint(0, height-1), randint(0, width-1)
+            loops += self.add_loop(level, y, x)
 
         # place an exit ladder
         y, x = randint(0, height - 1), randint(0, width - 1)

squirrelbattle/tests/mapgeneration_test.py

@@ -7,11 +7,19 @@ from typing import List
 
 from squirrelbattle.interfaces import Map, Tile
 from squirrelbattle.mapgeneration import broguelike
+from squirrelbattle.display.texturepack import TexturePack
 
 
 class TestBroguelike(unittest.TestCase):
     def setUp(self) -> None:
         self.generator = broguelike.Generator()
+        self.stom = lambda x : Map.load_from_string("0 0\n" + x)
+        self.mtos = lambda x : x.draw_string(TexturePack.ASCII_PACK)
+
+    def test_dist(self):
+        m = self.stom(".. ..\n ... ")
+        distance = broguelike.dist(m.tiles, 0, 0, 0, 4)
+        self.assertEqual(distance, 6)
 
     def is_connex(self, grid: List[List[Tile]]) -> bool:
         h, w = len(grid), len(grid[0])
@@ -29,3 +37,17 @@ class TestBroguelike(unittest.TestCase):
     def test_connexity(self) -> None:
         m = self.generator.run()
         self.assertTrue(self.is_connex(m.tiles))
+
+    def test_doors(self) -> None:
+        # corridors shouldn't loop back into the room
+        pass
+
+    def test_loops(self) -> None:
+        m = self.stom(3*"..   ..\n")
+        self.generator.add_loop(m.tiles, 1, 3)
+        s = self.mtos(m)
+        self.assertEqual(s, "..   ..\n.......\n..   ..")
+        self.assertFalse(self.generator.add_loop(m.tiles, 0, 0))
+        m = self.stom("...\n. .\n...")
+        self.assertFalse(self.generator.add_loop(m.tiles, 1, 1))
+