Merge branch 'map_generation' into 'doors'

# Conflicts:
#   squirrelbattle/mapgeneration/broguelike.py

squirrelbattle/mapgeneration/broguelike.py

@@ -26,8 +26,11 @@ DEFAULT_PARAMS = {
     "spawn_per_region": [1, 2],
 }
 
-
+def dist(level, y1, x1, y2, x2):
-def dist(level: List[List[Tile]], y1: int, x1: int, y2: int, x2: int) -> int:
+    """
+    Compute the minimum walking distance between points (y1, x1) and (y2, x2) on a Tile grid
+    """
+    # simple breadth first search
     copy = [[t for t in row] for row in level]
     dist = -1
     queue, next_queue = [[y1, x1]], [0]
@@ -56,12 +59,19 @@ class Generator:
     def room_fits(level: List[List[Tile]], y: int, x: int,
                   room: List[List[Tile]], door_y: int, door_x: int,
                   dy: int, dx: int) -> bool:
+        """
+        Using point (door_y, door_x) in the room as a reference and placing it 
+        over point (y, x) in the level, returns whether or not the room fits
+        here 
+        """
         lh, lw = len(level), len(level[0])
         rh, rw = len(room), len(room[0])
         if not(0 < y + dy < lh and 0 < x + dx < lw):
             return False
+        # door must be placed on an empty tile, and point into a floor tile
         if level[y][x] != Tile.EMPTY or level[y + dy][x + dx] != Tile.FLOOR:
             return False
+        # now we verify floor tiles in both grids do not overlap
         for ry in range(rh):
             for rx in range(rw):
                 if room[ry][rx] == Tile.FLOOR:
@@ -82,6 +92,10 @@ class Generator:
     @staticmethod
     def place_room(level: List[List[Tile]], y: int, x: int,
                    room: List[List[Tile]], door_y: int, door_x: int) -> None:
+        """
+        Mutates level in place to add the room. Placement is determined by 
+        making (door_y, door_x) in the room correspond with (y, x) in the level
+        """
         rh, rw = len(room), len(room[0])
         level[y][x] = Tile.DOOR
         for ry in range(rh):
@@ -91,12 +105,20 @@ class Generator:
 
     @staticmethod
     def add_loop(level: List[List[Tile]], y: int, x: int) -> bool:
+        """
+        Try to add a corridor between two far apart floor tiles, passing 
+        through point (y, x).
+        """
         h, w = len(level), len(level[0])
+        
         if level[y][x] != Tile.EMPTY:
             return False
-        # loop over both axis
+
+        # loop over both directions, trying to place both veritcal
+        # and horizontal corridors
         for dx, dy in [[0, 1], [1, 0]]:
-            # then we find two floor tiles, exiting if we ever move oob
+            # then we find two floor tiles, one on each side of (y, x)
+            # exiting if we don't find two (reach the edge of the map before)
             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
@@ -105,9 +127,10 @@ class Generator:
             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() -> bool:
