nodes/unit.py

Part of Tanks of Freedom.

"""Unit nodes: Sprite2D wrapper with stats, AP and per-turn flags.

Visual is a procedural numpy texture from ``textures.make_unit``; a small
health bar Sprite2D is parented to the unit so it follows during animation.

Movement is fire-and-forget, call ``begin_move(path)`` and the unit walks
along the cells over time. ``move_finished`` signal fires when done so the
world can chain follow-up actions (capture / attack / end-of-step audio).
"""

from __future__ import annotations

from simvx.core import Node2D, Signal
from simvx.core.animation.sprite import Sprite2D

from .data import PLAYER_BLUE, PLAYER_RED, TILE_H, UNIT_HELICOPTER, UNIT_STATS
from .textures import make_health_bar, make_unit

# Step duration in seconds: keeps animation snappy but readable.
STEP_TIME = 0.18


class Unit(Node2D):
    """Single combat unit on the iso grid."""

    def __init__(self, *, unit_type: int, owner: int, cell: tuple[int, int], tile_map, **kwargs):
        super().__init__(name=f"unit_{owner}_{unit_type}_{cell[0]}_{cell[1]}", **kwargs)
        self.type = unit_type
        self.owner = owner
        self.cell = cell
        self._tile_map = tile_map

        stats = UNIT_STATS[unit_type]
        self.life = stats["life"]
        self.max_life = stats["max_life"]
        self.max_ap = stats["max_ap"]
        self.ap = self.max_ap
        self.attack_ap = stats["attack_ap"]
        self.attacks_left = stats["max_attacks"]
        self.is_air = unit_type == UNIT_HELICOPTER
        self.can_capture = stats["can_capture"]

        # Position the unit at the cell centre.
        wx, wy = tile_map.map_to_world(cell)
        # Float units a bit above the iso ground so they stack visually.
        self.position = (wx, wy - TILE_H * 0.4)

        self._sprite = Sprite2D(
            texture=make_unit(unit_type, owner),
            width=48,
            height=54,
            filter="nearest",
            position=(0, 0),
        )
        self.add_child(self._sprite)

        self._healthbar = Sprite2D(
            texture=make_health_bar(1.0),
            width=28,
            height=5,
            filter="nearest",
            position=(0, -30),
        )
        self.add_child(self._healthbar)

        # Signals
        self.move_finished = Signal()  # Emits when current path animation ends.
        self.died = Signal()  # Emits right before destroy().

        # Animation state.
        self._path: list[tuple[int, int]] = []
        self._step_t = 0.0
        self._anim_from: tuple[float, float] | None = None
        self._anim_to: tuple[float, float] | None = None
        self._moving = False

    # ----------------------------------------------------------- properties
    def is_blue(self) -> bool:
        return self.owner == PLAYER_BLUE

    def is_red(self) -> bool:
        return self.owner == PLAYER_RED

    @property
    def life_fraction(self) -> float:
        return self.life / self.max_life if self.max_life > 0 else 0.0

    @property
    def is_moving(self) -> bool:
        """True while the unit is animating along a path."""
        return self._moving

    # --------------------------------------------------------------- combat
    def can_attack(self) -> bool:
        """True when the unit still has the AP and the attack slot to strike."""
        return self.ap >= self.attack_ap and self.attacks_left > 0

    def consume_attack(self) -> None:
        self.ap = max(0, self.ap - self.attack_ap)
        self.attacks_left = max(0, self.attacks_left - 1)

    def end_turn_refresh(self) -> None:
        """Reset AP at the start of the owner's next turn."""
        self.ap = self.max_ap
        self.attacks_left = UNIT_STATS[self.type]["max_attacks"]

    def kill(self) -> None:
        self.died()
        self.destroy()

    # -------------------------------------------------------- move animation
    def begin_move(self, path: list[tuple[int, int]]) -> None:
        """Walk along ``path`` (cells). First cell should equal current cell.

        AP is decremented by ``len(path) - 1`` immediately so the unit can't
        be re-issued. ``move_finished`` fires when the last step lands.
        """
        if len(path) <= 1:
            self.cell = path[-1] if path else self.cell
            self.move_finished()
            return
        steps = path[1:]
        self.ap = max(0, self.ap - len(steps))
        self._path = steps
        self._step_t = 0.0
        self._begin_step()
        self._moving = True

    def _begin_step(self) -> None:
        target = self._path[0]
        wx, wy = self._tile_map.map_to_world(target)
        self._anim_from = (self.position.x, self.position.y)
        self._anim_to = (wx, wy - TILE_H * 0.4)

    def on_update(self, dt: float) -> None:
        if not self._moving:
            return
        self._step_t += dt
        u = min(1.0, self._step_t / STEP_TIME)
        # Linear lerp: small distance per step keeps it crisp.
        ax, ay = self._anim_from
        bx, by = self._anim_to
        self.position = (ax + (bx - ax) * u, ay + (by - ay) * u)
        if u >= 1.0:
            # Land
            self.cell = self._path.pop(0)
            self._step_t = 0.0
            if self._path:
                self._begin_step()
            else:
                self._moving = False
                self.move_finished()

    # ----------------------------------------------------------- visuals
    def refresh_health_bar(self) -> None:
        """Repaint the health bar after ``life`` changed.

        Combat resolution writes ``life`` directly (it is a pure function over
        plain attributes), so the world calls this once the damage is in.
        """
        # Replace texture in place by reassigning .texture (Sprite2D
        # invalidates the GPU id and the next frame uploads the new array).
        self._healthbar.texture = make_health_bar(self.life_fraction)

    def set_dim(self, dim: bool) -> None:
        """Grey the sprite out while it is not this unit's side's turn."""
        self._sprite.colour = (0.55, 0.55, 0.6, 1.0) if dim else (1.0, 1.0, 1.0, 1.0)