refactor effect names in loadmgef. Added a map from effect index to non-gmst effect name for use in lua scripts.

apps/openmw/mwgui/spellcreationdialog.cpp

@@ -37,8 +37,8 @@ namespace
         const MWWorld::Store<ESM::GameSetting>& gmst
             = MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
 
-        return gmst.find(ESM::MagicEffect::effectIdToString(id1))->mValue.getString()
+        return gmst.find(ESM::MagicEffect::effectIdToGmstString(id1))->mValue.getString()
-            < gmst.find(ESM::MagicEffect::effectIdToString(id2))->mValue.getString();
+            < gmst.find(ESM::MagicEffect::effectIdToGmstString(id2))->mValue.getString();
     }
 
     void init(ESM::ENAMstruct& effect)
@@ -196,7 +196,8 @@ namespace MWGui
         mEffectImage->setImageTexture(Misc::ResourceHelpers::correctIconPath(
             effect->mIcon, MWBase::Environment::get().getResourceSystem()->getVFS()));
 
-        mEffectName->setCaptionWithReplacing("#{" + ESM::MagicEffect::effectIdToString(effect->mIndex) + "}");
+        mEffectName->setCaptionWithReplacing(
+            "#{" + std::string(ESM::MagicEffect::effectIdToGmstString(effect->mIndex)) + "}");
 
         mEffect.mEffectID = effect->mIndex;
 
@@ -552,7 +553,7 @@ namespace MWGui
             mAvailableEffectsList->addItem(MWBase::Environment::get()
                                                .getESMStore()
                                                ->get<ESM::GameSetting>()
-                                               .find(ESM::MagicEffect::effectIdToString(effectId))
+                                               .find(ESM::MagicEffect::effectIdToGmstString(effectId))
                                                ->mValue.getString());
             mButtonMapping[i] = effectId;
             ++i;
@@ -565,7 +566,7 @@ namespace MWGui
             const std::string& name = MWBase::Environment::get()
                                           .getESMStore()
                                           ->get<ESM::GameSetting>()
-                                          .find(ESM::MagicEffect::effectIdToString(effectId))
+                                          .find(ESM::MagicEffect::effectIdToGmstString(effectId))
                                           ->mValue.getString();
             MyGUI::Widget* w = mAvailableEffectsList->getItemWidget(name);
 

apps/openmw/mwgui/spellicons.cpp

@@ -162,10 +162,10 @@ namespace MWGui
                     image->setImageTexture(Misc::ResourceHelpers::correctIconPath(
                         effect->mIcon, MWBase::Environment::get().getResourceSystem()->getVFS()));
 
-                    const std::string& name = ESM::MagicEffect::effectIdToString(effectId);
+                    std::string_view name = ESM::MagicEffect::effectIdToGmstString(effectId);
 
                     ToolTipInfo tooltipInfo;
-                    tooltipInfo.caption = "#{" + name + "}";
+                    tooltipInfo.caption = "#{" + std::string(name) + "}";
                     tooltipInfo.icon = effect->mIcon;
                     tooltipInfo.imageSize = 16;
                     tooltipInfo.wordWrap = false;

apps/openmw/mwgui/tooltips.cpp

@@ -954,7 +954,7 @@ namespace MWGui
     void ToolTips::createMagicEffectToolTip(MyGUI::Widget* widget, short id)
     {
         const ESM::MagicEffect* effect = MWBase::Environment::get().getESMStore()->get<ESM::MagicEffect>().find(id);
-        const std::string& name = ESM::MagicEffect::effectIdToString(id);
+        std::string_view name = ESM::MagicEffect::effectIdToGmstString(id);
 
         std::string icon = effect->mIcon;
         int slashPos = icon.rfind('\\');
@@ -963,7 +963,7 @@ namespace MWGui
 
         widget->setUserString("ToolTipType", "Layout");
         widget->setUserString("ToolTipLayout", "MagicEffectToolTip");
-        widget->setUserString("Caption_MagicEffectName", "#{" + name + "}");
+        widget->setUserString("Caption_MagicEffectName", "#{" + std::string(name) + "}");
         widget->setUserString("Caption_MagicEffectDescription", effect->mDescription);
         widget->setUserString("Caption_MagicEffectSchool", "#{sSchool}: " + sSchoolNames[effect->mData.mSchool]);
         widget->setUserString("ImageTexture_MagicEffectImage", icon);

apps/openmw/mwlua/magicbindings.cpp

@@ -191,12 +191,9 @@ namespace MWLua
 
         sol::table effect(context.mLua->sol(), sol::create);
         magicApi["EFFECT_TYPE"] = LuaUtil::makeStrictReadOnly(effect);
-        for (int id = 0; id < ESM::MagicEffect::Length; ++id)
+        for (const auto& it : ESM::MagicEffect::sEffectNames)
         {
-            auto name = ESM::MagicEffect::effectIdToString(id);
+            effect[it.second] = Misc::StringUtils::lowerCase(it.second);
-            // Chop off the 'sEffect' prefix present on 100% of effect id strings
-            name = name.substr(7);
-            effect[name] = Misc::StringUtils::lowerCase(name);
         }
 
         // Spell store
@@ -266,7 +263,7 @@ namespace MWLua
         auto effectParamsT = lua.new_usertype<ESM::ENAMstruct>("ESM3_EffectParams");
         effectParamsT[sol::meta_function::to_string] = [magicEffectStore](const ESM::ENAMstruct& params) {
             const ESM::MagicEffect* const rec = magicEffectStore->find(params.mEffectID);
-            return "ESM3_EffectParams[" + ESM::MagicEffect::effectIdToString(rec->mIndex) + "]";
+            return "ESM3_EffectParams[" + std::string(ESM::MagicEffect::effectIdToGmstString(rec->mIndex)) + "]";
         };
         effectParamsT["effect"]
             = sol::readonly_property([magicEffectStore](const ESM::ENAMstruct& params) -> const ESM::MagicEffect* {
@@ -299,11 +296,10 @@ namespace MWLua
         auto magicEffectT = context.mLua->sol().new_usertype<ESM::MagicEffect>("ESM3_MagicEffect");
 
         magicEffectT[sol::meta_function::to_string] = [](const ESM::MagicEffect& rec) {
-            return "ESM3_MagicEffect[" + ESM::MagicEffect::effectIdToString(rec.mIndex) + "]";
+            return "ESM3_MagicEffect[" + std::string(ESM::MagicEffect::effectIdToGmstString(rec.mIndex)) + "]";
         };
         magicEffectT["id"] = sol::readonly_property([](const ESM::MagicEffect& rec) -> std::string {
-            auto gmstName = ESM::MagicEffect::effectIdToString(rec.mIndex);
+            auto name = ESM::MagicEffect::effectIdToName(rec.mIndex);
-            auto name = gmstName.substr(7); // Remove the 'sEffect' prefix
             return Misc::StringUtils::lowerCase(name);
         });
         magicEffectT["name"] = sol::readonly_property([](const ESM::MagicEffect& rec) -> std::string_view {
@@ -311,7 +307,7 @@ namespace MWLua
                 .getWorld()
                 ->getStore()
                 .get<ESM::GameSetting>()
-                .find(ESM::MagicEffect::effectIdToString(rec.mIndex))
+                .find(ESM::MagicEffect::effectIdToGmstString(rec.mIndex))
                 ->mValue.getString();
         });
         magicEffectT["school"]
@@ -331,11 +327,10 @@ namespace MWLua
         auto activeEffectT = context.mLua->sol().new_usertype<ActiveEffect>("ActiveEffect");
 
         activeEffectT[sol::meta_function::to_string] = [](const ActiveEffect& effect) {
-            return "ActiveEffect[" + ESM::MagicEffect::effectIdToString(effect.key.mId) + "]";
+            return "ActiveEffect[" + std::string(ESM::MagicEffect::effectIdToGmstString(effect.key.mId)) + "]";
         };
         activeEffectT["id"] = sol::readonly_property([](const ActiveEffect& effect) -> std::string {
-            auto gmstName = ESM::MagicEffect::effectIdToString(effect.key.mId);
+            auto name = ESM::MagicEffect::effectIdToName(effect.key.mId);
-            auto name = gmstName.substr(7); // Remove the 'sEffect' prefix
             return Misc::StringUtils::lowerCase(name);
         });
         activeEffectT["name"]
@@ -575,7 +570,7 @@ namespace MWLua
             if (!effects.isActor())
                 return sol::nullopt;
 
-            auto id = ESM::MagicEffect::effectStringToId("sEffect" + std::string(idStr));
+            auto id = ESM::MagicEffect::effectNameToId(idStr);
             auto* rec = MWBase::Environment::get().getWorld()->getStore().get<ESM::MagicEffect>().find(id);
 
             MWMechanics::EffectKey key = MWMechanics::EffectKey(id);

apps/openmw/mwmechanics/magiceffects.cpp

@@ -268,7 +268,7 @@ namespace MWMechanics
 
         if (spellLine.empty())
         {
-            const std::string& effectIDStr = ESM::MagicEffect::effectIdToString(effect.mIndex);
+            std::string_view effectIDStr = ESM::MagicEffect::effectIdToGmstString(effect.mIndex);
             spellLine = windowManager->getGameSettingString(effectIDStr, {});
         }
 

apps/openmw/mwscript/miscextensions.cpp

@@ -582,7 +582,7 @@ namespace MWScript
                     k.has_value() && *k >= 0 && *k <= 32767)
                     key = *k;
                 else
-                    key = ESM::MagicEffect::effectStringToId({ effect });
+                    key = ESM::MagicEffect::effectGmstIdToId(effect);
 
                 const MWMechanics::CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
 

apps/openmw/mwworld/esmstore.cpp

@@ -538,8 +538,8 @@ namespace MWWorld
                     {
                         iter->mAttribute = -1;
                         Log(Debug::Verbose)
-                            << ESM::MagicEffect::effectIdToString(iter->mEffectID) << " effect of spell '" << spell.mId
+                            << ESM::MagicEffect::effectIdToGmstString(iter->mEffectID) << " effect of spell '"
-                            << "' has an attribute argument present. Dropping the argument.";
+                            << spell.mId << "' has an attribute argument present. Dropping the argument.";
                         changed = true;
                     }
                 }
@@ -549,8 +549,8 @@ namespace MWWorld
                     {
                         iter->mSkill = -1;
                         Log(Debug::Verbose)
-                            << ESM::MagicEffect::effectIdToString(iter->mEffectID) << " effect of spell '" << spell.mId
+                            << ESM::MagicEffect::effectIdToGmstString(iter->mEffectID) << " effect of spell '"
-                            << "' has a skill argument present. Dropping the argument.";
+                            << spell.mId << "' has a skill argument present. Dropping the argument.";
                         changed = true;
                     }
                 }
@@ -558,8 +558,9 @@ namespace MWWorld
                 {
                     iter->mSkill = -1;
                     iter->mAttribute = -1;
-                    Log(Debug::Verbose) << ESM::MagicEffect::effectIdToString(iter->mEffectID) << " effect of spell '"
+                    Log(Debug::Verbose) << ESM::MagicEffect::effectIdToGmstString(iter->mEffectID)
-                                        << spell.mId << "' has argument(s) present. Dropping the argument(s).";
+                                        << " effect of spell '" << spell.mId
+                                        << "' has argument(s) present. Dropping the argument(s).";
                     changed = true;
                 }
 

components/esm3/loadmgef.cpp

@@ -351,171 +351,307 @@ namespace ESM
             return -1;
     }
 
-    static std::map<short, std::string> genNameMap()
+    // Map effect ID to GMST name
-    {
+    const std::map<int, std::string> MagicEffect::sGmstEffectIds = {
-        // Map effect ID to GMST name
+        { MagicEffect::AbsorbAttribute, "sEffectAbsorbAttribute" },
-        // http://www.uesp.net/morrow/hints/mweffects.shtml
+        { MagicEffect::AbsorbFatigue, "sEffectAbsorbFatigue" },
-        std::map<short, std::string> names;
+        { MagicEffect::AbsorbHealth, "sEffectAbsorbHealth" },
-        names[85] = "sEffectAbsorbAttribute";
+        { MagicEffect::AbsorbMagicka, "sEffectAbsorbSpellPoints" },
-        names[88] = "sEffectAbsorbFatigue";
+        { MagicEffect::AbsorbSkill, "sEffectAbsorbSkill" },
-        names[86] = "sEffectAbsorbHealth";
+        { MagicEffect::AlmsiviIntervention, "sEffectAlmsiviIntervention" },
-        names[87] = "sEffectAbsorbSpellPoints";
+        { MagicEffect::Blind, "sEffectBlind" },
-        names[89] = "sEffectAbsorbSkill";
+        { MagicEffect::BoundBattleAxe, "sEffectBoundBattleAxe" },
-        names[63] = "sEffectAlmsiviIntervention";
+        { MagicEffect::BoundBoots, "sEffectBoundBoots" },
-        names[47] = "sEffectBlind";
+        { MagicEffect::BoundCuirass, "sEffectBoundCuirass" },
-        names[123] = "sEffectBoundBattleAxe";
+        { MagicEffect::BoundDagger, "sEffectBoundDagger" },
-        names[129] = "sEffectBoundBoots";
+        { MagicEffect::BoundGloves, "sEffectBoundGloves" },
-        names[127] = "sEffectBoundCuirass";
+        { MagicEffect::BoundHelm, "sEffectBoundHelm" },
-        names[120] = "sEffectBoundDagger";
+        { MagicEffect::BoundLongbow, "sEffectBoundLongbow" },
-        names[131] = "sEffectBoundGloves";
+        { MagicEffect::ExtraSpell, "sEffectExtraSpell" },
-        names[128] = "sEffectBoundHelm";
+        { MagicEffect::BoundLongsword, "sEffectBoundLongsword" },
-        names[125] = "sEffectBoundLongbow";
+        { MagicEffect::BoundMace, "sEffectBoundMace" },
-        names[126] = "sEffectExtraSpell";
+        { MagicEffect::BoundShield, "sEffectBoundShield" },
-        names[121] = "sEffectBoundLongsword";
+        { MagicEffect::BoundSpear, "sEffectBoundSpear" },
-        names[122] = "sEffectBoundMace";
+        { MagicEffect::Burden, "sEffectBurden" },
-        names[130] = "sEffectBoundShield";
+        { MagicEffect::CalmCreature, "sEffectCalmCreature" },
-        names[124] = "sEffectBoundSpear";
+        { MagicEffect::CalmHumanoid, "sEffectCalmHumanoid" },
-        names[7] = "sEffectBurden";
+        { MagicEffect::Chameleon, "sEffectChameleon" },
-        names[50] = "sEffectCalmCreature";
+        { MagicEffect::Charm, "sEffectCharm" },
-        names[49] = "sEffectCalmHumanoid";
+        { MagicEffect::CommandCreature, "sEffectCommandCreatures" },
-        names[40] = "sEffectChameleon";
+        { MagicEffect::CommandHumanoid, "sEffectCommandHumanoids" },
-        names[44] = "sEffectCharm";
+        { MagicEffect::Corprus, "sEffectCorpus" }, // NB this typo. (bethesda made it)
-        names[118] = "sEffectCommandCreatures";
+        { MagicEffect::CureBlightDisease, "sEffectCureBlightDisease" },
-        names[119] = "sEffectCommandHumanoids";
+        { MagicEffect::CureCommonDisease, "sEffectCureCommonDisease" },
-        names[132] = "sEffectCorpus"; // NB this typo. (bethesda made it)
+        { MagicEffect::CureCorprusDisease, "sEffectCureCorprusDisease" },
-        names[70] = "sEffectCureBlightDisease";
+        { MagicEffect::CureParalyzation, "sEffectCureParalyzation" },
-        names[69] = "sEffectCureCommonDisease";
+        { MagicEffect::CurePoison, "sEffectCurePoison" },
-        names[71] = "sEffectCureCorprusDisease";
+        { MagicEffect::DamageAttribute, "sEffectDamageAttribute" },
-        names[73] = "sEffectCureParalyzation";
+        { MagicEffect::DamageFatigue, "sEffectDamageFatigue" },
-        names[72] = "sEffectCurePoison";
+        { MagicEffect::DamageHealth, "sEffectDamageHealth" },
-        names[22] = "sEffectDamageAttribute";
+        { MagicEffect::DamageMagicka, "sEffectDamageMagicka" },
-        names[25] = "sEffectDamageFatigue";
+        { MagicEffect::DamageSkill, "sEffectDamageSkill" },
-        names[23] = "sEffectDamageHealth";
+        { MagicEffect::DemoralizeCreature, "sEffectDemoralizeCreature" },
-        names[24] = "sEffectDamageMagicka";
+        { MagicEffect::DemoralizeHumanoid, "sEffectDemoralizeHumanoid" },
-        names[26] = "sEffectDamageSkill";
+        { MagicEffect::DetectAnimal, "sEffectDetectAnimal" },
-        names[54] = "sEffectDemoralizeCreature";
+        { MagicEffect::DetectEnchantment, "sEffectDetectEnchantment" },
-        names[53] = "sEffectDemoralizeHumanoid";
+        { MagicEffect::DetectKey, "sEffectDetectKey" },
-        names[64] = "sEffectDetectAnimal";
+        { MagicEffect::DisintegrateArmor, "sEffectDisintegrateArmor" },
-        names[65] = "sEffectDetectEnchantment";
+        { MagicEffect::DisintegrateWeapon, "sEffectDisintegrateWeapon" },
-        names[66] = "sEffectDetectKey";
+        { MagicEffect::Dispel, "sEffectDispel" },
-        names[38] = "sEffectDisintegrateArmor";
+        { MagicEffect::DivineIntervention, "sEffectDivineIntervention" },
-        names[37] = "sEffectDisintegrateWeapon";
+        { MagicEffect::DrainAttribute, "sEffectDrainAttribute" },
-        names[57] = "sEffectDispel";
+        { MagicEffect::DrainFatigue, "sEffectDrainFatigue" },
-        names[62] = "sEffectDivineIntervention";
+        { MagicEffect::DrainHealth, "sEffectDrainHealth" },
-        names[17] = "sEffectDrainAttribute";
+        { MagicEffect::DrainMagicka, "sEffectDrainSpellpoints" },
-        names[20] = "sEffectDrainFatigue";
+        { MagicEffect::DrainSkill, "sEffectDrainSkill" },
-        names[18] = "sEffectDrainHealth";
+        { MagicEffect::Feather, "sEffectFeather" },
-        names[19] = "sEffectDrainSpellpoints";
+        { MagicEffect::FireDamage, "sEffectFireDamage" },
-        names[21] = "sEffectDrainSkill";
+        { MagicEffect::FireShield, "sEffectFireShield" },
-        names[8] = "sEffectFeather";
+        { MagicEffect::FortifyAttack, "sEffectFortifyAttackBonus" },
-        names[14] = "sEffectFireDamage";
+        { MagicEffect::FortifyAttribute, "sEffectFortifyAttribute" },
-        names[4] = "sEffectFireShield";
+        { MagicEffect::FortifyFatigue, "sEffectFortifyFatigue" },
-        names[117] = "sEffectFortifyAttackBonus";
+        { MagicEffect::FortifyHealth, "sEffectFortifyHealth" },
-        names[79] = "sEffectFortifyAttribute";
+        { MagicEffect::FortifyMagicka, "sEffectFortifySpellpoints" },
-        names[82] = "sEffectFortifyFatigue";
+        { MagicEffect::FortifyMaximumMagicka, "sEffectFortifyMagickaMultiplier" },
-        names[80] = "sEffectFortifyHealth";
+        { MagicEffect::FortifySkill, "sEffectFortifySkill" },
-        names[81] = "sEffectFortifySpellpoints";
+        { MagicEffect::FrenzyCreature, "sEffectFrenzyCreature" },
-        names[84] = "sEffectFortifyMagickaMultiplier";
+        { MagicEffect::FrenzyHumanoid, "sEffectFrenzyHumanoid" },
-        names[83] = "sEffectFortifySkill";
+        { MagicEffect::FrostDamage, "sEffectFrostDamage" },
-        names[52] = "sEffectFrenzyCreature";
+        { MagicEffect::FrostShield, "sEffectFrostShield" },
-        names[51] = "sEffectFrenzyHumanoid";
+        { MagicEffect::Invisibility, "sEffectInvisibility" },
-        names[16] = "sEffectFrostDamage";
+        { MagicEffect::Jump, "sEffectJump" },
-        names[6] = "sEffectFrostShield";
+        { MagicEffect::Levitate, "sEffectLevitate" },
-        names[39] = "sEffectInvisibility";
+        { MagicEffect::Light, "sEffectLight" },
-        names[9] = "sEffectJump";
+        { MagicEffect::LightningShield, "sEffectLightningShield" },
-        names[10] = "sEffectLevitate";
+        { MagicEffect::Lock, "sEffectLock" },
-        names[41] = "sEffectLight";
+        { MagicEffect::Mark, "sEffectMark" },
-        names[5] = "sEffectLightningShield";
+        { MagicEffect::NightEye, "sEffectNightEye" },
-        names[12] = "sEffectLock";
+        { MagicEffect::Open, "sEffectOpen" },
-        names[60] = "sEffectMark";
+        { MagicEffect::Paralyze, "sEffectParalyze" },
-        names[43] = "sEffectNightEye";
+        { MagicEffect::Poison, "sEffectPoison" },
-        names[13] = "sEffectOpen";
+        { MagicEffect::RallyCreature, "sEffectRallyCreature" },
-        names[45] = "sEffectParalyze";
+        { MagicEffect::RallyHumanoid, "sEffectRallyHumanoid" },
-        names[27] = "sEffectPoison";
+        { MagicEffect::Recall, "sEffectRecall" },
-        names[56] = "sEffectRallyCreature";
+        { MagicEffect::Reflect, "sEffectReflect" },
-        names[55] = "sEffectRallyHumanoid";
+        { MagicEffect::RemoveCurse, "sEffectRemoveCurse" },
-        names[61] = "sEffectRecall";
+        { MagicEffect::ResistBlightDisease, "sEffectResistBlightDisease" },
-        names[68] = "sEffectReflect";
+        { MagicEffect::ResistCommonDisease, "sEffectResistCommonDisease" },
-        names[100] = "sEffectRemoveCurse";
+        { MagicEffect::ResistCorprusDisease, "sEffectResistCorprusDisease" },
-        names[95] = "sEffectResistBlightDisease";
+        { MagicEffect::ResistFire, "sEffectResistFire" },
-        names[94] = "sEffectResistCommonDisease";
+        { MagicEffect::ResistFrost, "sEffectResistFrost" },
-        names[96] = "sEffectResistCorprusDisease";
+        { MagicEffect::ResistMagicka, "sEffectResistMagicka" },
-        names[90] = "sEffectResistFire";
+        { MagicEffect::ResistNormalWeapons, "sEffectResistNormalWeapons" },
-        names[91] = "sEffectResistFrost";
+        { MagicEffect::ResistParalysis, "sEffectResistParalysis" },
-        names[93] = "sEffectResistMagicka";
+        { MagicEffect::ResistPoison, "sEffectResistPoison" },
-        names[98] = "sEffectResistNormalWeapons";
+        { MagicEffect::ResistShock, "sEffectResistShock" },
-        names[99] = "sEffectResistParalysis";
+        { MagicEffect::RestoreAttribute, "sEffectRestoreAttribute" },
-        names[97] = "sEffectResistPoison";
+        { MagicEffect::RestoreFatigue, "sEffectRestoreFatigue" },
-        names[92] = "sEffectResistShock";
+        { MagicEffect::RestoreHealth, "sEffectRestoreHealth" },
-        names[74] = "sEffectRestoreAttribute";
+        { MagicEffect::RestoreMagicka, "sEffectRestoreSpellPoints" },
-        names[77] = "sEffectRestoreFatigue";
+        { MagicEffect::RestoreSkill, "sEffectRestoreSkill" },
-        names[75] = "sEffectRestoreHealth";
+        { MagicEffect::Sanctuary, "sEffectSanctuary" },
-        names[76] = "sEffectRestoreSpellPoints";
+        { MagicEffect::Shield, "sEffectShield" },
-        names[78] = "sEffectRestoreSkill";
+        { MagicEffect::ShockDamage, "sEffectShockDamage" },
-        names[42] = "sEffectSanctuary";
+        { MagicEffect::Silence, "sEffectSilence" },
-        names[3] = "sEffectShield";
+        { MagicEffect::SlowFall, "sEffectSlowFall" },
-        names[15] = "sEffectShockDamage";
+        { MagicEffect::Soultrap, "sEffectSoultrap" },
-        names[46] = "sEffectSilence";
+        { MagicEffect::Sound, "sEffectSound" },
-        names[11] = "sEffectSlowFall";
+        { MagicEffect::SpellAbsorption, "sEffectSpellAbsorption" },
-        names[58] = "sEffectSoultrap";
+        { MagicEffect::StuntedMagicka, "sEffectStuntedMagicka" },
-        names[48] = "sEffectSound";
+        { MagicEffect::SummonAncestralGhost, "sEffectSummonAncestralGhost" },
-        names[67] = "sEffectSpellAbsorption";
+        { MagicEffect::SummonBonelord, "sEffectSummonBonelord" },
-        names[136] = "sEffectStuntedMagicka";
+        { MagicEffect::SummonBonewalker, "sEffectSummonLeastBonewalker" },
-        names[106] = "sEffectSummonAncestralGhost";
+        { MagicEffect::SummonCenturionSphere, "sEffectSummonCenturionSphere" },
-        names[110] = "sEffectSummonBonelord";
+        { MagicEffect::SummonClannfear, "sEffectSummonClannfear" },
-        names[108] = "sEffectSummonLeastBonewalker";
+        { MagicEffect::SummonDaedroth, "sEffectSummonDaedroth" },
-        names[134] = "sEffectSummonCenturionSphere";
+        { MagicEffect::SummonDremora, "sEffectSummonDremora" },
-        names[103] = "sEffectSummonClannfear";
+        { MagicEffect::SummonFlameAtronach, "sEffectSummonFlameAtronach" },
-        names[104] = "sEffectSummonDaedroth";
+        { MagicEffect::SummonFrostAtronach, "sEffectSummonFrostAtronach" },
-        names[105] = "sEffectSummonDremora";
+        { MagicEffect::SummonGoldenSaint, "sEffectSummonGoldenSaint" },
-        names[114] = "sEffectSummonFlameAtronach";
+        { MagicEffect::SummonGreaterBonewalker, "sEffectSummonGreaterBonewalker" },
-        names[115] = "sEffectSummonFrostAtronach";
+        { MagicEffect::SummonHunger, "sEffectSummonHunger" },
-        names[113] = "sEffectSummonGoldenSaint";
+        { MagicEffect::SummonScamp, "sEffectSummonScamp" },
-        names[109] = "sEffectSummonGreaterBonewalker";
+        { MagicEffect::SummonSkeletalMinion, "sEffectSummonSkeletalMinion" },
-        names[112] = "sEffectSummonHunger";
+        { MagicEffect::SummonStormAtronach, "sEffectSummonStormAtronach" },
-        names[102] = "sEffectSummonScamp";
+        { MagicEffect::SummonWingedTwilight, "sEffectSummonWingedTwilight" },
-        names[107] = "sEffectSummonSkeletalMinion";
+        { MagicEffect::SunDamage, "sEffectSunDamage" },
-        names[116] = "sEffectSummonStormAtronach";
+        { MagicEffect::SwiftSwim, "sEffectSwiftSwim" },
-        names[111] = "sEffectSummonWingedTwilight";
+        { MagicEffect::Telekinesis, "sEffectTelekinesis" },
-        names[135] = "sEffectSunDamage";
+        { MagicEffect::TurnUndead, "sEffectTurnUndead" },
-        names[1] = "sEffectSwiftSwim";
+        { MagicEffect::Vampirism, "sEffectVampirism" },
-        names[59] = "sEffectTelekinesis";
+        { MagicEffect::WaterBreathing, "sEffectWaterBreathing" },
-        names[101] = "sEffectTurnUndead";
+        { MagicEffect::WaterWalking, "sEffectWaterWalking" },
-        names[133] = "sEffectVampirism";
+        { MagicEffect::WeaknessToBlightDisease, "sEffectWeaknesstoBlightDisease" },
-        names[0] = "sEffectWaterBreathing";
+        { MagicEffect::WeaknessToCommonDisease, "sEffectWeaknesstoCommonDisease" },
-        names[2] = "sEffectWaterWalking";
+        { MagicEffect::WeaknessToCorprusDisease, "sEffectWeaknesstoCorprusDisease" },
-        names[33] = "sEffectWeaknesstoBlightDisease";
+        { MagicEffect::WeaknessToFire, "sEffectWeaknesstoFire" },
-        names[32] = "sEffectWeaknesstoCommonDisease";
+        { MagicEffect::WeaknessToFrost, "sEffectWeaknesstoFrost" },
-        names[34] = "sEffectWeaknesstoCorprusDisease";
+        { MagicEffect::WeaknessToMagicka, "sEffectWeaknesstoMagicka" },
-        names[28] = "sEffectWeaknesstoFire";
+        { MagicEffect::WeaknessToNormalWeapons, "sEffectWeaknesstoNormalWeapons" },
-        names[29] = "sEffectWeaknesstoFrost";
+        { MagicEffect::WeaknessToPoison, "sEffectWeaknesstoPoison" },
-        names[31] = "sEffectWeaknesstoMagicka";
+        { MagicEffect::WeaknessToShock, "sEffectWeaknesstoShock" },
-        names[36] = "sEffectWeaknesstoNormalWeapons";
-        names[35] = "sEffectWeaknesstoPoison";
-        names[30] = "sEffectWeaknesstoShock";
 
         // bloodmoon
-        names[138] = "sEffectSummonCreature01";
+        { MagicEffect::SummonWolf, "sEffectSummonCreature01" },
-        names[139] = "sEffectSummonCreature02";
+        { MagicEffect::SummonBear, "sEffectSummonCreature02" },
-        names[140] = "sEffectSummonCreature03";
+        { MagicEffect::SummonBonewolf, "sEffectSummonCreature03" },
-        names[141] = "sEffectSummonCreature04";
+        { MagicEffect::SummonCreature04, "sEffectSummonCreature04" },
-        names[142] = "sEffectSummonCreature05";
+        { MagicEffect::SummonCreature05, "sEffectSummonCreature05" },
 
         // tribunal
-        names[137] = "sEffectSummonFabricant";
+        { MagicEffect::SummonFabricant, "sEffectSummonFabricant" },
+    };
 
-        return names;
+    // Map effect ID to identifying name
-    }
+    const std::map<int, std::string> MagicEffect::sEffectNames = {
-    const std::map<short, std::string> MagicEffect::sNames = genNameMap();
+        { MagicEffect::AbsorbAttribute, "AbsorbAttribute" },
+        { MagicEffect::AbsorbFatigue, "AbsorbFatigue" },
+        { MagicEffect::AbsorbHealth, "AbsorbHealth" },
+        { MagicEffect::AbsorbMagicka, "AbsorbMagicka" },
+        { MagicEffect::AbsorbSkill, "AbsorbSkill" },
+        { MagicEffect::AlmsiviIntervention, "AlmsiviIntervention" },
+        { MagicEffect::Blind, "Blind" },
+        { MagicEffect::BoundBattleAxe, "BoundBattleAxe" },
+        { MagicEffect::BoundBoots, "BoundBoots" },
+        { MagicEffect::BoundCuirass, "BoundCuirass" },
+        { MagicEffect::BoundDagger, "BoundDagger" },
+        { MagicEffect::BoundGloves, "BoundGloves" },
+        { MagicEffect::BoundHelm, "BoundHelm" },
+        { MagicEffect::BoundLongbow, "BoundLongbow" },
+        { MagicEffect::ExtraSpell, "ExtraSpell" },
+        { MagicEffect::BoundLongsword, "BoundLongsword" },
+        { MagicEffect::BoundMace, "BoundMace" },
+        { MagicEffect::BoundShield, "BoundShield" },
+        { MagicEffect::BoundSpear, "BoundSpear" },
+        { MagicEffect::Burden, "Burden" },
+        { MagicEffect::CalmCreature, "CalmCreature" },
+        { MagicEffect::CalmHumanoid, "CalmHumanoid" },
+        { MagicEffect::Chameleon, "Chameleon" },
+        { MagicEffect::Charm, "Charm" },
+        { MagicEffect::CommandCreature, "CommandCreature" },
+        { MagicEffect::CommandHumanoid, "CommandHumanoid" },
+        { MagicEffect::Corprus, "Corprus" }, // NB this typo. (bethesda made it)
+        { MagicEffect::CureBlightDisease, "CureBlightDisease" },
+        { MagicEffect::CureCommonDisease, "CureCommonDisease" },
+        { MagicEffect::CureCorprusDisease, "CureCorprusDisease" },
+        { MagicEffect::CureParalyzation, "CureParalyzation" },
+        { MagicEffect::CurePoison, "CurePoison" },
+        { MagicEffect::DamageAttribute, "DamageAttribute" },
+        { MagicEffect::DamageFatigue, "DamageFatigue" },
+        { MagicEffect::DamageHealth, "DamageHealth" },
+        { MagicEffect::DamageMagicka, "DamageMagicka" },
+        { MagicEffect::DamageSkill, "DamageSkill" },
+        { MagicEffect::DemoralizeCreature, "DemoralizeCreature" },
+        { MagicEffect::DemoralizeHumanoid, "DemoralizeHumanoid" },
+        { MagicEffect::DetectAnimal, "DetectAnimal" },
+        { MagicEffect::DetectEnchantment, "DetectEnchantment" },
+        { MagicEffect::DetectKey, "DetectKey" },
+        { MagicEffect::DisintegrateArmor, "DisintegrateArmor" },
+        { MagicEffect::DisintegrateWeapon, "DisintegrateWeapon" },
+        { MagicEffect::Dispel, "Dispel" },
+        { MagicEffect::DivineIntervention, "DivineIntervention" },
+        { MagicEffect::DrainAttribute, "DrainAttribute" },
+        { MagicEffect::DrainFatigue, "DrainFatigue" },
+        { MagicEffect::DrainHealth, "DrainHealth" },
+        { MagicEffect::DrainMagicka, "DrainMagicka" },
+        { MagicEffect::DrainSkill, "DrainSkill" },
+        { MagicEffect::Feather, "Feather" },
+        { MagicEffect::FireDamage, "FireDamage" },
+        { MagicEffect::FireShield, "FireShield" },
+        { MagicEffect::FortifyAttack, "FortifyAttack" },
+        { MagicEffect::FortifyAttribute, "FortifyAttribute" },
+        { MagicEffect::FortifyFatigue, "FortifyFatigue" },
+        { MagicEffect::FortifyHealth, "FortifyHealth" },
+        { MagicEffect::FortifyMagicka, "FortifyMagicka" },
+        { MagicEffect::FortifyMaximumMagicka, "FortifyMaximumMagicka" },
+        { MagicEffect::FortifySkill, "FortifySkill" },
+        { MagicEffect::FrenzyCreature, "FrenzyCreature" },
+        { MagicEffect::FrenzyHumanoid, "FrenzyHumanoid" },
+        { MagicEffect::FrostDamage, "FrostDamage" },
+        { MagicEffect::FrostShield, "FrostShield" },
+        { MagicEffect::Invisibility, "Invisibility" },
+        { MagicEffect::Jump, "Jump" },
+        { MagicEffect::Levitate, "Levitate" },
+        { MagicEffect::Light, "Light" },
+        { MagicEffect::LightningShield, "LightningShield" },
+        { MagicEffect::Lock, "Lock" },
+        { MagicEffect::Mark, "Mark" },
+        { MagicEffect::NightEye, "NightEye" },
+        { MagicEffect::Open, "Open" },
+        { MagicEffect::Paralyze, "Paralyze" },
+        { MagicEffect::Poison, "Poison" },
+        { MagicEffect::RallyCreature, "RallyCreature" },
+        { MagicEffect::RallyHumanoid, "RallyHumanoid" },
+        { MagicEffect::Recall, "Recall" },
+        { MagicEffect::Reflect, "Reflect" },
+        { MagicEffect::RemoveCurse, "RemoveCurse" },
+        { MagicEffect::ResistBlightDisease, "ResistBlightDisease" },
+        { MagicEffect::ResistCommonDisease, "ResistCommonDisease" },
+        { MagicEffect::ResistCorprusDisease, "ResistCorprusDisease" },
+        { MagicEffect::ResistFire, "ResistFire" },
+        { MagicEffect::ResistFrost, "ResistFrost" },
+        { MagicEffect::ResistMagicka, "ResistMagicka" },
+        { MagicEffect::ResistNormalWeapons, "ResistNormalWeapons" },
+        { MagicEffect::ResistParalysis, "ResistParalysis" },
+        { MagicEffect::ResistPoison, "ResistPoison" },
+        { MagicEffect::ResistShock, "ResistShock" },
+        { MagicEffect::RestoreAttribute, "RestoreAttribute" },
+        { MagicEffect::RestoreFatigue, "RestoreFatigue" },
+        { MagicEffect::RestoreHealth, "RestoreHealth" },
+        { MagicEffect::RestoreMagicka, "RestoreMagicka" },
+        { MagicEffect::RestoreSkill, "RestoreSkill" },
+        { MagicEffect::Sanctuary, "Sanctuary" },
+        { MagicEffect::Shield, "Shield" },
+        { MagicEffect::ShockDamage, "ShockDamage" },
+        { MagicEffect::Silence, "Silence" },
+        { MagicEffect::SlowFall, "SlowFall" },
+        { MagicEffect::Soultrap, "Soultrap" },
+        { MagicEffect::Sound, "Sound" },
+        { MagicEffect::SpellAbsorption, "SpellAbsorption" },
+        { MagicEffect::StuntedMagicka, "StuntedMagicka" },
+        { MagicEffect::SummonAncestralGhost, "SummonAncestralGhost" },
+        { MagicEffect::SummonBonelord, "SummonBonelord" },
+        { MagicEffect::SummonBonewalker, "SummonBonewalker" },
+        { MagicEffect::SummonCenturionSphere, "SummonCenturionSphere" },
+        { MagicEffect::SummonClannfear, "SummonClannfear" },
+        { MagicEffect::SummonDaedroth, "SummonDaedroth" },
+        { MagicEffect::SummonDremora, "SummonDremora" },
+        { MagicEffect::SummonFlameAtronach, "SummonFlameAtronach" },
+        { MagicEffect::SummonFrostAtronach, "SummonFrostAtronach" },
+        { MagicEffect::SummonGoldenSaint, "SummonGoldenSaint" },
+        { MagicEffect::SummonGreaterBonewalker, "SummonGreaterBonewalker" },
+        { MagicEffect::SummonHunger, "SummonHunger" },
+        { MagicEffect::SummonScamp, "SummonScamp" },
+        { MagicEffect::SummonSkeletalMinion, "SummonSkeletalMinion" },
+        { MagicEffect::SummonStormAtronach, "SummonStormAtronach" },
+        { MagicEffect::SummonWingedTwilight, "SummonWingedTwilight" },
+        { MagicEffect::SunDamage, "SunDamage" },
+        { MagicEffect::SwiftSwim, "SwiftSwim" },
+        { MagicEffect::Telekinesis, "Telekinesis" },
+        { MagicEffect::TurnUndead, "TurnUndead" },
+        { MagicEffect::Vampirism, "Vampirism" },
+        { MagicEffect::WaterBreathing, "WaterBreathing" },
+        { MagicEffect::WaterWalking, "WaterWalking" },
+        { MagicEffect::WeaknessToBlightDisease, "WeaknessToBlightDisease" },
+        { MagicEffect::WeaknessToCommonDisease, "WeaknessToCommonDisease" },
+        { MagicEffect::WeaknessToCorprusDisease, "WeaknessToCorprusDisease" },
+        { MagicEffect::WeaknessToFire, "WeaknessToFire" },
+        { MagicEffect::WeaknessToFrost, "WeaknessToFrost" },
+        { MagicEffect::WeaknessToMagicka, "WeaknessToMagicka" },
+        { MagicEffect::WeaknessToNormalWeapons, "WeaknessToNormalWeapons" },
+        { MagicEffect::WeaknessToPoison, "WeaknessToPoison" },
+        { MagicEffect::WeaknessToShock, "WeaknessToShock" },
 
-    const std::string& MagicEffect::effectIdToString(short effectID)
+        // bloodmoon
-    {
+        { MagicEffect::SummonWolf, "SummonWolf" },
-        std::map<short, std::string>::const_iterator name = sNames.find(effectID);
+        { MagicEffect::SummonBear, "SummonBear" },
-        if (name == sNames.end())
+        { MagicEffect::SummonBonewolf, "SummonBonewolf" },
-            throw std::runtime_error(std::string("Unimplemented effect ID ") + std::to_string(effectID));
+        { MagicEffect::SummonCreature04, "SummonCreature04" },
+        { MagicEffect::SummonCreature05, "SummonCreature05" },
 
-        return name->second;
+        // tribunal
-    }
+        { MagicEffect::SummonFabricant, "SummonFabricant" },
+    };
 
     class FindSecond
     {
@@ -535,17 +671,6 @@ namespace ESM
         }
     };
 
