263 lines
10 KiB
Python
263 lines
10 KiB
Python
# Eryn Wells <eryn@erynwells.me>
|
|
|
|
import random
|
|
from dataclasses import dataclass
|
|
from typing import Iterator, List, Optional
|
|
|
|
import numpy as np
|
|
import tcod
|
|
|
|
from . import log
|
|
from .geometry import Direction, Point, Rect, Size
|
|
from .tile import Empty, Floor, Shroud, Wall
|
|
|
|
class Map:
|
|
def __init__(self, size: Size):
|
|
self.size = size
|
|
|
|
self.generator = RoomsAndCorridorsGenerator(size=size)
|
|
self.tiles = self.generator.generate()
|
|
|
|
# Map tiles that are currently visible to the player
|
|
self.visible = np.full(tuple(self.size), fill_value=False, order='F')
|
|
# Map tiles that the player has explored
|
|
self.explored = np.full(tuple(self.size), fill_value=False, order='F')
|
|
|
|
@property
|
|
def rooms(self) -> List['Room']:
|
|
'''The list of rooms in the map'''
|
|
return self.generator.rooms
|
|
|
|
def random_walkable_position(self) -> Point:
|
|
# TODO: Include hallways
|
|
random_room: RectangularRoom = random.choice(self.rooms)
|
|
floor: List[Point] = list(random_room.walkable_tiles)
|
|
random_position_in_room = random.choice(floor)
|
|
return random_position_in_room
|
|
|
|
def tile_is_in_bounds(self, point: Point) -> bool:
|
|
'''Return True if the given point is inside the bounds of the map'''
|
|
return 0 <= point.x < self.size.width and 0 <= point.y < self.size.height
|
|
|
|
def tile_is_walkable(self, point: Point) -> bool:
|
|
'''Return True if the tile at the given point is walkable'''
|
|
return self.tiles[point.x, point.y]['walkable']
|
|
|
|
def print_to_console(self, console: tcod.Console) -> None:
|
|
'''Render the map to the console.'''
|
|
size = self.size
|
|
|
|
# If a tile is in the visible array, draw it with the "light" color. If it's not, but it's in the explored
|
|
# array, draw it with the "dark" color. Otherwise, draw it as Empty.
|
|
console.tiles_rgb[0:size.width, 0:size.height] = np.select(
|
|
condlist=[self.visible, self.explored],
|
|
choicelist=[self.tiles['light'], self.tiles['dark']],
|
|
default=Shroud)
|
|
|
|
class MapGenerator:
|
|
def __init__(self, *, size: Size):
|
|
self.size = size
|
|
self.rooms: List['Room'] = []
|
|
|
|
def generate(self) -> np.ndarray:
|
|
'''
|
|
Generate a tile grid
|
|
|
|
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()
|
|
|
|
class RoomsAndCorridorsGenerator(MapGenerator):
|
|
'''Generate a rooms-and-corridors style map with BSP.'''
|
|
|
|
@dataclass
|
|
class Configuration:
|
|
minimum_room_size: Size
|
|
maximum_room_size: Size
|
|
|
|
DefaultConfiguration = Configuration(
|
|
minimum_room_size=Size(5, 5),
|
|
maximum_room_size=Size(15, 15),
|
|
)
|
|
|
|
def __init__(self, *, size: Size, config: Optional[Configuration] = None):
|
|
super().__init__(size=size)
|
|
self.configuration = config if config else RoomsAndCorridorsGenerator.DefaultConfiguration
|
|
|
|
self.rng: tcod.random.Random = tcod.random.Random()
|
|
|
|
self.rooms: List['RectangularRoom'] = []
|
|
self.tiles: Optional[np.ndarray] = None
|
|
|
|
def generate(self) -> np.ndarray:
|
|
if self.tiles:
|
|
return self.tiles
|
|
|
|
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)
|
|
bsp.split_recursive(
|
|
depth=4,
|
|
# Add 2 to the minimum width and height to account for walls
|
|
min_width=minimum_room_size.width + 2, min_height=minimum_room_size.height + 2,
|
|
max_horizontal_ratio=3, max_vertical_ratio=3)
|
|
|
|
tiles = np.full(tuple(self.size), fill_value=Empty, order='F')
|
|
|
|
# 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:
|
|
log.MAP.debug(node_bounds)
|
|
|
|
left_room: RectangularRoom = getattr(node.children[0], room_attrname)
|
|
right_room: RectangularRoom = getattr(node.children[1], room_attrname)
|
|
|
|
left_room_bounds = left_room.bounds
|
|
right_room_bounds = right_room.bounds
|
|
|
|
log.MAP.debug(' left: %s, %s', node.children[0], left_room_bounds)
|
|
log.MAP.debug('right: %s, %s', node.children[1], 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)
|
|
|
|
for x, y in tcod.los.bresenham(tuple(start_point), tuple(corner)).tolist():
|
|
tiles[x, y] = Floor
|
|
for x, y in tcod.los.bresenham(tuple(corner), tuple(end_point)).tolist():
|
|
tiles[x, y] = Floor
|
|
else:
|
|
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
|
|
|
|
for room in 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
|
|
|
|
self.tiles = tiles
|
|
|
|
return tiles
|
|
|
|
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))
|
|
|
|
class Room:
|
|
'''An abstract room. It can be any size or shape.'''
|
|
|
|
@property
|
|
def walkable_tiles(self) -> Iterator[Point]:
|
|
raise NotImplementedError()
|
|
|
|
class RectangularRoom(Room):
|
|
'''A rectangular room defined by a Rect.
|
|
|
|
Attributes
|
|
----------
|
|
bounds : Rect
|
|
A rectangle that defines the room. This rectangle includes the tiles used for the walls, so the floor is 1 tile
|
|
inset from the bounds.
|
|
'''
|
|
|
|
def __init__(self, bounds: Rect):
|
|
self.bounds = bounds
|
|
|
|
@property
|
|
def center(self) -> Point:
|
|
'''The center of the room, truncated according to integer math rules'''
|
|
return self.bounds.midpoint
|
|
|
|
@property
|
|
def walkable_tiles(self) -> Rect:
|
|
floor_rect = self.bounds.inset_rect(top=1, right=1, bottom=1, left=1)
|
|
for y in range(floor_rect.min_y, floor_rect.max_y + 1):
|
|
for x in range(floor_rect.min_x, floor_rect.max_x + 1):
|
|
yield Point(x, y)
|
|
|
|
@property
|
|
def walls(self) -> Iterator[Point]:
|
|
bounds = self.bounds
|
|
min_y = bounds.min_y
|
|
max_y = bounds.max_y
|
|
min_x = bounds.min_x
|
|
max_x = bounds.max_x
|
|
for y in range(min_y, max_y + 1):
|
|
for x in range(min_x, max_x + 1):
|
|
if y == min_y or y == max_y or x == min_x or x == max_x:
|
|
yield Point(x, y)
|
|
|
|
def __repr__(self) -> str:
|
|
return f'{self.__class__.__name__}({self.bounds})'
|