Use ESM::decompose to handle WPDTstruct

7 files changed, 82 insertions, 32 deletions

diff --git a/apps/openmw/mwclass/creature.cpp b/apps/openmw/mwclass/creature.cpp
index 2de58c6127..b6c607b415 100644
--- a/apps/openmw/mwclass/creature.cpp
+++ b/apps/openmw/mwclass/creature.cpp
@@ -316,11 +316,11 @@ namespace MWClass
         {
             const unsigned char* attack = nullptr;
             if (type == ESM::Weapon::AT_Chop)
-                attack = weapon.get<ESM::Weapon>()->mBase->mData.mChop;
+                attack = weapon.get<ESM::Weapon>()->mBase->mData.mChop.data();
             else if (type == ESM::Weapon::AT_Slash)
-                attack = weapon.get<ESM::Weapon>()->mBase->mData.mSlash;
+                attack = weapon.get<ESM::Weapon>()->mBase->mData.mSlash.data();
             else if (type == ESM::Weapon::AT_Thrust)
-                attack = weapon.get<ESM::Weapon>()->mBase->mData.mThrust;
+                attack = weapon.get<ESM::Weapon>()->mBase->mData.mThrust.data();
             if (attack)
             {
                 damage = attack[0] + ((attack[1] - attack[0]) * attackStrength);
diff --git a/apps/openmw/mwclass/npc.cpp b/apps/openmw/mwclass/npc.cpp
index b7540ebe04..98384254d3 100644
--- a/apps/openmw/mwclass/npc.cpp
+++ b/apps/openmw/mwclass/npc.cpp
@@ -635,11 +635,11 @@ namespace MWClass
         {
             const unsigned char* attack = nullptr;
             if (type == ESM::Weapon::AT_Chop)
-                attack = weapon.get<ESM::Weapon>()->mBase->mData.mChop;
+                attack = weapon.get<ESM::Weapon>()->mBase->mData.mChop.data();
             else if (type == ESM::Weapon::AT_Slash)
-                attack = weapon.get<ESM::Weapon>()->mBase->mData.mSlash;
+                attack = weapon.get<ESM::Weapon>()->mBase->mData.mSlash.data();
             else if (type == ESM::Weapon::AT_Thrust)
-                attack = weapon.get<ESM::Weapon>()->mBase->mData.mThrust;
+                attack = weapon.get<ESM::Weapon>()->mBase->mData.mThrust.data();
             if (attack)
             {
                 damage = attack[0] + ((attack[1] - attack[0]) * attackStrength);
diff --git a/apps/openmw/mwmechanics/combat.cpp b/apps/openmw/mwmechanics/combat.cpp
index 831c3ff7ab..b9852e1b41 100644
--- a/apps/openmw/mwmechanics/combat.cpp
+++ b/apps/openmw/mwmechanics/combat.cpp
@@ -246,14 +246,16 @@ namespace MWMechanics
                 return;
             }
 
-            const unsigned char* attack = weapon.get<ESM::Weapon>()->mBase->mData.mChop;
-            damage = attack[0] + ((attack[1] - attack[0]) * attackStrength); // Bow/crossbow damage
-
-            // Arrow/bolt damage
-            // NB in case of thrown weapons, we are applying the damage twice since projectile == weapon
-            attack = projectile.get<ESM::Weapon>()->mBase->mData.mChop;
-            damage += attack[0] + ((attack[1] - attack[0]) * attackStrength);
-
+            {
+                const auto& attack = weapon.get<ESM::Weapon>()->mBase->mData.mChop;
+                damage = attack[0] + ((attack[1] - attack[0]) * attackStrength); // Bow/crossbow damage
+            }
+            {
+                // Arrow/bolt damage
+                // NB in case of thrown weapons, we are applying the damage twice since projectile == weapon
+                const auto& attack = projectile.get<ESM::Weapon>()->mBase->mData.mChop;
+                damage += attack[0] + ((attack[1] - attack[0]) * attackStrength);
+            }
             adjustWeaponDamage(damage, weapon, attacker);
         }
 
diff --git a/apps/openmw_test_suite/esm3/testsaveload.cpp b/apps/openmw_test_suite/esm3/testsaveload.cpp
index 8c7896b08a..6d5fdf1c14 100644
--- a/apps/openmw_test_suite/esm3/testsaveload.cpp
+++ b/apps/openmw_test_suite/esm3/testsaveload.cpp
@@ -8,6 +8,7 @@
 #include <components/esm3/loaddial.hpp>
 #include <components/esm3/loadregn.hpp>
 #include <components/esm3/loadscpt.hpp>
+#include <components/esm3/loadweap.hpp>
 #include <components/esm3/player.hpp>
 #include <components/esm3/quickkeys.hpp>
 
@@ -554,6 +555,53 @@ namespace ESM
             EXPECT_EQ(result.mList[0].mMagnMax, record.mList[0].mMagnMax);
         }
 
+        TEST_P(Esm3SaveLoadRecordTest, weaponShouldNotChange)
+        {
+            Weapon record = {
+                .mData = {
+                    .mWeight = 0,
+                    .mValue = 1,
+                    .mType = 2,
+                    .mHealth = 3,
+                    .mSpeed = 4,
+                    .mReach = 5,
+                    .mEnchant = 6,
+                    .mChop = { 7, 8 },
+                    .mSlash = { 9, 10 },
+                    .mThrust = { 11, 12 },
+                    .mFlags = 13,
+                },
+                .mRecordFlags = 0,
+                .mId = generateRandomRefId(32),
+                .mEnchant = generateRandomRefId(32),
+                .mScript = generateRandomRefId(32),
+                .mName = generateRandomString(32),
+                .mModel = generateRandomString(32),
+                .mIcon = generateRandomString(32),
+            };
+
+            Weapon result;
+            saveAndLoadRecord(record, GetParam(), result);
+
+            EXPECT_EQ(result.mData.mWeight, record.mData.mWeight);
+            EXPECT_EQ(result.mData.mValue, record.mData.mValue);
+            EXPECT_EQ(result.mData.mType, record.mData.mType);
+            EXPECT_EQ(result.mData.mHealth, record.mData.mHealth);
+            EXPECT_EQ(result.mData.mSpeed, record.mData.mSpeed);
+            EXPECT_EQ(result.mData.mReach, record.mData.mReach);
+            EXPECT_EQ(result.mData.mEnchant, record.mData.mEnchant);
+            EXPECT_EQ(result.mData.mChop, record.mData.mChop);
+            EXPECT_EQ(result.mData.mSlash, record.mData.mSlash);
+            EXPECT_EQ(result.mData.mThrust, record.mData.mThrust);
+            EXPECT_EQ(result.mData.mFlags, record.mData.mFlags);
+            EXPECT_EQ(result.mId, record.mId);
+            EXPECT_EQ(result.mEnchant, record.mEnchant);
+            EXPECT_EQ(result.mScript, record.mScript);
+            EXPECT_EQ(result.mName, record.mName);
+            EXPECT_EQ(result.mModel, record.mModel);
+            EXPECT_EQ(result.mIcon, record.mIcon);
+        }
+
         INSTANTIATE_TEST_SUITE_P(FormatVersions, Esm3SaveLoadRecordTest, ValuesIn(getFormats()));
     }
 }