+                # switching up dy and dx here pivots the axis, so 
+                # (y+dx, x+dy) and (y-dx, x-dy) are the tiles adjacent to 
+                # (y, x), but not on the original axis
                 for delta_x, delta_y in [[dy, dx], [-dy, -dx]]:
                     for i in range(1, y2 - y1 + x2 - x1):
                         if not (0 <= y1 + delta_y + i * dy < h
@@ -117,6 +140,8 @@ class Generator:
                                 .can_walk():
                             return False
                 return True
+            # if adding the path would make the two tiles significantly closer
+            # and its sides don't touch already placed terrain, build it
             if dist(level, y1, x1, y2, x2) < 20 and verify_sides():
                 y, x = y1 + dy, x1 + dx
                 while level[y][x] == Tile.EMPTY:
@@ -127,6 +152,10 @@ class Generator:
 
     @staticmethod
     def place_walls(level: List[List[Tile]]) -> None:
+        """
+        Place wall tiles on every empty tile that is adjacent (in the largest
+        sense), to a floor tile
+        """
         h, w = len(level), len(level[0])
         for y in range(h):
             for x in range(w):
@@ -136,11 +165,25 @@ class Generator:
                             level[ny][nx] = Tile.WALL
 
     def corr_meta_info(self) -> Tuple[int, int, int, int]:
+        """
+        Return info about the extra grid space that should be allocated for the
+        room, and where the room should be built along this extra grid space.
+        Because grids are usually thight around the room, this gives us extra
+        place to add a corridor later. Corridor length and orientation is
+        implicitly derived from this info.
+
+        h_sup and w_sup represent the extra needed space along each axis,
+        and h_off and w_off are the offset at which to build the room
+        """
         if random() < self.params["corridor_chance"]:
             h_sup = randint(self.params["min_v_corr"],
                             self.params["max_v_corr"]) if random() < .5 else 0
+            # we only allow extra space allocation along one axis,
+            # because there won't more than one exit corridor
             w_sup = 0 if h_sup else randint(self.params["min_h_corr"],
                                             self.params["max_h_corr"])
+            # implicitly choose which direction along the axis
+            # the corridor will be pointing to
             h_off = h_sup if random() < .5 else 0
             w_off = w_sup if random() < .5 else 0
             return h_sup, w_sup, h_off, w_off
@@ -149,6 +192,12 @@ class Generator:
     @staticmethod
     def build_door(room: List[List[Tile]], y: int, x: int,
                    dy: int, dx: int, length: int) -> bool:
+        """
+        Tries to build the exit from the room at given coordinates
+        Depending on parameter length, it will either attempt to build a 
+        simple door, or a long corridor.  Return value is a boolean 
+        signifying whether or not the exit was successfully built
+        """
         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) \
@@ -160,6 +209,7 @@ class Generator:
             if 0 <= ny < rh and 0 <= nx < rw \
                     and room[ny][nx] != Tile.EMPTY:
                 return False
+        # see if the path ahead is clear. needed in the case of non convex room
         for i in range(length + 1):
             if room[y + i * dy][x + i * dx] != Tile.EMPTY:
                 return False
@@ -170,6 +220,10 @@ class Generator:
     @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]:
+        """
+        Attach an exit to the room. If extra space was allocated to
+        the grid, make sure a corridor is properly built
+        """
         length = h_sup + w_sup
         dy, dx = 0, 0
         if length > 0:
@@ -178,11 +232,13 @@ class Generator:
             else:
                 dx = -1 if w_off else 1
         else:
+            # determine door direction for rooms without corridors
             if random() < .5:
                 dy = -1 if random() < .5 else 1
             else:
                 dx = -1 if random() < .5 else 1
 
+        # loop over all possible positions in a random order
         rh, rw = len(room), len(room[0])
         yxs = [i for i in range(rh * rw)]
         shuffle(yxs)
@@ -191,11 +247,18 @@ class Generator:
             if room[y][x] == Tile.EMPTY and \
                     Generator.build_door(room, y, x, dy, dx, length):
                 break
+        else:
+            return None, None
 
         return y + length * dy, x + length * dx, dy, dx
 
     def create_circular_room(self, spawnable: bool = True) \
             -> Tuple[List[List[Tile]], int, int, int, int]:
+        """
+        Create and return as a tile grid a room that is circular in shape, and 
+        may have a center, also circular hole
+        Also return door info so we know how to place the room in the level
+        """
         if random() < self.params["large_circular_room"]:
             r = randint(5, 10)
         else:
@@ -222,8 +285,11 @@ class Generator:
                 else:
                     room[-1].append(Tile.EMPTY)
 
+        # log all placed tiles as spawn positions
         if spawnable:
             self.register_spawn_area(room)
+
+        # attach exit
         door_y, door_x, dy, dx = self.attach_door(room, h_sup, w_sup,
                                                   h_off, w_off)
 
@@ -231,9 +297,18 @@ class Generator:
 
     def create_random_room(self, spawnable: bool = True) \
             -> Tuple[List[list], int, int, int, int]:
