feat(lighting): mode additive amb color per emissor

source/game/map/map.cpp

@@ -1,5 +1,6 @@
 #include "game/map/map.hpp"
 
+#include <algorithm>
 #include <cmath>
 #include <stdexcept>
 #include <unordered_map>
@@ -49,18 +50,45 @@ namespace Map {
             return yaml_key;
         }
 
+        // Parser comú d'un color YAML 3-tupla a bytes. Retorna nullopt
+        // si el node no és una seqüència de 3 elements. Usat pels
+        // overrides de sala i, en `entity_manager_loadlevel.cpp`, també
+        // pels defaults de tipus i overrides de spawn (passa pel mateix
+        // helper per coherència). `clamp` defensiu per a YAMLs que
+        // entreguen valors fora de 0..255.
+        auto parseColorTriplet(const fkyaml::node& node) -> std::optional<std::array<std::uint8_t, 3>> {
+            if (!node.is_sequence() || node.size() != 3) { return std::nullopt; }
+            auto clamp = [](int v) { return static_cast<std::uint8_t>(std::clamp(v, 0, 255)); };
+            return std::array<std::uint8_t, 3>{
+                clamp(node[0].get_value<int>()),
+                clamp(node[1].get_value<int>()),
+                clamp(node[2].get_value<int>()),
+            };
+        }
+
         // Llegeix el bloc opcional `lighting:` del YAML d'una sala i
-        // actualitza `light_level` (si declara `level`) i el mapping
-        // `g_room_emitters`. Idempotent: cada `Map::loadFrom` neteja el
-        // mapping abans de poblar-lo, així no s'arrosseguen overrides
+        // actualitza `light_level`, `lighting_mode` i el mapping
+        // `g_room_emitters`. Idempotent: cada `Map::loadFrom` reseteja
+        // tot l'estat abans de poblar-lo, així no s'arrosseguen valors
         // d'una sala anterior.
         void loadLightingBlock(const fkyaml::node& yaml) {
             g_room_emitters.clear();
+            lighting_mode = Lighting::Mode::Subtractive;
             if (!yaml.contains("lighting")) { return; }
             const auto& lighting = yaml["lighting"];
             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);
+                }
+            }
             if (!lighting.contains("emitters") || !lighting["emitters"].is_mapping()) { return; }
             const auto& em = lighting["emitters"];
             for (auto it = em.begin(); it != em.end(); ++it) {
@@ -73,6 +101,7 @@ namespace Map {
                     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"]); }
                 }
                 g_room_emitters[KEY] = ov;
             }

source/game/map/map.hpp

@@ -2,11 +2,15 @@
 
 #include <SDL3/SDL.h>
 
+#include <array>
+#include <cstdint>
 #include <functional>
 #include <optional>
 #include <string>
 #include <utility>
 
+#include "core/rendering/lighting.hpp"
+
 // Mapa d'una piràmide: sala rectangular amb marcador superior, muros pels
 // quatre costats i graella de sarcòfags envoltada per un passadís a cada
 // cantó. La geometria (graella, pitch, amplada de murs) es carrega des del
@@ -60,6 +64,13 @@ namespace Map {
     // al root es manté per compatibilitat enrere.
     inline float light_level = 1.0F;
 
+    // Mode de composició de la pasada d'il·luminació (subtractive per
+    // defecte; additive si la sala declara `lighting.mode: additive`).
+    // Veure el comentari de `core/rendering/lighting.hpp` per a la
+    // semàntica de cada mode. En subtractive, els colors dels emissors
+    // s'ignoren — el camí és el de sempre.
+    inline Lighting::Mode lighting_mode = Lighting::Mode::Subtractive;
+
     // Override d'emissor declarat al bloc opcional `lighting.emitters.<tipus>`
     // de la sala. Tres formes acceptades al YAML:
     //   <tipus>: false              → desactiva la llum per a tot el tipus
@@ -80,6 +91,10 @@ namespace Map {
         bool enabled{true};
         std::optional<int> radius;
         std::optional<bool> flicker;
+        // Color emès en mode additive. `nullopt` → conservar el color
+        // del tipus (default blanc 255,255,255 si el tipus no en declara).
+        // La forma YAML és `color: [r, g, b]` (bytes 0..255).
+        std::optional<std::array<std::uint8_t, 3>> color;
     };
 
     // Consulta l'override de sala per a un tipus d'entitat (clau singular,