nodes/player.py

Part of Dodge the Creeps.

"""Player: moves with keys, a stick or the drawn pad, and emits `hit`."""

from __future__ import annotations

import math

from simvx.core import (
    AnimatedSprite2D,
    Axis2D,
    CharacterBody2D,
    CircleShape2D,
    Controller,
    Input,
    InputContext,
    Key,
    Property,
    Signal,
    Vec2,
)

from .sprite_sheets import player_sheet


class Player(CharacterBody2D):
    """Player character.

    Implemented with `CharacterBody2D` (so we get group-based collision queries
    for free) plus a child `AnimatedSprite2D` for the walk/up animations. The
    `hit` signal is emitted when the main scene detects collision with a mob.
    """

    # Walking is one typed action rather than four opposed ones, so the two key
    # sets, a controller's left stick and the drawn pad's stick all feed the
    # same binding and the one furthest from rest wins. The context is live
    # exactly while this node is in the tree, so a test that loads the player
    # alone can steer it without registering anything.
    input_context = InputContext(
        {
            "move": [
                Axis2D(up=Key.W, down=Key.S, left=Key.A, right=Key.D),
                Axis2D(up=Key.UP, down=Key.DOWN, left=Key.LEFT, right=Key.RIGHT),
                Controller.LEFT_STICK,
            ],
        },
        name="player",
    )

    speed = Property(400.0, range=(0, 1000), hint="Pixels per second")

    #: How far sideways the player has to lean before the walk sprite is the
    #: one to show, as a fraction of a fully pushed stick.
    SIDEWAYS = 0.25

    hit = Signal()

    def __init__(self, **kwargs):
        # Capsule-ish radius: generous enough to catch any mob touching the
        # player sprite at scale 0.5 (~50px wide).
        super().__init__(shape=CircleShape2D(24.0), **kwargs)
        self.add_to_group("player")
        self._alive = False  # mirrors Godot's `hide()` / `show()` flow

        walk_sheet, walk_w, walk_h = player_sheet("walk")
        self.sprite = self.add_child(
            AnimatedSprite2D(
                texture=walk_sheet,
                frames_h=2,
                frames_v=1,
                width=walk_w,
                height=walk_h,
                scale=Vec2(0.5, 0.5),
                name="AnimatedSprite2D",
            )
        )
        self.sprite.add_animation("walk", frames=[0, 1], fps=5.0, loop=True)
        self.sprite.add_animation("up", frames=[0, 1], fps=5.0, loop=True)
        # `player_sheet` is cached, so the "up" sheet is only built the first
        # time the player walks upward.
        self._current_anim = "walk"

    def _switch_anim(self, name: str):
        if self._current_anim == name and self.sprite.playing:
            return
        if self._current_anim != name:
            # Assigning `texture` invalidates the sprite's GPU handle on its
            # own, so the new sheet is uploaded on the next frame.
            self.sprite.texture = player_sheet(name)[0]
            self._current_anim = name
        self.sprite.play(name)

    def overlapping_mobs(self) -> list:
        """Mobs whose circular collider currently overlaps the player's.

        Replaces the old arcade ``CharacterBody2D.get_overlapping(group=)``: these
        ports integrate motion by hand (no PhysicsRoot / broadphase), so collision
        is a direct circle-circle distance test over the ``mobs`` group, exactly
        what the old arcade query did internally.
        """
        if not self.tree:
            return []
        pr = float(self.shape.radius)
        px, py = float(self.position.x), float(self.position.y)
        hits = []
        for mob in self.tree.group("mobs"):
            mr = float(mob.shape.radius)
            dx, dy = px - float(mob.position.x), py - float(mob.position.y)
            if dx * dx + dy * dy <= (pr + mr) * (pr + mr):
                hits.append(mob)
        return hits

    def start(self, position: Vec2):
        """Spawn at *position*, restoring visibility and collision."""
        self.position = Vec2(position)
        self.rotation = 0.0
        self.visible = True
        self.sprite.visible = True
        self._alive = True

    def kill(self):
        """Hide and disable. Mirrors Godot's deferred CollisionShape disable."""
        self._alive = False
        self.visible = False
        self.sprite.visible = False
        self.sprite.stop()

    def on_update(self, dt: float):
        if not self._alive:
            return

        # One read covers the keys, a controller's stick and the drawn pad.
        # A held key reads as a full unit, a stick as how far it is pushed, so
        # the same line walks at full speed on a keyboard and eases on a stick.
        direction = Input.value("move")
        velocity = direction * self.speed

        if direction.length() > 0:
            # Pick animation: the sideways walk once the player is leaning far
            # enough sideways for it to read, otherwise the up/down sprite.
            if abs(float(direction.x)) > self.SIDEWAYS:
                self._switch_anim("walk")
                # Flip horizontally by negative X scale; preserve magnitude.
                sx = -0.5 if direction.x < 0 else 0.5
                self.sprite.scale = Vec2(sx, 0.5)
                self.rotation = 0.0
            else:
                self._switch_anim("up")
                self.sprite.scale = Vec2(0.5, 0.5)
                # Face downward when moving down: flip the whole player.
                self.rotation = math.pi if direction.y > 0 else 0.0
        else:
            self.sprite.stop()

        self.position += velocity * dt
        # Clamp to the live size of whatever this node draws into, so a resize
        # moves the walls with it.
        width, height = self.viewport_size
        self.position = Vec2(
            max(0.0, min(float(width), float(self.position.x))),
            max(0.0, min(float(height), float(self.position.y))),
        )