nodes/game.py

Part of Claustrowordia.

"""Game: the top-level scene wiring grid, hand, scoring, and audio."""

from __future__ import annotations

from simvx.core import AudioPlayer, Node2D, Signal, Sprite2D, Text2D
from simvx.core.coroutines import wait
from simvx.core.input.state import Input
from simvx.core.math.types import Vec2

from . import audio as audio_mod
from . import dictionary as dict_mod
from .grid import GRID_H, GRID_W, Grid
from .hand import HAND_SIZE, Hand
from .textures import TILE_SIZE, get_drop_preview
from .tile import Tile


class _ModalPanel(Node2D):
    """Dimmed backdrop plus a bordered box, used by the title and game-over screens.

    Drawn above every board node via z_index (Node2D sorts siblings by
    absolute_z_index); the accompanying text sits one layer higher.
    """

    def __init__(self, viewport: Vec2, size: Vec2, centre_y: float, name: str) -> None:
        super().__init__(name=name)
        self._vp = viewport
        self._size = size
        self._centre_y = centre_y
        self.z_index = 500
        self.visible = False

    def box_rect(self) -> tuple[float, float, float, float]:
        bx = (self._vp.x - self._size.x) / 2
        by = self._centre_y - self._size.y / 2
        return bx, by, self._size.x, self._size.y

    def on_draw(self, renderer) -> None:
        w, h = self._vp.x, self._vp.y
        renderer.draw_rect((0, 0), (w, h), colour=(0.0, 0.0, 0.0, 0.72), filled=True)
        bx, by, bw, bh = self.box_rect()
        renderer.draw_rect((bx - 5, by - 5), (bw + 10, bh + 10), colour=(1.0, 0.55, 0.20, 1.0), filled=True)
        renderer.draw_rect((bx, by), (bw, bh), colour=(0.12, 0.10, 0.16, 1.0), filled=True)


