ksys/dmg: Implementing some of DamageManagerBase. Added some temporary classes/variables used by DamageManagerBase.

src/KingSystem/Damage/dmgDamageManagerBase.cpp

@@ -0,0 +1,273 @@
+#include "KingSystem/Damage/dmgDamageManagerBase.h"
+#include "Game/DLC/aoc2.h"
+#include "KingSystem/ActorSystem/actActor.h"
+#include "KingSystem/ActorSystem/actActorConstDataAccess.h"
+#include "KingSystem/ActorSystem/actActorParamMgr.h"
+#include "KingSystem/ActorSystem/actLifeRecoveryInfo.h"
+#include "KingSystem/Resource/GeneralParamList/resGParamListObjectGeneral.h"
+#include "KingSystem/Resource/resResourceGParamList.h"
+
+namespace ksys::dmg {
+
+DamageManagerBase_UnknownBase1::DamageManagerBase_UnknownBase1(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) {}
+
+u32 DamageManagerBase::getDamage() {
+    u32 result;
+    if (canTakeDamage())
+        result = mDamage;
+    else
+        result = 0LL;
+
+    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->mActorParam->mData.mGParamList;
+
+    const 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.
+        onApplyDamage();
+        return false;
+    }
+
+    s32 damage = getDamage();
+    if (damage >= 1) {
+        if (isPlayerClass(mActor)) {
+            if (getAttacker()->hasProc()) {
+                tryBuffDamage(damage);
+            }
+        }
+    }
+
+    tryApplyDamageRecovery(damage);
+
+    // Actually deal damage
+    onApplyDamage();
+    f32 old_life = life;
+    life = std::max(0, life - damage);
+    bool did_damage = old_life != life;
+
+    return did_damage;
+}
+
+void DamageManagerBase::tryBuffDamage(s32& damage) {
+    if (!uking::aoc2::instance()) {
+        return;
+    }
+
+    if (!uking::aoc2::instance()->checkFlag2(uking::aoc2::Flags2::EnableHardMode)) {
+        return;
+    }
+
+    if (!uking::aoc2::instance()->checkFlag1(uking::aoc2::Flags1::ApplyDamageMultiplier)) {
+        return;
+    }
+
+    act::ActorConstDataAccess acc;
+    act::acquireActor(getAttacker(), &acc);
+    if (uking::aoc2::shouldApplyMasterModeDamageMultiplier(acc)) {
+        uking::aoc2::buffDamage(damage);
+    }
+}
+
+void DamageManagerBase::tryApplyDamageRecovery(s32& damage) {
+    if (!uking::aoc2::instance()) {
+        return;
+    }
+
+    if (!uking::aoc2::instance()->checkFlag2(uking::aoc2::Flags2::EnableHardMode)) {
+        return;
+    }
+
+    if (!uking::aoc2::instance()->checkFlag1(uking::aoc2::Flags1::EnableLifeRegen)) {
+        return;
+    }
+
+    if (!mActor->getLifeRecoverInfo()) {
+        return;
+    }
+
+    // Take damage from extra HP1, and modify damage.
+    // Returns true if damage remains? No more regen?
+    act::LifeRecoverInfo* life_recovery_info = mActor->getLifeRecoverInfo();
+    if (life_recovery_info->onApplyDamage(damage)) {
+        // Update flags and counter.
+        life_recovery_info->onApplyDamage_0();
+    }
+}
+
+s32 DamageManagerBase::getNumCallbacks() {
+    // More like number of supported event types, than number of callbacks.
+    // These seem to return a fixed number for each different DamageManager class.
+    return 0;
+}
+
+bool DamageManagerBase::initCallbacks(sead::Heap*) {
+    // Does nothing in the Base class, and doesn't seem like any of the known classes actually
+    // override this yet.
+    return true;
+}
+
+bool DamageManagerBase::allocStruct20(sead::Heap* heap) {
+    mStruct20_a = new (heap) Struct20;
+    if (!mStruct20_a) {
+        return false;
+    }
+
+    mStruct20_b = new (heap) Struct20;
+    return mStruct20_b != nullptr;
+}
+
+void DamageManagerBase::preDelete1() {
+    if (mStruct20_a) {
+        delete mStruct20_a;
+        mStruct20_a = nullptr;
+    }
+    if (mStruct20_b) {
+        delete mStruct20_b;
+        mStruct20_b = nullptr;
+    }
+}
+
+bool DamageManagerBase::canTakeDamage() {
+    u32 damageTypeMaybe = m49(getField50());
+    if (!DamageInfoMgr::instance()) {
+        return false;
+    }
+
+    s32 idx = mDamageReactionTableStuff;
+    if (idx < 0) {
+        return false;
+    }
+
+    if (!DamageInfoMgr::instance()->mDamagesArray.isBufferReady()) {
+        return false;
+    }
+
+    DamageInfoMgr::DamageItem& item = DamageInfoMgr::instance()->mDamagesArray[idx];
+    return item.mCanTakeDamageFromType[damageTypeMaybe] & 0x1;
+}
+
+void DamageManagerBase::handleDamageForPlayer(u32* a2, u32* a3, u32* a4, u32* a5, u32* a6) {
+    Struct20* currentStruct = sead::DynamicCast<Struct20>(mStruct20_b);
+    if (!currentStruct) {
+        return;
+    }
+
+    *a2 = currentStruct->mField_8;
+    *a3 = currentStruct->mField_C;
+    *a5 = currentStruct->mField_14;
+    *a6 = currentStruct->mField_18;
+    *a4 = currentStruct->mField_10;
+}
+
+bool DamageManagerBase::addDamage(s64, s32 damage, s32 df48, s32 minDmg, s32 f50, s32 f54,
+                                  s32 f40) {
+    mDamage += damage;
+    mField_48 += df48;
+    mMinDmg += minDmg;
+
+    if (mField_54 >= f54) {
+        return false;
+    }
+
+    mField_50 = f50;
+    mField_54 = f54;
+    mField_40 = f40;
+
+    return true;
+}
+
+s32 DamageManagerBase::m49(s32 damageTypeMaybe) {
+    if (damageTypeMaybe == 3) {
+        return 2;
+    }
+
+    return 0;
+}
+
+}  // namespace ksys::dmg