-    short MagicEffect::effectStringToId(std::string_view effect)
-    {
-        std::map<short, std::string>::const_iterator name;
-
-        name = std::find_if(sNames.begin(), sNames.end(), FindSecond(effect));
-        if (name == sNames.end())
-            throw std::runtime_error("Unimplemented effect " + std::string(effect));
-
-        return name->first;
-    }
-
     MagicEffect::MagnitudeDisplayType MagicEffect::getMagnitudeDisplayType() const
     {
         if (mData.mFlags & NoMagnitude)
@@ -587,6 +712,42 @@ namespace ESM
         mDescription.clear();
     }
 
+    std::string_view MagicEffect::effectIdToGmstString(int effectID)
+    {
+        auto name = sGmstEffectIds.find(effectID);
+        if (name == sGmstEffectIds.end())
+            throw std::runtime_error(std::string("Unimplemented effect ID ") + std::to_string(effectID));
+
+        return name->second;
+    }
+
+    std::string_view MagicEffect::effectIdToName(int effectID)
+    {
+        auto name = sEffectNames.find(effectID);
+        if (name == sEffectNames.end())
+            throw std::runtime_error(std::string("Unimplemented effect ID ") + std::to_string(effectID));
+
+        return name->second;
+    }
+
+    int MagicEffect::effectNameToId(std::string_view effect)
+    {
+        auto name = std::find_if(sEffectNames.begin(), sEffectNames.end(), FindSecond(effect));
+        if (name == sEffectNames.end())
+            throw std::runtime_error("Unimplemented effect " + std::string(effect));
+
+        return name->first;
+    }
+
+    int MagicEffect::effectGmstIdToId(std::string_view gmstId)
+    {
+        auto name = std::find_if(sGmstEffectIds.begin(), sGmstEffectIds.end(), FindSecond(gmstId));
+        if (name == sGmstEffectIds.end())
+            throw std::runtime_error("Unimplemented effect " + std::string(gmstId));
+
+        return name->first;
+    }
+
     RefId MagicEffect::indexToRefId(int index)
     {
         if (index == -1)

components/esm3/loadmgef.hpp

@@ -79,11 +79,6 @@ namespace ESM
             float mUnknown2; // Called "Size Cap" in CS
         }; // 36 bytes
 
-        static const std::map<short, std::string> sNames;
-
-        static const std::string& effectIdToString(short effectID);
-        static short effectStringToId(std::string_view effect);
-
         /// Returns the effect that provides resistance against \a effect (or -1 if there's none)
         static short getResistanceEffect(short effect);
         /// Returns the effect that induces weakness against \a effect (or -1 if there's none)
@@ -269,6 +264,13 @@ namespace ESM
             Length
         };
 
+        static const std::map<int, std::string> sGmstEffectIds;
+        static const std::map<int, std::string> sEffectNames;
+        static std::string_view effectIdToGmstString(int effectID);
+        static std::string_view effectIdToName(int effectID);
+        static int effectNameToId(std::string_view effect);
+        static int effectGmstIdToId(std::string_view gmstId);
+
         static const std::string_view sIndexNames[MagicEffect::Length];
 
         static RefId indexToRefId(int index);