feat(lighting): flicker proporcional al radi amb overrides per emissor

source/game/entities/entity.hpp

@@ -7,6 +7,7 @@
 #include <optional>
 #include <string>
 
+#include "core/rendering/lighting.hpp"
 #include "game/entities/animation_component.hpp"
 
 // Forward-declaracions: mantenim aquest header lleuger. `Player` viu a
@@ -296,6 +297,15 @@ class Entity {
         light_offset_y_ = y;
     }
 
+    // Paràmetres del flicker resolts per a aquest emissor (combinació
+    // del global de `data/config/lighting.yaml` + overrides del tipus,
+    // sala i spawn). Només té efecte si `light_flicker_` és true. El
+    // construct path li passa una còpia ja resolta — el raster (lighting.cpp)
+    // només la llegeix. Es publica per camps perquè el bloc YAML
+    // `flicker_params:` permet sobreescriure qualsevol subconjunt.
+    [[nodiscard]] auto getFlickerParams() const -> const Lighting::FlickerConfig& { return flicker_params_; }
+    void setFlickerParams(const Lighting::FlickerConfig& fp) { flicker_params_ = fp; }
+
     // Identificador estable per al flicker. Cada Entity rep un valor
     // únic a la construcció (contador estàtic) i el conserva fins a la
     // mort — així el patró del flicker no "deriva" quan l'entitat es
