Move Damage to Game/ and add more DamageInfoMgr members

Damage stuff seems to be considered game code rather than KingSystem
code based on the function order in the executable and on the fact
that the Damage code uses other components that are known to be
in Game/U-King rather than in KingSystem.

src/Game/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_subdirectory(Actor)
 add_subdirectory(AI)
+add_subdirectory(Damage)
 add_subdirectory(DLC)
 add_subdirectory(UI)
 

src/Game/Damage/CMakeLists.txt

@@ -1,8 +1,9 @@
 target_sources(uking PRIVATE
     dmgDamageCallback.h
-    dmgDamageInfoManager.h
     dmgDamageManagerBase.h
     dmgDamageManagerBase.cpp
+    dmgInfoManager.cpp
+    dmgInfoManager.h
     dmgStruct20.h
     dmgStruct20.cpp
 )

src/Game/Damage/dmgDamageCallback.h

@@ -2,9 +2,9 @@
 
 #include <basis/seadTypes.h>
 
-#include "KingSystem/Damage/dmgDamageManagerBase.h"
+#include "Game/Damage/dmgDamageManagerBase.h"
 
-namespace ksys::dmg {
+namespace uking::dmg {
 
 class DamageManagerBase;
 
@@ -20,4 +20,4 @@ public:
     u32 mEventId;
 };
 
-}  // namespace ksys::dmg
+}  // namespace uking::dmg

src/Game/Damage/dmgDamageManagerBase.cpp

@@ -1,22 +1,25 @@
-#include "KingSystem/Damage/dmgDamageManagerBase.h"
+#include "Game/Damage/dmgDamageManagerBase.h"
 #include "Game/DLC/aoc2.h"
 #include "KingSystem/ActorSystem/actActor.h"
 #include "KingSystem/ActorSystem/actActorConstDataAccess.h"
 #include "KingSystem/ActorSystem/actActorParam.h"
+#include "KingSystem/ActorSystem/actActorUtil.h"
 #include "KingSystem/ActorSystem/actLifeRecoveryInfo.h"
 #include "KingSystem/Resource/GeneralParamList/resGParamListObjectGeneral.h"
 #include "KingSystem/Resource/resResourceGParamList.h"
 
