ksys/act: split IDamageManager out of DamageManagerBase

DamageManagerBase's root base class (previously
DamageManagerBase_UnknownBase1) holds the damage callback list, and its
code is linked among the ActorSystem objects rather than with the
Game/Actor/Damage files. It appears to be an engine-side abstract base,
so let's move it to KingSystem/ActorSystem as ksys::act::IDamageManager
(unofficial name, following the ksys IManager/Manager pattern and
Actor::getDamageMgr), together with DamageCallback and Struct20Base, and
have Actor::getDamageMgr return it. DamageManagerBase now overrides its
getters and inherits addDamageCallback/removeDamageCallback from it.

The rest of the damage code stays in Game/Actor/Damage but is regrouped
to match link order: Struct20::combineMaybe moves into
actDamageManagerBase.cpp, Struct20::reset becomes inline and
dmgStruct20.cpp becomes actDamageMgr.cpp. The uking::dmg namespace is
merged into uking::act, so the files there take the act prefix too, and
dmgInfoManager becomes actDamageInfoMgr after the class it holds.

(AI assisted using Claude Fable 5.1 and Claude Opus 5.5)

10 files changed, 95 insertions, 228 deletions

diff --git a/src/Game/Actor/Damage/CMakeLists.txt b/src/Game/Actor/Damage/CMakeLists.txt
index 1a590388..b9910e99 100644
--- a/src/Game/Actor/Damage/CMakeLists.txt
+++ b/src/Game/Actor/Damage/CMakeLists.txt
@@ -1,9 +1,8 @@
 target_sources(uking PRIVATE
-    dmgDamageCallback.h
-    dmgDamageManagerBase.h
-    dmgDamageManagerBase.cpp
-    dmgInfoManager.cpp
-    dmgInfoManager.h
-    dmgStruct20.h
-    dmgStruct20.cpp
+    actDamageInfoMgr.cpp
+    actDamageInfoMgr.h
+    actDamageManagerBase.cpp
+    actDamageManagerBase.h
+    actDamageMgr.cpp
+    actStruct20.h
 )
diff --git a/src/Game/Actor/Damage/dmgInfoManager.cpp b/src/Game/Actor/Damage/actDamageInfoMgr.cpp
index 0b220990..e794326a 100644
--- a/src/Game/Actor/Damage/dmgInfoManager.cpp
+++ b/src/Game/Actor/Damage/actDamageInfoMgr.cpp
@@ -1,10 +1,10 @@
-#include "Game/Actor/Damage/dmgInfoManager.h"
+#include "Game/Actor/Damage/actDamageInfoMgr.h"
 #include "Game/Scene/gameScene.h"
 #include "KingSystem/ActorSystem/actGlobalParameter.h"
 #include "KingSystem/GameData/gdtCommonFlagsUtils.h"
 #include "KingSystem/Resource/GeneralParamList/resGParamListObjectGlobal.h"
 
-namespace uking::dmg {
+namespace uking::act {
 
 SEAD_SINGLETON_DISPOSER_IMPL(DamageInfoMgr)
 
@@ -66,4 +66,4 @@ bool DamageInfoMgr::isTrueFormMasterSword() const {
     return mMasterSwordDetectedEvil;
 }
 
-}  // namespace uking::dmg
+}  // namespace uking::act
diff --git a/src/Game/Actor/Damage/dmgInfoManager.h b/src/Game/Actor/Damage/actDamageInfoMgr.h
index 773e190d..60cf1f88 100644
--- a/src/Game/Actor/Damage/dmgInfoManager.h
+++ b/src/Game/Actor/Damage/actDamageInfoMgr.h
@@ -8,7 +8,7 @@
 #include "KingSystem/ActorSystem/actBaseProcLink.h"
 #include "KingSystem/Resource/resHandle.h"
 
-namespace uking::dmg {
+namespace uking::act {
 
 // FIXME: incomplete
 class DamageInfoMgr {
@@ -59,4 +59,4 @@ private:
 };
 KSYS_CHECK_SIZE_NX150(DamageInfoMgr, 0x12F0);
 
-}  // namespace uking::dmg
+}  // namespace uking::act
diff --git a/src/Game/Actor/Damage/dmgDamageManagerBase.cpp b/src/Game/Actor/Damage/actDamageManagerBase.cpp
index 26e8876b..ab634ec4 100644
--- a/src/Game/Actor/Damage/dmgDamageManagerBase.cpp
+++ b/src/Game/Actor/Damage/actDamageManagerBase.cpp
@@ -1,6 +1,5 @@
-#include "Game/Actor/Damage/dmgDamageManagerBase.h"
+#include "Game/Actor/Damage/actDamageManagerBase.h"
 #include "Game/AOC/aocHardModeManager.h"