@@ -339,6 +349,7 @@ class Entity {
     std::uint8_t light_color_b_{255};
     int light_offset_x_{0};
     int light_offset_y_{0};
+    Lighting::FlickerConfig flicker_params_{};
     bool dead_{false};
     SDL_FlipMode flip_{SDL_FLIP_NONE};
     EventBus* bus_{nullptr};

source/game/entities/entity_manager_loadlevel.cpp

@@ -174,6 +174,9 @@ namespace {
         std::uint8_t color_b{255};
         int offset_x{0};
         int offset_y{0};
+        // Inicialitzat al global a `readLight`; overrides parcials del
+        // tipus/sala/spawn modifiquen camps concrets sense tocar la resta.
+        Lighting::FlickerConfig flicker_params{};
     };
 
     // Helper compartit entre les tres capes (tipus, sala via Map, spawn)
@@ -196,14 +199,28 @@ namespace {
         return true;
     }
 
+    // Aplica els camps presents al bloc `flicker_params: { ... }` sobre
+    // una `FlickerConfig` ja inicialitzada (típicament amb el global o
+    // amb el resultat d'una capa anterior). Camps absents es respecten
+    // — per a poder sobreescriure'n només un.
+    void applyFlickerOverrides(const fkyaml::node& fp, Lighting::FlickerConfig& out) {
+        if (fp.contains("wave_amplitude_ratio")) { out.wave_amplitude_ratio = fp["wave_amplitude_ratio"].get_value<float>(); }
+        if (fp.contains("wave_frequency_hz")) { out.wave_frequency_hz = fp["wave_frequency_hz"].get_value<float>(); }
+        if (fp.contains("noise_amplitude_ratio")) { out.noise_amplitude_ratio = fp["noise_amplitude_ratio"].get_value<float>(); }
+        if (fp.contains("noise_frequency_hz")) { out.noise_frequency_hz = fp["noise_frequency_hz"].get_value<float>(); }
+    }
+
     auto readLight(const fkyaml::node& tmpl) -> LightTemplate {
-        if (!tmpl.contains("light")) { return {}; }
-        const auto& l = tmpl["light"];
         LightTemplate out;
+        // Punt de partida del flicker: el global de lighting.yaml.
+        out.flicker_params = Lighting::flickerConfig();
+        if (!tmpl.contains("light")) { return out; }
+        const auto& l = tmpl["light"];
         if (l.contains("radius")) { out.radius = l["radius"].get_value<int>(); }
         if (l.contains("flicker")) { out.flicker = l["flicker"].get_value<bool>(); }
         if (l.contains("color")) { readColorTriplet(l["color"], out.color_r, out.color_g, out.color_b); }
         if (l.contains("offset")) { readOffsetPair(l["offset"], out.offset_x, out.offset_y); }
+        if (l.contains("flicker_params")) { applyFlickerOverrides(l["flicker_params"], out.flicker_params); }
         return out;
     }
 
@@ -215,10 +232,14 @@ namespace {
     // Forma 3: la sala declara `<tipus>: true` o `<tipus>: { ... }` → els
     // camps presents a l'override sobreescriuen el default; els absents
     // (`std::nullopt`) cauen al default del tipus.
-    auto resolveLightWithRoom(const std::string& type, LightTemplate type_default) -> LightTemplate {
+    auto resolveLightWithRoom(const std::string& type, const LightTemplate& type_default) -> LightTemplate {
         const auto* room = Map::getRoomEmitterOverride(type);
         if (room == nullptr) { return type_default; }
-        if (!room->enabled) { return LightTemplate{}; }
+        if (!room->enabled) {
+            LightTemplate empty;
+            empty.flicker_params = Lighting::flickerConfig();
+            return empty;
+        }
         LightTemplate out = type_default;
         if (room->radius.has_value()) { out.radius = *room->radius; }
         if (room->flicker.has_value()) { out.flicker = *room->flicker; }
@@ -231,6 +252,10 @@ namespace {
             out.offset_x = (*room->offset)[0];
             out.offset_y = (*room->offset)[1];
         }
+        if (room->flicker_wave_amplitude_ratio.has_value()) { out.flicker_params.wave_amplitude_ratio = *room->flicker_wave_amplitude_ratio; }
+        if (room->flicker_wave_frequency_hz.has_value()) { out.flicker_params.wave_frequency_hz = *room->flicker_wave_frequency_hz; }
+        if (room->flicker_noise_amplitude_ratio.has_value()) { out.flicker_params.noise_amplitude_ratio = *room->flicker_noise_amplitude_ratio; }
+        if (room->flicker_noise_frequency_hz.has_value()) { out.flicker_params.noise_frequency_hz = *room->flicker_noise_frequency_hz; }
         return out;
     }
 
@@ -266,6 +291,11 @@ namespace {
             int y{};
             if (readOffsetPair(l["offset"], x, y)) { entity.setLightOffset(x, y); }
         }
+        if (l.contains("flicker_params")) {
+            Lighting::FlickerConfig fp = entity.getFlickerParams();
+            applyFlickerOverrides(l["flicker_params"], fp);
+            entity.setFlickerParams(fp);
+        }
     }
 
     // Bloc `collision: { size: [w, h], base_size: [bw, bh]?, offset: [x, y]? }`
@@ -399,6 +429,7 @@ namespace {
         entity->setLightFlicker(LIGHT.flicker);
         entity->setLightColor(LIGHT.color_r, LIGHT.color_g, LIGHT.color_b);
         entity->setLightOffset(LIGHT.offset_x, LIGHT.offset_y);
+        entity->setFlickerParams(LIGHT.flicker_params);
         anchor_out = readAnchor(tmpl);
         return entity;
     }

source/game/entities/player.cpp

@@ -155,6 +155,9 @@ void Player::readLightBlock(const fkyaml::node& yaml) {
     light_color_b = 255;
     light_offset_x = 0;
     light_offset_y = 0;
+    // Punt de partida del flicker: el global de lighting.yaml. El bloc
+    // opcional `flicker_params:` del personatge sobreescriu camps concrets.
+    flicker_params = Lighting::flickerConfig();
     if (!yaml.contains("light")) { return; }
     const auto& l = yaml["light"];
     if (l.contains("radius")) { light_radius = l["radius"].get_value<int>(); }
@@ -178,6 +181,15 @@ void Player::readLightBlock(const fkyaml::node& yaml) {
             light_offset_y = o[1].get_value<int>();
         }
     }
+    // `flicker_params: { ... }` opcional. Qualsevol dels 4 camps absent
+    // conserva el valor heretat del global (vegeu inicialització a sobre).
+    if (l.contains("flicker_params")) {
+        const auto& fp = l["flicker_params"];
+        if (fp.contains("wave_amplitude_ratio")) { flicker_params.wave_amplitude_ratio = fp["wave_amplitude_ratio"].get_value<float>(); }
+        if (fp.contains("wave_frequency_hz")) { flicker_params.wave_frequency_hz = fp["wave_frequency_hz"].get_value<float>(); }
+        if (fp.contains("noise_amplitude_ratio")) { flicker_params.noise_amplitude_ratio = fp["noise_amplitude_ratio"].get_value<float>(); }
+        if (fp.contains("noise_frequency_hz")) { flicker_params.noise_frequency_hz = fp["noise_frequency_hz"].get_value<float>(); }
+    }
 }
 
 void Player::readCollisionBlock(const fkyaml::node& yaml, const std::string& yaml_path) {

source/game/entities/player.hpp

@@ -7,6 +7,7 @@
 #include <utility>
 #include <vector>
 
+#include "core/rendering/lighting.hpp"
 #include "core/rendering/sprite/animated_sprite.hpp"
 #include "core/rendering/surface.hpp"
 #include "external/fkyaml_node.hpp"
@@ -140,6 +141,10 @@ class Player : public AnimatedSprite {
     inline static std::uint8_t light_color_b = 255;
     inline static int light_offset_x = 0;
     inline static int light_offset_y = 0;
+    // Paràmetres del flicker resolts per al jugador (combinació del
+    // global + override del YAML del personatge + override de sala).
+    // Només té efecte si `light_flicker` és true.
+    inline static Lighting::FlickerConfig flicker_params{};
 
     // Ha de cridar-se abans d'instanciar Player; GameScene ho fa al ctor.
     static void loadFrom(const std::string& yaml_path);
@@ -160,6 +165,7 @@ class Player : public AnimatedSprite {
     [[nodiscard]] static auto getLightColorB() -> std::uint8_t { return light_color_b; }
     [[nodiscard]] static auto getLightOffsetX() -> int { return light_offset_x; }
     [[nodiscard]] static auto getLightOffsetY() -> int { return light_offset_y; }
+    [[nodiscard]] static auto getFlickerParams() -> const Lighting::FlickerConfig& { return flicker_params; }
     // Seed estable per al flicker: reusem `id_` (0 o 1 en multijugador
     // local) amb un offset gran per evitar col·lisions amb el contador
     // d'Entity (que arrenca des de 1). Així P1 i P2 oscil·len en fases

source/game/map/map.cpp

@@ -78,6 +78,52 @@ namespace Map {
             };
         }
 
+        // Llegeix el sub-bloc opcional `flicker_params:` d'un emissor de
+        // sala. Camps individuals — qualsevol absent conserva el valor
+        // del global (`Lighting::flickerConfig()`) o de la capa que ho
+        // precedeixi (tipus / sala).
+        void readFlickerOverrides(const fkyaml::node& fp, RoomEmitterOverride& ov) {
+            if (fp.contains("wave_amplitude_ratio")) { ov.flicker_wave_amplitude_ratio = fp["wave_amplitude_ratio"].get_value<float>(); }
+            if (fp.contains("wave_frequency_hz")) { ov.flicker_wave_frequency_hz = fp["wave_frequency_hz"].get_value<float>(); }
+            if (fp.contains("noise_amplitude_ratio")) { ov.flicker_noise_amplitude_ratio = fp["noise_amplitude_ratio"].get_value<float>(); }
+            if (fp.contains("noise_frequency_hz")) { ov.flicker_noise_frequency_hz = fp["noise_frequency_hz"].get_value<float>(); }
+        }
+
+        // Llegeix una entrada del mapping `lighting.emitters.<tipus>` en
+        // qualsevol de les seves 3 formes (bool curt o mapping detallat).
+        // Extret per mantenir `loadLightingBlock` sota el llindar de
+        // complexitat cognitiva de clang-tidy.
+        auto readEmitterEntry(const fkyaml::node& val) -> RoomEmitterOverride {
+            RoomEmitterOverride ov;
+            if (val.is_boolean()) {
+                ov.enabled = val.get_value<bool>();
+                return ov;
+            }
+            if (!val.is_mapping()) { return ov; }
+            ov.enabled = true;
+            if (val.contains("radius")) { ov.radius = val["radius"].get_value<int>(); }
+            if (val.contains("flicker")) { ov.flicker = val["flicker"].get_value<bool>(); }
+            if (val.contains("color")) { ov.color = parseColorTriplet(val["color"]); }
+            if (val.contains("offset")) { ov.offset = parseIntPair(val["offset"]); }
+            if (val.contains("flicker_params")) { readFlickerOverrides(val["flicker_params"], ov); }
+            return ov;
+        }
+
+        // Llegeix la subclau `mode:` del bloc `lighting:` i actualitza
+        // `lighting_mode`. Avisa via Log si el valor no és reconegut.
+        // Extret de `loadLightingBlock` per la mateixa raó.
+        void readLightingMode(const fkyaml::node& lighting) {
+            if (!lighting.contains("mode")) { return; }
+            const auto MODE_STR = lighting["mode"].get_value<std::string>();
+            if (MODE_STR == "additive") {
+                lighting_mode = Lighting::Mode::ADDITIVE;
+            } else if (MODE_STR == "subtractive") {
+                lighting_mode = Lighting::Mode::SUBTRACTIVE;
+            } else {
+                Log::warn("Map", "lighting.mode '{}' desconegut — s'usa subtractive", MODE_STR);
+            }
+        }
+
         // Llegeix el bloc opcional `lighting:` del YAML d'una sala i
         // actualitza `light_level`, `lighting_mode` i el mapping
         // `g_room_emitters`. Idempotent: cada `Map::loadFrom` reseteja
@@ -91,32 +137,12 @@ namespace Map {
             if (lighting.contains("level")) {
                 light_level = lighting["level"].get_value<float>();
             }
-            if (lighting.contains("mode")) {
-                const auto MODE_STR = lighting["mode"].get_value<std::string>();
-                if (MODE_STR == "additive") {
-                    lighting_mode = Lighting::Mode::ADDITIVE;
-                } else if (MODE_STR == "subtractive") {
-                    lighting_mode = Lighting::Mode::SUBTRACTIVE;
-                } else {
-                    Log::warn("Map", "lighting.mode '{}' desconegut — s'usa subtractive", MODE_STR);
-                }
-            }
+            readLightingMode(lighting);
             if (!lighting.contains("emitters") || !lighting["emitters"].is_mapping()) { return; }
             const auto& em = lighting["emitters"];
             for (auto it = em.begin(); it != em.end(); ++it) {
                 const auto KEY = normalizeEmitterKey(it.key().get_value<std::string>());
-                const auto& val = it.value();
-                RoomEmitterOverride ov;
-                if (val.is_boolean()) {
-                    ov.enabled = val.get_value<bool>();
-                } else if (val.is_mapping()) {
-                    ov.enabled = true;
-                    if (val.contains("radius")) { ov.radius = val["radius"].get_value<int>(); }
-                    if (val.contains("flicker")) { ov.flicker = val["flicker"].get_value<bool>(); }
-                    if (val.contains("color")) { ov.color = parseColorTriplet(val["color"]); }
-                    if (val.contains("offset")) { ov.offset = parseIntPair(val["offset"]); }
-                }
-                g_room_emitters[KEY] = ov;
+                g_room_emitters[KEY] = readEmitterEntry(it.value());
             }
         }
     }  // namespace

source/game/map/map.hpp

@@ -99,6 +99,14 @@ namespace Map {
         // sprite (píxels enters; Y creix avall). `nullopt` → conservar
         // l'offset del tipus (default [0, 0]). Forma YAML: `offset: [x, y]`.
         std::optional<std::array<int, 2>> offset;
+        // Overrides parcials per cada camp del `FlickerConfig` (ràtio
+        // d'amplitud i freqüència del wave + noise). `nullopt` → no
+        // toca aquell camp (conserva el del tipus, que al seu torn pot
+        // ser el global). Forma YAML: `flicker_params: { wave_frequency_hz: 1.0, ... }`.
+        std::optional<float> flicker_wave_amplitude_ratio;
+        std::optional<float> flicker_wave_frequency_hz;
+        std::optional<float> flicker_noise_amplitude_ratio;
+        std::optional<float> flicker_noise_frequency_hz;
     };
 
     // Consulta l'override de sala per a un tipus d'entitat (clau singular,

source/game/scenes/game_scene.cpp

@@ -259,6 +259,10 @@ namespace {
             Player::light_offset_x = (*room->offset)[0];
             Player::light_offset_y = (*room->offset)[1];
         }
+        if (room->flicker_wave_amplitude_ratio.has_value()) { Player::flicker_params.wave_amplitude_ratio = *room->flicker_wave_amplitude_ratio; }
+        if (room->flicker_wave_frequency_hz.has_value()) { Player::flicker_params.wave_frequency_hz = *room->flicker_wave_frequency_hz; }
+        if (room->flicker_noise_amplitude_ratio.has_value()) { Player::flicker_params.noise_amplitude_ratio = *room->flicker_noise_amplitude_ratio; }
+        if (room->flicker_noise_frequency_hz.has_value()) { Player::flicker_params.noise_frequency_hz = *room->flicker_noise_frequency_hz; }
     }
 
 }  // namespace
