nodes/gameboard.py

Part of GDQuest Open RPG.

"""Hand-authored overworld map and BFS pathfinder."""

from __future__ import annotations

from collections import deque

from .settings import GRID_H, GRID_W, TILE

# Tile codes
GRASS = 0
PATH = 1
WATER = 2
WALL = 3
TREE = 4
SAND = 5
SHRINE = 6

# Walkability
WALKABLE = {GRASS, PATH, SAND, SHRINE}


def _make_map() -> list[list[int]]:
    m = [[GRASS for _ in range(GRID_W)] for _ in range(GRID_H)]
    # river along top
    for x in range(0, GRID_W):
        m[0][x] = WATER
    # bridge / path
    for y in range(1, GRID_H):
        m[y][GRID_W // 2] = PATH
    for x in range(2, GRID_W - 2):
        m[8][x] = PATH
    # tree border bottom-left
    for x in range(2, 8):
        m[14][x] = TREE
    for y in range(11, 15):
        m[y][2] = TREE
    # walls / building (top-right)
    for y in range(2, 6):
        for x in range(GRID_W - 6, GRID_W - 2):
            m[y][x] = WALL
    for x in range(GRID_W - 5, GRID_W - 3):
        m[5][x] = PATH  # door
    # sand patch
    for y in range(11, 14):
        for x in range(20, 25):
            m[y][x] = SAND
    # save shrine
    m[10][3] = SHRINE
    # bottom water row
    for x in range(0, GRID_W):
        if x not in (GRID_W // 2,):
            m[GRID_H - 1][x] = WATER
    return m


TILES: list[list[int]] = _make_map()


def in_bounds(cx: int, cy: int) -> bool:
    return 0 <= cx < GRID_W and 0 <= cy < GRID_H


def is_walkable(cx: int, cy: int) -> bool:
    if not in_bounds(cx, cy):
        return False
    return TILES[cy][cx] in WALKABLE


def cell_to_pixel(cx: int, cy: int) -> tuple[float, float]:
    return cx * TILE + TILE * 0.5, cy * TILE + TILE * 0.5


def pixel_to_cell(px: float, py: float) -> tuple[int, int]:
    return int(px // TILE), int(py // TILE)


def bfs_path(src: tuple[int, int], dst: tuple[int, int]) -> list[tuple[int, int]]:
    """Return list of cells from `src` to `dst` (inclusive). Empty if unreachable."""
    if src == dst or not is_walkable(*dst):
        return []
    came: dict[tuple[int, int], tuple[int, int] | None] = {src: None}
    q = deque([src])
    while q:
        cur = q.popleft()
        if cur == dst:
            break
        cx, cy = cur
        for nx, ny in ((cx + 1, cy), (cx - 1, cy), (cx, cy + 1), (cx, cy - 1)):
            n = (nx, ny)
            if n not in came and is_walkable(nx, ny):
                came[n] = cur
                q.append(n)
    if dst not in came:
        return []
    path: list[tuple[int, int]] = []
    cur: tuple[int, int] | None = dst
    while cur is not None:
        path.append(cur)
        cur = came[cur]
    return list(reversed(path))[1:]  # exclude src


# Map of which cell triggers a battle encounter, dialogue, or shrine.
# (cell): ('encounter', 'wolves')  | ('dialogue', 'monk')  | ('save')
TRIGGERS: dict[tuple[int, int], tuple[str, str]] = {
    (GRID_W // 2, 5): ("encounter", "wolves"),
    (3, 10): ("save", ""),
    (15, 8): ("encounter", "bears"),
    (24, 12): ("encounter", "bugcats"),
}

# NPC spawns: cell -> (kind, dialogue_id)
NPCS: list[dict] = [
    {"cell": (5, 8), "kind": "monk", "dialogue": "monk"},
    {"cell": (10, 4), "kind": "smith", "dialogue": "smith"},
    {"cell": (22, 9), "kind": "wizard_npc", "dialogue": "wizard_npc"},
]


# Pre-baked dialogue scripts (speaker, text)
DIALOGUES: dict[str, list[tuple[str, str]]] = {
    "monk": [
        ("Monk", "Greetings, traveller."),
        ("Monk", "Beware the wolves at the bridge."),
        ("Monk", "And the bears past the river bend."),
    ],
    "smith": [
        ("Smith", "I'm too busy to chat."),
        ("Smith", "...fine. Don't lose your sword."),
    ],
    "wizard_npc": [
        ("Old Mage", "Have you tried casting spells?"),
        ("Old Mage", "Energy refills as you take damage. A poor trade, perhaps."),
    ],
    "encounter_wolves": [
        ("Wolf", "*growls menacingly*"),
        ("Knight", "Form up! Two on the right."),
    ],
    "encounter_bears": [
        ("Bear", "*roars*"),
        ("Knight", "Watch out for the big one!"),
    ],
    "encounter_bugcats": [
        ("Bugcat", "*chitters*"),
        ("Squirrel", "Easy pickings."),
    ],
    "victory": [
        ("Knight", "We won!"),
        ("Knight", "Onward."),
    ],
    "defeat": [
        ("Knight", "We lost..."),
        ("Knight", "Back to the shrine."),
    ],
    "save": [
        ("Shrine", "Your party is restored."),
        ("Shrine", "Progress saved."),
    ],
}