-namespace ksys::dmg {
+namespace uking::dmg {
 
-DamageManagerBase_UnknownBase1::DamageManagerBase_UnknownBase1(act::Actor* actor) : mActor(actor) {}
+DamageManagerBase_UnknownBase1::DamageManagerBase_UnknownBase1(ksys::act::Actor* actor)
+    : mActor(actor) {}
 
 // 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(act::Actor* actor) : DamageManagerBase_UnknownBase1(actor) {}
+DamageManagerBase::DamageManagerBase(ksys::act::Actor* actor)
+    : DamageManagerBase_UnknownBase1(actor) {}
 
 u32 DamageManagerBase::getDamage() {
     u32 result;
@@ -106,7 +109,7 @@ void DamageManagerBase::removeDamageCallback(DamageCallback* callback) {
 bool DamageManagerBase::applyDamage(s32& life) {
     auto* param_list = mActor->getParam()->getRes().mGParamList;
 
-    const res::GParamListObjectGeneral& params = *param_list->getGeneral();
+    const ksys::res::GParamListObjectGeneral& params = *param_list->getGeneral();
     if (params.mIsLifeInfinite.ref()) {
         // Since life is infinite, we don't need to modify the damage or life.
         // But we still call the "callback" as if damage was done.
@@ -116,7 +119,7 @@ bool DamageManagerBase::applyDamage(s32& life) {
 
     s32 damage = getDamage();
     if (damage >= 1) {
-        if (isPlayerClass(mActor)) {
+        if (ksys::act::isPlayerProfile(mActor)) {
             if (getAttacker()->hasProc()) {
                 tryBuffDamage(damage);
             }
@@ -148,8 +151,8 @@ void DamageManagerBase::tryBuffDamage(s32& damage) {
         return;
     }
 
-    act::ActorConstDataAccess acc;
-    act::acquireActor(getAttacker(), &acc);
+    ksys::act::ActorConstDataAccess acc;
+    ksys::act::acquireActor(getAttacker(), &acc);
     if (uking::aoc2::shouldApplyMasterModeDamageMultiplier(acc)) {
         uking::aoc2::buffDamage(damage);
     }
@@ -175,7 +178,7 @@ void DamageManagerBase::tryApplyDamageRecovery(s32& damage) {
 
     // Take damage from extra HP1, and modify damage.
     // Returns true if damage remains? No more regen?
-    act::LifeRecoverInfo* life_recovery_info = mActor->getLifeRecoverInfo();
+    ksys::act::LifeRecoverInfo* life_recovery_info = mActor->getLifeRecoverInfo();
     if (life_recovery_info->onApplyDamage(damage)) {
         // Update flags and counter.
         life_recovery_info->onApplyDamage_0();
@@ -272,4 +275,4 @@ s32 DamageManagerBase::m49(s32 damageTypeMaybe) {
     return 0;
 }
 
-}  // namespace ksys::dmg
+}  // namespace uking::dmg

src/Game/Damage/dmgDamageManagerBase.h

@@ -5,23 +5,23 @@
 #include <heap/seadExpHeap.h>
 #include <prim/seadRuntimeTypeInfo.h>
 
+#include "Game/Damage/dmgDamageCallback.h"
+#include "Game/Damage/dmgInfoManager.h"
+#include "Game/Damage/dmgStruct20.h"
 #include "KingSystem/ActorSystem/actBaseProcLink.h"
-#include "KingSystem/Damage/dmgDamageCallback.h"
-#include "KingSystem/Damage/dmgDamageInfoManager.h"
-#include "KingSystem/Damage/dmgStruct20.h"
 
 namespace ksys::act {
 class Actor;
 class ActorParam;
 }  // namespace ksys::act
 
-namespace ksys::dmg {
+namespace uking::dmg {
 
 // FIXME: Unknown base. This base seems to handle callbacks and messaging, so maybe a shared base?
 class DamageManagerBase_UnknownBase1 {
 public:
-    DamageManagerBase_UnknownBase1(act::Actor* WeaponActor);
-    virtual ~DamageManagerBase_UnknownBase1() {}
+    explicit DamageManagerBase_UnknownBase1(ksys::act::Actor* WeaponActor);
+    virtual ~DamageManagerBase_UnknownBase1() = default;
 
     // Sturct20 for Damage receive/send?
     Struct20Base* mStruct20_a = nullptr;
@@ -46,8 +46,8 @@ public:
 class DamageManagerBase : public DamageManagerBase_UnknownBase1,
                           public DamageManagerBase_UnknownBase2 {
 public:
-    DamageManagerBase(act::Actor* actor);
-    virtual ~DamageManagerBase() = default;
+    explicit DamageManagerBase(ksys::act::Actor* actor);
+    ~DamageManagerBase() override = default;
 
     SEAD_RTTI_BASE(DamageManagerBase)
 
@@ -139,7 +139,4 @@ private:
 };
 KSYS_CHECK_SIZE_NX150(DamageManagerBase, 0x68);
 
-// FIXME: Move into static helper class?
-bool isPlayerClass(ksys::act::Actor* Actor);
-
-}  // namespace ksys::dmg
+}  // namespace uking::dmg

src/Game/Damage/dmgInfoManager.cpp

@@ -0,0 +1,7 @@
+#include "Game/Damage/dmgInfoManager.h"
+
+namespace uking::dmg {
+
+SEAD_SINGLETON_DISPOSER_IMPL(DamageInfoMgr)
+
+}  // namespace uking::dmg

src/Game/Damage/dmgInfoManager.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+#include <container/seadBuffer.h>
+#include <container/seadSafeArray.h>
+#include <heap/seadDisposer.h>
+#include <thread/seadReadWriteLock.h>
+#include "KingSystem/ActorSystem/actBaseProcLink.h"
+#include "KingSystem/Resource/resHandle.h"
+
+namespace uking::dmg {
+
+// FIXME: incomplete
+class DamageInfoMgr {
+    SEAD_SINGLETON_DISPOSER(DamageInfoMgr);
+    DamageInfoMgr();
+    virtual ~DamageInfoMgr();
+
+public:
+    // FIXME: incomplete
+    class DamageItem {
+    public:
+        s32 mField_0;  // unknown
+        sead::SafeArray<u8, 3> mCanTakeDamageFromType;
+    };
+
+    bool isTrueFormMasterSword() const;
+
+    /* 0x0028 */ u8 TEMP_8[0x5d0 - 0x28];
+    /* 0x05d0 */ ksys::res::Handle mReactionTable;
+    /* 0x0620 */ sead::Buffer<DamageItem> mDamagesArray;
+    /* 0x0630 */ u8 TEMP_630[0xd00 - 0x630];
+    /* 0x0d00 */ sead::ReadWriteLock mLock;
+    /* 0x0db8 */ u8 TEMP_db8[0x11e4 - 0xdb8];
+    /* 0x11e4 */ f32 mMasterSwordSearchEvilDist;
+    /* 0x11e8 */ bool mMasterSwordDetectedEvil;
+    /* 0x11e9 */ bool mMasterSwordDisableTrueForm;
+    /* 0x11ea */ bool mOneHitObliteratorActive;
+    /* 0x11f0 */ ksys::act::BaseProcLink _11f0;
+    /* 0x1200 */ ksys::act::BaseProcLink _1200;
+    /* 0x1210 */ ksys::act::BaseProcLink _1210;
+    /* 0x1220 */ ksys::act::BaseProcLink _1230;
+    /* 0x1230 */ sead::ReadWriteLock mProcLinkLock;
+    /* 0x12e8 */ void* _12e8;
+};
+KSYS_CHECK_SIZE_NX150(DamageInfoMgr, 0x12F0);
+
+}  // namespace uking::dmg

src/Game/Damage/dmgStruct20.cpp

@@ -1,6 +1,6 @@
-#include "KingSystem/Damage/dmgStruct20.h"
+#include "Game/Damage/dmgStruct20.h"
 
-namespace ksys::dmg {
+namespace uking::dmg {
 
 void Struct20::reset() {
     mField_8 = 0;
@@ -50,4 +50,4 @@ void Struct20_2::combineMaybe(Struct20Base* other) {
     }
 }
 
-}  // namespace ksys::dmg
+}  // namespace uking::dmg

src/Game/Damage/dmgStruct20.h

@@ -5,7 +5,7 @@
 
 #include "KingSystem/Utils/Types.h"
 
-namespace ksys::dmg {
+namespace uking::dmg {
 
 // What exactly Struct20 is, isn't known yet.
 // It is used by the Damage Managers, especially DamageManager and up, not so much in
@@ -61,4 +61,4 @@ public:
 };
 KSYS_CHECK_SIZE_NX150(Struct20_2, 0x38);
 
-}  // namespace ksys::dmg
+}  // namespace uking::dmg

src/KingSystem/CMakeLists.txt

@@ -6,7 +6,6 @@ add_subdirectory(ActorSystem)
 add_subdirectory(Cooking)
 add_subdirectory(Ecosystem)
 add_subdirectory(Event)
-add_subdirectory(Damage)
 add_subdirectory(Framework)
 add_subdirectory(Map)
 add_subdirectory(MessageSystem)

src/KingSystem/Damage/dmgDamageInfoManager.h

@@ -1,33 +0,0 @@
-#pragma once
-
-#include <basis/seadTypes.h>
-#include <container/seadBuffer.h>
-#include <container/seadSafeArray.h>
-#include <heap/seadDisposer.h>
-
-#include "KingSystem/Resource/resHandle.h"
-
-namespace ksys::dmg {
-
-// FIXME: incomplete
-class DamageInfoMgr {
-public:
-    SEAD_SINGLETON_DISPOSER(DamageInfoMgr);
-    DamageInfoMgr();
-    virtual ~DamageInfoMgr();
-
-public:
-    // FIXME: incomplete
-    class DamageItem {
-    public:
-        s32 mField_0;  // unknown
-        sead::SafeArray<u8, 3> mCanTakeDamageFromType;
-    };
-
-    u8 TEMP1[0x5F0];                         // Fields
-    res::Handle* mReactionTable;             // 0x5D0
-    sead::Buffer<DamageItem> mDamagesArray;  // 0x620
-};
-// KSYS_CHECK_SIZE_NX150(DamageInfoMgr, 0x12F0);
-
-}  // namespace ksys::dmg