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

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;
     }