Merge branch 'Serialize-magic-effect-RefId-directly' into 'master'

Capostrophic · Capostrophic · commit a95543fec96a · 2026-02-04T15:51:42.000+03:00
Serialize active magic effects and dynamic ENAM-based record RefIds directly

See merge request OpenMW/openmw!5141
diff --git a/components/esm3/activespells.cpp b/components/esm3/activespells.cpp
@@ -86,7 +86,7 @@ namespace ESM
 
                 for (auto& effect : params.mEffects)
                 {
-                    esm.writeHNT("MGEF", ESM::MagicEffect::refIdToIndex(effect.mEffectId));
+                    esm.writeHNRefId("MGEF", effect.mEffectId);
                     if (const ESM::RefId* id = std::get_if<ESM::RefId>(&effect.mArg))
                     {
                         if (!id->empty())
@@ -171,10 +171,15 @@ namespace ESM
 
                 while (esm.isNextSub("MGEF"))
                 {
-                    int32_t effectId;
                     ActiveEffect effect;
-                    esm.getHT(effectId);
-                    effect.mEffectId = ESM::MagicEffect::indexToRefId(effectId);
+                    if (format <= MaxSerializeEffectRefIdFormatVersion)
+                    {
+                        int32_t effectId;
+                        esm.getHT(effectId);
+                        effect.mEffectId = ESM::MagicEffect::indexToRefId(effectId);
+                    }
+                    else
+                        effect.mEffectId = esm.getRefId();
                     if (format <= MaxActorIdSaveGameFormatVersion)
                     {
                         int32_t arg = -1;
diff --git a/components/esm3/creaturestats.cpp b/components/esm3/creaturestats.cpp
@@ -129,14 +129,21 @@ namespace ESM
         {
             while (esm.isNextSub("SUMM"))
             {
-                int32_t magicEffect;
-                esm.getHT(magicEffect);
+                RefId effectId;
+                if (esm.getFormatVersion() <= MaxSerializeEffectRefIdFormatVersion)
+                {
+                    int32_t magicEffect;
+                    esm.getHT(magicEffect);
+                    effectId = ESM::MagicEffect::indexToRefId(magicEffect);
+                }
+                else
+                    effectId = esm.getRefId();
                 RefNum actor;
                 if (esm.getFormatVersion() <= MaxActorIdSaveGameFormatVersion)
                     esm.getHNT(actor.mIndex, "ACID");
                 else
                     actor = esm.getFormId(true, "ACID");
-                mSummonedCreatures.emplace(ESM::MagicEffect::indexToRefId(magicEffect), actor);
+                mSummonedCreatures.emplace(effectId, actor);
             }
         }
 
@@ -251,7 +258,7 @@ namespace ESM
 
         for (const auto& [effectId, actor] : mSummonedCreatures)
         {
-            esm.writeHNT("SUMM", ESM::MagicEffect::refIdToIndex(effectId));
+            esm.writeHNRefId("SUMM", effectId);
             esm.writeFormId(actor, true, "ACID");
         }
 
diff --git a/components/esm3/effectlist.cpp b/components/esm3/effectlist.cpp
@@ -5,7 +5,9 @@
 
 #include <format>
 
+#include <components/esm/attr.hpp>
 #include <components/esm3/loadmgef.hpp>
+#include <components/esm3/loadskil.hpp>
 #include <components/misc/concepts.hpp>
 
 namespace ESM
@@ -20,6 +22,12 @@ namespace ESM
             int32_t mRange, mArea, mDuration, mMagnMin, mMagnMax;
         };
 
+        // Struct with residual binary fields from ENAM
+        struct EffectParams
+        {
+            int32_t mRange, mArea, mDuration, mMagnMin, mMagnMax;
+        };
+
         void toBinary(const ENAMstruct& src, EsmENAMstruct& dst)
         {
             int16_t index = static_cast<int16_t>(ESM::MagicEffect::refIdToIndex(src.mEffectID));
@@ -39,7 +47,7 @@ namespace ESM
         {
             int16_t index = src.mEffectID;
             if (index < 0 || index >= ESM::MagicEffect::Length)
-                throw std::runtime_error(std::format("Cannot deserialize effect with index {}", index));
+                throw std::runtime_error(std::format("Cannot deserialize effect into ENAM with index {}.", index));
             dst.mEffectID = ESM::MagicEffect::indexToRefId(index);
             dst.mSkill = src.mSkill;
             dst.mAttribute = src.mAttribute;
@@ -49,6 +57,16 @@ namespace ESM
             dst.mMagnMin = src.mMagnMin;
             dst.mMagnMax = src.mMagnMax;
         }
+
+        template <typename T, typename U>
+        void setEffectParams(const T& src, U& dst)
+        {
+            dst.mRange = src.mRange;
+            dst.mArea = src.mArea;
+            dst.mDuration = src.mDuration;
+            dst.mMagnMin = src.mMagnMin;
+            dst.mMagnMax = src.mMagnMax;
+        }
     }
 
     template <Misc::SameAsWithoutCvref<EsmENAMstruct> T>
@@ -57,6 +75,12 @@ namespace ESM
         f(v.mEffectID, v.mSkill, v.mAttribute, v.mRange, v.mArea, v.mDuration, v.mMagnMin, v.mMagnMax);
     }
 
+    template <Misc::SameAsWithoutCvref<EffectParams> T>
+    void decompose(T&& v, const auto& f)
+    {
+        f(v.mRange, v.mArea, v.mDuration, v.mMagnMin, v.mMagnMax);
+    }
+
     void EffectList::load(ESMReader& esm)
     {
         mList.clear();
@@ -81,21 +105,46 @@ namespace ESM
 
     void EffectList::add(ESMReader& esm)
     {
-        EsmENAMstruct bin;
-        esm.getSubComposite(bin);
-
         ENAMstruct s;
-        fromBinary(bin, s);
+        if (esm.getFormatVersion() <= MaxSerializeEffectRefIdFormatVersion)
+        {
+            EsmENAMstruct bin;
+            esm.getSubComposite(bin);
+            fromBinary(bin, s);
+        }
+        else
+        {
+            EffectParams p;
+            esm.getSubComposite(p);
+            setEffectParams(p, s);
+            s.mEffectID = esm.getHNRefId("ENID");
+            s.mSkill = static_cast<signed char>(ESM::Skill::refIdToIndex(esm.getHNORefId("ENSK")));
+            s.mAttribute = static_cast<signed char>(ESM::Attribute::refIdToIndex(esm.getHNORefId("ENAT")));
+        }
         mList.push_back({ s, static_cast<uint32_t>(mList.size()) });
     }
 
     void EffectList::save(ESMWriter& esm) const
     {
         for (const IndexedENAMstruct& enam : mList)
         {
-            EsmENAMstruct bin;
-            toBinary(enam.mData, bin);
-            esm.writeNamedComposite("ENAM", bin);
+            if (esm.getFormatVersion() <= MaxSerializeEffectRefIdFormatVersion)
+            {
+                EsmENAMstruct bin;
+                toBinary(enam.mData, bin);
+                esm.writeNamedComposite("ENAM", bin);
+            }
+            else
+            {
+                if (enam.mData.mEffectID.empty())
+                    throw std::runtime_error("Cannot serialize empty effect into ENAM.");
+                EffectParams p;
+                setEffectParams(enam.mData, p);
+                esm.writeNamedComposite("ENAM", p);
+                esm.writeHNRefId("ENID", enam.mData.mEffectID);
+                esm.writeHNORefId("ENSK", ESM::Skill::indexToRefId(enam.mData.mSkill));
+                esm.writeHNORefId("ENAT", ESM::Attribute::indexToRefId(enam.mData.mAttribute));
+            }
         }
     }
 
diff --git a/components/esm3/formatversion.hpp b/components/esm3/formatversion.hpp
@@ -29,7 +29,8 @@ namespace ESM
     inline constexpr FormatVersion MaxActiveSpellTypeVersion = 31;
     inline constexpr FormatVersion MaxPlayerBeforeCellDataFormatVersion = 32;
     inline constexpr FormatVersion MaxActorIdSaveGameFormatVersion = 34;
-    inline constexpr FormatVersion CurrentSaveGameFormatVersion = 35;
+    inline constexpr FormatVersion MaxSerializeEffectRefIdFormatVersion = 35;
+    inline constexpr FormatVersion CurrentSaveGameFormatVersion = 36;
 
     inline constexpr FormatVersion MinSupportedSaveGameFormatVersion = 5;
     inline constexpr FormatVersion OpenMW0_49MinSaveGameFormatVersion = 5;
diff --git a/components/esm3/magiceffects.cpp b/components/esm3/magiceffects.cpp
@@ -12,7 +12,7 @@ namespace ESM
     {
         for (const auto& [key, params] : mEffects)
         {
-            esm.writeHNT("EFID", ESM::MagicEffect::refIdToIndex(key));
+            esm.writeHNRefId("EFID", key);
             esm.writeHNT("BASE", params.first);
             esm.writeHNT("MODI", params.second);
         }
@@ -22,15 +22,22 @@ namespace ESM
     {
         while (esm.isNextSub("EFID"))
         {
-            int32_t id;
+            RefId effectId;
+            if (esm.getFormatVersion() <= MaxSerializeEffectRefIdFormatVersion)
+            {
+                int32_t id;
+                esm.getHT(id);
+                effectId = ESM::MagicEffect::indexToRefId(id);
+            }
+            else
+                effectId = esm.getRefId();
             std::pair<int32_t, float> params;
-            esm.getHT(id);
             esm.getHNT(params.first, "BASE");
             if (esm.getFormatVersion() <= MaxClearModifiersFormatVersion)
                 params.second = 0.f;
             else
                 esm.getHNT(params.second, "MODI");
-            mEffects.emplace(ESM::MagicEffect::indexToRefId(id), params);
+            mEffects.emplace(effectId, params);
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -129,14 +129,21 @@ namespace ESM`
`129`	`129`	`{`
`130`	`130`	`while (esm.isNextSub("SUMM"))`
`131`	`131`	`{`
`132`		`- int32_t magicEffect;`
`133`		`- esm.getHT(magicEffect);`
	`132`	`+ RefId effectId;`
	`133`	`+ if (esm.getFormatVersion() <= MaxSerializeEffectRefIdFormatVersion)`
	`134`	`+ {`
	`135`	`+ int32_t magicEffect;`
	`136`	`+ esm.getHT(magicEffect);`
	`137`	`+ effectId = ESM::MagicEffect::indexToRefId(magicEffect);`
	`138`	`+ }`
	`139`	`+ else`
	`140`	`+ effectId = esm.getRefId();`
`134`	`141`	`RefNum actor;`
`135`	`142`	`if (esm.getFormatVersion() <= MaxActorIdSaveGameFormatVersion)`
`136`	`143`	`esm.getHNT(actor.mIndex, "ACID");`
`137`	`144`	`else`
`138`	`145`	`actor = esm.getFormId(true, "ACID");`
`139`		`- mSummonedCreatures.emplace(ESM::MagicEffect::indexToRefId(magicEffect), actor);`
	`146`	`+ mSummonedCreatures.emplace(effectId, actor);`
`140`	`147`	`}`
`141`	`148`	`}`
`142`	`149`
`@@ -251,7 +258,7 @@ namespace ESM`
`251`	`258`
`252`	`259`	`for (const auto& [effectId, actor] : mSummonedCreatures)`
`253`	`260`	`{`
`254`		`- esm.writeHNT("SUMM", ESM::MagicEffect::refIdToIndex(effectId));`
	`261`	`+ esm.writeHNRefId("SUMM", effectId);`
`255`	`262`	`esm.writeFormId(actor, true, "ACID");`
`256`	`263`	`}`
`257`	`264`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ namespace ESM`
`12`	`12`	`{`
`13`	`13`	`for (const auto& [key, params] : mEffects)`
`14`	`14`	`{`
`15`		`- esm.writeHNT("EFID", ESM::MagicEffect::refIdToIndex(key));`
	`15`	`+ esm.writeHNRefId("EFID", key);`
`16`	`16`	`esm.writeHNT("BASE", params.first);`
`17`	`17`	`esm.writeHNT("MODI", params.second);`
`18`	`18`	`}`
`@@ -22,15 +22,22 @@ namespace ESM`
`22`	`22`	`{`
`23`	`23`	`while (esm.isNextSub("EFID"))`
`24`	`24`	`{`
`25`		`- int32_t id;`
	`25`	`+ RefId effectId;`
	`26`	`+ if (esm.getFormatVersion() <= MaxSerializeEffectRefIdFormatVersion)`
	`27`	`+ {`
	`28`	`+ int32_t id;`
	`29`	`+ esm.getHT(id);`
	`30`	`+ effectId = ESM::MagicEffect::indexToRefId(id);`
	`31`	`+ }`
	`32`	`+ else`
	`33`	`+ effectId = esm.getRefId();`
`26`	`34`	`std::pair<int32_t, float> params;`
`27`		`- esm.getHT(id);`
`28`	`35`	`esm.getHNT(params.first, "BASE");`
`29`	`36`	`if (esm.getFormatVersion() <= MaxClearModifiersFormatVersion)`
`30`	`37`	`params.second = 0.f;`
`31`	`38`	`else`
`32`	`39`	`esm.getHNT(params.second, "MODI");`
`33`		`- mEffects.emplace(ESM::MagicEffect::indexToRefId(id), params);`
	`40`	`+ mEffects.emplace(effectId, params);`
`34`	`41`	`}`
`35`	`42`	`}`
`36`	`43`