Add FireDrum2D actor

.gitignore

@@ -44,3 +44,4 @@ perf.data.old
 # Tooling
 /toolchain/clang-*
 tools/check
+/cmake-build-debug

data/odyssey_functions.csv

@@ -15656,15 +15656,15 @@ Address,Quality,Size,Name
 0x000000710027f4b4,U,000028,_ZNK2al10FunctorV0MIP18FastenerRailKeeperMS1_FvvEEclEv
 0x000000710027f4d0,U,000076,_ZNK2al10FunctorV0MIP18FastenerRailKeeperMS1_FvvEE5cloneEv
 0x000000710027f51c,U,000004,_ZN2al10FunctorV0MIP18FastenerRailKeeperMS1_FvvEED0Ev
-0x000000710027f520,U,000144,_ZN10FireDrum2DC2EPKc
-0x000000710027f5b0,U,000140,_ZN10FireDrum2DC1EPKc
-0x000000710027f63c,U,000128,_ZN10FireDrum2D4initERKN2al13ActorInitInfoE
-0x000000710027f6bc,U,000100,_ZN10FireDrum2D12attackSensorEPN2al9HitSensorES2_
-0x000000710027f720,U,000008,_ZN10FireDrum2D10receiveMsgEPKN2al9SensorMsgEPNS0_9HitSensorES5_
-0x000000710027f728,U,000060,_ZN10FireDrum2D7exeWaitEv
-0x000000710027f764,U,000088,_ZN10FireDrum2D7exeBurnEv
-0x000000710027f7bc,U,000008,_ZNK10FireDrum2D23getActorDimensionKeeperEv
-0x000000710027f7c4,U,000008,_ZThn264_NK10FireDrum2D23getActorDimensionKeeperEv
+0x000000710027f520,O,000144,_ZN10FireDrum2DC2EPKc
+0x000000710027f5b0,O,000140,_ZN10FireDrum2DC1EPKc
+0x000000710027f63c,O,000128,_ZN10FireDrum2D4initERKN2al13ActorInitInfoE
+0x000000710027f6bc,O,000100,_ZN10FireDrum2D12attackSensorEPN2al9HitSensorES2_
+0x000000710027f720,O,000008,_ZN10FireDrum2D10receiveMsgEPKN2al9SensorMsgEPNS0_9HitSensorES5_
+0x000000710027f728,O,000060,_ZN10FireDrum2D7exeWaitEv
+0x000000710027f764,O,000088,_ZN10FireDrum2D7exeBurnEv
+0x000000710027f7bc,O,000008,_ZNK10FireDrum2D23getActorDimensionKeeperEv
+0x000000710027f7c4,O,000008,_ZThn264_NK10FireDrum2D23getActorDimensionKeeperEv
 0x000000710027f7cc,U,000064,
 0x000000710027f80c,U,000092,
 0x000000710027f868,U,000152,_ZN11FireHydrantC2EPKc
@@ -34195,22 +34195,22 @@ Address,Quality,Size,Name
 0x0000007100541620,U,000016,_ZN2rs28calcAllShineNumCollectBgmNpcEPK14GameDataHolder
 0x0000007100541630,U,000020,_ZN2rs24calcGetShineNumHintPhotoEPK14GameDataHolder
 0x0000007100541644,U,000072,_ZN20ActorDimensionKeeperC1EPKN2al9LiveActorE
-0x000000710054168c,U,000012,_ZN20ActorDimensionKeeper8validateEv
-0x0000007100541698,U,000032,_ZN20ActorDimensionKeeper10invalidateEv
+0x000000710054168c,O,000012,_ZN20ActorDimensionKeeper8validateEv
+0x0000007100541698,O,000032,_ZN20ActorDimensionKeeper10invalidateEv
 0x00000071005416b8,U,000012,_ZN20ActorDimensionKeeper17forceChange2DKeepEv
 0x00000071005416c4,U,000008,_ZN20ActorDimensionKeeper20forceEndChange2DKeepEv
 0x00000071005416cc,U,000340,_ZN20ActorDimensionKeeper6updateEv
 0x0000007100541820,U,000284,
-0x000000710054193c,U,000052,_ZN2rs21createDimensionKeeperEPKN2al9LiveActorE
+0x000000710054193c,O,000052,_ZN2rs21createDimensionKeeperEPKN2al9LiveActorE
 0x0000007100541970,U,000004,_ZN2rs21updateDimensionKeeperEP20ActorDimensionKeeper
 0x0000007100541974,U,000012,_ZN2rs27getSpecialPurposeName2DOnlyEv
 0x0000007100541980,U,000072,_ZN2rs24createAndSetFilter2DOnlyEPN2al9LiveActorE
 0x00000071005419c8,U,000048,_ZN2rs32createCollisionPartsFilter2DOnlyEv
-0x00000071005419f8,U,000032,_ZN2rs4is2DEPK13IUseDimension
-0x0000007100541a18,U,000032,_ZN2rs10isIn2DAreaEPK13IUseDimension
-0x0000007100541a38,U,000060,_ZN2rs4is3DEPK13IUseDimension
-0x0000007100541a74,U,000032,_ZN2rs10isChange2DEPK13IUseDimension
-0x0000007100541a94,U,000032,_ZN2rs10isChange3DEPK13IUseDimension
+0x00000071005419f8,O,000032,_ZN2rs4is2DEPK13IUseDimension
+0x0000007100541a18,O,000032,_ZN2rs10isIn2DAreaEPK13IUseDimension
+0x0000007100541a38,O,000060,_ZN2rs4is3DEPK13IUseDimension
+0x0000007100541a74,O,000032,_ZN2rs10isChange2DEPK13IUseDimension
+0x0000007100541a94,O,000032,_ZN2rs10isChange3DEPK13IUseDimension
 0x0000007100541ab4,U,000092,_ZN2rs17isNearSnapSurfaceEPK13IUseDimensionf
 0x0000007100541b10,U,000108,_ZN2rs17calcLockDirectionEPN4sead7Vector3IfEEPK13IUseDimension
 0x0000007100541b7c,U,000104,_ZN2rs20calcDimensionGravityEPN4sead7Vector3IfEEPK13IUseDimensionRKS2_

lib/al/LiveActor/LiveActor.h

@@ -70,10 +70,10 @@ class LiveActor : public al::IUseNerve,
                   public al::IUseRail,
                   public al::IUseHioNode {
 public:
-    LiveActor(const char*);  // TODO requires implementation
+    LiveActor(const char* name);  // TODO requires implementation
 
     virtual NerveKeeper* getNerveKeeper() const override;
-    virtual void init(const ActorInitInfo&);
+    virtual void init(const ActorInitInfo& info);
     virtual void initAfterPlacement();
     virtual void appear();
     virtual void makeActorAlive();
@@ -84,8 +84,9 @@ public:
     virtual void draw() const;
     virtual void startClipped();
     virtual void endClipped();
-    virtual void attackSensor(HitSensor*, HitSensor*);
-    virtual bool receiveMsg(const SensorMsg*, HitSensor*, HitSensor*);  // NOTE: return type unknown
+    virtual void attackSensor(HitSensor* target, HitSensor* source);
+    virtual bool receiveMsg(const SensorMsg* message, HitSensor* source,
+                            HitSensor* target);  // NOTE: return type unknown
     virtual bool receiveMsgScreenPoint(const SensorMsg*, ScreenPointer*,
                                        ScreenPointTarget*);  // NOTE: return type unknown
     virtual const char* getName() const override;

lib/al/actor/ActorInitInfo.h

@@ -55,7 +55,7 @@ public:
     void initViewIdHostActor(const ActorInitInfo&, const LiveActor*);
     void initNoViewId(const PlacementInfo*, const ActorInitInfo&);
 
-    const al::PlacementInfo& getPlacementInfo() const {return *mPlacementInfo;}
+    const al::PlacementInfo& getPlacementInfo() const { return *mPlacementInfo; }
 
 private:
     al::LiveActorGroup* mLiveActorGroup1;

lib/al/async/FunctorV0M.h

@@ -15,7 +15,7 @@ class FunctorV0M : public FunctorBase {
 public:
     inline FunctorV0M() {}
     inline FunctorV0M(T objPointer, F functPointer)
-        : mObjPointer(objPointer), mFunctor(functPointer) {};
+        : mObjPointer(objPointer), mFunctor(functPointer){};
     inline FunctorV0M(const FunctorV0M<T, F>& copy) = default;
 
     void operator()() const override;

lib/al/byaml/ByamlHeader.h

@@ -13,7 +13,7 @@ public:
 private:
     union {
         int _0;
-        unsigned short mTag, mVersion; // unusable due to different loading mechanisms
+        unsigned short mTag, mVersion;  // unusable due to different loading mechanisms
     };
 
     int mHashKeyOffset;

lib/al/camera/CameraDirector.h

@@ -22,7 +22,6 @@ class CameraResourceHolder;
 class CameraFlagCtrl;
 class CameraInSwitchOnAreaDirector;
 
-
 class CameraDirector : public HioNode, IUseExecutor {
 public:
     virtual ~CameraDirector();

lib/al/layout/StageSceneLayout.h

@@ -19,7 +19,8 @@ class MapMini;
 
 class StageSceneLayout : al::NerveStateBase {
 public:
-    StageSceneLayout(const char*, const al::LayoutInitInfo&, const al::PlayerHolder*, const al::SubCameraRenderer*);
+    StageSceneLayout(const char*, const al::LayoutInitInfo&, const al::PlayerHolder*,
+                     const al::SubCameraRenderer*);
     ~StageSceneLayout();
 
     void startActionAll(const char*);

lib/al/player/PlayerAnimator.h

@@ -1,7 +1,7 @@
 #pragma once
 
+#include <prim/seadSafeString.h>
 #include "PlayerAnimFrameCtrl.h"
-#include "sead/prim/seadSafeString.h"
 
 class PlayerAnimator {
 public:

lib/al/sensor/HitSensor.h

@@ -42,4 +42,4 @@ public:
     const sead::Vector3<float>* mFollowPos;   // _48
     const sead::Matrix34<float>* mFollowMtx;  // _50
 };
-};  // namespace al
+};  // namespace al

lib/al/sensor/SensorMsg.h

@@ -0,0 +1,9 @@
+#pragma once
+
+namespace al {
+
+class SensorMsg;
+
+bool isMsgPlayerDisregard(al::SensorMsg const* message);
+
+}  // namespace al

lib/al/util/InputUtil.h

@@ -7,9 +7,8 @@
 namespace al {
 class IUseCamera;
 
-
 bool isValidReplayController(u32);
-sead::ControllerBase* getReplayController(u32); //return type might be wrong
+sead::ControllerBase* getReplayController(u32);  // return type might be wrong
 
 bool isPadTypeJoySingle(int);
 
@@ -52,7 +51,7 @@ bool isPadTriggerLeftStick(int);
 bool isPadTriggerRightStick(int);
 bool isPadTriggerPressLeftStick(int);
 bool isPadTriggerPressRightStick(int);
-bool isPadTriggerUiCursorUp(int); //TODO implement below
+bool isPadTriggerUiCursorUp(int);  // TODO implement below
 bool isPadTriggerUiCursorDown(int);
 bool isPadTriggerUiCursorLeft(int);
 bool isPadTriggerUiCursorRight(int);
@@ -85,14 +84,14 @@ bool isPadRepeatUpRightStick(int);
 bool isPadRepeatDownRightStick(int);
 bool isPadRepeatLeftRightStick(int);
 bool isPadRepeatRightRightStick(int);
-bool isPadRepeatUiCursorUp(int); //TODO implement below
+bool isPadRepeatUiCursorUp(int);  // TODO implement below
 bool isPadRepeatUiCursorDown(int);
 bool isPadRepeatUiCursorLeft(int);
 bool isPadRepeatUiCursorRight(int);
 
 bool isPadHoldPressLeftStick(int);
 bool isPadHoldPressRightStick(int);
-bool isPadHold(int,int);
+bool isPadHold(int, int);
 bool isPadHoldA(int);
 bool isPadHoldB(int);
 bool isPadHoldX(int);
@@ -163,7 +162,7 @@ bool isPadReleaseUpRightStick(int);
 bool isPadReleaseDownRightStick(int);
 bool isPadReleaseLeftRightStick(int);
 bool isPadReleaseRightRightStick(int);
-bool isPadReleaseUiCursorUp(int); //TODO implement below
+bool isPadReleaseUiCursorUp(int);  // TODO implement below
 bool isPadReleaseUiCursorDown(int);
 bool isPadReleaseUiCursorLeft(int);
 bool isPadReleaseUiCursorRight(int);
@@ -191,6 +190,6 @@ int getMainJoyPadDoublePort();
 int getMainJoyPadSingleRightPort();
 int getMainJoyPadSingleLeftPort();
 
-bool isSameNpadId(u32, int); //TODO implement
+bool isSameNpadId(u32, int);  // TODO implement
 
 }  // namespace al

lib/game/Player.h

@@ -8,9 +8,6 @@ class LiveActor;
 
 namespace rs {
 
-bool is2D(const IUseDimension*);
-bool isIn2DArea(const IUseDimension*);
-
 bool isGuardNosePainCap(const al::LiveActor*);
 
 }  // namespace rs

lib/game/actor/ActorDimensionKeeper.h

@@ -0,0 +1,33 @@
+#pragma once
+
+namespace al {
+class LiveActor;
+}
+class In2DAreaMoveControl;
+
+class ActorDimensionKeeper {
+public:
+    ActorDimensionKeeper(const al::LiveActor* actor);
+    void validate();
+    void invalidate();
+    void forceChange2DKeep();
+    void forceEndChange2DKeep();
+    bool update();
+
+    bool getIs2D() const { return is2D; }
+    bool getIsIn2DArea() const { return isIn2DArea; }
+    bool getIsCurrently2D() const { return isCurrently2D; }
+    bool getIsCanChange2D() const { return isCanChange2D; }
+    bool getIsCanChange3D() const { return isCanChange3D; }
+
+private:
+    const al::LiveActor* mLiveActor;
+    bool isValid = true;
+    bool is2D = false;
+    bool isIn2DArea = false;
+    bool isCurrently2D = false;
+    bool isCanChange2D = false;
+    bool isCanChange3D = false;
+    In2DAreaMoveControl* mIn2DAreaMoveControl = nullptr;
+};
+static_assert(sizeof(ActorDimensionKeeper) == 0x18);

lib/game/objects/FireDrum2D/FireDrum2D.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "al/LiveActor/LiveActor.h"
+#include "al/util/NerveUtil.h"
+#include "game/iuse/IUseDimension.h"
+
+namespace al {
+class ActorInitInfo;
+}
+class ActorDimensionKeeper;
+
+class FireDrum2D : public al::LiveActor, public IUseDimension {
+public:
+    FireDrum2D(const char* name);
+    void init(const al::ActorInitInfo& info) override;
+    void attackSensor(al::HitSensor* target, al::HitSensor* source) override;
+    bool receiveMsg(const al::SensorMsg* message, al::HitSensor* source,
+                    al::HitSensor* target) override;
+
+    void exeWait();
+    void exeBurn();
+
+    ActorDimensionKeeper* getActorDimensionKeeper() const override;
+
+private:
+    ActorDimensionKeeper* mActorDimensionKeeper = nullptr;
+};
+
+namespace {
+NERVE_HEADER(FireDrum2D, Wait)
+NERVE_HEADER(FireDrum2D, Burn)
+}  // namespace

lib/game/objects/Mofumofu/MofumofuWarpHole.h

@@ -7,8 +7,8 @@
 
 class MofumofuWarpHole : public al::LiveActor {
 public:
-    MofumofuWarpHole(const char*);
-    void init(const al::ActorInitInfo&) override;
+    MofumofuWarpHole(const char* name);
+    void init(const al::ActorInitInfo& info) override;
     void appear() override;
     void disappear();
     void close();

lib/rs/Dimension.h

@@ -0,0 +1,21 @@
+#pragma once
+
+namespace al {
+class LiveActor;
+}
+class IUseDimension;
+class ActorDimensionKeeper;
+
+namespace rs {
+
+ActorDimensionKeeper* createDimensionKeeper(const al::LiveActor* actor);
+void updateDimensionKeeper(ActorDimensionKeeper* keeper);
+
+bool is2D(const IUseDimension* dimension);
+bool isIn2DArea(const IUseDimension* dimension);
+bool isChange2D(const IUseDimension* dimension);
+bool isChange3D(const IUseDimension* dimension);
+bool is3D(const IUseDimension* dimension);
+void snap2D(const al::LiveActor* actor, const IUseDimension* dimension, float unk_distance);
+
+}  // namespace rs

lib/rs/Player.h

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace al {
+class LiveActor;
+}
+
+namespace rs {
+
+bool isGuardNosePainCap(const al::LiveActor* actor);
+
+}  // namespace rs

lib/rs/Sensor.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace al {
+class HitSensor;
+}
+
+namespace rs {
+
+bool sendMsgEnemyAttack2D(al::HitSensor* source, al::HitSensor* target);
+bool sendMsgTouchFireDrum2D(al::HitSensor* source, al::HitSensor* target);
+
+}  // namespace rs

src/CMakeLists.txt

@@ -1 +1,3 @@
 add_subdirectory(al)
+add_subdirectory(rs)
+add_subdirectory(game)

src/al/CMakeLists.txt

@@ -7,7 +7,6 @@ add_subdirectory(input)
 add_subdirectory(iuse)
 add_subdirectory(LiveActor)
 add_subdirectory(nerve)
-add_subdirectory(objects)
 add_subdirectory(player)
 add_subdirectory(pose)
 add_subdirectory(resource)

src/al/actor/Placement.cpp

@@ -8,7 +8,8 @@ void PlacementInfo::set(const al::ByamlIter& r_0, const al::ByamlIter& rZoneIter
     mZoneIter = rZoneIter;
 }
 
-PlacementId::PlacementId() : mId(nullptr), mUnitConfigName(nullptr), mZoneId(nullptr), mCommonID(nullptr) {}
+PlacementId::PlacementId()
+    : mId(nullptr), mUnitConfigName(nullptr), mZoneId(nullptr), mCommonID(nullptr) {}
 
 PlacementId::PlacementId(const char* p_0, const char* pUnitConfig, const char* pID)
     : mId(p_0), mUnitConfigName(pUnitConfig), mZoneId(pID), mCommonID(nullptr) {}

src/al/async/FunctorV0M.cpp

@@ -14,8 +14,7 @@ FunctorV0M<T, F>* FunctorV0M<T, F>::clone() const {
     return new FunctorV0M<T, F>(*this);
 }
 
-template<class T, class F>
+template <class T, class F>
 FunctorV0M<T, F>::~FunctorV0M<T, F>() = default;
 
-
 }  // namespace al

src/al/byaml/ByamlData.cpp

@@ -22,8 +22,6 @@ unsigned int ByamlData::getValue() const {
     return mValue;
 }
 
-
-
 int ByamlHashPair::getKey(bool isRev) const {
     return isRev ? bswap_24(mData) : mData & 0xFFFFFF;
 }

src/al/input/PlayerInput.cpp

@@ -1,487 +1,487 @@
-#include "al/input/PlayerInput.h"
-
-#include "al/LiveActor/LiveActor.h"
-#include "al/input/JoyPadAccelPoseAnalyzer.h"
-#include "al/input/PlayerInputFunction.h"
-#include "al/input/rsSeparatePlay.h"
-#include "al/player/PlayerFunction.h"
-#include "al/player/rsPlayerState.h"
-#include "al/util/InputUtil.h"
-#include "al/util/MathUtil.h"
-#include "al/util/VectorUtil.h"
-
-PlayerInput::PlayerInput(const al::LiveActor*, const IUsePlayerCollision*, const IUseDimension*) {
-}  // FIXME remove this
-
-bool PlayerInput::isEnableCarry() const {
-    if (mDisableInput)
-        return false;
-
-    return PlayerInputFunction::isHoldAction(mLiveActor,
-                                             PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isTriggerCarryStart() const {
-    if (mDisableInput)
-        return false;
-
-    return PlayerInputFunction::isTriggerAction(mLiveActor,
-                                                PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isTriggerCarryRelease() const {
-    if (mDisableInput)
-        return false;
-
-    if (PlayerInputFunction::isTriggerAction(mLiveActor,
-                                             PlayerFunction::getPlayerInputPort(mLiveActor)))
-        return true;
-
-    if (mDisableInput)
-        return false;
-
-    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
-}
-
-bool PlayerInput::isTriggerSwingActionMario() const {
-    if (mDisableInput)
-        return false;
-
-    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
-}
-
-bool PlayerInput::isTriggerCarryReleaseBySwing() const {
-    if (mDisableInput)
-        return false;
-    if (!PlayerInputFunction::isTriggerAction(mLiveActor,
-                                              PlayerFunction::getPlayerInputPort(mLiveActor))) {
-        if (mDisableInput)
-            return false;
-        if (!mJoyPadAccelPoseAnalyzer1->isSwingAnyHand())
-            return false;
-    }
-    if (mDisableInput)
-        return false;
-    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
-}
-
-bool PlayerInput::isTriggerAction() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isTriggerAction(mLiveActor,
-                                                PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isTriggerJump() const {
-    if (mDisableInput)
-        return false;
-    auto* dimension = mDimension;
-    if (dimension && rs::is2D(dimension) && rs::isIn2DArea(dimension)) {
-        if (!mDisableInput && mJoyPadAccelPoseAnalyzer1->isSwingAnyHand())
-            return true;
-    }
-    return PlayerInputFunction::isTriggerJump(mLiveActor,
-                                              PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isTriggerHipDrop() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isTriggerSubAction(mLiveActor,
-                                                   PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isTriggerHeadSliding() const {
-    if (mDisableInput)
-        return false;
-    if (PlayerInputFunction::isTriggerAction(mLiveActor,
-                                             PlayerFunction::getPlayerInputPort(mLiveActor)))
-        return true;
-    if (mDisableInput)
-        return false;
-    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
-}
-
-bool PlayerInput::isTriggerPaddle() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isTriggerJump(mLiveActor,
-                                              PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isTriggerRolling(bool a1) const {
-    if (mDisableInput)
-        return false;
-    if (!PlayerInputFunction::isHoldSubAction(mLiveActor,
-                                              PlayerFunction::getPlayerInputPort(mLiveActor)) &&
-        !a1)
-        return false;
-    if (PlayerInputFunction::isTriggerAction(mLiveActor,
-                                             PlayerFunction::getPlayerInputPort(mLiveActor)))
-        return true;
-    if (mDisableInput)
-        return false;
-    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
-}
-
-bool PlayerInput::isTriggerRollingRestartSwing() const {
-    if (mDisableInput)
-        return false;
-    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
-}
-
-bool PlayerInput::isTriggerRollingCancelHipDrop(bool a1) const {
-    if (mDisableInput)
-        return false;
-    if (!PlayerInputFunction::isHoldSubAction(mLiveActor,
-                                              PlayerFunction::getPlayerInputPort(mLiveActor)) &&
-        !a1)
-        return false;
-    if (PlayerInputFunction::isTriggerAction(mLiveActor,
-                                             PlayerFunction::getPlayerInputPort(mLiveActor)))
-        return true;
-    if (mDisableInput)
-        return false;
-    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
-}
-
-bool PlayerInput::isTriggerHackAction() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isTriggerAction(mLiveActor,
-                                                PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isTriggerHackJump() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isTriggerJump(mLiveActor,
-                                              PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isTriggerHackSwing() const {
-    if (mDisableInput)
-        return false;
-    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
-}
-
-bool PlayerInput::isTriggerHackEnd() const {
-    if (mDisableInput)
-        return false;
-    auto inputPort = PlayerFunction::getPlayerInputPort(mLiveActor);
-    return PlayerInputFunction::isTriggerSubAction(mLiveActor, inputPort);
-}
-
-bool PlayerInput::isTriggerHackSeparateJump() const {
-    if (mDisableInput)
-        return false;
-    if (!rs::isSeparatePlay(mLiveActor))
-        return false;
-    auto inputPort = al::getPlayerControllerPort(1);
-    return PlayerInputFunction::isTriggerJump(mLiveActor, inputPort);
-}
-
-bool PlayerInput::isTriggerSeparateCapJangoHelp() const {
-    if (mDisableInput)
-        return false;
-    if (!rs::isSeparatePlay(mLiveActor))
-        return false;
-    auto inputPort = al::getPlayerControllerPort(1);
-    return PlayerInputFunction::isTriggerAction(mLiveActor, inputPort) ||
-           PlayerInputFunction::isTriggerJump(mLiveActor, inputPort) ||
-           PlayerInputFunction::isTriggerSubAction(mLiveActor, inputPort);
-}
-
-bool PlayerInput::isHoldHackSeparateJump() const {
-    if (mDisableInput)
-        return false;
-    if (!rs::isSeparatePlay(mLiveActor))
-        return false;
-    auto inputPort = al::getPlayerControllerPort(1);
-    return PlayerInputFunction::isHoldJump(mLiveActor, inputPort);
-}
-
-bool PlayerInput::isTriggerGetOff() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isTriggerSubAction(mLiveActor,
-                                                   PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isHoldAction() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isHoldAction(mLiveActor,
-                                             PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isHoldJump() const {
-    if (mDisableInput)
-        return false;
-    auto* dimension = mDimension;
-    if (dimension && rs::is2D(dimension) && rs::isIn2DArea(dimension) && _88 > 0) {
-        return true;
-    }
-    return PlayerInputFunction::isHoldJump(mLiveActor,
-                                           PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isHoldHipDrop() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isHoldSubAction(mLiveActor,
-                                                PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isTriggerStartTalk() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isTriggerTalk(mLiveActor,
-                                              PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isTriggerStartWorldWarp() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isTriggerStartWorldWarp(
-        mLiveActor, PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isTriggerCancelWorldWarp() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isTriggerCancelWorldWarp(
-        mLiveActor, PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isTriggerSpinCap() const {
-    if (mDisableInput)
-        return false;
-    auto inputPort = PlayerFunction::getPlayerInputPort(mLiveActor);
-    if (PlayerInputFunction::isTriggerAction(mLiveActor, inputPort))
-        return true;
-    if (mDisableInput)
-        return false;
-    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
-}
-
-bool PlayerInput::isTriggerToggleStayCap() const {
-    if (mDisableInput)
-        return false;
-    if (!rs::isSeparatePlay(mLiveActor))
-        return false;
-    auto inputPort = al::getPlayerControllerPort(1);
-    return PlayerInputFunction::isTriggerAction(mLiveActor, inputPort);
-}
-
-bool PlayerInput::isTriggerSpinAttackSeparate() const {
-    if (mDisableInput)
-        return false;
-    if (!rs::isSeparatePlay(mLiveActor))
-        return false;
-    if (!mDisableInput && mJoyPadAccelPoseAnalyzer1->isSwingAnyHand())
-        return true;
-    return PlayerInputFunction::isTriggerAction(mLiveActor, al::getPlayerControllerPort(0));
-}
-
-int PlayerInput::getSeparatePlay1P() {
-    return al::getPlayerControllerPort(0);
-}
-
-bool PlayerInput::isTriggerCapReturn() const {
-    if (mDisableInput)
-        return false;
-    if (!rs::isSeparatePlay(mLiveActor)) {
-        if (mDisableInput)
-            return false;
-        auto inputPort = PlayerFunction::getPlayerInputPort(mLiveActor);
-        if (PlayerInputFunction::isTriggerAction(mLiveActor, inputPort))
-            return true;
-        if (mDisableInput)
-            return false;
-        return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
-    }
-    if (mDisableInput || !rs::isSeparatePlay(mLiveActor))
-        return false;
-    auto inputPort = al::getPlayerControllerPort(1);
-    if (PlayerInputFunction::isTriggerAction(mLiveActor, inputPort))
-        return true;
-    if (mDisableInput || !rs::isSeparatePlay(mLiveActor))
-        return false;
-    return mJoyPadAccelPoseAnalyzer2->isSwingAnyHand();
-}
-
-bool PlayerInput::isTriggerCapAttackSeparate() const {
-    if (mDisableInput || !rs::isSeparatePlay(mLiveActor))
-        return false;
-    auto inputPort = al::getPlayerControllerPort(1);
-    if (PlayerInputFunction::isTriggerAction(mLiveActor, inputPort))
-        return true;
-    if (mDisableInput || !rs::isSeparatePlay(mLiveActor))
-        return false;
-    return mJoyPadAccelPoseAnalyzer2->isSwingAnyHand();
-}
-
-bool PlayerInput::isTriggerSwingActionCap() const {
-    if (mDisableInput || !rs::isSeparatePlay(mLiveActor))
-        return false;
-    return mJoyPadAccelPoseAnalyzer2->isSwingAnyHand();
-}
-
-bool PlayerInput::isTriggerCapSingleHandThrow() const {
-    if (mDisableInput)
-        return false;
-    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
-}
-
-bool PlayerInput::isTriggerCapDoubleHandThrow() const {
-    if (mDisableInput)
-        return false;
-    return mJoyPadAccelPoseAnalyzer1->isSwingDoubleHandSameDir();
-}
-
-bool PlayerInput::isTriggerCapSeparateJump() const {
-    if (mDisableInput)
-        return false;
-    if (!rs::isSeparatePlay(mLiveActor))
-        return false;
-    auto inputPort = al::getPlayerControllerPort(1);
-    return PlayerInputFunction::isTriggerJump(mLiveActor, inputPort);
-}
-
-bool PlayerInput::isTriggerCapSeparateHipDrop() const {
-    if (mDisableInput)
-        return false;
-    if (!rs::isSeparatePlay(mLiveActor))
-        return false;
-    auto inputPort = al::getPlayerControllerPort(1);
-    return PlayerInputFunction::isTriggerSubAction(mLiveActor, inputPort);
-}
-
-bool PlayerInput::isTriggerSwingPoleClimbFast() const {
-    if (mDisableInput)
-        return false;
-    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
-}
-
-bool PlayerInput::isHoldPoleClimbDown() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isHoldSubAction(mLiveActor,
-                                                PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isTriggerAppendCapAttack(bool a1) const {
-    if (mDisableInput)
-        return false;
-    if (!rs::isSeparatePlay(mLiveActor) || a1) {
-        if (mDisableInput)
-            return false;
-        return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
-    }
-    if (mDisableInput || !rs::isSeparatePlay(mLiveActor))
-        return false;
-    return mJoyPadAccelPoseAnalyzer2->isSwingAnyHand();
-}
-
-bool PlayerInput::isHoldSpinCap() const {
-    if (mDisableInput || rs::isSeparatePlay(mLiveActor))
-        return false;
-    return PlayerInputFunction::isHoldAction(mLiveActor,
-                                             PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isHoldCapAction() const {
-    if (mDisableInput)
-        return false;
-    if (rs::isSeparatePlay(mLiveActor))
-        return !PlayerInputFunction::isTriggerAction(mLiveActor, al::getPlayerControllerPort(1));
-    return PlayerInputFunction::isHoldAction(mLiveActor,
-                                             PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isHoldPoleClimbFast() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isHoldAction(mLiveActor,
-                                             PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isHoldWallCatchMoveFast() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isHoldAction(mLiveActor,
-                                             PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isHoldHackAction() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isHoldAction(mLiveActor,
-                                             PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isHoldHackJump() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isHoldJump(mLiveActor,
-                                           PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isTriggerChange2D() const {
-    if (mDisableInput)
-        return false;
-    auto inputPort = PlayerFunction::getPlayerInputPort(mLiveActor);
-    return al::isPadTriggerZL(inputPort) || al::isPadTriggerZR(inputPort);
-}
-
-bool PlayerInput::isTriggerChange3D() const {
-    if (mDisableInput)
-        return false;
-    auto inputPort = PlayerFunction::getPlayerInputPort(mLiveActor);
-    return al::isPadTriggerZL(inputPort) || al::isPadTriggerZR(inputPort);
-}
-
-bool PlayerInput::isReleaseJump() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isReleaseJump(mLiveActor,
-                                              PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isReleaseHackAction() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isReleaseAction(mLiveActor,
-                                                PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isReleaseHackJump() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isReleaseJump(mLiveActor,
-                                              PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isEnableDashInput() const {
-    if (mDisableInput)
-        return false;
-    return PlayerInputFunction::isHoldAction(mLiveActor,
-                                             PlayerFunction::getPlayerInputPort(mLiveActor));
-}
-
-bool PlayerInput::isThrowTypeSpiral(const sead::Vector2f& a1) const {
-    if (al::isNearZero(a1, 0.001))
-        return false;
-    float absX = (a1.x > 0 ? a1.x : -a1.x);
-    float absY = (a1.y > 0 ? a1.y : -a1.y);
-    return absX > absY;
-}
-
-bool PlayerInput::isThrowTypeRolling(const sead::Vector2f& a1) const {
-    if (al::isNearZero(a1, 0.001))
-        return !al::isNearZero(a1.y, 0.001);
-    float absX = (a1.x > 0 ? a1.x : -a1.x);
-    float absY = (a1.y > 0 ? a1.y : -a1.y);
-    return !(absX > absY) && !al::isNearZero(a1.y, 0.001);
-}
+#include "al/input/PlayerInput.h"
+
+#include "al/LiveActor/LiveActor.h"
+#include "al/input/JoyPadAccelPoseAnalyzer.h"
+#include "al/input/PlayerInputFunction.h"
+#include "al/input/rsSeparatePlay.h"
+#include "al/player/PlayerFunction.h"
+#include "al/util/InputUtil.h"
+#include "al/util/MathUtil.h"
+#include "al/util/VectorUtil.h"
+#include "rs/Dimension.h"
+
+PlayerInput::PlayerInput(const al::LiveActor*, const IUsePlayerCollision*, const IUseDimension*) {
+}  // FIXME remove this
+
+bool PlayerInput::isEnableCarry() const {
+    if (mDisableInput)
+        return false;
+
+    return PlayerInputFunction::isHoldAction(mLiveActor,
+                                             PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isTriggerCarryStart() const {
+    if (mDisableInput)
+        return false;
+
+    return PlayerInputFunction::isTriggerAction(mLiveActor,
+                                                PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isTriggerCarryRelease() const {
+    if (mDisableInput)
+        return false;
+
+    if (PlayerInputFunction::isTriggerAction(mLiveActor,
+                                             PlayerFunction::getPlayerInputPort(mLiveActor)))
+        return true;
+
+    if (mDisableInput)
+        return false;
+
+    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
+}
+
+bool PlayerInput::isTriggerSwingActionMario() const {
+    if (mDisableInput)
+        return false;
+
+    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
+}
+
+bool PlayerInput::isTriggerCarryReleaseBySwing() const {
+    if (mDisableInput)
+        return false;
+    if (!PlayerInputFunction::isTriggerAction(mLiveActor,
+                                              PlayerFunction::getPlayerInputPort(mLiveActor))) {
+        if (mDisableInput)
+            return false;
+        if (!mJoyPadAccelPoseAnalyzer1->isSwingAnyHand())
+            return false;
+    }
+    if (mDisableInput)
+        return false;
+    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
+}
+
+bool PlayerInput::isTriggerAction() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isTriggerAction(mLiveActor,
+                                                PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isTriggerJump() const {
+    if (mDisableInput)
+        return false;
+    auto* dimension = mDimension;
+    if (dimension && rs::is2D(dimension) && rs::isIn2DArea(dimension)) {
+        if (!mDisableInput && mJoyPadAccelPoseAnalyzer1->isSwingAnyHand())
+            return true;
+    }
+    return PlayerInputFunction::isTriggerJump(mLiveActor,
+                                              PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isTriggerHipDrop() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isTriggerSubAction(mLiveActor,
+                                                   PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isTriggerHeadSliding() const {
+    if (mDisableInput)
+        return false;
+    if (PlayerInputFunction::isTriggerAction(mLiveActor,
+                                             PlayerFunction::getPlayerInputPort(mLiveActor)))
+        return true;
+    if (mDisableInput)
+        return false;
+    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
+}
+
+bool PlayerInput::isTriggerPaddle() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isTriggerJump(mLiveActor,
+                                              PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isTriggerRolling(bool a1) const {
+    if (mDisableInput)
+        return false;
+    if (!PlayerInputFunction::isHoldSubAction(mLiveActor,
+                                              PlayerFunction::getPlayerInputPort(mLiveActor)) &&
+        !a1)
+        return false;
+    if (PlayerInputFunction::isTriggerAction(mLiveActor,
+                                             PlayerFunction::getPlayerInputPort(mLiveActor)))
+        return true;
+    if (mDisableInput)
+        return false;
+    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
+}
+
+bool PlayerInput::isTriggerRollingRestartSwing() const {
+    if (mDisableInput)
+        return false;
+    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
+}
+
+bool PlayerInput::isTriggerRollingCancelHipDrop(bool a1) const {
+    if (mDisableInput)
+        return false;
+    if (!PlayerInputFunction::isHoldSubAction(mLiveActor,
+                                              PlayerFunction::getPlayerInputPort(mLiveActor)) &&
+        !a1)
+        return false;
+    if (PlayerInputFunction::isTriggerAction(mLiveActor,
+                                             PlayerFunction::getPlayerInputPort(mLiveActor)))
+        return true;
+    if (mDisableInput)
+        return false;
+    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
+}
+
+bool PlayerInput::isTriggerHackAction() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isTriggerAction(mLiveActor,
+                                                PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isTriggerHackJump() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isTriggerJump(mLiveActor,
+                                              PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isTriggerHackSwing() const {
+    if (mDisableInput)
+        return false;
+    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
+}
+
+bool PlayerInput::isTriggerHackEnd() const {
+    if (mDisableInput)
+        return false;
+    auto inputPort = PlayerFunction::getPlayerInputPort(mLiveActor);
+    return PlayerInputFunction::isTriggerSubAction(mLiveActor, inputPort);
+}
+
+bool PlayerInput::isTriggerHackSeparateJump() const {
+    if (mDisableInput)
+        return false;
+    if (!rs::isSeparatePlay(mLiveActor))
+        return false;
+    auto inputPort = al::getPlayerControllerPort(1);
+    return PlayerInputFunction::isTriggerJump(mLiveActor, inputPort);
+}
+
+bool PlayerInput::isTriggerSeparateCapJangoHelp() const {
+    if (mDisableInput)
+        return false;
+    if (!rs::isSeparatePlay(mLiveActor))
+        return false;
+    auto inputPort = al::getPlayerControllerPort(1);
+    return PlayerInputFunction::isTriggerAction(mLiveActor, inputPort) ||
+           PlayerInputFunction::isTriggerJump(mLiveActor, inputPort) ||
+           PlayerInputFunction::isTriggerSubAction(mLiveActor, inputPort);
+}
+
+bool PlayerInput::isHoldHackSeparateJump() const {
+    if (mDisableInput)
+        return false;
+    if (!rs::isSeparatePlay(mLiveActor))
+        return false;
+    auto inputPort = al::getPlayerControllerPort(1);
+    return PlayerInputFunction::isHoldJump(mLiveActor, inputPort);
+}
+
+bool PlayerInput::isTriggerGetOff() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isTriggerSubAction(mLiveActor,
+                                                   PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isHoldAction() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isHoldAction(mLiveActor,
+                                             PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isHoldJump() const {
+    if (mDisableInput)
+        return false;
+    auto* dimension = mDimension;
+    if (dimension && rs::is2D(dimension) && rs::isIn2DArea(dimension) && _88 > 0) {
+        return true;
+    }
+    return PlayerInputFunction::isHoldJump(mLiveActor,
+                                           PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isHoldHipDrop() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isHoldSubAction(mLiveActor,
+                                                PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isTriggerStartTalk() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isTriggerTalk(mLiveActor,
+                                              PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isTriggerStartWorldWarp() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isTriggerStartWorldWarp(
+        mLiveActor, PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isTriggerCancelWorldWarp() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isTriggerCancelWorldWarp(
+        mLiveActor, PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isTriggerSpinCap() const {
+    if (mDisableInput)
+        return false;
+    auto inputPort = PlayerFunction::getPlayerInputPort(mLiveActor);
+    if (PlayerInputFunction::isTriggerAction(mLiveActor, inputPort))
+        return true;
+    if (mDisableInput)
+        return false;
+    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
+}
+
+bool PlayerInput::isTriggerToggleStayCap() const {
+    if (mDisableInput)
+        return false;
+    if (!rs::isSeparatePlay(mLiveActor))
+        return false;
+    auto inputPort = al::getPlayerControllerPort(1);
+    return PlayerInputFunction::isTriggerAction(mLiveActor, inputPort);
+}
+
+bool PlayerInput::isTriggerSpinAttackSeparate() const {
+    if (mDisableInput)
+        return false;
+    if (!rs::isSeparatePlay(mLiveActor))
+        return false;
+    if (!mDisableInput && mJoyPadAccelPoseAnalyzer1->isSwingAnyHand())
+        return true;
+    return PlayerInputFunction::isTriggerAction(mLiveActor, al::getPlayerControllerPort(0));
+}
+
+int PlayerInput::getSeparatePlay1P() {
+    return al::getPlayerControllerPort(0);
+}
+
+bool PlayerInput::isTriggerCapReturn() const {
+    if (mDisableInput)
+        return false;
+    if (!rs::isSeparatePlay(mLiveActor)) {
+        if (mDisableInput)
+            return false;
+        auto inputPort = PlayerFunction::getPlayerInputPort(mLiveActor);
+        if (PlayerInputFunction::isTriggerAction(mLiveActor, inputPort))
+            return true;
+        if (mDisableInput)
+            return false;
+        return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
+    }
+    if (mDisableInput || !rs::isSeparatePlay(mLiveActor))
+        return false;
+    auto inputPort = al::getPlayerControllerPort(1);
+    if (PlayerInputFunction::isTriggerAction(mLiveActor, inputPort))
+        return true;
+    if (mDisableInput || !rs::isSeparatePlay(mLiveActor))
+        return false;
+    return mJoyPadAccelPoseAnalyzer2->isSwingAnyHand();
+}
+
+bool PlayerInput::isTriggerCapAttackSeparate() const {
+    if (mDisableInput || !rs::isSeparatePlay(mLiveActor))
+        return false;
+    auto inputPort = al::getPlayerControllerPort(1);
+    if (PlayerInputFunction::isTriggerAction(mLiveActor, inputPort))
+        return true;
+    if (mDisableInput || !rs::isSeparatePlay(mLiveActor))
+        return false;
+    return mJoyPadAccelPoseAnalyzer2->isSwingAnyHand();
+}
+
+bool PlayerInput::isTriggerSwingActionCap() const {
+    if (mDisableInput || !rs::isSeparatePlay(mLiveActor))
+        return false;
+    return mJoyPadAccelPoseAnalyzer2->isSwingAnyHand();
+}
+
+bool PlayerInput::isTriggerCapSingleHandThrow() const {
+    if (mDisableInput)
+        return false;
+    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
+}
+
+bool PlayerInput::isTriggerCapDoubleHandThrow() const {
+    if (mDisableInput)
+        return false;
+    return mJoyPadAccelPoseAnalyzer1->isSwingDoubleHandSameDir();
+}
+
+bool PlayerInput::isTriggerCapSeparateJump() const {
+    if (mDisableInput)
+        return false;
+    if (!rs::isSeparatePlay(mLiveActor))
+        return false;
+    auto inputPort = al::getPlayerControllerPort(1);
+    return PlayerInputFunction::isTriggerJump(mLiveActor, inputPort);
+}
+
+bool PlayerInput::isTriggerCapSeparateHipDrop() const {
+    if (mDisableInput)
+        return false;
+    if (!rs::isSeparatePlay(mLiveActor))
+        return false;
+    auto inputPort = al::getPlayerControllerPort(1);
+    return PlayerInputFunction::isTriggerSubAction(mLiveActor, inputPort);
+}
+
+bool PlayerInput::isTriggerSwingPoleClimbFast() const {
+    if (mDisableInput)
+        return false;
+    return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
+}
+
+bool PlayerInput::isHoldPoleClimbDown() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isHoldSubAction(mLiveActor,
+                                                PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isTriggerAppendCapAttack(bool a1) const {
+    if (mDisableInput)
+        return false;
+    if (!rs::isSeparatePlay(mLiveActor) || a1) {
+        if (mDisableInput)
+            return false;
+        return mJoyPadAccelPoseAnalyzer1->isSwingAnyHand();
+    }
+    if (mDisableInput || !rs::isSeparatePlay(mLiveActor))
+        return false;
+    return mJoyPadAccelPoseAnalyzer2->isSwingAnyHand();
+}
+
+bool PlayerInput::isHoldSpinCap() const {
+    if (mDisableInput || rs::isSeparatePlay(mLiveActor))
+        return false;
+    return PlayerInputFunction::isHoldAction(mLiveActor,
+                                             PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isHoldCapAction() const {
+    if (mDisableInput)
+        return false;
+    if (rs::isSeparatePlay(mLiveActor))
+        return !PlayerInputFunction::isTriggerAction(mLiveActor, al::getPlayerControllerPort(1));
+    return PlayerInputFunction::isHoldAction(mLiveActor,
+                                             PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isHoldPoleClimbFast() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isHoldAction(mLiveActor,
+                                             PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isHoldWallCatchMoveFast() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isHoldAction(mLiveActor,
+                                             PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isHoldHackAction() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isHoldAction(mLiveActor,
+                                             PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isHoldHackJump() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isHoldJump(mLiveActor,
+                                           PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isTriggerChange2D() const {
+    if (mDisableInput)
+        return false;
+    auto inputPort = PlayerFunction::getPlayerInputPort(mLiveActor);
+    return al::isPadTriggerZL(inputPort) || al::isPadTriggerZR(inputPort);
+}
+
+bool PlayerInput::isTriggerChange3D() const {
+    if (mDisableInput)
+        return false;
+    auto inputPort = PlayerFunction::getPlayerInputPort(mLiveActor);
+    return al::isPadTriggerZL(inputPort) || al::isPadTriggerZR(inputPort);
+}
+
+bool PlayerInput::isReleaseJump() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isReleaseJump(mLiveActor,
+                                              PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isReleaseHackAction() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isReleaseAction(mLiveActor,
+                                                PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isReleaseHackJump() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isReleaseJump(mLiveActor,
+                                              PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isEnableDashInput() const {
+    if (mDisableInput)
+        return false;
+    return PlayerInputFunction::isHoldAction(mLiveActor,
+                                             PlayerFunction::getPlayerInputPort(mLiveActor));
+}
+
+bool PlayerInput::isThrowTypeSpiral(const sead::Vector2f& a1) const {
+    if (al::isNearZero(a1, 0.001))
+        return false;
+    float absX = (a1.x > 0 ? a1.x : -a1.x);
+    float absY = (a1.y > 0 ? a1.y : -a1.y);
+    return absX > absY;
+}
+
+bool PlayerInput::isThrowTypeRolling(const sead::Vector2f& a1) const {
+    if (al::isNearZero(a1, 0.001))
+        return !al::isNearZero(a1.y, 0.001);
+    float absX = (a1.x > 0 ? a1.x : -a1.x);
+    float absY = (a1.y > 0 ? a1.y : -a1.y);
+    return !(absX > absY) && !al::isNearZero(a1.y, 0.001);
+}

src/al/iuse/IUseExecutor.cpp

@@ -4,4 +4,4 @@ namespace al {
 
 void IUseExecutor::draw() const {}
 
-}
+}  // namespace al

src/al/objects/CMakeLists.txt

@@ -1 +0,0 @@
-add_subdirectory(Mofumofu)

src/al/player/PlayerPainPartsKeeper.cpp

@@ -3,8 +3,8 @@
 #include "al/model/PartsModel.h"
 #include "al/player/PlayerCostumeInfo.h"
 #include "al/player/PlayerModelHolder.h"
-#include "al/player/rsPlayerState.h"
 #include "al/util/LiveActorUtil.h"
+#include "rs/Player.h"
 
 PlayerPainPartsKeeper::PlayerPainPartsKeeper(const al::LiveActor* liveActor,
                                              const PlayerCostumeInfo* costumeInfo)

src/al/util/InputUtil.cpp

@@ -5,7 +5,8 @@
 namespace al {
 
 sead::ControllerBase* getController_(int port) {
-    return al::isValidReplayController(port) ? getReplayController(port) : sead::ControllerMgr::instance()->getController(port);
+    return al::isValidReplayController(port) ? getReplayController(port) :
+                                               sead::ControllerMgr::instance()->getController(port);
 }
 
 sead::ControllerBase* getController(int port) {
@@ -62,16 +63,16 @@ bool isPadTriggerLeft(int port) {
 bool isPadTriggerRight(int port) {
     return isPadTrigger(port, 1 << 19);
 }
-bool isPadTriggerLeftUp(int port){
+bool isPadTriggerLeftUp(int port) {
     return isPadHoldLeftUp(port) && (getController(port)->getButtonsTrigger() & 0x50000);
 }
-bool isPadTriggerLeftDown(int port){
+bool isPadTriggerLeftDown(int port) {
     return isPadHoldLeftDown(port) && (getController(port)->getButtonsTrigger() & 0x60000);
 }
-bool isPadTriggerRightUp(int port){
+bool isPadTriggerRightUp(int port) {
     return isPadHoldRightUp(port) && (getController(port)->getButtonsTrigger() & 0x90000);
 }
-bool isPadTriggerRightDown(int port){
+bool isPadTriggerRightDown(int port) {
     return isPadHoldRightDown(port) && (getController(port)->getButtonsTrigger() & 0xA0000);
 }
 bool isPadTriggerHome(int port) {
@@ -135,299 +136,298 @@ bool isPadTriggerPressRightStick(int port) {
     return isPadTrigger2(port);
 }
 
-bool isPadRepeat(int port, int button){
+bool isPadRepeat(int port, int button) {
     sead::ControllerBase* controller = getController(port);
     return (controller->getButtonsTrigger() | controller->getButtonsRepeat()) & button;
 }
-bool isPadRepeatA(int port){
+bool isPadRepeatA(int port) {
     return isPadRepeat(port, 1);
 }
-bool isPadRepeatB(int port){
+bool isPadRepeatB(int port) {
     return isPadRepeat(port, 1 << 1);
 }
-bool isPadRepeatX(int port){
+bool isPadRepeatX(int port) {
     return isPadRepeat(port, 1 << 3);
 }
-bool isPadRepeatY(int port){
+bool isPadRepeatY(int port) {
     return isPadRepeat(port, 1 << 4);
 }
-bool isPadRepeatZL(int port){
+bool isPadRepeatZL(int port) {
     return isPadRepeat(port, 1 << 2);
 }
-bool isPadRepeatZR(int port){
+bool isPadRepeatZR(int port) {
     return isPadRepeat(port, 1 << 5);
 }
-bool isPadRepeatL(int port){
+bool isPadRepeatL(int port) {
     return isPadRepeat(port, 1 << 13);
 }
-bool isPadRepeatR(int port){
+bool isPadRepeatR(int port) {
     return isPadRepeat(port, 1 << 14);
 }
-bool isPadRepeat1(int port){
+bool isPadRepeat1(int port) {
     return isPadRepeat(port, 1 << 7);
 }
-bool isPadRepeat2(int port){
+bool isPadRepeat2(int port) {
     return isPadRepeat(port, 1 << 6);
 }
-bool isPadRepeatUp(int port){
+bool isPadRepeatUp(int port) {
     return isPadRepeat(port, 1 << 16);
 }
-bool isPadRepeatDown(int port){
+bool isPadRepeatDown(int port) {
     return isPadRepeat(port, 1 << 17);
 }
-bool isPadRepeatLeft(int port){
+bool isPadRepeatLeft(int port) {
     return isPadRepeat(port, 1 << 18);
 }
-bool isPadRepeatRight(int port){
+bool isPadRepeatRight(int port) {
     return isPadRepeat(port, 1 << 19);
 }
-bool isPadRepeatHome(int port){
+bool isPadRepeatHome(int port) {
     return isPadRepeat(port, 1 << 8);
 }
-bool isPadRepeatStart(int port){
+bool isPadRepeatStart(int port) {
     return isPadRepeat(port, 1 << 11);
 }
-bool isPadRepeatSelect(int port){
+bool isPadRepeatSelect(int port) {
     return isPadRepeat(port, 1 << 12);
 }
-bool isPadRepeatPlus(int port){
+bool isPadRepeatPlus(int port) {
     return isPadRepeat(port, 1 << 10);
 }
-bool isPadRepeatMinus(int port){
+bool isPadRepeatMinus(int port) {
     return isPadRepeat(port, 1 << 9);
 }
-bool isPadRepeatTouch(){
+bool isPadRepeatTouch() {
     return isPadRepeat(getTouchPanelPort(), 1 << 15);
 }
-bool isPadRepeatUpLeftStick(int port){
+bool isPadRepeatUpLeftStick(int port) {
     return isPadRepeat(port, 1 << 20);
 }
-bool isPadRepeatDownLeftStick(int port){
+bool isPadRepeatDownLeftStick(int port) {
     return isPadRepeat(port, 1 << 21);
 }
-bool isPadRepeatLeftLeftStick(int port){
+bool isPadRepeatLeftLeftStick(int port) {
     return isPadRepeat(port, 1 << 22);
 }
-bool isPadRepeatRightLeftStick(int port){
+bool isPadRepeatRightLeftStick(int port) {
     return isPadRepeat(port, 1 << 23);
 }
-bool isPadRepeatUpRightStick(int port){
+bool isPadRepeatUpRightStick(int port) {
     return isPadRepeat(port, 1 << 24);
 }
-bool isPadRepeatDownRightStick(int port){
+bool isPadRepeatDownRightStick(int port) {
     return isPadRepeat(port, 1 << 25);
 }
-bool isPadRepeatLeftRightStick(int port){
+bool isPadRepeatLeftRightStick(int port) {
     return isPadRepeat(port, 1 << 26);
 }
-bool isPadRepeatRightRightStick(int port){
+bool isPadRepeatRightRightStick(int port) {
     return isPadRepeat(port, 1 << 27);
 }
 
-
-bool isPadHoldPressLeftStick(int port){
+bool isPadHoldPressLeftStick(int port) {
     return isPadHold1(port);
 }
-bool isPadHoldPressRightStick(int port){
+bool isPadHoldPressRightStick(int port) {
     return isPadHold2(port);
 }
-bool isPadHold(int port, int button){
+bool isPadHold(int port, int button) {
     return getController(port)->getButtonsHold() & button;
 }
-bool isPadHoldA(int port){
+bool isPadHoldA(int port) {
     return isPadHold(port, 1);
 }
-bool isPadHoldB(int port){
+bool isPadHoldB(int port) {
     return isPadHold(port, 1 << 1);
 }
-bool isPadHoldX(int port){
+bool isPadHoldX(int port) {
     return isPadHold(port, 1 << 3);
 }
-bool isPadHoldY(int port){
+bool isPadHoldY(int port) {
     return isPadHold(port, 1 << 4);
 }
-bool isPadHoldZL(int port){
+bool isPadHoldZL(int port) {
     return isPadHold(port, 1 << 2);
 }
-bool isPadHoldZR(int port){
+bool isPadHoldZR(int port) {
     return isPadHold(port, 1 << 5);
 }
-bool isPadHoldL(int port){
+bool isPadHoldL(int port) {
     return isPadHold(port, 1 << 13);
 }
-bool isPadHoldR(int port){
+bool isPadHoldR(int port) {
     return isPadHold(port, 1 << 14);
 }
-bool isPadHold1(int port){
+bool isPadHold1(int port) {
     return isPadHold(port, 1 << 7);
 }
-bool isPadHold2(int port){
+bool isPadHold2(int port) {
     return isPadHold(port, 1 << 6);
 }
-bool isPadHoldUp(int port){
+bool isPadHoldUp(int port) {
     return isPadHold(port, 1 << 16);
 }
-bool isPadHoldDown(int port){
+bool isPadHoldDown(int port) {
     return isPadHold(port, 1 << 17);
 }
-bool isPadHoldLeft(int port){
+bool isPadHoldLeft(int port) {
     return isPadHold(port, 1 << 18);
 }
-bool isPadHoldRight(int port){
+bool isPadHoldRight(int port) {
     return isPadHold(port, 1 << 19);
 }
-bool isPadHoldLeftUp(int port){
+bool isPadHoldLeftUp(int port) {
     return (getController(port)->getButtonsHold() & 0x50000) == 0x50000;
 }
-bool isPadHoldLeftDown(int port){
+bool isPadHoldLeftDown(int port) {
     return (getController(port)->getButtonsHold() & 0x60000) == 0x60000;
 }
-bool isPadHoldRightUp(int port){
+bool isPadHoldRightUp(int port) {
     return (getController(port)->getButtonsHold() & 0x90000) == 0x90000;
 }
-bool isPadHoldRightDown(int port){
+bool isPadHoldRightDown(int port) {
     return (getController(port)->getButtonsHold() & 0xA0000) == 0xA0000;
 }
-bool isPadHoldHome(int port){
+bool isPadHoldHome(int port) {
     return isPadHold(port, 1 << 8);
 }
-bool isPadHoldStart(int port){
+bool isPadHoldStart(int port) {
     return isPadHold(port, 1 << 11);
 }
-bool isPadHoldSelect(int port){
+bool isPadHoldSelect(int port) {
     return isPadHold(port, 1 << 12);
 }
-bool isPadHoldPlus(int port){
+bool isPadHoldPlus(int port) {
     return isPadHold(port, 1 << 10);
 }
-bool isPadHoldMinus(int port){
+bool isPadHoldMinus(int port) {
     return isPadHold(port, 1 << 9);
 }
-bool isPadHoldAny(int port){
+bool isPadHoldAny(int port) {
     return isPadHold(port, 0xFFF7FFF);
 }
-bool isPadHoldAnyWithoutStick(int port){
+bool isPadHoldAnyWithoutStick(int port) {
     return isPadHold(port, 0xF7FFF);
 }
-bool isPadHoldTouch(){
+bool isPadHoldTouch() {
     return isPadHold(getTouchPanelPort(), 1 << 15);
 }
-bool isPadHoldUpLeftStick(int port){
+bool isPadHoldUpLeftStick(int port) {
     return isPadHold(port, 1 << 20);
 }
-bool isPadHoldDownLeftStick(int port){
+bool isPadHoldDownLeftStick(int port) {
     return isPadHold(port, 1 << 21);
 }
-bool isPadHoldLeftLeftStick(int port){
+bool isPadHoldLeftLeftStick(int port) {
     return isPadHold(port, 1 << 22);
 }
-bool isPadHoldRightLeftStick(int port){
+bool isPadHoldRightLeftStick(int port) {
     return isPadHold(port, 1 << 23);
 }
-bool isPadHoldUpRightStick(int port){
+bool isPadHoldUpRightStick(int port) {
     return isPadHold(port, 1 << 24);
 }
-bool isPadHoldDownRightStick(int port){
+bool isPadHoldDownRightStick(int port) {
     return isPadHold(port, 1 << 25);
 }
-bool isPadHoldLeftRightStick(int port){
+bool isPadHoldLeftRightStick(int port) {
     return isPadHold(port, 1 << 26);
 }
-bool isPadHoldRightRightStick(int port){
+bool isPadHoldRightRightStick(int port) {
     return isPadHold(port, 1 << 27);
 }
-bool isPadHoldLeftStick(int port){
+bool isPadHoldLeftStick(int port) {
     return isPadHold(port, 0xF00000);
 }
-bool isPadHoldRightStick(int port){
+bool isPadHoldRightStick(int port) {
     return isPadHold(port, 0xF000000);
 }
 
 bool isPadRelease(int port, int button) {
     return getController(port)->getButtonsRelease() & button;
 }
-bool isPadReleaseA(int port){
+bool isPadReleaseA(int port) {
     return isPadRelease(port, 1);
 }
-bool isPadReleaseB(int port){
+bool isPadReleaseB(int port) {
     return isPadRelease(port, 1 << 1);
 }
-bool isPadReleaseX(int port){
+bool isPadReleaseX(int port) {
     return isPadRelease(port, 1 << 3);
 }
-bool isPadReleaseY(int port){
+bool isPadReleaseY(int port) {
     return isPadRelease(port, 1 << 4);
 }
-bool isPadReleaseZL(int port){
+bool isPadReleaseZL(int port) {
     return isPadRelease(port, 1 << 2);
 }
-bool isPadReleaseZR(int port){
+bool isPadReleaseZR(int port) {
     return isPadRelease(port, 1 << 5);
 }
-bool isPadReleaseL(int port){
+bool isPadReleaseL(int port) {
     return isPadRelease(port, 1 << 13);
 }
-bool isPadReleaseR(int port){
+bool isPadReleaseR(int port) {
     return isPadRelease(port, 1 << 14);
 }
-bool isPadRelease1(int port){
+bool isPadRelease1(int port) {
     return isPadRelease(port, 1 << 7);
 }
-bool isPadRelease2(int port){
+bool isPadRelease2(int port) {
     return isPadRelease(port, 1 << 6);
 }
-bool isPadReleaseUp(int port){
+bool isPadReleaseUp(int port) {
     return isPadRelease(port, 1 << 16);
 }
-bool isPadReleaseDown(int port){
+bool isPadReleaseDown(int port) {
     return isPadRelease(port, 1 << 17);
 }
-bool isPadReleaseLeft(int port){
+bool isPadReleaseLeft(int port) {
     return isPadRelease(port, 1 << 18);
 }
-bool isPadReleaseRight(int port){
+bool isPadReleaseRight(int port) {
     return isPadRelease(port, 1 << 19);
 }
-bool isPadReleaseHome(int port){
+bool isPadReleaseHome(int port) {
     return isPadRelease(port, 1 << 8);
 }
-bool isPadReleaseStart(int port){
+bool isPadReleaseStart(int port) {
     return isPadRelease(port, 1 << 11);
 }
-bool isPadReleaseSelect(int port){
+bool isPadReleaseSelect(int port) {
     return isPadRelease(port, 1 << 12);
 }
-bool isPadReleasePlus(int port){
+bool isPadReleasePlus(int port) {
     return isPadRelease(port, 1 << 10);
 }
-bool isPadReleaseMinus(int port){
+bool isPadReleaseMinus(int port) {
     return isPadRelease(port, 1 << 9);
 }
-bool isPadReleaseTouch(){
+bool isPadReleaseTouch() {
     return isPadRelease(getTouchPanelPort(), 1 << 15);
 }
-bool isPadReleaseUpLeftStick(int port){
+bool isPadReleaseUpLeftStick(int port) {
     return isPadRelease(port, 1 << 20);
 }
-bool isPadReleaseDownLeftStick(int port){
+bool isPadReleaseDownLeftStick(int port) {
     return isPadRelease(port, 1 << 21);
 }
-bool isPadReleaseLeftLeftStick(int port){
+bool isPadReleaseLeftLeftStick(int port) {
     return isPadRelease(port, 1 << 22);
 }
-bool isPadReleaseRightLeftStick(int port){
+bool isPadReleaseRightLeftStick(int port) {
     return isPadRelease(port, 1 << 23);
 }
-bool isPadReleaseUpRightStick(int port){
+bool isPadReleaseUpRightStick(int port) {
     return isPadRelease(port, 1 << 24);
 }
-bool isPadReleaseDownRightStick(int port){
+bool isPadReleaseDownRightStick(int port) {
     return isPadRelease(port, 1 << 25);
 }
-bool isPadReleaseLeftRightStick(int port){
+bool isPadReleaseLeftRightStick(int port) {
     return isPadRelease(port, 1 << 26);
 }
-bool isPadReleaseRightRightStick(int port){
+bool isPadReleaseRightRightStick(int port) {
     return isPadRelease(port, 1 << 27);
 }
 
@@ -441,31 +441,33 @@ const sead::Vector2f& getRightStick(int port) {
 void getPadCrossDir(sead::Vector2f* vec, int port) {
     vec->x = 0;
     vec->y = 0;
-    if(isPadHoldUp(port))
+    if (isPadHoldUp(port))
         vec->y = 1;
-    if(isPadHoldDown(port))
+    if (isPadHoldDown(port))
         vec->y = -1;
-    if(isPadHoldLeft(port))
+    if (isPadHoldLeft(port))
         vec->x = -1;
-    if(isPadHoldRight(port))
+    if (isPadHoldRight(port))
         vec->x = 1;
 }
 void getPadCrossDirSideways(sead::Vector2f* vec, int port) {
     vec->x = 0;
     vec->y = 0;
-    if(isPadHoldUp(port))
+    if (isPadHoldUp(port))
         vec->x = -1;
-    if(isPadHoldDown(port))
+    if (isPadHoldDown(port))
         vec->x = 1;
-    if(isPadHoldLeft(port))
+    if (isPadHoldLeft(port))
         vec->y = -1;
-    if(isPadHoldRight(port))
+    if (isPadHoldRight(port))
         vec->y = 1;
 }
 
 #ifdef NON_MATCHING
 void calcTouchScreenPos(sead::Vector2f* vec) {
-    *vec = getController(getTouchPanelPort())->getTouchScreenPos(); //uses w8 for storage instead and inserts another write at +4 bytes
+    *vec = getController(getTouchPanelPort())
+               ->getTouchScreenPos();  // uses w8 for storage instead and inserts another write at
+                                       // +4 bytes
 }
 #endif
 
@@ -475,15 +477,15 @@ bool isTouchPosInRect(const sead::Vector2f& rect_pos, const sead::Vector2f& size
     sead::Vector2f pos;
     calcTouchScreenPos(&pos);
 
-    if(rect_pos.x > pos.x)
+    if (rect_pos.x > pos.x)
         return false;
-    if(pos.x >= (rect_pos.x+size.x))
+    if (pos.x >= (rect_pos.x + size.x))
         return false;
-    if(rect_pos.y > pos.y)
+    if (rect_pos.y > pos.y)
         return false;
-    if(pos.y > rect_pos.y+size.y)
+    if (pos.y > rect_pos.y + size.y)
         return false;
-    
+
     return true;
 }
 
@@ -493,12 +495,14 @@ void setPadRepeat(int a1, int a2, int a3, int port) {
 
 int getPlayerControllerPort(int playerNo) {
     auto* manager = sead::ControllerMgr::instance();
-    sead::Controller* controller = manager->getControllerByOrder(sead::ControllerDefine::ControllerId::_15, playerNo);
+    sead::Controller* controller =
+        manager->getControllerByOrder(sead::ControllerDefine::ControllerId::_15, playerNo);
     return manager->findControllerPort(controller);
 }
 int getTouchPanelPort() {
     auto* manager = sead::ControllerMgr::instance();
-    sead::Controller* controller = manager->getControllerByOrder(sead::ControllerDefine::ControllerId::_16, 0);
+    sead::Controller* controller =
+        manager->getControllerByOrder(sead::ControllerDefine::ControllerId::_16, 0);
     return manager->findControllerPort(controller);
 }
 int getMainControllerPort() {
@@ -514,4 +518,4 @@ int getMainJoyPadSingleLeftPort() {
     return 2;
 }
 
-}
+}  // namespace al

src/game/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_subdirectory(actor)
+add_subdirectory(objects)

src/game/actor/ActorDimensionKeeper.cpp

@@ -0,0 +1,16 @@
+#include "game/actor/ActorDimensionKeeper.h"
+
+void ActorDimensionKeeper::validate() {
+    isValid = true;
+}
+
+void ActorDimensionKeeper::invalidate() {
+    isValid = false;
+
+    if (is2D) {
+        is2D = false;
+        isIn2DArea = false;
+        isCurrently2D = false;
+        isCanChange3D = true;
+    }
+}

src/game/actor/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(odyssey PRIVATE
+    ActorDimensionKeeper.cpp
+)

src/game/objects/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_subdirectory(FireDrum2D)
+add_subdirectory(Mofumofu)

src/game/objects/FireDrum2D/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(odyssey PRIVATE
+    FireDrum2D.cpp
+)

src/game/objects/FireDrum2D/FireDrum2D.cpp

@@ -0,0 +1,59 @@
+#include "game/objects/FireDrum2D/FireDrum2D.h"
+
+#include "al/sensor/SensorMsg.h"
+#include "al/util/LiveActorUtil.h"
+#include "al/util/NerveUtil.h"
+#include "al/util/OtherUtil.h"
+#include "rs/Dimension.h"
+#include "rs/Sensor.h"
+
+FireDrum2D::FireDrum2D(const char* name) : LiveActor(name) {}
+
+void FireDrum2D::init(const al::ActorInitInfo& info) {
+    al::initActor(this, info);
+    al::initNerve(this, &nrvWait, 0);
+    mActorDimensionKeeper = rs::createDimensionKeeper(this);
+    rs::updateDimensionKeeper(mActorDimensionKeeper);
+
+    if (rs::isIn2DArea(this)) {
+        rs::snap2D(this, this, 500.0f);
+        makeActorAlive();
+    } else {
+        makeActorDead();
+    }
+}
+
+ActorDimensionKeeper* FireDrum2D::getActorDimensionKeeper() const {
+    return mActorDimensionKeeper;
+}
+
+void FireDrum2D::exeWait() {
+    if (al::isFirstStep(this)) {
+        al::startAction(this, "Burn");
+    }
+}
+
+void FireDrum2D::exeBurn() {
+    if (al::isFirstStep(this)) {
+        al::startAction(this, "Wait");
+    }
+    if (al::isActionEnd(this)) {
+        al::setNerve(this, &nrvWait);
+    }
+}
+
+void FireDrum2D::attackSensor(al::HitSensor* source, al::HitSensor* target) {
+    if (rs::sendMsgTouchFireDrum2D(target, source) || rs::sendMsgEnemyAttack2D(target, source)) {
+        al::setNerve(this, &nrvBurn);
+    }
+}
+
+bool FireDrum2D::receiveMsg(const al::SensorMsg* message, al::HitSensor* source,
+                            al::HitSensor* target) {
+    return al::isMsgPlayerDisregard(message);
+}
+
+namespace {
+NERVE_IMPL(FireDrum2D, Wait)
+NERVE_IMPL(FireDrum2D, Burn)
+}  // namespace

src/game/objects/Mofumofu/MofumofuWarpHole.cpp

@@ -1,4 +1,4 @@
-#include "al/objects/Mofumofu/MofumofuWarpHole.h"
+#include "game/objects/Mofumofu/MofumofuWarpHole.h"
 
 #include <math/seadQuat.h>
 #include <math/seadVector.h>

src/rs/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(odyssey PRIVATE
+    Dimension.cpp
+)

src/rs/Dimension.cpp

@@ -0,0 +1,34 @@
+#include "rs/Dimension.h"
+
+#include "al/LiveActor/LiveActor.h"
+#include "game/actor/ActorDimensionKeeper.h"
+#include "game/iuse/IUseDimension.h"
+
+namespace rs {
+
+ActorDimensionKeeper* createDimensionKeeper(const al::LiveActor* actor) {
+    return new ActorDimensionKeeper(actor);
+}
+
+bool is2D(const IUseDimension* dimension) {
+    return dimension->getActorDimensionKeeper()->getIs2D();
+}
+
+bool is3D(const IUseDimension* dimension) {
+    ActorDimensionKeeper* keeper = dimension->getActorDimensionKeeper();
+    return !keeper->getIs2D() && !keeper->getIsCurrently2D();
+}
+
+bool isChange2D(const IUseDimension* dimension) {
+    return dimension->getActorDimensionKeeper()->getIsCanChange2D();
+}
+
+bool isChange3D(const IUseDimension* dimension) {
+    return dimension->getActorDimensionKeeper()->getIsCanChange3D();
+}
+
+bool isIn2DArea(const IUseDimension* dimension) {
+    return dimension->getActorDimensionKeeper()->getIsIn2DArea();
+}
+
+}  // namespace rs