Refactor map generator package
- Move room generators to map.generators.room - Move corridor generators to map.generators.corridor Generators have a generate() method that generates the things they place, and an apply() method that applies their objects to a grid of tiles.
This commit is contained in:
parent
843aa2823f
commit
9a04692539
7 changed files with 391 additions and 262 deletions
29
erynrl/map/generator/__init__.py
Normal file
29
erynrl/map/generator/__init__.py
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
import numpy as np
|
||||
|
||||
from ..tile import Empty
|
||||
from .corridor import CorridorGenerator
|
||||
from .room import RoomGenerator
|
||||
|
||||
|
||||
class MapGenerator:
|
||||
'''Abstract base class defining an interface for generating a map and applying it to a set of tiles.'''
|
||||
|
||||
def generate(self, tiles: np.ndarray):
|
||||
raise NotImplementedError()
|
||||
|
||||
|
||||
class RoomsAndCorridorsGenerator(MapGenerator):
|
||||
'''
|
||||
Generates a classic "rooms and corridors" style map with the given room and corridor generators.
|
||||
'''
|
||||
|
||||
def __init__(self, room_generator: RoomGenerator, corridor_generator: CorridorGenerator):
|
||||
self.room_generator = room_generator
|
||||
self.corridor_generator = corridor_generator
|
||||
|
||||
def generate(self, tiles: np.ndarray):
|
||||
self.room_generator.generate()
|
||||
self.room_generator.apply(tiles)
|
||||
|
||||
self.corridor_generator.generate(self.room_generator.rooms)
|
||||
self.corridor_generator.apply(tiles)
|
||||
92
erynrl/map/generator/corridor.py
Normal file
92
erynrl/map/generator/corridor.py
Normal file
|
|
@ -0,0 +1,92 @@
|
|||
'''
|
||||
Defines an abstract CorridorGenerator and several concrete subclasses. These classes generate corridors between rooms.
|
||||
'''
|
||||
|
||||
import random
|
||||
from itertools import pairwise
|
||||
from typing import List
|
||||
|
||||
import tcod
|
||||
import numpy as np
|
||||
|
||||
from ... import log
|
||||
from ...geometry import Point
|
||||
from ..room import Room
|
||||
from ..tile import Empty, Floor, Wall
|
||||
|
||||
|
||||
class CorridorGenerator:
|
||||
'''
|
||||
Corridor generators produce corridors between rooms.
|
||||
'''
|
||||
|
||||
def generate(self, rooms: List[Room]) -> bool:
|
||||
'''Generate corridors given a list of rooms.'''
|
||||
raise NotImplementedError()
|
||||
|
||||
def apply(self, tiles: np.ndarray):
|
||||
'''Apply corridors to a tile grid.'''
|
||||
raise NotImplementedError()
|
||||
|
||||
|
||||
class ElbowCorridorGenerator(CorridorGenerator):
|
||||
'''
|
||||
Generators corridors using a simple "elbow" algorithm:
|
||||
|
||||
```
|
||||
For each pair of rooms:
|
||||
1. Find the midpoint of the bounding rect of each room
|
||||
2. Calculate an elbow point
|
||||
3. Draw a path from the midpoint of the first room to the elbow point
|
||||
4. Draw a path from the elbow point to the midpoint of the second room
|
||||
```
|
||||
'''
|
||||
|
||||
def __init__(self):
|
||||
self.corridors: List[List[Point]] = []
|
||||
|
||||
def generate(self, rooms: List[Room]) -> bool:
|
||||
for (left_room, right_room) in pairwise(rooms):
|
||||
left_room_bounds = left_room.bounds
|
||||
right_room_bounds = right_room.bounds
|
||||
|
||||
log.MAP.debug(' left: %s, %s', left_room, left_room_bounds)
|
||||
log.MAP.debug('right: %s, %s', right_room, right_room_bounds)
|
||||
|
||||
start_point = left_room_bounds.midpoint
|
||||
end_point = right_room_bounds.midpoint
|
||||
|
||||
# Randomly choose whether to move horizontally then vertically or vice versa
|
||||
if random.random() < 0.5:
|
||||
corner = Point(end_point.x, start_point.y)
|
||||
else:
|
||||
corner = Point(start_point.x, end_point.y)
|
||||
|
||||
log.MAP.debug('Digging a tunnel between %s and %s with corner %s', start_point, end_point, corner)
|
||||
log.MAP.debug('|-> start: %s', left_room_bounds)
|
||||
log.MAP.debug('`-> end: %s', right_room_bounds)
|
||||
|
||||
corridor: List[Point] = []
|
||||
|
||||
for x, y in tcod.los.bresenham(tuple(start_point), tuple(corner)).tolist():
|
||||
corridor.append(Point(x, y))
|
||||
for x, y in tcod.los.bresenham(tuple(corner), tuple(end_point)).tolist():
|
||||
corridor.append(Point(x, y))
|
||||
|
||||
self.corridors.append(corridor)
|
||||
|
||||
return True
|
||||
|
||||
def apply(self, tiles):
|
||||
for corridor in self.corridors:
|
||||
for pt in corridor:
|
||||
tiles[pt.x, pt.y] = Floor
|
||||
for neighbor in pt.neighbors:
|
||||
if not (0 <= neighbor.x < tiles.shape[0] and 0 <= neighbor.y < tiles.shape[1]):
|
||||
continue
|
||||
if tiles[neighbor.x, neighbor.y] == Empty:
|
||||
tiles[neighbor.x, neighbor.y] = Wall
|
||||
|
||||
|
||||
class NetHackCorridorGenerator(CorridorGenerator):
|
||||
'''A corridor generator that produces doors and corridors that look like Nethack's Dungeons of Doom levels.'''
|
||||
174
erynrl/map/generator/room.py
Normal file
174
erynrl/map/generator/room.py
Normal file
|
|
@ -0,0 +1,174 @@
|
|||
import random
|
||||
from dataclasses import dataclass
|
||||
from typing import List, Optional
|
||||
|
||||
import numpy as np
|
||||
import tcod
|
||||
|
||||
from ... import log
|
||||
from ...geometry import Direction, Point, Rect, Size
|
||||
from ..room import Room, RectangularRoom
|
||||
from ..tile import Empty, Floor, Wall
|
||||
|
||||
|
||||
class RoomGenerator:
|
||||
'''Abstract room generator class.'''
|
||||
|
||||
def __init__(self, *, size: Size):
|
||||
self.size = size
|
||||
self.rooms: List[Room] = []
|
||||
|
||||
def generate(self) -> bool:
|
||||
'''
|
||||
Generate a list of rooms.
|
||||
|
||||
Subclasses should implement this and fill in their specific map
|
||||
generation algorithm.
|
||||
|
||||
Returns
|
||||
-------
|
||||
np.ndarray
|
||||
A two-dimensional array of tiles. Dimensions should match the given size.
|
||||
'''
|
||||
raise NotImplementedError()
|
||||
|
||||
def apply(self, tiles: np.ndarray):
|
||||
'''
|
||||
Apply the generated list of rooms to an array of tiles. Subclasses must implement this.
|
||||
|
||||
Arguments
|
||||
---------
|
||||
tiles: np.ndarray
|
||||
The array of tiles to update.
|
||||
'''
|
||||
raise NotImplementedError()
|
||||
|
||||
|
||||
class BSPRoomGenerator(RoomGenerator):
|
||||
'''Generate a rooms-and-corridors style map with BSP.'''
|
||||
|
||||
@dataclass
|
||||
class Configuration:
|
||||
'''Configuration parameters for BSPRoomGenerator.'''
|
||||
|
||||
minimum_room_size: Size
|
||||
maximum_room_size: Size
|
||||
|
||||
DefaultConfiguration = Configuration(
|
||||
minimum_room_size=Size(7, 7),
|
||||
maximum_room_size=Size(20, 20),
|
||||
)
|
||||
|
||||
def __init__(self, *, size: Size, config: Optional[Configuration] = None):
|
||||
super().__init__(size=size)
|
||||
self.configuration = config if config else BSPRoomGenerator.DefaultConfiguration
|
||||
|
||||
self.rng: tcod.random.Random = tcod.random.Random()
|
||||
|
||||
self.rooms: List[RectangularRoom] = []
|
||||
self.tiles: Optional[np.ndarray] = None
|
||||
|
||||
def generate(self) -> bool:
|
||||
if self.rooms:
|
||||
return True
|
||||
|
||||
minimum_room_size = self.configuration.minimum_room_size
|
||||
maximum_room_size = self.configuration.maximum_room_size
|
||||
|
||||
# Recursively divide the map into squares of various sizes to place rooms in.
|
||||
bsp = tcod.bsp.BSP(x=0, y=0, width=self.size.width, height=self.size.height)
|
||||
|
||||
# Add 2 to the minimum width and height to account for walls
|
||||
gap_for_walls = 2
|
||||
bsp.split_recursive(
|
||||
depth=4,
|
||||
min_width=minimum_room_size.width + gap_for_walls,
|
||||
min_height=minimum_room_size.height + gap_for_walls,
|
||||
max_horizontal_ratio=1.1,
|
||||
max_vertical_ratio=1.1
|
||||
)
|
||||
|
||||
# Generate the rooms
|
||||
rooms: List['RectangularRoom'] = []
|
||||
|
||||
room_attrname = f'{__class__.__name__}.room'
|
||||
|
||||
for node in bsp.post_order():
|
||||
node_bounds = self.__rect_from_bsp_node(node)
|
||||
|
||||
if node.children:
|
||||
continue
|
||||
|
||||
log.MAP.debug('%s (room) %s', node_bounds, node)
|
||||
|
||||
# Generate a room size between minimum_room_size and maximum_room_size. The minimum value is
|
||||
# straight-forward, but the maximum value needs to be clamped between minimum_room_size and the size of
|
||||
# the node.
|
||||
width_range = (
|
||||
minimum_room_size.width,
|
||||
min(maximum_room_size.width, max(
|
||||
minimum_room_size.width, node.width - 2))
|
||||
)
|
||||
height_range = (
|
||||
minimum_room_size.height,
|
||||
min(maximum_room_size.height, max(
|
||||
minimum_room_size.height, node.height - 2))
|
||||
)
|
||||
|
||||
size = Size(self.rng.randint(*width_range),
|
||||
self.rng.randint(*height_range))
|
||||
origin = Point(node.x + self.rng.randint(1, max(1, node.width - size.width - 1)),
|
||||
node.y + self.rng.randint(1, max(1, node.height - size.height - 1)))
|
||||
bounds = Rect(origin, size)
|
||||
|
||||
log.MAP.debug('`-> %s', bounds)
|
||||
|
||||
room = RectangularRoom(bounds)
|
||||
setattr(node, room_attrname, room)
|
||||
rooms.append(room)
|
||||
|
||||
if not hasattr(node.parent, room_attrname):
|
||||
setattr(node.parent, room_attrname, room)
|
||||
elif random.random() < 0.5:
|
||||
setattr(node.parent, room_attrname, room)
|
||||
|
||||
# Pass up a random child room so that parent nodes can connect subtrees to each other.
|
||||
parent = node.parent
|
||||
if parent:
|
||||
node_room = getattr(node, room_attrname)
|
||||
if not hasattr(node.parent, room_attrname):
|
||||
setattr(node.parent, room_attrname, node_room)
|
||||
elif random.random() < 0.5:
|
||||
setattr(node.parent, room_attrname, node_room)
|
||||
|
||||
self.rooms = rooms
|
||||
|
||||
return True
|
||||
|
||||
def apply(self, tiles: np.ndarray):
|
||||
for room in self.rooms:
|
||||
for wall_position in room.walls:
|
||||
if tiles[wall_position.x, wall_position.y] != Floor:
|
||||
tiles[wall_position.x, wall_position.y] = Wall
|
||||
|
||||
bounds = room.bounds
|
||||
# The range of a numpy array slice is [a, b).
|
||||
floor_rect = bounds.inset_rect(top=1, right=1, bottom=1, left=1)
|
||||
tiles[floor_rect.min_x:floor_rect.max_x + 1,
|
||||
floor_rect.min_y:floor_rect.max_y + 1] = Floor
|
||||
|
||||
for y in range(self.size.height):
|
||||
for x in range(self.size.width):
|
||||
pos = Point(x, y)
|
||||
if tiles[x, y] != Floor:
|
||||
continue
|
||||
|
||||
neighbors = (pos + direction for direction in Direction.all())
|
||||
for neighbor in neighbors:
|
||||
if tiles[neighbor.x, neighbor.y] != Empty:
|
||||
continue
|
||||
tiles[neighbor.x, neighbor.y] = Wall
|
||||
|
||||
def __rect_from_bsp_node(self, node: tcod.bsp.BSP) -> Rect:
|
||||
'''Create a Rect from the given BSP node object'''
|
||||
return Rect(Point(node.x, node.y), Size(node.width, node.height))
|
||||
Loading…
Add table
Add a link
Reference in a new issue