-#include "Game/Actor/Damage/dmgDamageCallback.h"
 #include "KingSystem/ActorSystem/actActor.h"
 #include "KingSystem/ActorSystem/actActorLinkConstDataAccess.h"
 #include "KingSystem/ActorSystem/actActorParam.h"
@@ -9,18 +8,14 @@
 #include "KingSystem/Resource/Actor/resResourceGParamList.h"
 #include "KingSystem/Resource/GeneralParamList/resGParamListObjectGeneral.h"
 
-namespace uking::dmg {
-
-DamageManagerBase_UnknownBase1::DamageManagerBase_UnknownBase1(ksys::act::Actor* actor)
-    : mActor(actor) {}
+namespace uking::act {
 
 // Compiler seems to combine zero(0) writes to (0x0 ,0x8) and (0x10, 0x18)
 // when writing the vtable and Actor.
 // The original Compiler writes (0x8, 0x10) in one 'stp', and writes 0x0 and 0x18 individually with
 // 'str'. The rest seems to fall out of sync due to that, but it's otherwise functionally the same.
 // NON_MATCHING: Incorrect order.
-DamageManagerBase::DamageManagerBase(ksys::act::Actor* actor)
-    : DamageManagerBase_UnknownBase1(actor) {}
+DamageManagerBase::DamageManagerBase(ksys::act::Actor* actor) : IDamageManager(actor) {}
 
 u32 DamageManagerBase::getDamage() {
     u32 result;
@@ -32,81 +27,6 @@ u32 DamageManagerBase::getDamage() {
     return result;
 }
 
-void DamageManagerBase::addDamageCallback(s32 eventId, DamageCallback* callback) {
-    if (mCallbacks.isBufferReady() && !callback->mDamageManager) {
-        DamageCallback* next = mCallbacks[eventId];
-        if (next) {
-            DamageCallback* prev;
-            while (next) {
-                prev = next;
-                next = next->mNext;
-            }
-
-            prev->mNext = callback;
-            callback->mPrev = prev;
-        } else {
-            mCallbacks[eventId] = callback;
-        }
-
-        callback->mDamageManager = this;
-        callback->mEventId = eventId;
-    }
-}
-
-void DamageManagerBase::removeDamageCallback(DamageCallback* callback) {
-    if (!mCallbacks.isBufferReady() || callback->mDamageManager != this) {
-        return;
-    }
-
-    u32 event_id = callback->mEventId;
-    DamageCallback* current_callback = mCallbacks[event_id];
-    if (!current_callback) {
-        if (mActor) {
-            // Logging about trying to remove missing callback?
-            mActor->nullsub_4649();
-        }
-
-        callback->mDamageManager = nullptr;
-        callback->mEventId = -1;
-#ifdef MATCHING_HACK_NX_CLANG
-        asm("");  // Stop optimizing with the other clear below
-#endif
-        return;
-    }
-
-    if (current_callback == callback) {
-        mCallbacks[event_id] = callback->mNext;
-        current_callback = mCallbacks[event_id];
-        if (current_callback) {
-            current_callback->mPrev = nullptr;
-        }
-#ifdef MATCHING_HACK_NX_CLANG
-        asm("");  // Stop re-using variables, generating an extra register
-#endif
-    } else {
-        do {
-            if (current_callback == callback) {
-                DamageCallback* prev = callback->mPrev;
-                if (prev) {
-                    prev->mNext = callback->mNext;
-                }
-                DamageCallback* next = callback->mNext;
-                if (next) {
-                    next->mPrev = callback->mPrev;
-                }
-            }
-            current_callback = current_callback->mNext;
-        } while (current_callback);
-    }
-    callback->mNext = nullptr;
-#ifdef MATCHING_HACK_NX_CLANG
-    asm("");  // Stop combining the mNext and mDamageManager
-#endif
-    callback->mDamageManager = nullptr;
-    callback->mEventId = -1;
-    callback->mPrev = nullptr;
-}
-
 bool DamageManagerBase::applyDamage(s32& life) {
     auto* param_list = mActor->getParam()->getRes().mGParamList;
 
@@ -276,4 +196,19 @@ s32 DamageManagerBase::m49(s32 damageTypeMaybe) {
     return 0;
 }
 
-}  // namespace uking::dmg
+void Struct20::combineMaybe(ksys::act::Struct20Base* other) {
+    Struct20* otherStruct = sead::DynamicCast<Struct20>(other);
+    if (!otherStruct) {
+        return;
+    }
+
+    mField_8 += otherStruct->mField_8;
+    mField_C += otherStruct->mField_C;
+    mField_10 += otherStruct->mField_10;
+    if (mField_18 < otherStruct->mField_18) {
+        mField_14 = otherStruct->mField_14;
+        mField_18 = otherStruct->mField_18;
+    }
+}
+
+}  // namespace uking::act
diff --git a/src/Game/Actor/Damage/dmgDamageManagerBase.h b/src/Game/Actor/Damage/actDamageManagerBase.h
index dc92804c..3df0fe90 100644
--- a/src/Game/Actor/Damage/dmgDamageManagerBase.h
+++ b/src/Game/Actor/Damage/actDamageManagerBase.h
@@ -3,39 +3,20 @@
 #include <basis/seadTypes.h>
 #include <container/seadBuffer.h>
 #include <heap/seadExpHeap.h>
+#include <math/seadVector.h>
 #include <prim/seadRuntimeTypeInfo.h>
 
-#include "Game/Actor/Damage/dmgInfoManager.h"
-#include "Game/Actor/Damage/dmgStruct20.h"
+#include "Game/Actor/Damage/actDamageInfoMgr.h"
+#include "Game/Actor/Damage/actStruct20.h"
 #include "KingSystem/ActorSystem/actBaseProcLink.h"
+#include "KingSystem/ActorSystem/actIDamageManager.h"
 
 namespace ksys::act {
 class Actor;
 class ActorParam;
 }  // namespace ksys::act
 
-namespace uking::dmg {
-
-class DamageCallback;
-
-// FIXME: Unknown base. This base seems to handle callbacks and messaging, so maybe a shared base?
-class DamageManagerBase_UnknownBase1 {
-public:
-    explicit DamageManagerBase_UnknownBase1(ksys::act::Actor* WeaponActor);
-    virtual ~DamageManagerBase_UnknownBase1() = default;
-
-    // Sturct20 for Damage receive/send?
-    Struct20Base* mStruct20_a = nullptr;
-    Struct20Base* mStruct20_b = nullptr;
-
-    ksys::act::Actor* mActor = nullptr;
-
-    sead::Buffer<DamageCallback*> mCallbacks{};
-
-    // Callback status flags?
-    s32 mField_30 = 0;
-    s8 mField_34 = 0;
-};
+namespace uking::act {
 
 // FIXME: Unknown base 2. Helper functions maybe? Might also contain some of the fields from
 // DamageManagerBase.
@@ -44,25 +25,22 @@ public:
     virtual ~DamageManagerBase_UnknownBase2() = default;
 };
 
-class DamageManagerBase : public DamageManagerBase_UnknownBase1,
-                          public DamageManagerBase_UnknownBase2 {
+class DamageManagerBase : public ksys::act::IDamageManager, public DamageManagerBase_UnknownBase2 {
 public:
     explicit DamageManagerBase(ksys::act::Actor* actor);
     ~DamageManagerBase() override = default;
 
-    SEAD_RTTI_BASE(DamageManagerBase)
-
-    virtual u32 getDamage();
-    virtual s32 getField48() { return mField_48; }
-    virtual s32 getMinDmg() { return mMinDmg; }
-    virtual s32 getField50() { return mField_50; }
-    virtual s32 getField54() { return mField_54; }
-    virtual bool checkDamageFlags() { return false; }
-    virtual s32 getFlags2() { return mFlags2; }
-    virtual void addDamageCallback(s32 eventId, DamageCallback* callback);
-    virtual void removeDamageCallback(DamageCallback* callback);
+    SEAD_RTTI_OVERRIDE(DamageManagerBase, ksys::act::IDamageManager)
+
+    u32 getDamage() override;
+    s32 getField48() override { return mField_48; }
+    s32 getMinDmg() override { return mMinDmg; }
+    s32 getField50() override { return mField_50; }
+    s32 getField54() override { return mField_54; }
+    bool checkDamageFlags() override { return false; }
+    s32 getFlags2() override { return mFlags2; }
     virtual f32 m13() { return 0.0f; }
-    virtual bool m14() { return false; }
+    virtual bool getStasisBlowVelocity(sead::Vector3f* velocity) { return false; }
     virtual bool applyDamage(s32& life);
     virtual bool m16() { return false; }
     virtual void accumulateStasisBlowVelocity() {}
@@ -140,4 +118,4 @@ private:
 };
 KSYS_CHECK_SIZE_NX150(DamageManagerBase, 0x68);
 
-}  // namespace uking::dmg
+}  // namespace uking::act
diff --git a/src/Game/Actor/Damage/actDamageMgr.cpp b/src/Game/Actor/Damage/actDamageMgr.cpp
new file mode 100644
index 00000000..22a478b4
--- /dev/null
+++ b/src/Game/Actor/Damage/actDamageMgr.cpp
@@ -0,0 +1,30 @@
+#include "Game/Actor/Damage/actStruct20.h"
+
+namespace uking::act {
+
+void Struct20_2::reset() {
+    mField_1C = 0;
+    mField_30 = false;
+
+    Struct20::reset();
+}
+
+void Struct20_2::combineMaybe(ksys::act::Struct20Base* other) {
+    Struct20_2* otherStruct = sead::DynamicCast<Struct20_2>(other);
+    if (!otherStruct) {
+        Struct20::combineMaybe(other);
+        return;
+    }
+
+    mField_1C |= otherStruct->mField_1C;
+    Struct20::combineMaybe(other);
+    if (mField_18 == otherStruct->mField_18 && otherStruct->mField_30) {
+        mField_30 = true;
+        mField_20 = otherStruct->mField_20;
+        mField_24 = otherStruct->mField_24;
+        mField_28 = otherStruct->mField_28;
+        mField_2C = otherStruct->mField_2C;
+    }
+}
+
+}  // namespace uking::act
diff --git a/src/Game/Actor/Damage/dmgStruct20.h b/src/Game/Actor/Damage/actStruct20.h
index e3601caf..7c341311 100644
--- a/src/Game/Actor/Damage/dmgStruct20.h
+++ b/src/Game/Actor/Damage/actStruct20.h
@@ -3,9 +3,10 @@
 #include <basis/seadTypes.h>
 #include <prim/seadRuntimeTypeInfo.h>
 
+#include "KingSystem/ActorSystem/actIDamageManager.h"
 #include "KingSystem/Utils/Types.h"
 
-namespace uking::dmg {
+namespace uking::act {
 
 // What exactly Struct20 is, isn't known yet.
 // It is used by the Damage Managers, especially DamageManager and up, not so much in
@@ -14,25 +15,15 @@ namespace uking::dmg {
 
 // TODO: Figure out exactly what Struct20 does and rename struct + variables to fit.
 
-class Struct20Base {
-    SEAD_RTTI_BASE(Struct20Base)
-
-public:
-    virtual ~Struct20Base() = default;
-
-    virtual void reset();
-    virtual void combineMaybe(Struct20Base* other);
-};
-
-class Struct20 : public Struct20Base {
-    SEAD_RTTI_OVERRIDE(Struct20, Struct20Base)
+class Struct20 : public ksys::act::Struct20Base {
+    SEAD_RTTI_OVERRIDE(Struct20, ksys::act::Struct20Base)
 
 public:
     ~Struct20() override { ; }
 
     void reset() override;
 
-    __attribute__((noinline)) void combineMaybe(Struct20Base* other) override;
+    __attribute__((noinline)) void combineMaybe(ksys::act::Struct20Base* other) override;
 
     // Unknown which fields belong in Struct20 vs Struct20Base
     u32 mField_8 = 0;
@@ -44,6 +35,14 @@ public:
 };
 KSYS_CHECK_SIZE_NX150(Struct20, 0x20);
 
+inline void Struct20::reset() {
+    mField_8 = 0;
+    mField_C = 0;
+    mField_10 = 0;
+    mField_14 = -1;
+    mField_18 = -1;
+}
+
 class Struct20_2 : public Struct20 {
     SEAD_RTTI_OVERRIDE(Struct20_2, Struct20)
 
@@ -51,7 +50,7 @@ public:
     ~Struct20_2() override { ; }
 
     void reset() override;
-    void combineMaybe(Struct20Base* other) override;
+    void combineMaybe(ksys::act::Struct20Base* other) override;
 
     f32 mField_20;
     f32 mField_24;
@@ -61,4 +60,4 @@ public:
 };
 KSYS_CHECK_SIZE_NX150(Struct20_2, 0x38);
 
-}  // namespace uking::dmg
+}  // namespace uking::act
diff --git a/src/Game/Actor/Damage/dmgDamageCallback.h b/src/Game/Actor/Damage/dmgDamageCallback.h
deleted file mode 100644
index b62e2658..00000000
--- a/src/Game/Actor/Damage/dmgDamageCallback.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#include <basis/seadTypes.h>
-
-namespace uking::dmg {
-
-class DamageManagerBase;
-
-// FIXME: incomplete
-class DamageCallback {
-public:
-    virtual ~DamageCallback() {}
-    virtual void call(u32* a1, s32* a2, u32* a3, u32* a4, u32* a5, u64 a6);
-
-    DamageCallback* mPrev;
-    DamageCallback* mNext;
-    DamageManagerBase* mDamageManager;  // Might be a different base class(Interface?)
-    u32 mEventId;
-};
-
-}  // namespace uking::dmg
diff --git a/src/Game/Actor/Damage/dmgStruct20.cpp b/src/Game/Actor/Damage/dmgStruct20.cpp
deleted file mode 100644
index d52eb3a6..00000000
--- a/src/Game/Actor/Damage/dmgStruct20.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "Game/Actor/Damage/dmgStruct20.h"
-
-namespace uking::dmg {
-
-void Struct20::reset() {
-    mField_8 = 0;
-    mField_C = 0;
-    mField_10 = 0;
-    mField_14 = -1;
-    mField_18 = -1;
-}
-
-void Struct20::combineMaybe(Struct20Base* other) {
-    Struct20* otherStruct = sead::DynamicCast<Struct20>(other);
-    if (!otherStruct) {
-        return;
-    }
-
-    mField_8 += otherStruct->mField_8;
-    mField_C += otherStruct->mField_C;
-    mField_10 += otherStruct->mField_10;
-    if (mField_18 < otherStruct->mField_18) {
-        mField_14 = otherStruct->mField_14;
-        mField_18 = otherStruct->mField_18;
-    }
-}
-
-void Struct20_2::reset() {
-    mField_1C = 0;
-    mField_30 = false;
-
-    Struct20::reset();
-}
-
-void Struct20_2::combineMaybe(Struct20Base* other) {
-    Struct20_2* otherStruct = sead::DynamicCast<Struct20_2>(other);
-    if (!otherStruct) {
-        Struct20::combineMaybe(other);
-        return;
-    }
-
-    mField_1C |= otherStruct->mField_1C;
-    Struct20::combineMaybe(other);
-    if (mField_18 == otherStruct->mField_18 && otherStruct->mField_30) {
-        mField_30 = true;
-        mField_20 = otherStruct->mField_20;
-        mField_24 = otherStruct->mField_24;
-        mField_28 = otherStruct->mField_28;
-        mField_2C = otherStruct->mField_2C;
-    }
-}
-
-}  // namespace uking::dmg
diff --git a/src/Game/UI/uiUtils.cpp b/src/Game/UI/uiUtils.cpp
index 3d4e4979..839f3336 100644
--- a/src/Game/UI/uiUtils.cpp
+++ b/src/Game/UI/uiUtils.cpp
@@ -1,6 +1,6 @@
 #include "Game/UI/uiUtils.h"
 #include "Game/AOC/aocHardModeManager.h"
-#include "Game/Actor/Damage/dmgInfoManager.h"
+#include "Game/Actor/Damage/actDamageInfoMgr.h"
 #include "Game/Actor/actPlayerCreateMgr.h"
 #include "Game/Actor/actWeapon.h"
 #include "Game/UI/uiPauseMenuDataMgr.h"
@@ -56,7 +56,7 @@ void getWeaponStats(const PouchItem& item, WeaponStats* stats) {
     } else if (isMasterSwordItem(item)) {
         int power = 0;
         if (item.getValue() > 0) {
-            const bool is_true_form = dmg::DamageInfoMgr::instance()->isTrueFormMasterSword();
+            const bool is_true_form = act::DamageInfoMgr::instance()->isTrueFormMasterSword();
             auto* info_ = ksys::act::InfoData::instance();
             const char* name = item.getName().cstr();
             if (is_true_form) {
@@ -69,7 +69,7 @@ void getWeaponStats(const PouchItem& item, WeaponStats* stats) {
         stats->power = power;
 
     } else if (isOneHitObliteratorActorName(item.getName())) {
-        stats->power = dmg::DamageInfoMgr::instance()->isOneHitObliteratorActive() ? 99999 : 1;
+        stats->power = act::DamageInfoMgr::instance()->isOneHitObliteratorActive() ? 99999 : 1;
     } else {
         stats->power =
             ksys::act::getAttackPower(ksys::act::InfoData::instance(), item.getName().cstr());