nodes/player.py

Part of GDQuest Open RPG.

"""PlayerController: grid movement on one typed action, plus interact."""

from __future__ import annotations

from simvx.core import Sprite2D
from simvx.core.input.state import Input
from simvx.core.math.types import Vec2
from simvx.core.signals import Signal

from . import sprites as art
from .controls import EXPLORING
from .gameboard import bfs_path, cell_to_pixel, is_walkable
from .settings import TILE


class Player(Sprite2D):
    """Top-down player. Step-based movement (one tile per press, smooth lerp)."""

    #: Walking, talking and click-to-path are live exactly while the player is
    #: in the tree, so a test that mounts the player alone can drive them.
    input_context = EXPLORING

    MOVE_SPEED = 4.0  # tiles/sec
    #: How far ``move`` must be pushed before it counts as a step. A key is full
    #: deflection, so this only matters to a stick and a drawn thumb.
    STEP_DEADZONE = 0.5

    def __init__(self, start_cell: tuple[int, int] = (15, 8)) -> None:
        super().__init__(texture=art.knight_sprite())
        self.filter = "nearest"
        self.width = TILE
        self.height = TILE
        self.cell: tuple[int, int] = tuple(start_cell)
        self.position = self.cell_to_world(self.cell)
        self._target: tuple[int, int] | None = None
        self._move_t = 0.0
        self._from_pos = Vec2(self.position)
        self._to_pos = Vec2(self.position)
        self._input_enabled = True
        self._path: list[tuple[int, int]] = []  # for click-to-path

        self.cell_arrived = Signal()  # (cx, cy)
        self.interact_requested = Signal()  # (cell,) - the cell in front

        self._facing: tuple[int, int] = (0, 1)  # last direction faced

    @staticmethod
    def cell_to_world(cell: tuple[int, int]) -> Vec2:
        x, y = cell_to_pixel(*cell)
        return Vec2(x, y)

    def set_input_enabled(self, enabled: bool) -> None:
        """Hand control to (or take it from) the player.

        Disabling also drops any queued click-to-path steps: a path that kept
        walking through a dialogue or a fade would silently cross trigger cells
        and leave the player somewhere else when control came back.
        """
        self._input_enabled = enabled
        if not enabled:
            self._path = []

    # ------------------------------------------------------------------
    # Step movement
    # ------------------------------------------------------------------
    def _try_step(self, dx: int, dy: int) -> bool:
        cx, cy = self.cell
        nx, ny = cx + dx, cy + dy
        if not is_walkable(nx, ny):
            return False
        self._target = (nx, ny)
        self._from_pos = Vec2(self.position)
        self._to_pos = self.cell_to_world(self._target)
        self._move_t = 0.0
        self._facing = (dx, dy) if (dx, dy) != (0, 0) else self._facing
        return True

    def on_update(self, dt: float) -> None:
        # Movement lerp
        if self._target is not None:
            duration = 1.0 / self.MOVE_SPEED
            self._move_t += dt
            t = min(1.0, self._move_t / duration)
            # Ease-out for snappier feel
            ease = 1.0 - (1.0 - t) * (1.0 - t)
            self.position = Vec2(
                self._from_pos.x + (self._to_pos.x - self._from_pos.x) * ease,
                self._from_pos.y + (self._to_pos.y - self._from_pos.y) * ease,
            )
            if t >= 1.0:
                self.cell = self._target
                self._target = None
                self.position = self._to_pos
                self.cell_arrived.emit(self.cell[0], self.cell[1])
                # Continue path if click-to-path is active. `cell_arrived` may
                # have started a dialogue or an encounter, which revokes input:
                # re-read the flag rather than walking on through the fade.
                if self._path and self._input_enabled:
                    nxt = self._path.pop(0)
                    dx = nxt[0] - self.cell[0]
                    dy = nxt[1] - self.cell[1]
                    if not self._try_step(dx, dy):
                        self._path = []
                # Fall through to input check so a held key continues stepping.
            else:
                return

        if not self._input_enabled:
            return

        # Polled input: one typed action, whichever device is driving it. Hold
        # to step continuously. A new step cancels the current click path.
        # The grid takes one direction at a time, so a diagonal push resolves to
        # its longer half, and a tie goes to the vertical.
        move = Input.value("move")
        dx = dy = 0
        if move.length() >= self.STEP_DEADZONE:
            if abs(move.y) >= abs(move.x):
                dy = 1 if move.y > 0 else -1
            else:
                dx = 1 if move.x > 0 else -1
        if dx != 0 or dy != 0:
            self._path = []
            self._try_step(dx, dy)
            return

        # Interact: emit interact for the cell in front. E or the pad's bottom
        # face button; SPACE and ENTER stay with dialogue and the battle menu so
        # one press never does two things.
        if Input.just_pressed("interact"):
            tx = self.cell[0] + self._facing[0]
            ty = self.cell[1] + self._facing[1]
            self.interact_requested.emit((tx, ty))
            return

        # Click-to-path: BFS to the tapped cell.
        if Input.just_pressed("walk_to"):
            mx, my = Input.mouse_position
            tx, ty = int(mx // TILE), int(my // TILE)
            if 0 <= tx and 0 <= ty:
                path = bfs_path(self.cell, (tx, ty))
                if path:
                    self._path = path[1:]  # first step happens immediately
                    nxt = path[0]
                    dx = nxt[0] - self.cell[0]
                    dy = nxt[1] - self.cell[1]
                    self._try_step(dx, dy)