+        """
+        Randomly select a room shape and return one such room along with its 
+        door info. Set spawnable to False is the room should be marked as a
+        potential spawning region on the map
+        """
         return self.create_circular_room()
 
     def register_spawn_area(self, area: List[List[Tile]]) -> None:
+        """
+        Register all floor positions relative to the input grid
+        for later use
+        """
         spawn_positions = []
         for y, line in enumerate(area):
             for x, tile in enumerate(line):
@@ -242,12 +317,27 @@ class Generator:
         self.queued_area = spawn_positions
 
     def update_spawnable(self, y: int, x: int) -> None:
-        if self.queued_area is not None:
+        """
+        Convert previous spawn positions relative to the room grid to actual
+        actual spawn positions on the level grid, using the position of the 
+        top left corner of the room on the level, then log them as a 
+        spawnable region
+        """
+        if self.queued_area != None:
             translated_area = [[y+ry, x+rx] for ry, rx in self.queued_area]
             self.spawn_areas.append(translated_area)
         self.queued_area = None
 
     def populate(self, rv: Map) -> None:
+        """
+        Populate every spawnable area with some randomly chosen, randomly
+        placed entity
+        """
+        if self.queued_area is not None:
+            translated_area = [[y + ry, x + rx] for ry, rx in self.queued_area]
+            self.spawn_areas.append(translated_area)
+        self.queued_area = None
+
         min_c, max_c = self.params["spawn_per_region"]
         for region in self.spawn_areas:
             entity_count = randint(min_c, max_c)
@@ -259,6 +349,10 @@ class Generator:
                 rv.add_entity(entity)
 
     def run(self) -> Map:
+        """
+        Using procedural generation, build and return a full map, populated
+        with entities
+        """
         height, width = self.params["height"], self.params["width"]
         level = [width * [Tile.EMPTY] for _ignored in range(height)]
 
@@ -266,24 +360,30 @@ class Generator:
         mem, self.params["corridor_chance"] = self.params["corridor_chance"], 0
         starting_room, _, _, _, _ = self.create_random_room(spawnable=False)
         dim_v, dim_h = len(starting_room), len(starting_room[0])
+        # because Generator.room_fits checks that the exit door is correctly
+        # placed, but the starting room has no exit door, we find a positoin
+        # manually
         pos_y, pos_x = randint(0, height - dim_v - 1),\
             randint(0, width - dim_h - 1)
         self.place_room(level, pos_y, pos_x, starting_room, 0, 0)
+        # remove the door that was placed
         if starting_room[0][0] != Tile.FLOOR:
             level[pos_y][pos_x] = Tile.EMPTY
         self.params["corridor_chance"] = mem
 
-        # find a starting position
+        # find a starting position for the player
         sy, sx = randint(0, height - 1), randint(0, width - 1)
         while level[sy][sx] != Tile.FLOOR:
             sy, sx = randint(0, height - 1), randint(0, width - 1)
         level[sy][sx] = Tile.LADDER
 
-        # now we loop until we've tried enough, or we've added enough rooms
+        # now we loop until we're bored, or we've added enough rooms
         tries, rooms_built = 0, 0
         while tries < self.params["tries"] \
                 and rooms_built < self.params["max_rooms"]:
 
+            # build a room, try to fit it everywhere in a random order, and
+            # place it at the first possible position
             room, door_y, door_x, dy, dx = self.create_random_room()
             positions = [i for i in range(height * width)]
             shuffle(positions)
@@ -298,6 +398,12 @@ class Generator:
 
         # post-processing
         self.place_walls(level)
+
+        # because when a room is placed, it leads to exactly one previously
+        # placed room, the level has a tree like structure with the starting
+        # room as the root
+        # to avoid boring player backtracking, we add some cycles to the room
+        # graph in post processing by placing additional corridors
         tries, loops = 0, 0
         while tries < self.params["loop_tries"] and \
                 loops < self.params["loop_max"]: