Implement some commonly used ActorConstDataAccess functions

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) {