diff --git a/components/esm3/esmreader.hpp b/components/esm3/esmreader.hpp
index ca9f191a5d..4af2264828 100644
--- a/components/esm3/esmreader.hpp
+++ b/components/esm3/esmreader.hpp
@@ -191,13 +191,7 @@ namespace ESM
 
         void getSubComposite(auto& value)
         {
-            decompose(value, [&](auto&... args) {
-                constexpr size_t size = (0 + ... + sizeof(decltype(args)));
-                getSubHeader();
-                if (mCtx.leftSub != size)
-                    reportSubSizeMismatch(size, mCtx.leftSub);
-                (getT(args), ...);
-            });
+            decompose(value, [&](auto&... args) { getHT(args...); });
         }
 
         template <typename T, typename = std::enable_if_t<IsReadable<T>>>
diff --git a/components/esm3/loadweap.cpp b/components/esm3/loadweap.cpp
index 31c03b00fe..f06abf4e7c 100644
--- a/components/esm3/loadweap.cpp
+++ b/components/esm3/loadweap.cpp
@@ -1,11 +1,20 @@
 #include "loadweap.hpp"
 
-#include "components/esm/defs.hpp"
+#include <components/esm/defs.hpp>
+#include <components/misc/concepts.hpp>
+
 #include "esmreader.hpp"
 #include "esmwriter.hpp"
 
 namespace ESM
 {
+    template <Misc::SameAsWithoutCvref<Weapon::WPDTstruct> T>
+    void decompose(T&& v, const auto& f)
+    {
+        f(v.mWeight, v.mValue, v.mType, v.mHealth, v.mSpeed, v.mReach, v.mEnchant, v.mChop, v.mSlash, v.mThrust,
+            v.mFlags);
+    }
+
     void Weapon::load(ESMReader& esm, bool& isDeleted)
     {
         isDeleted = false;
@@ -29,8 +38,7 @@ namespace ESM
                     mName = esm.getHString();
                     break;
                 case fourCC("WPDT"):
-                    esm.getHT(mData.mWeight, mData.mValue, mData.mType, mData.mHealth, mData.mSpeed, mData.mReach,
-                        mData.mEnchant, mData.mChop, mData.mSlash, mData.mThrust, mData.mFlags);
+                    esm.getSubComposite(mData);
                     hasData = true;
                     break;
                 case fourCC("SCRI"):
@@ -68,7 +76,7 @@ namespace ESM
 
         esm.writeHNCString("MODL", mModel);
         esm.writeHNOCString("FNAM", mName);
-        esm.writeHNT("WPDT", mData, 32);
+        esm.writeNamedComposite("WPDT", mData);
         esm.writeHNOCRefId("SCRI", mScript);
         esm.writeHNOCString("ITEX", mIcon);
         esm.writeHNOCRefId("ENAM", mEnchant);
@@ -84,9 +92,9 @@ namespace ESM
         mData.mSpeed = 0;
         mData.mReach = 0;
         mData.mEnchant = 0;
-        mData.mChop[0] = mData.mChop[1] = 0;
-        mData.mSlash[0] = mData.mSlash[1] = 0;
-        mData.mThrust[0] = mData.mThrust[1] = 0;
+        mData.mChop.fill(0);
+        mData.mSlash.fill(0);
+        mData.mThrust.fill(0);
         mData.mFlags = 0;
 
         mName.clear();
diff --git a/components/esm3/loadweap.hpp b/components/esm3/loadweap.hpp
index ba1599b1df..8323176a64 100644
--- a/components/esm3/loadweap.hpp
+++ b/components/esm3/loadweap.hpp
@@ -1,6 +1,7 @@
 #ifndef OPENMW_ESM_WEAP_H
 #define OPENMW_ESM_WEAP_H
 
+#include <array>
 #include <string>
 
 #include "components/esm/refid.hpp"
@@ -59,8 +60,6 @@ namespace ESM
             Silver = 0x02
         };
 
-#pragma pack(push)
-#pragma pack(1)
         struct WPDTstruct
         {
             float mWeight;
@@ -69,10 +68,9 @@ namespace ESM
             uint16_t mHealth;
             float mSpeed, mReach;
             uint16_t mEnchant; // Enchantment points. The real value is mEnchant/10.f
-            unsigned char mChop[2], mSlash[2], mThrust[2]; // Min and max
+            std::array<unsigned char, 2> mChop, mSlash, mThrust; // Min and max
             int32_t mFlags;
         }; // 32 bytes
-#pragma pack(pop)
 
         WPDTstruct mData;