Implement some commonly used ActorConstDataAccess functions

src/KingSystem/ActorSystem/CMakeLists.txt

@@ -2,6 +2,7 @@ target_sources(uking PRIVATE
   Profiles/actRopeBase.cpp
   Profiles/actRopeBase.h
 
+  actActor.cpp
   actActor.h
   actActorCaptureMgr.cpp
   actActorCaptureMgr.h

src/KingSystem/ActorSystem/actActor.cpp

@@ -0,0 +1,10 @@
+#include "KingSystem/ActorSystem/actActor.h"
+#include "KingSystem/ActorSystem/actActorParam.h"
+
+namespace ksys::act {
+
+const sead::SafeString& Actor::getProfile() const {
+    return mActorParam->getProfile();
+}
+
+}  // namespace ksys::act

src/KingSystem/ActorSystem/actActor.h

@@ -1,11 +1,17 @@
 #pragma once
 
+#include <math/seadMatrix.h>
+#include <math/seadVector.h>
 #include <prim/seadTypedBitFlag.h>
 #include "KingSystem/ActorSystem/actBaseProc.h"
 #include "KingSystem/Map/mapMubinIter.h"
 
 namespace ksys {
 
+namespace map {
+class Object;
+}  // namespace map
+
 namespace act {
 
 namespace ai {
@@ -23,15 +29,38 @@ public:
         _4 = 4,
     };
 
+    enum class ActorFlag {
+        _18 = 0x18,
+        _25 = 0x25,
+        _2b = 0x2b,
+    };
+
+    enum class DeleteType {
+        _1 = 1,
+        _2 = 2,
+        _3 = 3,
+    };
+
     Actor();  // FIXME
     ~Actor() override;
 
     SEAD_RTTI_OVERRIDE(Actor, BaseProc)
 
+    const sead::SafeString& getProfile() const;
+    const char* getUniqueName() const;
+
     ai::RootAi* getRootAi() const { return mRootAi; }
     const ActorParam* getParam() const { return mActorParam; }
+    map::Object* getMapObject() const { return mMapObject; }
     const map::MubinIter& getMapObjIter() const { return mMapObjIter; }
 
+    bool checkFlag(ActorFlag flag) const;
+    bool deleteEx(DeleteType type, DeleteReason reason, bool* ok = nullptr);
+
+    void setProperties(int x, const sead::Matrix34f& mtx, const sead::Vector3f& vel,
+                       const sead::Vector3f& ang_vel, const sead::Vector3f& scale,
+                       bool is_life_infinite, int i, int life) const;
+
     virtual s32 getMaxLife();
 
     virtual LifeRecoverInfo* getLifeRecoverInfo();
@@ -54,9 +83,11 @@ protected:
     /* 0x578 */ u8 TEMP_0x578[0x648 - 0x578];
     /* 0x648 */ map::MubinIter mMapObjIter;
     /* 0x658 */ u8 TEMP_0x650[0x710 - 0x658];
-    // The name could be incorrect.
+    /* ..... */  // The name could be incorrect.
     /* 0x710 */ sead::TypedBitFlag<StasisFlag> mStasisFlags;
-    /* 0x714 */ u8 TEMP_0x714[0x838 - 0x714];  // FIXME
+    /* 0x714 */ u8 TEMP_0x714[0x7c8 - 0x714];  // FIXME
+    /* 0x7c8 */ map::Object* mMapObject;
+    /* 0x7d0 */ u8 TEMP_0x7d0[0x838 - 0x7d0];
 };
 KSYS_CHECK_SIZE_NX150(Actor, 0x838);
 

src/KingSystem/ActorSystem/actActorConstDataAccess.cpp

@@ -1,6 +1,16 @@
 #include "KingSystem/ActorSystem/actActorConstDataAccess.h"
 #include <prim/seadRuntimeTypeInfo.h>
 #include "KingSystem/ActorSystem/actActor.h"
+#include "KingSystem/ActorSystem/actActorParam.h"
+#include "KingSystem/ActorSystem/actActorUtil.h"
+#include "KingSystem/ActorSystem/actAiRoot.h"
+#include "KingSystem/Map/mapObject.h"
+#include "KingSystem/Resource/GeneralParamList/resGParamListObjectAttack.h"
+#include "KingSystem/Resource/GeneralParamList/resGParamListObjectEnemy.h"
+#include "KingSystem/Resource/GeneralParamList/resGParamListObjectHorseTargetedInfo.h"
+#include "KingSystem/Resource/GeneralParamList/resGParamListObjectLiftable.h"
+#include "KingSystem/Resource/GeneralParamList/resGParamListObjectSystem.h"
+#include "KingSystem/Resource/resResourceGParamList.h"
 
 namespace ksys::act {
 
@@ -10,6 +20,10 @@ static BaseProc* getProcIfActor(BaseProc* proc) {
     return nullptr;
 }
 
+inline Actor* ActorConstDataAccess::getActor() const {
+    return static_cast<Actor*>(getProcIfActor(mProc));
+}
+
 bool ActorConstDataAccess::acquireActor(const ActorLinkConstDataAccess& other) {
     return acquire(getProcIfActor(other.mProc));
 }
@@ -19,11 +33,11 @@ bool ActorConstDataAccess::hasProc(BaseProc* proc) const {
 }
 
 bool ActorConstDataAccess::hasProc(const BaseProcLink& link) const {
-    return link.hasProcById(getProcIfActor(mProc));
+    return link.hasProcById(getActor());
 }
 
 bool ActorConstDataAccess::linkAcquire(BaseProcLink* link) const {
-    auto* proc = getProcIfActor(mProc);
+    auto* proc = getActor();
     if (proc)
         return link->acquire(proc, false);
 
@@ -32,7 +46,7 @@ bool ActorConstDataAccess::linkAcquire(BaseProcLink* link) const {
 }
 
 bool ActorConstDataAccess::linkAcquireImmediately(BaseProcLink* link) const {
-    auto* proc = getProcIfActor(mProc);
+    auto* proc = getActor();
     if (proc)
         return link->acquire(proc, true);
 
@@ -40,6 +54,27 @@ bool ActorConstDataAccess::linkAcquireImmediately(BaseProcLink* link) const {
     return false;
 }
 
+bool ActorConstDataAccess::isPlayerProfile() const {
+    return act::isPlayerProfile(getActor());
+}
+
+bool ActorConstDataAccess::isWeaponProfile() const {
+    return act::isWeaponProfile(getActor());
+}
+
+bool ActorConstDataAccess::isNPCProfile() const {
+    return act::isNPCProfile(getActor());
+}
+
+bool ActorConstDataAccess::isEnemyProfile() const {
+    return act::isEnemyProfile(getActor());
+}
+
+const sead::SafeString& ActorConstDataAccess::getProfile() const {
+    auto* actor = getActor();
+    return actor && actor->getParam() ? actor->getProfile() : sead::SafeString::cEmptyString;
+}
+
 void ActorConstDataAccess::debugLog(s32, const sead::SafeString&) const {
     // Intentionally left empty.
 }
@@ -51,15 +86,57 @@ const sead::SafeString& ActorConstDataAccess::getName() const {
     return proc->getName();
 }
 
+const sead::SafeString& ActorConstDataAccess::getLiftType() const {
+    auto* actor = getActor();
+    if (!actor)
+        return sead::SafeString::cEmptyString;
+    return actor->getParam()->getRes().mGParamList->getLiftable()->mLiftType.ref();
+}
+
+bool ActorConstDataAccess::isDisableFreezeLift() const {
+    auto* actor = getActor();
+    if (!actor)
+        return false;
+    return actor->getParam()->getRes().mGParamList->getLiftable()->mDisableFreezeLift.ref();
+}
+
+bool ActorConstDataAccess::isDisableBurnLift() const {
+    auto* actor = getActor();
+    if (!actor)
+        return false;
+    return actor->getParam()->getRes().mGParamList->getLiftable()->mDisableBurnLift.ref();
+}
+
+bool ActorConstDataAccess::hasTag(const char* tag) const {
+    auto* actor = getActor();
+    if (!actor)
+        return false;
+    return actor->getParam()->getRes().mActorLink->hasTag(tag);
+}
+
+bool ActorConstDataAccess::hasTag(u32 tag) const {
+    auto* actor = getActor();
+    if (!actor)
+        return false;
+    return actor->getParam()->getRes().mActorLink->hasTag(tag);
+}
+
+const char* ActorConstDataAccess::getUniqueName() const {
+    auto* actor = getActor();
+    if (!actor)
+        return nullptr;
+    return actor->getUniqueName();
+}
+
 u32 ActorConstDataAccess::getId() const {
-    auto* proc = getProcIfActor(mProc);
+    auto* proc = getActor();
     if (!proc)
         return 0xffffffff;
     return proc->getId();
 }
 
 bool ActorConstDataAccess::acquireConnectedCalcParent(ActorLinkConstDataAccess* accessor) const {
-    auto* proc = getProcIfActor(mProc);
+    auto* proc = getActor();
     if (!proc)
         return false;
 
@@ -68,7 +145,7 @@ bool ActorConstDataAccess::acquireConnectedCalcParent(ActorLinkConstDataAccess*
 }
 
 bool ActorConstDataAccess::acquireConnectedCalcChild(ActorLinkConstDataAccess* accessor) const {
-    auto* proc = getProcIfActor(mProc);
+    auto* proc = getActor();
     if (!proc)
         return false;
 
@@ -77,10 +154,258 @@ bool ActorConstDataAccess::acquireConnectedCalcChild(ActorLinkConstDataAccess* a
 }
 
 bool ActorConstDataAccess::hasConnectedCalcParent() const {
-    auto* proc = getProcIfActor(mProc);
+    auto* proc = getActor();
     return proc && sead::DynamicCast<Actor>(proc->getConnectedCalcParent()) != nullptr;
 }
 
+bool ActorConstDataAccess::checkFlag2B() const {
+    auto* actor = getActor();
+    if (!actor)
+        return false;
+    return actor->checkFlag(Actor::ActorFlag::_2b);
+}
+
+bool ActorConstDataAccess::deleteLater(BaseProc::DeleteReason reason) const {
+    auto* actor = getActor();
+    if (!actor)
+        return false;
+    return actor->deleteLater(reason);
+}
+
+bool ActorConstDataAccess::deleteEx(BaseProc::DeleteReason reason) const {
+    auto* actor = getActor();
+    if (!actor)
+        return false;
+    return actor->deleteEx(Actor::DeleteType::_1, reason);
+}
+
+bool ActorConstDataAccess::sleep(BaseProc::SleepWakeReason reason) const {
+    auto* actor = getActor();
+    if (!actor)
+        return false;
+    actor->sleep(reason);
+    return true;
+}
+
+bool ActorConstDataAccess::wakeUp(BaseProc::SleepWakeReason reason) const {
+    auto* actor = getActor();
+    if (!actor)
+        return false;
+    actor->wakeUp(reason);
+    return true;
+}
+
+bool ActorConstDataAccess::setProperties(int x, const sead::Matrix34f& mtx,
+                                         const sead::Vector3f& vel, const sead::Vector3f& ang_vel,
+                                         const sead::Vector3f& scale, bool is_life_infinite, int i,
+                                         int life) const {
+    auto* actor = getActor();
+    if (!actor)
+        return false;
+    actor->setProperties(x, mtx, vel, ang_vel, scale, is_life_infinite, i, life);
+    return true;
+}
+
+bool ActorConstDataAccess::setProperties(const sead::Matrix34f& mtx, const sead::Vector3f& vel,
+                                         const sead::Vector3f& ang_vel, const sead::Vector3f& scale,
+                                         bool is_life_infinite, int i, int life) const {
+    return setProperties(0, mtx, vel, ang_vel, scale, is_life_infinite, i, life);
+}
+
+bool ActorConstDataAccess::isStateSleep() const {
+    auto* actor = getActor();
+    return actor && actor->isSleep();
+}
+
+bool ActorConstDataAccess::isStateCalc() const {
+    auto* actor = getActor();
+    return actor && actor->isCalc();
+}
+
+bool ActorConstDataAccess::isDeletedOrDeleting() const {
+    auto* actor = getActor();
+    return actor && actor->isDeletedOrDeleting();
+}
+
+res::GParamList* ActorConstDataAccess::getGParamList() const {
+    auto* actor = getActor();
+    if (!actor)
+        return nullptr;
+    return actor->getParam()->getRes().mGParamList;
+}
+
+res::Shop* ActorConstDataAccess::getShopData() const {
+    auto* actor = getActor();
+    if (!actor)
+        return nullptr;
+    return actor->getParam()->getRes().mShopData;
+}
+
+const sead::SafeString& ActorConstDataAccess::getAttackSpHitActor() const {
+    auto* actor = getActor();
+    if (!actor)
+        return sead::SafeString::cEmptyString;
+    return actor->getParam()->getRes().mGParamList->getAttack()->mSpHitActor.ref();
+}
+
+const sead::SafeString& ActorConstDataAccess::getAttackSpHitTag() const {
+    auto* actor = getActor();
+    if (!actor)
+        return sead::SafeString::cEmptyString;
+    return actor->getParam()->getRes().mGParamList->getAttack()->mSpHitTag.ref();
+}
+
+const sead::SafeString& ActorConstDataAccess::getAttackWeakHitTag() const {
+    auto* actor = getActor();
+    if (!actor)
+        return sead::SafeString::cEmptyString;
+    return actor->getParam()->getRes().mGParamList->getAttack()->mSpWeakHitActor.ref();
+}
+
+f32 ActorConstDataAccess::getAttackSpHitRatio() const {
+    auto* actor = getActor();
+    if (!actor)
+        return 1.0f;
+    return actor->getParam()->getRes().mGParamList->getAttack()->mSpHitRatio.ref();
+}
+
+s32 ActorConstDataAccess::getAttackPower() const {
+    auto* actor = getActor();
+    if (!actor)
+        return 0;
+    return actor->getParam()->getRes().mGParamList->getAttack()->mPower.ref();
+}
+
+map::ObjectLinkData* ActorConstDataAccess::getMapObjectLinkData() const {
+    auto* actor = getActor();
+    if (!actor)
+        return nullptr;
+
+    auto* object = actor->getMapObject();
+    if (!object)
+        return nullptr;
+
+    return object->getLinkData();
+}
+
+map::Object* ActorConstDataAccess::getMapObject() const {
+    auto* actor = getActor();
+    if (!actor)
+        return nullptr;
+    return actor->getMapObject();
+}
+
+s32 ActorConstDataAccess::getEnemyRank() const {
+    auto* actor = getActor();
+    if (!actor)
+        return 0;
+
+    auto* gparam = actor->getParam()->getRes().mGParamList;
+    if (!gparam || !gparam->getEnemy())
+        return 0;
+
+    return gparam->getEnemy()->mRank.ref();
+}
+
+bool ActorConstDataAccess::getSameGroupActorName(sead::SafeString* name) const {
+    auto* actor = getActor();
+    if (!actor) {
+        *name = sead::SafeString::cEmptyString;
+        return false;
+    }
+
+    auto* gparam = actor->getParam()->getRes().mGParamList;
+    if (!gparam || !gparam->getSystem()) {
+        *name = actor->getName();
+        return false;
+    }
+
+    const auto& group_name = gparam->getSystem()->mSameGroupActorName.ref();
+    if (group_name.isEmpty()) {
+        *name = actor->getName();
+        return false;
+    }
+
+    *name = group_name;
+    return true;
+}
+
+bool ActorConstDataAccess::checkFlag18() const {
+    auto* actor = getActor();
+    return actor && actor->checkFlag(Actor::ActorFlag::_18);
+}
+
+bool ActorConstDataAccess::isPlayerTheConnectedParent() const {
+    auto* actor = getActor();
+    if (!actor)
+        return false;
+
+    auto* parent = sead::DynamicCast<Actor>(actor->getConnectedCalcParent());
+    if (!parent)
+        return false;
+
+    return parent->getProfile() == "Player";
+}
+
+void ActorConstDataAccess::setThisActorAsParent(BaseProc* child, bool delete_parent_on_delete) {
+    auto* actor = getActor();
+    if (!actor)
+        return;
+    child->setConnectedCalcParent(actor, delete_parent_on_delete);
+}
+
+void ActorConstDataAccess::setThisActorAsChild(BaseProc* parent, bool delete_child_on_delete) {
+    auto* actor = getActor();
+    if (!actor)
+        return;
+    parent->setConnectedCalcChild(actor, delete_child_on_delete);
+}
+
+bool ActorConstDataAccess::isFlyingBalloon() const {
+    auto* actor = getActor();
+    if (!actor)
+        return false;
+    bool* value;
+    return actor->getRootAi()->getAITreeVariable(&value, "IsFlyingBalloon") && *value;
+}
+
+u32 ActorConstDataAccess::getBalloonHungActorBaseProcID() const {
+    auto* actor = getActor();
+    if (!actor)
+        return -1;
+    int* value;
+    if (!actor->getRootAi()->getAITreeVariable(&value, "BalloonHungActorBaseProcID"))
+        return -1;
+    return *value;
+}
+
+bool ActorConstDataAccess::checkFlag25() const {
+    auto* actor = getActor();
+    return actor && actor->checkFlag(Actor::ActorFlag::_25);
+}
+
+f32 ActorConstDataAccess::getHorseMoveRadius() const {
+    auto* actor = getActor();
+    if (!actor)
+        return -1.0;
+    return actor->getParam()->getRes().mGParamList->getHorseTargetedInfo()->mHorseMoveRadius.ref();
+}
+
+f32 ActorConstDataAccess::getHorseAvoidOffset() const {
+    auto* actor = getActor();
+    if (!actor)
+        return -1.0;
+    return actor->getParam()->getRes().mGParamList->getHorseTargetedInfo()->mHorseAvoidOffset.ref();
+}
+
+bool ActorConstDataAccess::horseTargetedIsCircularMoveAlways() const {
+    auto* actor = getActor();
+    if (!actor)
+        return false;
+    auto* gparam = actor->getParam()->getRes().mGParamList;
+    return gparam->getHorseTargetedInfo()->mIsCircularMoveAlways.ref();
+}
+
 bool acquireActor(BaseProcLink* link, ActorConstDataAccess* accessor) {
     return link->getProcInContext([accessor](BaseProc* proc, bool valid) {
         if (!proc) {

src/KingSystem/ActorSystem/actActorConstDataAccess.h

@@ -1,13 +1,27 @@
 #pragma once
 
+#include <math/seadMatrix.h>
+#include <math/seadVector.h>
 #include <prim/seadRuntimeTypeInfo.h>
 #include "KingSystem/ActorSystem/actActorLinkConstDataAccess.h"
 #include "KingSystem/ActorSystem/actBaseProc.h"
 #include "KingSystem/ActorSystem/actBaseProcLink.h"
 #include "KingSystem/Utils/Types.h"
 
+namespace ksys::map {
+class Object;
+class ObjectLinkData;
+}  // namespace ksys::map
+
+namespace ksys::res {
+class GParamList;
+class Shop;
+}  // namespace ksys::res
+
 namespace ksys::act {
 
+class Actor;
+
 class ActorConstDataAccess : public ActorLinkConstDataAccess {
 public:
     ActorConstDataAccess() = default;
@@ -34,23 +48,77 @@ public:
 
     void debugLog(s32, const sead::SafeString& method_name) const;
 
+    bool isPlayerProfile() const;
+    bool isWeaponProfile() const;
+    bool isNPCProfile() const;
+    bool isEnemyProfile() const;
+
     const sead::SafeString& getProfile() const;
     const sead::SafeString& getName() const;
+
+    const sead::SafeString& getLiftType() const;
+    bool isDisableFreezeLift() const;
+    bool isDisableBurnLift() const;
+
     bool hasTag(const char* tag) const;
     bool hasTag(u32 tag) const;
+    const char* getUniqueName() const;
     u32 getId() const;
     bool acquireConnectedCalcParent(ActorLinkConstDataAccess* accessor) const;
     bool acquireConnectedCalcChild(ActorLinkConstDataAccess* accessor) const;
     bool hasConnectedCalcParent() const;
+    bool checkFlag2B() const;
 
     bool deleteLater(BaseProc::DeleteReason reason) const;
-    bool fadeOutDelete(BaseProc::DeleteReason reason) const;
+    bool deleteEx(BaseProc::DeleteReason reason) const;
     bool sleep(BaseProc::SleepWakeReason reason) const;
     bool wakeUp(BaseProc::SleepWakeReason reason) const;
+    bool setProperties(int x, const sead::Matrix34f& mtx, const sead::Vector3f& vel,
+                       const sead::Vector3f& ang_vel, const sead::Vector3f& scale,
+                       bool is_life_infinite, int i, int life) const;
+    bool setProperties(const sead::Matrix34f& mtx, const sead::Vector3f& vel,
+                       const sead::Vector3f& ang_vel, const sead::Vector3f& scale,
+                       bool is_life_infinite, int i, int life) const;
+    bool isStateSleep() const;
+    bool isStateCalc() const;
+    bool isDeletedOrDeleting() const;
+
+    res::GParamList* getGParamList() const;
+    res::Shop* getShopData() const;
+
+    const sead::SafeString& getAttackSpHitActor() const;
+    const sead::SafeString& getAttackSpHitTag() const;
+    const sead::SafeString& getAttackWeakHitTag() const;
+    f32 getAttackSpHitRatio() const;
+    s32 getAttackPower() const;
+
+    map::ObjectLinkData* getMapObjectLinkData() const;
+    map::Object* getMapObject() const;
+
+    s32 getEnemyRank() const;
+
+    bool getSameGroupActorName(sead::SafeString* name) const;
+
+    bool checkFlag18() const;
+    bool isPlayerTheConnectedParent() const;
+
+    void setThisActorAsParent(BaseProc* child, bool delete_parent_on_delete);
+    void setThisActorAsChild(BaseProc* parent, bool delete_child_on_delete);
 
     bool isAttClientEnabled(const sead::SafeString& client) const;
 
+    bool isFlyingBalloon() const;
+    u32 getBalloonHungActorBaseProcID() const;
+
+    bool checkFlag25() const;
+
+    f32 getHorseMoveRadius() const;
+    f32 getHorseAvoidOffset() const;
+    bool horseTargetedIsCircularMoveAlways() const;
+
 private:
+    Actor* getActor() const;
+
     u8 _10 = 0;
 };
 KSYS_CHECK_SIZE_NX150(ActorConstDataAccess, 0x18);

src/KingSystem/ActorSystem/actActorLimiter.cpp

@@ -46,7 +46,7 @@ bool ActorLimiter::List::addActor(BaseProc* proc, bool allow_evicting_old_actors
                     acquireActor(&target_node->proc_link, &acc);
             }
 
-            acc.fadeOutDelete(BaseProc::DeleteReason::_15);
+            acc.deleteEx(BaseProc::DeleteReason::_15);
         }
 
         if (target_node == nullptr)

src/KingSystem/ActorSystem/actBaseProc.h

@@ -90,6 +90,7 @@ public:
     State getState() const { return mState; }
     bool isInit() const { return mState == State::Init; }
     bool isCalc() const { return mState == State::Calc; }
+    bool isSleep() const { return mState == State::Sleep; }
     bool isDeletedOrDeleting() const {
         return mState == State::Delete || mStateFlags.isOn(StateFlags::RequestDelete);
     }