scripts/fog_of_war.py

Part of Dungeon Explorer.

"""Per-tile fog of war visibility tracking."""

import numpy as np


class FogOfWar:
    """Tracks per-tile visibility for minimap and rendering.

    States: 0=unexplored (black), 1=explored (dimmed), 2=visible (fully lit).
    """

    def __init__(self, width: int, height: int, reveal_radius: int = 5):
        self.width = width
        self.height = height
        self.reveal_radius = reveal_radius
        self._tiles = [[0] * width for _ in range(height)]
        self._prev_visible: list[tuple[int, int]] = []

    def update(self, player_grid_x: int, player_grid_y: int) -> None:
        """Update visibility around the player position."""
        r = self.reveal_radius
        # Dim only previously visible tiles (not the full grid)
        for x, y in self._prev_visible:
            if self._tiles[y][x] == 2:
                self._tiles[y][x] = 1

        # Reveal around player and track visible tiles
        visible: list[tuple[int, int]] = []
        for dy in range(-r, r + 1):
            for dx in range(-r, r + 1):
                if dx * dx + dy * dy <= r * r:
                    nx, ny = player_grid_x + dx, player_grid_y + dy
                    if 0 <= nx < self.width and 0 <= ny < self.height:
                        self._tiles[ny][nx] = 2
                        visible.append((nx, ny))
        self._prev_visible = visible

    def get_state(self, x: int, y: int) -> int:
        """Get visibility state at grid position (0/1/2)."""
        if 0 <= x < self.width and 0 <= y < self.height:
            return self._tiles[y][x]
        return 0

    def state_array(self) -> np.ndarray:
        """Return the per-tile visibility state as an ``(H, W)`` int array.

        The instanced fog overlay reads this to recompute its tint plane in one
        vectorised pass (state -> dim alpha) whenever the fog changes. ``_tiles``
        is row-major ``[y][x]``, so the array indexes as ``[y, x]`` and feeds
        straight into ``TileMapLayer.set_cells`` (origin ``(0, 0)``).
        """
        return np.asarray(self._tiles, dtype=np.int32)

    def is_visible(self, x: int, y: int) -> bool:
        return self.get_state(x, y) == 2

    def is_explored(self, x: int, y: int) -> bool:
        return self.get_state(x, y) >= 1

    def reveal_all(self) -> None:
        """Reveal the entire map."""
        for y in range(self.height):
            for x in range(self.width):
                self._tiles[y][x] = 2

    def explored_fraction(self) -> float:
        """Return fraction of map that has been explored."""
        total = self.width * self.height
        explored = sum(1 for row in self._tiles for cell in row if cell > 0)
        return explored / max(1, total)

    def to_dict(self) -> dict:
        return {"width": self.width, "height": self.height, "tiles": self._tiles, "reveal_radius": self.reveal_radius}

    @classmethod
    def from_dict(cls, d: dict) -> FogOfWar:
        fog = cls(d["width"], d["height"], d.get("reveal_radius", 5))
        fog._tiles = d["tiles"]
        return fog