class Game(Node2D):
    """Root scene: 7×7 board + 7-tile hand + score HUD + audio."""

    score_changed = Signal()  # (new_score: int)
    game_over_changed = Signal()  # (over: bool)

    def __init__(self, viewport_size: Vec2) -> None:
        super().__init__(name="Game")
        self._viewport = viewport_size
        self.score = 0
        self.move_count = 0
        self.held: Tile | None = None
        self._held_origin_in_hand = True
        self.in_menu = True
        self.is_game_over = False
        self._scoring_lock = 0  # >0 while a check coroutine is running
        # Audio streams (built once)
        self._sfx_pop = audio_mod.make_pop()
        self._sfx_pickup = audio_mod.make_pickup()
        self._sfx_invalid = audio_mod.make_invalid()
        self._sfx_chime = audio_mod.make_word_chime()
        self._sfx_game_over = audio_mod.make_game_over()
        self._sfx_notes = [audio_mod.make_note(i) for i in range(10)]

    # ------------------------------------------------------------------
    def on_ready(self) -> None:
        # Audio players (added once; we restart them on each play() call).
        self._pop = self.add_child(AudioPlayer(stream=self._sfx_pop, bus="SFX", name="PopSfx"))
        self._pickup = self.add_child(AudioPlayer(stream=self._sfx_pickup, bus="SFX", name="PickupSfx"))
        self._invalid = self.add_child(AudioPlayer(stream=self._sfx_invalid, bus="SFX", name="InvalidSfx"))
        self._chime = self.add_child(AudioPlayer(stream=self._sfx_chime, bus="SFX", name="ChimeSfx"))
        self._gover = self.add_child(AudioPlayer(stream=self._sfx_game_over, bus="SFX", name="GameOverSfx"))
        self._note_players = [
            self.add_child(AudioPlayer(stream=s, bus="SFX", name=f"Note{i}")) for i, s in enumerate(self._sfx_notes)
        ]

        # Centred grid; hand below.
        cx = self._viewport.x / 2
        # Title takes ~80px at the top and the hand ~140px at the bottom. The grid
        # spans 7 × 80 = 560px, so centring it at 0.46 leaves a comfortable margin.
        grid_centre_y = self._viewport.y * 0.46
        self.grid = self.add_child(Grid(centre=Vec2(cx, grid_centre_y)))
        # Hand sits in the bottom band, below the grid.
        hand_y = self._viewport.y - 92
        self.hand = self.add_child(Hand(centre=Vec2(cx, hand_y)))

        # Drop preview (visible only while a tile is held + hovering a valid cell).
        self.preview = self.add_child(
            Sprite2D(
                texture=get_drop_preview(),
                width=TILE_SIZE,
                height=TILE_SIZE,
                name="DropPreview",
            )
        )
        self.preview.visible = False

        # HUD: title to the upper left, score to the upper right. Text2D z-orders
        # inline with the rest of the 2D scene, so the HUD declares a layer above
        # the modal dim backdrop (z=500) to stay legible over it.
        _HUD_Z = 550
        self.title_text = self.add_child(
            Text2D(
                text="CLAUSTROWORDIA",
                position=(32, 42),
                font_scale=1.5,
                colour=(0.95, 0.93, 0.82, 1.0),
            )
        )
        self.title_text.z_index = _HUD_Z
        self.score_text = self.add_child(
            Text2D(
                text="Score: 0",
                position=(self._viewport.x - 220, 42),
                font_scale=1.5,
                colour=(1.0, 0.85, 0.30, 1.0),
            )
        )
        self.score_text.z_index = _HUD_Z

        # Controls: vertical stack on the upper-left, below the title. They live
        # here rather than in a bottom strip because the hand of tiles occupies
        # the bottom band of the window.
        controls_lines = [
            "Click hand tile",
            "Click empty cell to place",
            "Right-click cancels",
            "R restart",
            "Esc quit",
        ]
        line_height = 36
        controls_top = 84  # below the title (y=42 + font row)
        self.controls_text_lines: list[Text2D] = []
        for i, line in enumerate(controls_lines):
            txt = self.add_child(
                Text2D(
                    text=line,
                    position=(20, controls_top + i * line_height),
                    font_scale=1.56,
                    colour=(0.95, 0.93, 0.82, 1.0),
                )
            )
            txt.z_index = _HUD_Z  # above the modal dim backdrop
            self.controls_text_lines.append(txt)

        # Game-over popup: a modal box (drawn above the board) with centred text
        # one layer higher, so it's clearly legible instead of low-contrast.
        self.gameover_panel = self.add_child(
            _ModalPanel(
                self._viewport,
                Vec2(560, 150),
                self._viewport.y * 0.40 + 21,
                name="GameOverPanel",
            )
        )
        self.gameover_text = self.add_child(
            Text2D(
                text="",
                position=(cx, self._viewport.y * 0.40 - 28),
                font_scale=2.2,
                align="centre",
                colour=(1.0, 0.62, 0.25, 1.0),
            )
        )
        self.gameover_text.z_index = 600
        self.gameover_text.visible = False
        self.gameover_sub = self.add_child(
            Text2D(
                text="",
                position=(cx, self._viewport.y * 0.40 + 34),
                font_scale=1.0,
                align="centre",
                colour=(0.97, 0.95, 0.86, 1.0),
            )
        )
        self.gameover_sub.z_index = 600
        self.gameover_sub.visible = False

        self._build_menu(cx)
        self._show_menu()

    # ------------------------------------------------------------------
    def _build_menu(self, cx: float) -> None:
        """Title screen: the same modal box as game-over, with the rules on it."""
        self.menu_panel = self.add_child(
            _ModalPanel(
                self._viewport,
                Vec2(760, 420),
                self._viewport.y * 0.5,
                name="MenuPanel",
            )
        )
        top = self._viewport.y * 0.5 - 210
        self.menu_nodes: list[Text2D] = []

        def _line(text: str, dy: float, scale: float, colour: tuple[float, float, float, float]) -> None:
            txt = self.add_child(
                Text2D(
                    text=text,
                    position=(cx, top + dy),
                    font_scale=scale,
                    align="centre",
                    colour=colour,
                )
            )
            txt.z_index = 600
            self.menu_nodes.append(txt)

        _line("CLAUSTROWORDIA", 42, 2.6, (1.0, 0.62, 0.25, 1.0))
        _line("A word puzzle after Antti Haavikko's Ludum Dare 50 winner", 102, 1.0, (0.85, 0.83, 0.74, 1.0))
        rules = [
            "Click a tile in your hand to pick it up",
            "Click an empty cell to place it",
            "Words along any row or column score",
            "Right-click cancels a pickup",
            "R restarts, Esc quits",
        ]
        for i, rule in enumerate(rules):
            _line(rule, 150 + i * 34, 1.15, (0.95, 0.93, 0.82, 1.0))
        _line("Click or press Enter to play", 344, 1.3, (1.0, 0.85, 0.30, 1.0))

    def _show_menu(self) -> None:
        self.in_menu = True
        self.menu_panel.visible = True
        for node in self.menu_nodes:
            node.visible = True
        self._set_hud_visible(False)
        self.grid.visible = False
        self.hand.visible = False

    def _start_game(self) -> None:
        self.in_menu = False
        self.menu_panel.visible = False
        for node in self.menu_nodes:
            node.visible = False
        self._set_hud_visible(True)
        self.grid.visible = True
        self.hand.visible = True
        # Deal the four pre-placed centre tiles + a hand of 7; they tween in.
        self._setup_initial_state()

    def _set_hud_visible(self, visible: bool) -> None:
        self.title_text.visible = visible
        self.score_text.visible = visible
        for txt in self.controls_text_lines:
            txt.visible = visible

    # ------------------------------------------------------------------
    def _setup_initial_state(self) -> None:
        # The letter pool is deliberately left as-is: the harness primes it with a
        # deterministic prefix before the game starts, and restart() clears it itself.
        # Four centre tiles at offset (-1,-1),(1,-1),(-1,1),(1,1) from board centre,
        # exactly mirroring the upstream layout.
        cx = (GRID_W - 1) // 2
        cy = (GRID_H - 1) // 2
        for dx, dy in ((-1, -1), (1, -1), (-1, 1), (1, 1)):
            letter = dict_mod.draw_letter()
            tile = Tile(letter=letter, locked=True)
            # Parent to the grid (like placed tiles) so grid visibility + restart's
            # grid.remove_child cover these centre tiles too. Grid sits at origin,
            # so cell_to_world (absolute) positions are unaffected.
            self.grid.add_child(tile)
            tile.set_position_immediate(self.grid.cell_to_world(cx + dx, cy + dy))
            self.grid.set(cx + dx, cy + dy, tile)
        # Deal 7 hand tiles
        for _ in range(HAND_SIZE):
            t = Tile(letter=dict_mod.draw_letter())
            self.hand.add_tile(t)

    # ------------------------------------------------------------------
    def on_update(self, dt: float) -> None:
        if self.in_menu:
            # Click / tap starts too, so the game is playable on touch.
            if Input.is_action_just_pressed("primary") or Input.is_action_just_pressed("start"):
                self._start_game()
            elif Input.is_action_just_pressed("quit"):
                self.app.quit()
            return

        if self.is_game_over:
            if Input.is_action_just_pressed("restart") or Input.is_action_just_pressed("primary"):
                self.restart()
            elif Input.is_action_just_pressed("quit"):
                self.app.quit()
            return

        if Input.is_action_just_pressed("quit"):
            self.app.quit()
            return

        mp = Input.mouse_position
        # Held tile follows the cursor; preview snaps to grid cell under cursor.
        if self.held is not None:
            self.held.set_target(Vec2(mp.x, mp.y), snap=False)
            cell = self.grid.world_to_cell(Vec2(mp.x, mp.y))
            if cell is not None and self.grid.is_empty(*cell):
                self.preview.position = self.grid.cell_to_world(*cell)
                self.preview.visible = True
            else:
                self.preview.visible = False

        # Click handling
        if Input.is_action_just_pressed("primary") and self._scoring_lock == 0:
            self._handle_lmb(Vec2(mp.x, mp.y))
        if Input.is_action_just_pressed("secondary") and self.held is not None:
            self._cancel_pickup()

    # ------------------------------------------------------------------
    def _handle_lmb(self, mp: Vec2) -> None:
        if self.held is None:
            # Try to pick a tile from the hand
            tile = self.hand.tile_at(mp)
            if tile is not None:
                self._pickup_from_hand(tile)
                return
        else:
            # Try to drop on a grid cell
            cell = self.grid.world_to_cell(mp)
            if cell is not None and self.grid.is_empty(*cell):
                self._drop_on_grid(cell)
            else:
                self._invalid.play()

    def _pickup_from_hand(self, tile: Tile) -> None:
        self.held = tile
        self._held_origin_in_hand = True
        # Detach from hand: keep the node parented to Game so it sits above grid in draw order.
        self.hand.tiles.remove(tile)
        self.hand.remove_child(tile)
        self.add_child(tile)
        self.hand.layout()
        self._pickup.play()

    def _cancel_pickup(self) -> None:
        if self.held is None:
            return
        # Re-attach to hand
        self.remove_child(self.held)
        self.hand.add_tile(self.held)
        self.held = None
        self.preview.visible = False

    def _drop_on_grid(self, cell: tuple[int, int]) -> None:
        gx, gy = cell
        tile = self.held
        assert tile is not None
        # Re-parent visually under grid so it sits with the cells
        self.remove_child(tile)
        self.grid.add_child(tile)
        target = self.grid.cell_to_world(gx, gy)
        tile.set_target(target, snap=False)
        tile.punch_in()
        self.grid.set(gx, gy, tile)
        self.held = None
        self.preview.visible = False
        self._pop.play()
        self.move_count += 1
        self.start_coroutine(self._check_words(gx, gy))

    # ------------------------------------------------------------------
    # Word checking: mirrors upstream Field.Check / CheckString.
    # ------------------------------------------------------------------
    def _check_words(self, gx: int, gy: int):
        self._scoring_lock += 1
        try:
            row_letters = self.grid.row_letters(gy)
            col_letters = self.grid.col_letters(gx)
            row_tiles = self.grid.row_tiles(gy)
            col_tiles = self.grid.col_tiles(gx)

            words: list[tuple[str, list[Tile], bool]] = []
            words.extend(self._collect_words(row_letters, gx, row_tiles, reverse=False))
            words.extend(self._collect_words(col_letters, gy, col_tiles, reverse=False))
            words.extend(
                self._collect_words(row_letters[::-1], (GRID_W - 1) - gx, list(reversed(row_tiles)), reverse=True)
            )
            words.extend(
                self._collect_words(col_letters[::-1], (GRID_H - 1) - gy, list(reversed(col_tiles)), reverse=True)
            )

            # De-dup: the same word over the same tiles in the same direction is one
            # find, but the same word read down a column as well as across a row counts twice.
            seen = set()
            unique = []
            for word, tiles, rev in words:
                key = (word, tuple(id(t) for t in tiles), rev)
                if key in seen:
                    continue
                seen.add(key)
                unique.append((word, tiles, rev))

            multi = 1
            unique.sort(key=lambda w: len(w[0]))
            for word, tiles, _rev in unique:
                yield from self._announce_word(word, tiles, multi)
                multi += 1
                yield from wait(0.35)

            # Deal a fresh tile (matches upstream's "deal-after-drop" behaviour)
            if not self.grid.is_full() and not self.is_game_over:
                t = Tile(letter=dict_mod.draw_letter())
                self.hand.add_tile(t)

            # Lose check
            if self.grid.is_full():
                self._trigger_game_over()
        finally:
            self._scoring_lock -= 1

    def _collect_words(
        self,
        text: str,
        must_include: int,
        tiles: list,
        reverse: bool,
    ) -> list[tuple[str, list[Tile], bool]]:
        """Find dictionary words in `text` that span the dropped index."""
        out: list[tuple[str, list[Tile], bool]] = []
        if len(text) < 3:
            return out
        for length in range(len(text), 2, -1):
            for start in range(0, len(text) - length + 1):
                w = text[start : start + length]
                if " " in w:
                    continue
                # Must cover the drop column/row
                if not (start <= must_include < start + length):
                    continue
                if dict_mod.is_word(w):
                    word_tiles = [t for t in tiles[start : start + length] if t is not None]
                    if len(word_tiles) == length:
                        out.append((w.lower(), word_tiles, reverse))
        return out

    def _announce_word(self, word: str, tiles: list[Tile], multi: int):
        # Score: length² × multiplier (full-match-bonus 10× per upstream)
        base = len(word) ** 2
        all_tiles = self.grid.all_tiles()
        is_full_match = all(t.matched or t in tiles for t in all_tiles)
        if is_full_match:
            multi *= 10
        score = base * multi
        # Per-letter pulse + ascending notes
        for i, t in enumerate(tiles):
            t.colourise_matched()
            t.shake(0.45)
            t.punch_score(i)
            self._note_players[min(i, len(self._note_players) - 1)].play()
            yield from wait(0.075)
        self._chime.play()
        self.score += score
        self.score_text.text = f"Score: {self.score}"
        self.score_changed(self.score)

    # ------------------------------------------------------------------
    def _trigger_game_over(self) -> None:
        self.is_game_over = True
        # Hide the board: the tile letters are Text2D children of the tiles, and
        # they would read as noise through the dimmed game-over popup.
        self.grid.visible = False
        self.hand.visible = False
        self.preview.visible = False
        if self.held is not None:
            self.held.visible = False
        self.gameover_panel.visible = True
        self.gameover_text.text = "GAME OVER"
        self.gameover_text.visible = True
        self.gameover_sub.text = f"Final score: {self.score}    Click or press R to restart"
        self.gameover_sub.visible = True
        self.game_over_changed(True)
        self._gover.play()

    def restart(self) -> None:
        # Wipe everything and rebuild
        for row in self.grid.cells:
            for t in row:
                if t is not None:
                    self.grid.remove_child(t)
        self.grid.cells = [[None for _ in range(GRID_W)] for _ in range(GRID_H)]
        self.hand.clear()
        self.score = 0
        self.move_count = 0
        self.held = None
        self.is_game_over = False
        self.grid.visible = True
        self.hand.visible = True
        self.gameover_panel.visible = False
        self.gameover_text.visible = False
        self.gameover_sub.visible = False
        self.score_text.text = "Score: 0"
        self.score_changed(0)
        self.game_over_changed(False)
        dict_mod.reset()
        self._setup_initial_state()


__all__ = ["Game"]