Use more fixed size ints

components/esm3/aisequence.cpp

@@ -196,7 +196,7 @@ namespace ESM
             int count = 0;
             while (esm.isNextSub("AIPK"))
             {
-                int type;
+                int32_t type;
                 esm.getHT(type);
 
                 mPackages.emplace_back();

components/esm3/loadcell.cpp

@@ -17,7 +17,7 @@ namespace ESM
         ///< Translate 8bit/24bit code (stored in refNum.mIndex) into a proper refNum
         void adjustRefNum(RefNum& refNum, const ESMReader& reader)
         {
-            unsigned int local = (refNum.mIndex & 0xff000000) >> 24;
+            uint32_t local = (refNum.mIndex & 0xff000000) >> 24;
 
             // If we have an index value that does not make sense, assume that it was an addition
             // by the present plugin (but a faulty one)
@@ -124,7 +124,7 @@ namespace ESM
             switch (esm.retSubName().toInt())
             {
                 case fourCC("INTV"):
-                    int waterl;
+                    int32_t waterl;
                     esm.getHT(waterl);
                     mWater = static_cast<float>(waterl);
                     mWaterInt = true;
@@ -192,7 +192,7 @@ namespace ESM
         {
             if (mWaterInt)
             {
-                int water = (mWater >= 0) ? (int)(mWater + 0.5) : (int)(mWater - 0.5);
+                int32_t water = (mWater >= 0) ? static_cast<int32_t>(mWater + 0.5) : static_cast<int32_t>(mWater - 0.5);
                 esm.writeHNT("INTV", water);
             }
             else
@@ -218,13 +218,13 @@ namespace ESM
         }
     }
 
-    void Cell::saveTempMarker(ESMWriter& esm, int tempCount) const
+    void Cell::saveTempMarker(ESMWriter& esm, int32_t tempCount) const
     {
         if (tempCount != 0)
             esm.writeHNT("NAM0", tempCount);
     }
 
-    void Cell::restore(ESMReader& esm, int iCtx) const
+    void Cell::restore(ESMReader& esm, size_t iCtx) const
     {
         esm.restoreContext(mContextList.at(iCtx));
     }
@@ -321,7 +321,7 @@ namespace ESM
 
     void Cell::blank()
     {
-        mName = "";
+        mName.clear();
         mRegion = ESM::RefId();
         mWater = 0;
         mWaterInt = false;

components/esm3/loadcell.hpp

@@ -34,7 +34,7 @@ namespace ESM
         RefNum mRefNum;
 
         // Coordinates of target exterior cell
-        int mTarget[2];
+        int32_t mTarget[2];
 
         // The content file format does not support moving objects to an interior cell.
         // The save game format does support moving to interior cells, but uses a different mechanism
@@ -153,13 +153,13 @@ namespace ESM
             ESMReader& esm, bool saveContext = true); // Load everything, except NAME, DATAstruct and references
 
         void save(ESMWriter& esm, bool isDeleted = false) const;
-        void saveTempMarker(ESMWriter& esm, int tempCount) const;
+        void saveTempMarker(ESMWriter& esm, int32_t tempCount) const;
 
         bool isExterior() const { return !(mData.mFlags & Interior); }
 
-        int getGridX() const { return mData.mX; }
+        int32_t getGridX() const { return mData.mX; }
 
-        int getGridY() const { return mData.mY; }
+        int32_t getGridY() const { return mData.mY; }
 
         bool hasWater() const { return ((mData.mFlags & HasWater) != 0) || isExterior(); }
 
@@ -172,7 +172,7 @@ namespace ESM
         // somewhere other than the file system, you need to pre-open the
         // ESMReader, and the filename must match the stored filename
         // exactly.
-        void restore(ESMReader& esm, int iCtx) const;
+        void restore(ESMReader& esm, size_t iCtx) const;
 
         std::string getDescription() const;
         ///< Return a short string describing the cell (mostly used for debugging/logging purpose)

components/esm3/loadcont.hpp

@@ -19,7 +19,7 @@ namespace ESM
 
     struct ContItem
     {
-        int mCount{ 0 };
+        int32_t mCount{ 0 };
         ESM::RefId mItem;
     };
 
@@ -48,12 +48,12 @@ namespace ESM
             Unknown = 8
         };
 
-        unsigned int mRecordFlags;
+        uint32_t mRecordFlags;
         RefId mId, mScript;
         std::string mName, mModel;
 
         float mWeight; // Not sure, might be max total weight allowed?
-        int mFlags;
+        int32_t mFlags;
         InventoryList mInventory;
 
         void load(ESMReader& esm, bool& isDeleted);

components/esm3/loadglob.hpp

@@ -25,7 +25,7 @@ namespace ESM
         /// Return a string descriptor for this record type. Currently used for debugging / error logs only.
         static std::string_view getRecordType() { return "Global"; }
 
-        unsigned int mRecordFlags;
+        uint32_t mRecordFlags;
         ESM::RefId mId;
         Variant mValue;
 

components/esm3/loadgmst.hpp

@@ -26,7 +26,7 @@ namespace ESM
         /// Return a string descriptor for this record type. Currently used for debugging / error logs only.
         static std::string_view getRecordType() { return "GameSetting"; }
 
-        unsigned int mRecordFlags;
+        uint32_t mRecordFlags;
         RefId mId;
 
         Variant mValue;

components/esm3/loadlevlist.cpp

@@ -30,7 +30,7 @@ namespace ESM
                     break;
                 case fourCC("INDX"):
                 {
-                    int length = 0;
+                    uint32_t length = 0;
                     esm.getHT(length);
                     mList.resize(length);
 
@@ -87,12 +87,12 @@ namespace ESM
 
         esm.writeHNT("DATA", mFlags);
         esm.writeHNT("NNAM", mChanceNone);
-        esm.writeHNT<int>("INDX", mList.size());
+        esm.writeHNT<uint32_t>("INDX", mList.size());
 
-        for (std::vector<LevelItem>::const_iterator it = mList.begin(); it != mList.end(); ++it)
+        for (const auto& item : mList)
         {
-            esm.writeHNCRefId(recName, it->mId);
+            esm.writeHNCRefId(recName, item.mId);
-            esm.writeHNT("INTV", it->mLevel);
+            esm.writeHNT("INTV", item.mLevel);
         }
     }
 

components/esm3/loadlevlist.hpp

@@ -24,15 +24,15 @@ namespace ESM
 
     struct LevelledListBase
     {
-        int mFlags;
+        int32_t mFlags;
         unsigned char mChanceNone; // Chance that none are selected (0-100)
-        unsigned int mRecordFlags;
+        uint32_t mRecordFlags;
         RefId mId;
 
         struct LevelItem
         {
             RefId mId;
-            short mLevel;
+            uint16_t mLevel;
         };
 
         std::vector<LevelItem> mList;

components/esm3/loadltex.hpp

@@ -29,7 +29,7 @@ namespace ESM
         // mId is merely a user friendly name for the texture in the editor.
         std::string mTexture;
         RefId mId;
-        int mIndex;
+        int32_t mIndex;
 
         void load(ESMReader& esm, bool& isDeleted);
         void save(ESMWriter& esm, bool isDeleted = false) const;

components/esm3/loadmgef.cpp

@@ -36,7 +36,7 @@ namespace ESM
 
         esm.getSubNameIs("MEDT");
         esm.getSubHeader();
-        int school;
+        int32_t school;
         esm.getT(school);
         mData.mSchool = MagicSchool::indexToSkillRefId(school);
         esm.getT(mData.mBaseCost);

components/esm3/loadmgef.hpp

@@ -25,7 +25,7 @@ namespace ESM
         /// Return a string descriptor for this record type. Currently used for debugging / error logs only.
         static std::string_view getRecordType() { return "MagicEffect"; }
 
-        unsigned int mRecordFlags;
+        uint32_t mRecordFlags;
         RefId mId;
 
         enum Flags
@@ -74,9 +74,9 @@ namespace ESM
         {
             RefId mSchool; // Skill id
             float mBaseCost;
-            int mFlags;
+            int32_t mFlags;
             // Glow color for enchanted items with this effect
-            int mRed, mGreen, mBlue;
+            int32_t mRed, mGreen, mBlue;
 
             float mUnknown1; // Called "Size X" in CS
             float mSpeed; // Speed of fired projectile
@@ -107,7 +107,7 @@ namespace ESM
         // there. They can be redefined in mods by setting the name in GMST
         // sEffectSummonCreature04/05 creature id in
         // sMagicCreature04ID/05ID.
-        int mIndex;
+        int32_t mIndex;
 
         void load(ESMReader& esm, bool& isDeleted);
         void save(ESMWriter& esm, bool isDeleted = false) const;

components/esm3/loadnpc.cpp

@@ -82,7 +82,7 @@ namespace ESM
                     break;
                 case fourCC("FLAG"):
                     hasFlags = true;
-                    int flags;
+                    int32_t flags;
                     esm.getHT(flags);
                     mFlags = flags & 0xFF;
                     mBloodType = ((flags >> 8) & 0xFF) >> 2;

components/esm3/loadnpc.hpp

@@ -79,28 +79,28 @@ namespace ESM
 
         struct NPDTstruct52
         {
-            short mLevel;
+            int16_t mLevel;
             unsigned char mStrength, mIntelligence, mWillpower, mAgility, mSpeed, mEndurance, mPersonality, mLuck;
 
             // mSkill can grow up to 200, it must be unsigned
             std::array<unsigned char, Skill::Length> mSkills;
 
             char mUnknown1;
-            unsigned short mHealth, mMana, mFatigue;
+            uint16_t mHealth, mMana, mFatigue;
             unsigned char mDisposition, mReputation, mRank;
             char mUnknown2;
-            int mGold;
+            int32_t mGold;
         }; // 52 bytes
 
         // Structure for autocalculated characters.
         //  This is only used for load and save operations.
         struct NPDTstruct12
         {
-            short mLevel;
+            int16_t mLevel;
             // see above
             unsigned char mDisposition, mReputation, mRank;
             char mUnknown1, mUnknown2, mUnknown3;
-            int mGold;
+            int32_t mGold;
         }; // 12 bytes
 #pragma pack(pop)
 
@@ -111,7 +111,7 @@ namespace ESM
 
         int getFactionRank() const; /// wrapper for mNpdt*, -1 = no rank
 
-        int mBloodType;
+        int32_t mBloodType;
         unsigned char mFlags;
 
         InventoryList mInventory;
@@ -125,7 +125,7 @@ namespace ESM
 
         AIPackageList mAiPackage;
 
-        unsigned int mRecordFlags;
+        uint32_t mRecordFlags;
         RefId mId, mRace, mClass, mFaction, mScript;
         std::string mModel, mName;
 

components/esm3/loadrace.hpp

@@ -27,13 +27,13 @@ namespace ESM
 
         struct SkillBonus
         {
-            int mSkill; // SkillEnum
+            int32_t mSkill; // SkillEnum
-            int mBonus;
+            int32_t mBonus;
         };
 
         struct MaleFemale
         {
-            int mMale, mFemale;
+            int32_t mMale, mFemale;
 
             int getValue(bool male) const;
         };
@@ -63,13 +63,13 @@ namespace ESM
             // as 'height' times 128. This has not been tested yet.
             MaleFemaleF mHeight, mWeight;
 
-            int mFlags; // 0x1 - playable, 0x2 - beast race
+            int32_t mFlags; // 0x1 - playable, 0x2 - beast race
 
         }; // Size = 140 bytes
 
         RADTstruct mData;
 
-        unsigned int mRecordFlags;
+        uint32_t mRecordFlags;
         std::string mName, mDescription;
         RefId mId;
         SpellList mPowers;

components/esm3/loadsndg.hpp

@@ -36,9 +36,9 @@ namespace ESM
         };
 
         // Type
-        int mType;
+        int32_t mType;
 
-        unsigned int mRecordFlags;
+        uint32_t mRecordFlags;
         RefId mId, mCreature, mSound;
 
         void load(ESMReader& esm, bool& isDeleted);

components/esm3/loadsscr.hpp

@@ -28,7 +28,7 @@ namespace ESM
         static std::string_view getRecordType() { return "StartScript"; }
 
         std::string mData;
-        unsigned int mRecordFlags;
+        uint32_t mRecordFlags;
         RefId mId;
 
         // Load a record and add it to the list

components/esm3/loadstat.hpp

@@ -31,7 +31,7 @@ namespace ESM
         /// Return a string descriptor for this record type. Currently used for debugging / error logs only.
         static std::string_view getRecordType() { return "Static"; }
 
-        unsigned int mRecordFlags;
+        uint32_t mRecordFlags;
         RefId mId;
         std::string mModel;
 

components/esm3/loadtes3.hpp

@@ -20,11 +20,11 @@ namespace ESM
             versions are 1.2 and 1.3. These correspond to:
             1.2 = 0x3f99999a and 1.3 = 0x3fa66666
         */
-        unsigned int version;
+        uint32_t version;
-        int type; // 0=esp, 1=esm, 32=ess (unused)
+        int32_t type; // 0=esp, 1=esm, 32=ess (unused)
         std::string author; // Author's name
         std::string desc; // File description
-        int records; // Number of records
+        int32_t records; // Number of records
     };
 
     struct GMDT

components/esm3/magiceffects.cpp

@@ -20,8 +20,8 @@ namespace ESM
     {
         while (esm.isNextSub("EFID"))
         {
-            int id;
+            int32_t id;
-            std::pair<int, float> params;
+            std::pair<int32_t, float> params;
             esm.getHT(id);
             esm.getHNT(params.first, "BASE");
             if (esm.getFormatVersion() <= MaxClearModifiersFormatVersion)

components/esm3/magiceffects.hpp

@@ -16,7 +16,7 @@ namespace ESM
     struct MagicEffects
     {
         // <Effect Id, Base value, Modifier>
-        std::map<int, std::pair<int, float>> mEffects;
+        std::map<int32_t, std::pair<int32_t, float>> mEffects;
 
         void load(ESMReader& esm);
         void save(ESMWriter& esm) const;
@@ -24,16 +24,16 @@ namespace ESM
 
     struct SummonKey
     {
-        SummonKey(int effectId, const ESM::RefId& sourceId, int index)
+        SummonKey(int32_t effectId, const ESM::RefId& sourceId, int32_t index)
             : mEffectId(effectId)
             , mSourceId(sourceId)
             , mEffectIndex(index)
         {
         }
 
-        int mEffectId;
+        int32_t mEffectId;
         ESM::RefId mSourceId;
-        int mEffectIndex;
+        int32_t mEffectIndex;
     };
 
     inline auto makeTupleRef(const SummonKey& value) noexcept

components/esm3/npcstats.cpp

@@ -21,7 +21,7 @@ namespace ESM
 
             Faction faction;
 
-            int expelled = 0;
+            int32_t expelled = 0;
             esm.getHNOT(expelled, "FAEX");
 
             if (expelled)
@@ -75,7 +75,7 @@ namespace ESM
         esm.getHNOT(hasWerewolfAttributes, "HWAT");
         if (hasWerewolfAttributes)
         {
-            StatState<int> dummy;
+            StatState<int32_t> dummy;
             for (int i = 0; i < ESM::Attribute::Length; ++i)
                 dummy.load(esm, intFallback);
             mWerewolfDeprecatedData = true;
@@ -130,21 +130,21 @@ namespace ESM
 
     void NpcStats::save(ESMWriter& esm) const
     {
-        for (auto iter(mFactions.begin()); iter != mFactions.end(); ++iter)
+        for (const auto& [id, faction] : mFactions)
         {
-            esm.writeHNRefId("FACT", iter->first);
+            esm.writeHNRefId("FACT", id);
 
-            if (iter->second.mExpelled)
+            if (faction.mExpelled)
             {
-                int expelled = 1;
+                int32_t expelled = 1;
                 esm.writeHNT("FAEX", expelled);
             }
 
-            if (iter->second.mRank >= 0)
+            if (faction.mRank >= 0)
-                esm.writeHNT("FARA", iter->second.mRank);
+                esm.writeHNT("FARA", faction.mRank);
 
-            if (iter->second.mReputation)
+            if (faction.mReputation)
-                esm.writeHNT("FARE", iter->second.mReputation);
+                esm.writeHNT("FARE", faction.mReputation);
         }
 
         if (mDisposition)
@@ -169,7 +169,7 @@ namespace ESM
             esm.writeHNT("LPRO", mLevelProgress);
 
         bool saveSkillIncreases = false;
-        for (int increase : mSkillIncrease)
+        for (int32_t increase : mSkillIncrease)
         {
             if (increase != 0)
             {
@@ -183,8 +183,8 @@ namespace ESM
         if (mSpecIncreases[0] != 0 || mSpecIncreases[1] != 0 || mSpecIncreases[2] != 0)
             esm.writeHNT("SPEC", mSpecIncreases);
 
-        for (auto iter(mUsedIds.begin()); iter != mUsedIds.end(); ++iter)
+        for (const RefId& id : mUsedIds)
-            esm.writeHNRefId("USED", *iter);
+            esm.writeHNRefId("USED", id);
 
         if (mTimeToStartDrowning)
             esm.writeHNT("DRTI", mTimeToStartDrowning);

components/esm3/npcstats.hpp

@@ -23,8 +23,8 @@ namespace ESM
         struct Faction
         {
             bool mExpelled;
-            int mRank;
+            int32_t mRank;
-            int mReputation;
+            int32_t mReputation;
 
             Faction();
         };
@@ -33,18 +33,18 @@ namespace ESM
 
         bool mWerewolfDeprecatedData;
 
-        std::map<ESM::RefId, Faction> mFactions; // lower case IDs
+        std::map<ESM::RefId, Faction> mFactions;
-        int mDisposition;
+        int32_t mDisposition;
         std::array<StatState<float>, ESM::Skill::Length> mSkills;
-        int mBounty;
+        int32_t mBounty;
-        int mReputation;
+        int32_t mReputation;
-        int mWerewolfKills;
+        int32_t mWerewolfKills;
-        int mLevelProgress;
+        int32_t mLevelProgress;
-        std::array<int, ESM::Attribute::Length> mSkillIncrease;
+        std::array<int32_t, ESM::Attribute::Length> mSkillIncrease;
-        std::array<int, 3> mSpecIncreases;
+        std::array<int32_t, 3> mSpecIncreases;
-        std::vector<ESM::RefId> mUsedIds; // lower case IDs
+        std::vector<ESM::RefId> mUsedIds;
         float mTimeToStartDrowning;
-        int mCrimeId;
+        int32_t mCrimeId;
 
         /// Initialize to default state
         void blank();

components/esm3/objectstate.cpp

@@ -49,7 +49,7 @@ namespace ESM
         esm.getHNOT(mFlags, "FLAG");
 
         // obsolete
-        int unused;
+        int32_t unused;
         esm.getHNOT(unused, "LTIM");
 
         mAnimationState.load(esm);
@@ -179,6 +179,6 @@ namespace ESM
         throw std::logic_error(error.str());
     }
 
-    ObjectState::~ObjectState() {}
+    ObjectState::~ObjectState() = default;
 
 }

components/esm3/objectstate.hpp

@@ -32,9 +32,9 @@ namespace ESM
         Locals mLocals;
         LuaScripts mLuaScripts;
         unsigned char mEnabled;
-        int mCount;
+        int32_t mCount;
         Position mPosition;
-        unsigned int mFlags;
+        uint32_t mFlags;
 
         // Is there any class-specific state following the ObjectState
         bool mHasCustomState;

components/esm3/player.hpp

@@ -27,8 +27,8 @@ namespace ESM
         RefId mMarkedCell;
         ESM::RefId mBirthsign;
 
-        int mCurrentCrimeId;
+        int32_t mCurrentCrimeId;
-        int mPaidCrimeId;
+        int32_t mPaidCrimeId;
 
         float mSaveAttributes[Attribute::Length];
         float mSaveSkills[Skill::Length];

components/esm3/projectilestate.hpp

@@ -23,7 +23,7 @@ namespace ESM
         Vector3 mPosition;
         Quaternion mOrientation;
 
-        int mActorId;
+        int32_t mActorId;
 
         void load(ESMReader& esm);
         void save(ESMWriter& esm) const;

components/esm3/queststate.hpp

@@ -14,7 +14,7 @@ namespace ESM
     struct QuestState
     {
         ESM::RefId mTopic; // lower case id
-        int mState;
+        int32_t mState;
         unsigned char mFinished;
 
         void load(ESMReader& esm);

components/esm3/savedgame.hpp

@@ -20,7 +20,7 @@ namespace ESM
 
         std::vector<std::string> mContentFiles;
         std::string mPlayerName;
-        int mPlayerLevel;
+        int32_t mPlayerLevel;
 
         // ID of class
         ESM::RefId mPlayerClassId;
@@ -34,7 +34,7 @@ namespace ESM
         std::string mDescription;
         std::vector<char> mScreenshot; // raw jpg-encoded data
 
-        int mCurrentDay = 0;
+        int32_t mCurrentDay = 0;
         float mCurrentHealth = 0;
         float mMaximumHealth = 0;
 

components/esm3/statstate.cpp

@@ -21,19 +21,19 @@ namespace ESM
         // We changed stats values from integers to floats; ensure backwards compatibility
         if (intFallback)
         {
-            int base = 0;
+            int32_t base = 0;
             esm.getHNT(base, "STBA");
             mBase = static_cast<T>(base);
 
-            int mod = 0;
+            int32_t mod = 0;
             esm.getHNOT(mod, "STMO");
             mMod = static_cast<T>(mod);
 
-            int current = 0;
+            int32_t current = 0;
             esm.getHNOT(current, "STCU");
             mCurrent = static_cast<T>(current);
 
-            int oldDamage = 0;
+            int32_t oldDamage = 0;
             esm.getHNOT(oldDamage, "STDA");
             mDamage = static_cast<float>(oldDamage);
         }

components/esm3/variant.cpp

@@ -17,7 +17,7 @@ namespace ESM
         template <typename T, bool orDefault = false>
         struct GetValue
         {
-            constexpr T operator()(int value) const { return static_cast<T>(value); }
+            constexpr T operator()(int32_t value) const { return static_cast<T>(value); }
 
             constexpr T operator()(float value) const { return static_cast<T>(value); }
 
@@ -41,7 +41,7 @@ namespace ESM
             {
             }
 
-            void operator()(int& value) const { value = static_cast<int>(mValue); }
+            void operator()(int32_t& value) const { value = static_cast<int32_t>(mValue); }
 
             void operator()(float& value) const { value = static_cast<float>(mValue); }
 
@@ -58,9 +58,9 @@ namespace ESM
         return std::get<std::string>(mData);
     }
 
-    int Variant::getInteger() const
+    int32_t Variant::getInteger() const
     {
-        return std::visit(GetValue<int>{}, mData);
+        return std::visit(GetValue<int32_t>{}, mData);
     }
 
     float Variant::getFloat() const
@@ -194,17 +194,17 @@ namespace ESM
 
             case VT_Short:
 
-                stream << "variant short: " << std::get<int>(mData);
+                stream << "variant short: " << std::get<int32_t>(mData);
                 break;
 
             case VT_Int:
 
-                stream << "variant int: " << std::get<int>(mData);
+                stream << "variant int: " << std::get<int32_t>(mData);
                 break;
 
             case VT_Long:
 
-                stream << "variant long: " << std::get<int>(mData);
+                stream << "variant long: " << std::get<int32_t>(mData);
                 break;
 
             case VT_Float:
@@ -259,7 +259,7 @@ namespace ESM
         std::get<std::string>(mData) = std::move(value);
     }
 
-    void Variant::setInteger(int value)
+    void Variant::setInteger(int32_t value)
     {
         std::visit(SetValue(value), mData);
     }

components/esm3/variant.hpp

@@ -25,7 +25,7 @@ namespace ESM
     class Variant
     {
         VarType mType;
-        std::variant<std::monostate, int, float, std::string> mData;
+        std::variant<std::monostate, int32_t, float, std::string> mData;
 
     public:
         enum Format
@@ -54,7 +54,7 @@ namespace ESM
         {
         }
 
-        explicit Variant(int value)
+        explicit Variant(int32_t value)
             : mType(VT_Long)
             , mData(value)
         {
@@ -71,7 +71,7 @@ namespace ESM
         const std::string& getString() const;
         ///< Will throw an exception, if value can not be represented as a string.
 
-        int getInteger() const;
+        int32_t getInteger() const;
         ///< Will throw an exception, if value can not be represented as an integer (implicit
         /// casting of float values is permitted).
 
@@ -93,7 +93,7 @@ namespace ESM
         void setString(std::string&& value);
         ///< Will throw an exception, if type is not compatible with string.
 
-        void setInteger(int value);
+        void setInteger(int32_t value);
         ///< Will throw an exception, if type is not compatible with integer.
 
         void setFloat(float value);

components/esm3/variantimp.cpp

@@ -46,7 +46,7 @@ namespace ESM
         esm.writeHNString("STRV", in);
     }
 
-    void readESMVariantValue(ESMReader& esm, Variant::Format format, VarType type, int& out)
+    void readESMVariantValue(ESMReader& esm, Variant::Format format, VarType type, int32_t& out)
     {
         if (type != VT_Short && type != VT_Long && type != VT_Int)
             throw std::logic_error("not an integer type");
@@ -60,9 +60,9 @@ namespace ESM
                 if (std::isnan(value))
                     out = 0;
                 else
-                    out = static_cast<short>(value);
+                    out = static_cast<int16_t>(value);
             else if (type == VT_Long)
-                out = static_cast<int>(value);
+                out = static_cast<int32_t>(value);
             else
                 esm.fail("unsupported global variable integer type");
         }
@@ -82,7 +82,7 @@ namespace ESM
         {
             if (type == VT_Short)
             {
-                short value;
+                int16_t value;
                 esm.getHT(value);
                 out = value;
             }
@@ -95,7 +95,7 @@ namespace ESM
         }
     }
 
-    void writeESMVariantValue(ESMWriter& esm, Variant::Format format, VarType type, int in)
+    void writeESMVariantValue(ESMWriter& esm, Variant::Format format, VarType type, int32_t in)
     {
         if (type != VT_Short && type != VT_Long && type != VT_Int)
             throw std::logic_error("not an integer type");
@@ -126,7 +126,7 @@ namespace ESM
         else if (format == Variant::Format_Local)
         {
             if (type == VT_Short)
-                esm.writeHNT("STTV", static_cast<short>(in));
+                esm.writeHNT("STTV", static_cast<int16_t>(in));
             else if (type == VT_Int)
                 esm.writeHNT("INTV", in);
             else

components/esm3/variantimp.hpp

@@ -12,13 +12,13 @@ namespace ESM
 
     void readESMVariantValue(ESMReader& reader, Variant::Format format, VarType type, float& value);
 
-    void readESMVariantValue(ESMReader& reader, Variant::Format format, VarType type, int& value);
+    void readESMVariantValue(ESMReader& reader, Variant::Format format, VarType type, int32_t& value);
 
     void writeESMVariantValue(ESMWriter& writer, Variant::Format format, VarType type, const std::string& value);
 
     void writeESMVariantValue(ESMWriter& writer, Variant::Format format, VarType type, float value);
 
-    void writeESMVariantValue(ESMWriter& writer, Variant::Format format, VarType type, int value);
+    void writeESMVariantValue(ESMWriter& writer, Variant::Format format, VarType type, int32_t value);
 
     struct ReadESMVariantValue
     {