@@ -590,6 +594,14 @@ void GameScene::loadRoom(const std::string& yaml_path) {
     // CLOSED amb visited buit, momies i altres actors a la posició inicial.
     config_.map_yaml = yaml_path;
     Map::loadFrom(yaml_path);
+    // Refresquem els statics del Player a partir del YAML i tornem a
+    // aplicar l'override d'aquesta sala. Sense això, una sala amb
+    // `players: false` deixa `light_radius=0` i, en transicionar a una
+    // altra sala que no toqui el camp (o digui `players: true`), els
+    // jugadors no tornen a emetre — l'override actual és "additiu"
+    // sobre els statics existents, no un reset.
+    Player::loadFrom(config_.player_yaml);
+    applyRoomLightOverrideToPlayer();
     // Tilemap pre-blita els tiles a un buffer ARGB intern al ctor — sense
     // reconstruir-lo, la imatge de la sala anterior es queda fixada per a
     // sempre. PaintLayer captura `tileset_path_`/`tileset_cols_` per valor
@@ -1054,17 +1066,18 @@ void GameScene::applyLightingPass() {
         .g = Player::getLightColorG(),
         .b = Player::getLightColorB(),
     };
+    const Lighting::FlickerConfig PLAYER_FP = Player::getFlickerParams();
     for (const auto& p : players_) {
         if (p->isOutOfPlay()) { continue; }
         const auto C = p->getLightCenter();
-        emitters.push_back({.cx = C.x, .cy = C.y, .radius = PLAYER_R, .seed = p->getLightSeed(), .flicker = PLAYER_FLICKER, .color = PLAYER_COLOR});
+        emitters.push_back({.cx = C.x, .cy = C.y, .radius = PLAYER_R, .seed = p->getLightSeed(), .flicker = PLAYER_FLICKER, .color = PLAYER_COLOR, .flicker_params = PLAYER_FP});
     }
     for (const auto* e : entity_manager_.getEntities()) {
         const int R = e->getLightRadius();
         if (R <= 0) { continue; }
         const auto C = e->getLightCenter();
         const Lighting::Color COL{.r = e->getLightColorR(), .g = e->getLightColorG(), .b = e->getLightColorB()};
-        emitters.push_back({.cx = C.x, .cy = C.y, .radius = R, .seed = e->getLightSeed(), .flicker = e->getLightFlicker(), .color = COL});
+        emitters.push_back({.cx = C.x, .cy = C.y, .radius = R, .seed = e->getLightSeed(), .flicker = e->getLightFlicker(), .color = COL, .flicker_params = e->getFlickerParams()});
     }
     Lighting::apply(Screen::get().getCanvasArgb(),
         Screen::get().getCanvasWidth(),