From 2e3816783fcf1c8fc3beccf0d14d1897a62f4df6 Mon Sep 17 00:00:00 2001 From: Sergio Valor Date: Tue, 5 May 2026 13:01:22 +0200 Subject: [PATCH] feat(immunity): API setImmunity/isImmune i lectura del bloc immunity --- source/core/rendering/surface.hpp | 4 +++ source/game/entities/player.cpp | 28 +++++++++++++++ source/game/entities/player.hpp | 58 +++++++++++++++++++++++++++++++ 3 files changed, 90 insertions(+) diff --git a/source/core/rendering/surface.hpp b/source/core/rendering/surface.hpp index b721202..4747a44 100644 --- a/source/core/rendering/surface.hpp +++ b/source/core/rendering/surface.hpp @@ -64,6 +64,10 @@ class Surface { void setPalette(const Palette& palette) { palette_ = palette; } [[nodiscard]] auto getPaletteColor(Uint8 index) const -> Uint32 { return palette_[index]; } + // Accés de lectura a la paleta sencera. L'usen consumidors que volen + // fer save/restore (p.ex. el blink d'immunitat del Player, que aplica + // una paleta plana abans del render i restaura la normal després). + [[nodiscard]] auto getPalette() const -> const Palette& { return palette_; } static void initializeSubPalette(SubPalette& palette) { std::iota(palette.begin(), palette.end(), 0); } diff --git a/source/game/entities/player.cpp b/source/game/entities/player.cpp index 21f6800..f93090c 100644 --- a/source/game/entities/player.cpp +++ b/source/game/entities/player.cpp @@ -14,6 +14,8 @@ #include "core/input/input_state.hpp" #include "core/rendering/canvas.hpp" #include "core/rendering/screen.hpp" +#include "core/rendering/surface.hpp" +#include "core/resources/palette_loader.hpp" #include "core/resources/resource_cache.hpp" #include "core/resources/resource_helper.hpp" #include "external/fkyaml_node.hpp" @@ -75,6 +77,7 @@ Player::JumpConfig Player::jump_config; Player::HurtConfig Player::hurt_config; Player::WhipConfig Player::whip_config; Player::DeathConfig Player::death_config; +Player::ImmunityConfig Player::immunity_config; void Player::loadFrom(const std::string& yaml_path) { auto bytes = Resource::Helper::loadFile(yaml_path); @@ -131,6 +134,11 @@ void Player::loadFrom(const std::string& yaml_path) { // vides. Si manca, el respawn és immediat i les vides queden a 3 // per defecte (no és un valor crític: avui no hi ha game over). readDeathBlock(yaml); + + // Bloc opcional `immunity:` — finestra de gràcia post-spawn. Si + // `duration_ms` és 0 (o el bloc manca) la mecànica queda + // desactivada i els hazards toquen al primer frame, com abans. + readImmunityBlock(yaml); } void Player::readCollisionBlock(const fkyaml::node& yaml, const std::string& yaml_path) { @@ -205,6 +213,20 @@ void Player::readDeathBlock(const fkyaml::node& yaml) { if (d.contains("lives")) { death_config.initial_lives = d["lives"].get_value(); } } +void Player::readImmunityBlock(const fkyaml::node& yaml) { + immunity_config = ImmunityConfig{}; + if (!yaml.contains("immunity")) { return; } + const auto& im = yaml["immunity"]; + if (im.contains("duration_ms")) { immunity_config.duration_ms = im["duration_ms"].get_value(); } + if (im.contains("blink_period_ms")) { immunity_config.blink_period_ms = im["blink_period_ms"].get_value(); } + // Paleta del blink: el basename val tant de clau al Resource::Cache + // com de path (`data/player/.pal`). Mateix patró que els sons. + if (im.contains("palette")) { + immunity_config.palette_key = im["palette"].get_value(); + Resource::Cache::get().loadPalette(immunity_config.palette_key, "data/player/" + immunity_config.palette_key + ".pal"); + } +} + void Player::readWhipBlock(const fkyaml::node& yaml) { whip_config = WhipConfig{}; if (!yaml.contains("whip")) { return; } @@ -372,6 +394,12 @@ Player::Player(const std::string& anim_key, int id, float x, float y, const Cont // GameScene el reescriu via `setSpawnPoint` quan canvia de sala. spawn_x_ = x; spawn_y_ = y; + // Cachegem la paleta normal del sprite ara que la Surface ja està + // carregada. El render del blink d'immunitat la restaura després + // d'aplicar la paleta plana — fer-ho via membre evita dependre de + // l'estat momentani de la Surface (que pot ser compartida entre + // jugadors del mateix personatge). + if (surface_ != nullptr) { normal_palette_ = surface_->getPalette(); } } void Player::update(float delta_time) { diff --git a/source/game/entities/player.hpp b/source/game/entities/player.hpp index b47290f..db694fb 100644 --- a/source/game/entities/player.hpp +++ b/source/game/entities/player.hpp @@ -8,6 +8,7 @@ #include #include "core/rendering/sprite/animated_sprite.hpp" +#include "core/rendering/surface.hpp" #include "external/fkyaml_node.hpp" #include "game/map/map.hpp" @@ -311,6 +312,25 @@ class Player : public AnimatedSprite { // game over. Públic per a HUD i tests. [[nodiscard]] auto getLivesRemaining() const -> int { return lives_remaining_; } + // Activa la immunitat per `duration_ms` ms. Mentre `isImmune()` és + // cert, `enterHurt` i `enterDying(GENERIC)` són no-op — els hazards no + // poden tocar el jugador. La caiguda per forats (`enterDying(HOLE)`) + // segueix funcionant: els forats no són dany convencional, són una + // sortida lògica del món. Idempotent: una segona crida reescriu el + // timer (no acumula). Visualment, el render alterna la paleta del + // sprite amb una paleta plana cada `immunity_config.blink_period_ms` + // ms. Si `duration_ms <= 0` és no-op (manera de cancel·lar + // explícitament la immunitat seria `setImmunity(0)` — equivalent al + // comportament natural quan el timer s'esgota). + void setImmunity(float duration_ms) { + if (duration_ms > 0.0F) { immunity_remaining_ms_ = duration_ms; } + } + + // Cert mentre el jugador té immunitat activa. Comprovat per + // `enterHurt` i `enterDying` per filtrar els hazards. La causa HOLE + // ignora aquest gate (vegeu `enterDying`). + [[nodiscard]] auto isImmune() const -> bool { return immunity_remaining_ms_ > 0.0F; } + // Reset complet a l'estat inicial: posició a (x, y), velocitats a 0, // estat GROUNDED, qualsevol flag de control reinicialitzat. Cridat // per GameScene a la transició ROOM_OUTRO → ROOM_INTRO. Idempotent @@ -664,6 +684,30 @@ class Player : public AnimatedSprite { // l'animació) i `initial_lives` es manté al default (3). static void readDeathBlock(const fkyaml::node& yaml); + // Configuració de la immunitat post-spawn llegida del bloc `immunity:` + // del YAML. `duration_ms` és el temps per defecte que dura cada + // immunitat (l'invoca `respawn`). `blink_period_ms` és el mig-cicle del + // parpadeig visual: cada `blink_period_ms` ms, el render alterna + // entre la paleta normal i la paleta `palette_key`. Si `duration_ms` + // és 0 (o el bloc manca) la immunitat queda desactivada i el + // comportament és l'antic. + struct ImmunityConfig { + float duration_ms{0.0F}; + int blink_period_ms{0}; + // Clau al Resource::Cache de la paleta plana usada al blink (basename + // del .pal a `data/player/`). Buida = no hi ha alternança visual, + // només la finestra lògica d'immunitat (que sense feedback visual + // pot ser confusa, però no és incorrecte). + std::string palette_key; + }; + static ImmunityConfig immunity_config; + + // Llig el bloc `immunity:` del YAML i n'omple `immunity_config`. Si + // hi ha `palette`, registra la paleta corresponent al Resource::Cache + // (path: `data/player/.pal`). Mateix patró que els altres + // readers — `loadFrom` el crida al final. + static void readImmunityBlock(const fkyaml::node& yaml); + // Activa l'estat ATTACKING en la direcció cardinal indicada (la // direcció cap on mira el jugador) i publica `whip_spawn` al bus // perquè el GameScene cree el `WhipAttack` corresponent. Posa el @@ -743,6 +787,20 @@ class Player : public AnimatedSprite { // LANDING_STUN i tot l'input queda bloquejat. float landing_stun_remaining_ms_{0.0F}; + // Temps restant d'immunitat (ms). Decreix cada frame al `tick`, + // independentment de l'estat — la immunitat és ortogonal al state + // machine. Mentre > 0, `enterHurt` i `enterDying(GENERIC)` són no-op. + // L'arma `setImmunity()` (cridada per `respawn` amb la durada del + // YAML), i el render alterna paleta cada `immunity_config.blink_period_ms`. + float immunity_remaining_ms_{0.0F}; + + // Còpia de la paleta normal del sprite (extreta de `surface_->getPalette()` + // al ctor). El render del blink l'usa per restaurar la paleta després + // d'aplicar la versió plana cada mig-cicle. Cachejada perquè la + // Surface pot ser compartida entre dos jugadors del mateix personatge + // i no és segur consultar-la entre swaps. + Palette normal_palette_{}; + // Estat anterior del botó de salt per fer detecció de flanc (saltem // només a la transició no-premut → premut, no mentre es manté). Es // manté un per teclat i un per mando perquè poden conviure.