nodes/building.py

Part of Mr. Rescue.

"""Procedural multi-floor building generator.

Three floors, each 16 tiles tall, 41 tiles wide (matches upstream MAPW=41,
floor-height = 16). Floors are stitched vertically: bottom floor at rows
32..47, middle 16..31, top 0..15. Ladders connect them at randomised x.

Each floor uses a template skeleton: outer walls, floor strip at the top
and bottom of the band, plus 2 internal "rooms" with door gaps. Random
spawn points are produced for the player, civilians, enemies, and fires.
"""

from __future__ import annotations

import random
from dataclasses import dataclass

import numpy as np

from .tile_grid import (
    PAPER_IDS,
    T_CRATE,
    T_DOOR,
    T_EMPTY,
    T_FLOOR,
    T_LADDER,
    T_PICTURE,
    T_PIPE,
    T_PLANT,
    T_SHELF,
    T_WAINSCOT,
    T_WALL,
    T_WINDOW,
    TILE_SIZE,
    TileGrid,
)

WIDTH_TILES = 41
FLOOR_HEIGHT = 16
NUM_FLOORS = 3
HEIGHT_TILES = FLOOR_HEIGHT * NUM_FLOORS  # 48

# Interior height inside each floor (rows between top and bottom solid bands).
INTERIOR_TOP = 1  # 1 row of ceiling at the top of each band
INTERIOR_BOTTOM = 14  # 14th row is the floor surface
# So inside band: rows 1..14 free, row 15 is floor surface (T_FLOOR).


@dataclass
class SpawnPlan:
    """Output of :func:`generate_layout`."""

    data: np.ndarray
    player_start: tuple[float, float]  # pixel coords (centre of feet)
    civilian_spawns: list[tuple[float, float]]
    enemy_spawns: list[tuple[float, float]]
    fire_seeds: list[tuple[int, int]]  # cell coords


# --------------------------------------------------------------------- helpers


def _hline(data: np.ndarray, row: int, x0: int, x1: int, tile: int):
    data[row, x0 : x1 + 1] = tile


def _vline(data: np.ndarray, col: int, y0: int, y1: int, tile: int):
    data[y0 : y1 + 1, col] = tile


def _gen_floor(
    data: np.ndarray,
    band_top: int,
    rng: random.Random,
    *,
    is_topmost: bool,
    ladders_above: list[int],
    ladders_below: list[int],
):
    """Carve a single floor band into ``data``. ``band_top`` = first row.

    Lays:
      - solid floor at row band_top + 14 (this is what the player walks on)
      - top ceiling at band_top (only if not topmost; the topmost band's
        ceiling is sky for "exit upward")
      - 2 internal walls with door gaps to make rooms
      - ladders at the supplied x coords (climbing into / out of this band)
    """
    band_bot_floor = band_top + INTERIOR_BOTTOM + 1  # 15
    band_top_ceil = band_top  # 0 of band

    # Floor surface
    _hline(data, band_bot_floor, 0, WIDTH_TILES - 1, T_FLOOR)

    # Ceiling: solid except: skip cells where ladders pass through (so the
    # player can climb up). Also skip the topmost band entirely (open sky).
    if not is_topmost:
        _hline(data, band_top_ceil, 0, WIDTH_TILES - 1, T_FLOOR)
        for lx in ladders_above:
            data[band_top_ceil, lx] = T_LADDER

    # Outer walls (left + right)
    _vline(data, 0, band_top_ceil, band_bot_floor, T_WALL)
    _vline(data, WIDTH_TILES - 1, band_top_ceil, band_bot_floor, T_WALL)

    # Internal walls (2 walls, dividing band into 3 rooms with doors).
    # Wall x coords picked from interior bands, minus the columns this band's
    # ladders run through: ladder cells are only carved into empty space, so a
    # wall landing on one would seal the storey off with no way up or down.
    ladder_cols = {*ladders_above, *ladders_below}
    wall_candidates = [x for x in range(8, WIDTH_TILES - 8, 4) if x not in ladder_cols]
    wall_xs = sorted(rng.sample(wall_candidates, 2))
    for wx in wall_xs:
        _vline(data, wx, band_top_ceil + 1, band_bot_floor - 1, T_WALL)
        # Door gap: 2 tiles tall above floor.
        data[band_bot_floor - 1, wx] = T_DOOR
        data[band_bot_floor - 2, wx] = T_DOOR

    # Ladders into this band's floor (so player can drop through).
    for lx in ladders_below:
        # Cut the floor + 1 cell above to make the ladder reach upward.
        data[band_bot_floor, lx] = T_LADDER
        # Continue ladder upward by 14 cells (entire interior).
        for ly in range(band_bot_floor - 1, band_top_ceil, -1):
            if data[ly, lx] == T_EMPTY:
                data[ly, lx] = T_LADDER

    # Same for ladders coming up from above (climbed-into ceiling).
    for lx in ladders_above:
        for ly in range(band_top_ceil + 1, band_bot_floor):
            if data[ly, lx] == T_EMPTY:
                data[ly, lx] = T_LADDER


