Eryn Wells
635aea5e3b
Use the new map generator mechanism to generate rooms via cellular atomata. Create a new CellularAtomatonRoomMethod class that uses the Cellular Atomton class to create a room. Add a FreefromRoom class that draws a room based on an ndarray of tiles. Along the way I discovered I have misunderstood how numpy arrays organize rows and columns. The numpy array creation routines take an 'order' argument that specifies whether arrays should be in C order (row major) or Fortran order (column major). Fortran order lets you index arrays with a more natural [x, y] coordinate order, and that's what the tutorials I've read have shown. So I've been using that. When I was developing the Cellular Atomaton, I wrote some code that assumed row- major order. I think I want to move everything to row-major / C-style, but that will take a bit more time.
117 lines
3.5 KiB
Python
117 lines
3.5 KiB
Python
# Eryn Wells <eryn@erynwels.me>
|
|
|
|
'''
|
|
Implements an abstract Room class, and subclasses that implement it. Rooms are basic components of maps.
|
|
'''
|
|
|
|
from typing import Iterable
|
|
|
|
import numpy as np
|
|
|
|
from ..geometry import Point, Rect, Vector
|
|
from .tile import Floor, Wall
|
|
|
|
|
|
class Room:
|
|
'''An abstract room. It can be any size or shape.'''
|
|
|
|
def __init__(self, bounds: Rect):
|
|
self.bounds: Rect = bounds
|
|
|
|
@property
|
|
def center(self) -> Point:
|
|
'''The center of the room, truncated according to integer math rules'''
|
|
return self.bounds.midpoint
|
|
|
|
@property
|
|
def wall_points(self) -> Iterable[Point]:
|
|
'''An iterator over all the points that make up the walls of this room.'''
|
|
raise NotImplementedError()
|
|
|
|
@property
|
|
def floor_points(self) -> Iterable[Point]:
|
|
'''An iterator over all the points that make of the floor of this room'''
|
|
raise NotImplementedError()
|
|
|
|
@property
|
|
def walkable_tiles(self) -> Iterable[Point]:
|
|
'''An iterator over all the points that are walkable in this room.'''
|
|
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.
|
|
'''
|
|
|
|
@property
|
|
def walkable_tiles(self) -> Iterable[Point]:
|
|
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 wall_points(self) -> Iterable[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 x in range(min_x, max_x + 1):
|
|
yield Point(x, min_y)
|
|
yield Point(x, max_y)
|
|
|
|
for y in range(min_y + 1, max_y):
|
|
yield Point(min_x, y)
|
|
yield Point(max_x, y)
|
|
|
|
@property
|
|
def floor_points(self) -> Iterable[Point]:
|
|
inset_bounds = self.bounds.inset_rect(1, 1, 1, 1)
|
|
|
|
min_y = inset_bounds.min_y
|
|
max_y = inset_bounds.max_y
|
|
min_x = inset_bounds.min_x
|
|
max_x = inset_bounds.max_x
|
|
|
|
for x in range(min_x, max_x + 1):
|
|
for y in range(min_y, max_y + 1):
|
|
yield Point(x, y)
|
|
|
|
def __repr__(self) -> str:
|
|
return f'{self.__class__.__name__}({self.bounds})'
|
|
|
|
|
|
class FreeformRoom(Room):
|
|
def __init__(self, bounds: Rect, tiles: np.ndarray):
|
|
super().__init__(bounds)
|
|
self.tiles = tiles
|
|
|
|
@property
|
|
def floor_points(self) -> Iterable[Point]:
|
|
room_origin_vector = Vector.from_point(self.bounds.origin)
|
|
for y, x in np.ndindex(self.tiles.shape):
|
|
if self.tiles[y, x] == Floor:
|
|
yield Point(x, y) + room_origin_vector
|
|
|
|
@property
|
|
def wall_points(self) -> Iterable[Point]:
|
|
room_origin_vector = Vector.from_point(self.bounds.origin)
|
|
for y, x in np.ndindex(self.tiles.shape):
|
|
if self.tiles[y, x] == Wall:
|
|
yield Point(x, y) + room_origin_vector
|
|
|
|
@property
|
|
def walkable_tiles(self) -> Iterable[Point]:
|
|
room_origin_vector = Vector.from_point(self.bounds.origin)
|
|
for y, x in np.ndindex(self.tiles.shape):
|
|
if self.tiles[y, x]['walkable']:
|
|
yield Point(x, y) + room_origin_vector
|