nodes/bird.py

Part of Clumsy Bird.

"""Player bird: gravity, flap, rotation."""

import math

from config import ASSETS, BIRD_REST_FRACTION, BIRD_X, FLAP_IMPULSE, GRAVITY, MAX_FALL_SPEED

from simvx.core import (
    AnimatedSprite2D,
    AudioPlayer,
    CharacterBody2D,
    Property,
    RectangleShape2D,
    Signal,
    Vec2,
)

from .audio import make_wing


class Bird(CharacterBody2D):
    """Player bird. Vertical-only motion; horizontal x is fixed.

    Motion is integrated by hand in ``on_fixed_update`` rather than with
    ``move_and_slide``, so the body's collider is never swept: it exists purely
    for the overlap queries in :meth:`overlaps_group`.
    """

    gravity = Property(GRAVITY, range=(200, 4000), hint="Pixels/sec^2 downward acceleration")
    flap_impulse = Property(FLAP_IMPULSE, range=(100, 1200), hint="Upward velocity on flap")
    max_fall_speed = Property(MAX_FALL_SPEED, range=(100, 2000))

    flapped = Signal()
    crashed = Signal()

    def __init__(self, **kwargs):
        # Slightly tighter collision than the full sprite so the bird doesn't
        # clip through the visible pipe rim.
        super().__init__(shape=RectangleShape2D(half_extents=Vec2(28, 18)), **kwargs)
        self.add_to_group("bird")
        self.alive = True
        self.frozen = True  # frozen until first flap (Get Ready phase)
        self._idle_time = 0.0

        # Sprite (3-frame flap animation; 85x60 per frame, sheet 255x60).
        self.sprite = self.add_child(
            AnimatedSprite2D(
                texture=str(ASSETS / "clumsy.png"),
                frames_h=3,
                frames_v=1,
                width=85,
                height=60,
                name="Sprite",
            )
        )
        self.sprite.add_animation("flying", [0, 1, 2, 1], fps=12, loop=True)
        self.sprite.add_animation("idle", [0], fps=1, loop=False)
        self.sprite.play("flying")

        # Wing SFX (procedural; see nodes/audio.py).
        self._wing_player = self.add_child(AudioPlayer(stream=make_wing(), bus="SFX", name="WingSFX"))

    # ------------------------------------------------------------------
    # Lifecycle
    # ------------------------------------------------------------------

    @property
    def rest_y(self) -> float:
        """Height the bird hovers at before the first flap, for this window."""
        return float(self.viewport_size.y) * BIRD_REST_FRACTION

    def on_enter_tree(self):
        # CharacterBody2D registers its body here, so the base hook runs first.
        super().on_enter_tree()
        # The viewport size is only knowable once the node is in a tree, so
        # the spawn point is set here rather than in __init__.
        self.position = Vec2(BIRD_X, self.rest_y)

    def on_fixed_update(self, dt: float):
        if not self.alive:
            # Dead-fall continues until the bird hits the ground; rotate to
            # face plant.
            self.velocity.y += self.gravity * dt
            self.velocity.y = min(self.velocity.y, self.max_fall_speed)
            self.position.y += self.velocity.y * dt
            self.rotation = min(self.rotation + math.radians(360) * dt, math.radians(90))
            return

        if self.frozen:
            # Idle bob until the first flap unfreezes us (see flap()).
            self._idle_time += dt
            self.position.y = self.rest_y + math.sin(self._idle_time * 4.0) * 8.0
            return

        # Gravity
        self.velocity.y += self.gravity * dt
        self.velocity.y = min(self.velocity.y, self.max_fall_speed)
        self.position.y += self.velocity.y * dt

        # Tilt runs from -25 degrees (rising fast) to +90 (falling fast). The
        # sprite is a child, so it inherits this rotation: setting it again on
        # the sprite would double the tilt.
        target_deg = max(-25.0, min(90.0, self.velocity.y * 0.18))
        self.rotation = math.radians(target_deg)

        # Crash on ceiling
        if self.position.y < -20:
            self.die()

    def overlaps_group(self, group: str) -> bool:
        """True if the bird's rectangular collider overlaps any body in *group*.

        A direct AABB rect-vs-rect test over the group's rectangular colliders:
        this port integrates motion itself and has no ``PhysicsRoot``, so there
        is no broadphase to query.
        """
        if not self.tree:
            return False
        bh = self.shape.half_extents
        bp = self.world_position
        for body in self.tree.group(group):
            oh = body.shape.half_extents
            op = body.world_position
            if abs(float(bp.x) - float(op.x)) <= float(bh[0]) + float(oh[0]) and abs(
                float(bp.y) - float(op.y)
            ) <= float(bh[1]) + float(oh[1]):
                return True
        return False

    # ------------------------------------------------------------------
    # API
    # ------------------------------------------------------------------

    def flap(self):
        """Apply one upward impulse. Ignored once the bird is dead.

        ``flapped`` is emitted before the impulse: PlayScene connects it
        ``once`` and answers by calling :meth:`start`, which zeroes velocity.
        """
        if not self.alive:
            return
        self.flapped.emit()
        self.velocity.y = -self.flap_impulse
        self._wing_player.stop()
        self._wing_player.play()

    def start(self):
        """Unfreeze: bird begins responding to gravity/input."""
        self.frozen = False
        self.position.y = self.rest_y
        self.velocity = Vec2(0, 0)

    def die(self):
        if not self.alive:
            return
        self.alive = False
        self.frozen = False
        self.sprite.stop()
        self.crashed.emit()