def _decorate(data: np.ndarray, rng: random.Random, floor_band_tops: list[int], occupied: set[tuple[int, int]]):
    """Paint the decorative back-wall layer over the bare interior.

    Runs AFTER spawn selection (which keys off structural T_EMPTY), so it never
    perturbs where civilians / fires / items land. Only ever overwrites
    ``T_EMPTY`` (and its own wallpaper), leaving walls, floors, ladders and
    doors untouched. All decoration is non-solid, so collision/platforming and
    fire spread are unchanged (wallpaper stays burnable like the air it
    replaces).
    """
    ground_props = (T_SHELF, T_CRATE, T_PLANT)
    for s, band_top in enumerate(floor_band_tops):
        paper = PAPER_IDS[s % len(PAPER_IDS)]
        band_bot_floor = band_top + INTERIOR_BOTTOM + 1  # floor surface row
        top_row = band_top + 1
        bot_row = band_bot_floor - 1  # interior row on the floor

        # 1) Back-fill every empty interior cell with this storey's wallpaper.
        for cy in range(top_row, band_bot_floor):
            for cx in range(WIDTH_TILES):
                if data[cy, cx] == T_EMPTY:
                    data[cy, cx] = paper

        # 2) Skirting board along the floor.
        for cx in range(1, WIDTH_TILES - 1):
            if data[bot_row, cx] == paper:
                data[bot_row, cx] = T_WAINSCOT

        # 3) Windows near the ceiling, looking onto the night skyline.
        offset = rng.randrange(0, 6)
        for cx in range(2 + offset, WIDTH_TILES - 2, 6):
            for cy in range(band_top + 2, band_top + 5):
                if data[cy, cx] == paper:
                    data[cy, cx] = T_WINDOW

        # 4) Back-wall props: framed pictures + the odd vertical pipe run.
        for cx in range(3, WIDTH_TILES - 3):
            if rng.random() < 0.05 and data[band_top + 6, cx] == paper and (cx, band_top + 6) not in occupied:
                data[band_top + 6, cx] = T_PICTURE
        if rng.random() < 0.7:
            px = rng.randrange(4, WIDTH_TILES - 4)
            for cy in range(top_row, bot_row):
                if data[cy, px] == paper:
                    data[cy, px] = T_PIPE

        # 5) Ground furniture standing on the skirting (replaces it at a few cols).
        cols = list(range(2, WIDTH_TILES - 2))
        rng.shuffle(cols)
        placed = 0
        want = rng.randint(4, 7)
        for cx in cols:
            if placed >= want:
                break
            if data[bot_row, cx] == T_WAINSCOT and data[bot_row - 1, cx] == paper and (cx, bot_row) not in occupied:
                data[bot_row, cx] = rng.choice(ground_props)
                placed += 1


def generate_layout(*, section: int = 1, seed: int | None = None) -> SpawnPlan:
    """Generate a SpawnPlan for the given section.

    ``section`` (1+) scales fire seeds, enemy count, and ladder placement
    randomness. The result is fully deterministic given a seed.
    """
    rng = random.Random(seed)

    data = np.full((HEIGHT_TILES, WIDTH_TILES), T_EMPTY, dtype=np.uint8)

    # Sky band above the building: top row = open exit zone.
    # We don't actually render rows below 0; instead, the topmost band has
    # an open ceiling so the player can climb out the top.

    # Pick ladder column for each floor boundary.
    # Two boundaries (between floor 0/1 and 1/2). Each boundary needs a single
    # ladder column shared by the floor below (its ceiling) and floor above
    # (its floor cut).
    ladder_lower = rng.randrange(8, WIDTH_TILES - 8)
    ladder_upper = rng.randrange(8, WIDTH_TILES - 8)
    while abs(ladder_upper - ladder_lower) < 6:
        ladder_upper = rng.randrange(8, WIDTH_TILES - 8)

    # Floor band tops (in tile rows): 0 (top), 16, 32 (bottom).
    floor_band_tops = [0, FLOOR_HEIGHT, FLOOR_HEIGHT * 2]

    # Order of generation: bottom floor (band_top=32) first.
    # Bottom band: ladder_above goes into ceiling at band_top=32 → ladder_lower.
    _gen_floor(
        data,
        band_top=floor_band_tops[2],
        rng=rng,
        is_topmost=False,
        ladders_above=[ladder_lower],
        ladders_below=[],
    )
    # Middle band: ladder_above = ladder_upper, ladder_below = ladder_lower.
    _gen_floor(
        data,
        band_top=floor_band_tops[1],
        rng=rng,
        is_topmost=False,
        ladders_above=[ladder_upper],
        ladders_below=[ladder_lower],
    )
    # Top band: ladder_below = ladder_upper. No ceiling (open sky) so player
    # can exit out the top.
    _gen_floor(
        data,
        band_top=floor_band_tops[0],
        rng=rng,
        is_topmost=True,
        ladders_above=[],
        ladders_below=[ladder_upper],
    )

    # Solid floor surface of each band: everything that walks does so with its
    # feet on the top edge of these rows, and spawns go in the row directly above.
    floor_rows = [bt + INTERIOR_BOTTOM + 1 for bt in floor_band_tops]

    # Spawns ---------------------------------------------------
    # Player: bottom floor, near left wall, on top of floor surface.
    pstart_cx = 4
    pstart_cy = floor_rows[2] - 1  # one row above floor surface
    player_start = (
        pstart_cx * TILE_SIZE + TILE_SIZE / 2,
        pstart_cy * TILE_SIZE + TILE_SIZE,
    )  # bottom-of-feet at floor top

    civilian_spawns: list[tuple[float, float]] = []
    enemy_spawns: list[tuple[float, float]] = []
    fire_seeds: list[tuple[int, int]] = []

    occupied: set[tuple[int, int]] = set()

    # 2-3 civilians per floor band so the building feels inhabited.
    for fr in floor_rows:
        want = rng.randint(2, 3)
        placed = 0
        for _ in range(40):
            if placed >= want:
                break
            cx = rng.randrange(3, WIDTH_TILES - 3)
            cy = fr - 1
            if data[cy, cx] != T_EMPTY:
                continue
            if (cx, cy) in occupied:
                continue
            occupied.add((cx, cy))
            civilian_spawns.append((cx * TILE_SIZE + TILE_SIZE / 2, cy * TILE_SIZE + TILE_SIZE))
            placed += 1

    # 1-2 enemies (scaled with section).
    enemy_count = 1 + min(2, section // 3)
    for _ in range(enemy_count):
        for _try in range(20):
            band = rng.randrange(NUM_FLOORS)
            fr = floor_rows[band]
            cx = rng.randrange(5, WIDTH_TILES - 5)
            cy = fr - 1
            if data[cy, cx] != T_EMPTY or (cx, cy) in occupied:
                continue
            occupied.add((cx, cy))
            enemy_spawns.append((cx * TILE_SIZE + TILE_SIZE / 2, cy * TILE_SIZE + TILE_SIZE))
            break

    # Fires: 3-5 seeds, scaled with section. Each seed must be on a burnable
    # cell adjacent to a floor surface (so flames have something to climb).
    fire_count = min(10, 5 + section)
    for _ in range(fire_count):
        for _try in range(30):
            band = rng.randrange(NUM_FLOORS)
            fr = floor_rows[band]
            cx = rng.randrange(2, WIDTH_TILES - 2)
            cy = fr - 1
            if data[cy, cx] != T_EMPTY or (cx, cy) in occupied:
                continue
            occupied.add((cx, cy))
            fire_seeds.append((cx, cy))
            break

    # Decorate the interior LAST, once all spawns are chosen from structural
    # emptiness, so the back-wall layer can't displace gameplay placement.
    _decorate(data, rng, floor_band_tops, occupied)

    return SpawnPlan(
        data=data,
        player_start=player_start,
        civilian_spawns=civilian_spawns,
        enemy_spawns=enemy_spawns,
        fire_seeds=fire_seeds,
    )


def make_tile_grid(plan: SpawnPlan) -> TileGrid:
    """Convenience wrapper to instantiate the renderable TileGrid from a plan."""
    return TileGrid(plan.data)