Set up REL templates (#60)

* Fix .data sections misidentified as .rodata by dtk

dtk can't always reliably identify REL sections in its initial analysis.
This is a manual fix - the list of RELs to fix was found by looking
at supposed .rodata splits that contained an fBase vtable, since vtables
should be in .data. This fix is required for scripted creation of REL actors
based on rel .data

* More consistent d/t header paths

* Data fixups for parsing

* Tmp actor file setup

* Fixes

* Set up almost all REL templates

* formatting

* Fix formatting

include/d/a/b/d_a_b_asura.h

@@ -0,0 +1,43 @@
+#ifndef D_A_B_ASURA_H
+#define D_A_B_ASURA_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcBAsura_c : public dAcEnBase_c {
+public:
+    dAcBAsura_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcBAsura_c() {}
+
+    STATE_FUNC_DECLARE(dAcBAsura_c, Attack);
+    STATE_FUNC_DECLARE(dAcBAsura_c, AttackHigh);
+    STATE_FUNC_DECLARE(dAcBAsura_c, AttackB);
+    STATE_FUNC_DECLARE(dAcBAsura_c, BreakLegB);
+    STATE_FUNC_DECLARE(dAcBAsura_c, BreakWaitB);
+    STATE_FUNC_DECLARE(dAcBAsura_c, ChargeB);
+    STATE_FUNC_DECLARE(dAcBAsura_c, CutAllB);
+    STATE_FUNC_DECLARE(dAcBAsura_c, Damage);
+    STATE_FUNC_DECLARE(dAcBAsura_c, DamageB);
+    STATE_FUNC_DECLARE(dAcBAsura_c, Dead);
+    STATE_FUNC_DECLARE(dAcBAsura_c, DeadB);
+    STATE_FUNC_DECLARE(dAcBAsura_c, Disconnect);
+    STATE_FUNC_DECLARE(dAcBAsura_c, DisconnectB);
+    STATE_FUNC_DECLARE(dAcBAsura_c, Fire);
+    STATE_FUNC_DECLARE(dAcBAsura_c, Recover);
+    STATE_FUNC_DECLARE(dAcBAsura_c, RecoverB);
+    STATE_FUNC_DECLARE(dAcBAsura_c, StunB);
+    STATE_FUNC_DECLARE(dAcBAsura_c, SummonB);
+    STATE_FUNC_DECLARE(dAcBAsura_c, SwordGame);
+    STATE_FUNC_DECLARE(dAcBAsura_c, Wait);
+    STATE_FUNC_DECLARE(dAcBAsura_c, WaitB);
+    STATE_FUNC_DECLARE(dAcBAsura_c, Start);
+    STATE_FUNC_DECLARE(dAcBAsura_c, StartB);
+    STATE_FUNC_DECLARE(dAcBAsura_c, Test);
+    STATE_FUNC_DECLARE(dAcBAsura_c, TestB);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcBAsura_c);
+};
+
+#endif

include/d/a/b/d_a_b_asura_arm.h

@@ -0,0 +1,21 @@
+#ifndef D_A_B_ASURA_ARM_H
+#define D_A_B_ASURA_ARM_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcAsuraArm_c : public dAcObjBase_c {
+public:
+    dAcAsuraArm_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcAsuraArm_c() {}
+
+    STATE_FUNC_DECLARE(dAcAsuraArm_c, Pulled);
+    STATE_FUNC_DECLARE(dAcAsuraArm_c, Wait);
+    STATE_FUNC_DECLARE(dAcAsuraArm_c, Demo);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcAsuraArm_c);
+};
+
+#endif

include/d/a/b/d_a_b_asura_foot.h

@@ -0,0 +1,20 @@
+#ifndef D_A_B_ASURA_FOOT_H
+#define D_A_B_ASURA_FOOT_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcAsuraFoot_c : public dAcObjBase_c {
+public:
+    dAcAsuraFoot_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcAsuraFoot_c() {}
+
+    STATE_FUNC_DECLARE(dAcAsuraFoot_c, Pulled);
+    STATE_FUNC_DECLARE(dAcAsuraFoot_c, Wait);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcAsuraFoot_c);
+};
+
+#endif

include/d/a/b/d_a_b_bbshockwave.h

@@ -0,0 +1,14 @@
+#ifndef D_A_B_BBSHOCKWAVE_H
+#define D_A_B_BBSHOCKWAVE_H
+
+#include <d/a/obj/d_a_obj_base.h>
+
+class dAcBBbshockwave_c : public dAcObjBase_c {
+public:
+    dAcBBbshockwave_c() {}
+    virtual ~dAcBBbshockwave_c() {}
+
+private:
+};
+
+#endif

include/d/a/b/d_a_b_bigboss.h

@@ -0,0 +1,48 @@
+#ifndef D_A_B_BIGBOSS_H
+#define D_A_B_BIGBOSS_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcBBigBoss_c : public dAcEnBase_c {
+public:
+    dAcBBigBoss_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcBBigBoss_c() {}
+
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, AppearWait);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, AppearDemo);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, Wait);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, Walk);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, Reach);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, Turn);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, ImpaAdvice);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, ShakeHead);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, HeadDamage);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, HeadDamageThrow);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, HeadPain);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, StunPain);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, HeadRecover);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, Attack);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, FrontFall);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, Rush);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, Rise);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, Tied);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, LevelUp);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, FootBroken);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, FootRecover);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, Stun);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, StunWait);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, StunRecover);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, StunDamage);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, StunFrontFall);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, Evacuation);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, StoneWait);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, SwordGameWait);
+    STATE_FUNC_DECLARE(dAcBBigBoss_c, SwordGameEnd);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcBBigBoss_c);
+};
+
+#endif

include/d/a/b/d_a_b_bigboss2.h

@@ -0,0 +1,62 @@
+#ifndef D_A_B_BIGBOSS2_H
+#define D_A_B_BIGBOSS2_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcBBigBoss2_c : public dAcEnBase_c {
+public:
+    dAcBBigBoss2_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcBBigBoss2_c() {}
+
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, AppearWait);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, AppearDemo);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, Wait);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, Walk);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, Reach);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, Turn);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, ImpaAdvice);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, ShakeHead);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, HeadDamage);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, HeadDamageThrow);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, HeadPain);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, StunPain);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, HeadRecover);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, DropByHand);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, Attack);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, FootBroken);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, BombHit);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, FootRecover);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, ArmBroken);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, ArmAttack);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, ArmRecover);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, Stun);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, StunWait);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, StunRecover);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, StunDamage);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, StunBombDamage);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, Mount);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, Fall);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, MountDamage);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, FrontFall);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, Rush);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, Rise);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, Tied);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, StunFrontFall);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, BadAdvice);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, CancelMount);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, MountArmBroken);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, LevelUp);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, RushDamage);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, GuardBallista);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, Evacuation);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, StoneWait);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, SwordGameWait);
+    STATE_FUNC_DECLARE(dAcBBigBoss2_c, SwordGameEnd);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcBBigBoss2_c);
+};
+
+#endif

include/d/a/b/d_a_b_bigboss3.h

@@ -0,0 +1,59 @@
+#ifndef D_A_B_BIGBOSS3_H
+#define D_A_B_BIGBOSS3_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcBBigBoss3_c : public dAcEnBase_c {
+public:
+    dAcBBigBoss3_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcBBigBoss3_c() {}
+
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, AppearWait);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, AppearDemo);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, Wait);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, Walk);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, Reach);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, Turn);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, ImpaAdvice);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, ShakeHead);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, HeadDamage);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, HeadDamageThrow);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, HeadPain);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, StunPain);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, DropByHand);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, Attack);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, FootBroken);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, BombHit);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, FootRecover);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, HeadRecover);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, ArmBroken);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, ArmRecover);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, Stun);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, StunWait);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, StunRecover);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, StunDamage);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, StunBombDamage);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, LevelUp);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, GuardBallista);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, ArmAttack);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, PreFly);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, PreFlyDemo);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, Fly);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, FlyPain);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, FlyFall);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, FlyFallGround);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, FlyFallGroundWait);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, FlyFallRecover);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, FlyReach);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, Evacuation);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, StoneWait);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, SwordGameWait);
+    STATE_FUNC_DECLARE(dAcBBigBoss3_c, SwordGameEnd);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcBBigBoss3_c);
+};
+
+#endif

include/d/a/b/d_a_b_bigbossbase.h

@@ -0,0 +1,14 @@
+#ifndef D_A_B_BIGBOSSBASE_H
+#define D_A_B_BIGBOSSBASE_H
+
+#include <d/a/e/d_a_en_base.h>
+
+class dAcBBigbossbase_c : public dAcEnBase_c {
+public:
+    dAcBBigbossbase_c() {}
+    virtual ~dAcBBigbossbase_c() {}
+
+private:
+};
+
+#endif

include/d/a/b/d_a_b_girahimu.h

@@ -0,0 +1,17 @@
+#ifndef D_A_B_GIRAHIMU_H
+#define D_A_B_GIRAHIMU_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcGirahimu_c : public dAcEnBase_c {
+public:
+    dAcGirahimu_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcGirahimu_c() {}
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcGirahimu_c);
+};
+
+#endif

include/d/a/b/d_a_b_girahimu2.h

@@ -0,0 +1,17 @@
+#ifndef D_A_B_GIRAHIMU2_H
+#define D_A_B_GIRAHIMU2_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcGirahimu2_c : public dAcEnBase_c {
+public:
+    dAcGirahimu2_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcGirahimu2_c() {}
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcGirahimu2_c);
+};
+
+#endif

include/d/a/b/d_a_b_girahimu3_base.h

@@ -0,0 +1,17 @@
+#ifndef D_A_B_GIRAHIMU3_BASE_H
+#define D_A_B_GIRAHIMU3_BASE_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcGirahimu3Base_c : public dAcEnBase_c {
+public:
+    dAcGirahimu3Base_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcGirahimu3Base_c() {}
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcGirahimu3Base_c);
+};
+
+#endif

include/d/a/b/d_a_b_girahimu3_first.h

@@ -0,0 +1,14 @@
+#ifndef D_A_B_GIRAHIMU3_FIRST_H
+#define D_A_B_GIRAHIMU3_FIRST_H
+
+#include <d/a/e/d_a_en_base.h>
+
+class dAcGirahimu3First_c : public dAcEnBase_c {
+public:
+    dAcGirahimu3First_c() {}
+    virtual ~dAcGirahimu3First_c() {}
+
+private:
+};
+
+#endif

include/d/a/b/d_a_b_girahimu3_second.h

@@ -0,0 +1,37 @@
+#ifndef D_A_B_GIRAHIMU3_SECOND_H
+#define D_A_B_GIRAHIMU3_SECOND_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcGirahimu3Second_c : public dAcEnBase_c {
+public:
+    dAcGirahimu3Second_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcGirahimu3Second_c() {}
+
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, Demo);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, Demo2);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, Wait);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, Walk);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, Attack);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, CounterAttack);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, Disturb);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, SwordBeamDamage);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, GuardSword);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, Provoke);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, KnifeReady);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, KnifeAttack);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, SwordBeamReady);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, SwordBeamAttack);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, SwordBeamRally);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, GuardJust);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, Damage);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, SummonSword);
+    STATE_FUNC_DECLARE(dAcGirahimu3Second_c, EscapeWarp);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcGirahimu3Second_c);
+};
+
+#endif

include/d/a/b/d_a_b_girahimu3_third.h

@@ -0,0 +1,31 @@
+#ifndef D_A_B_GIRAHIMU3_THIRD_H
+#define D_A_B_GIRAHIMU3_THIRD_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcGirahimu3Third_c : public dAcEnBase_c {
+public:
+    dAcGirahimu3Third_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcGirahimu3Third_c() {}
+
+    STATE_FUNC_DECLARE(dAcGirahimu3Third_c, Demo);
+    STATE_FUNC_DECLARE(dAcGirahimu3Third_c, SceneChange);
+    STATE_FUNC_DECLARE(dAcGirahimu3Third_c, Wait);
+    STATE_FUNC_DECLARE(dAcGirahimu3Third_c, Walk);
+    STATE_FUNC_DECLARE(dAcGirahimu3Third_c, GuardSword);
+    STATE_FUNC_DECLARE(dAcGirahimu3Third_c, Chance);
+    STATE_FUNC_DECLARE(dAcGirahimu3Third_c, SwordBeamDamage);
+    STATE_FUNC_DECLARE(dAcGirahimu3Third_c, RepairClaymore);
+    STATE_FUNC_DECLARE(dAcGirahimu3Third_c, Attack);
+    STATE_FUNC_DECLARE(dAcGirahimu3Third_c, CounterAttack);
+    STATE_FUNC_DECLARE(dAcGirahimu3Third_c, EscapeWarp);
+    STATE_FUNC_DECLARE(dAcGirahimu3Third_c, EscapeWarp2);
+    STATE_FUNC_DECLARE(dAcGirahimu3Third_c, GuardJust);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcGirahimu3Third_c);
+};
+
+#endif

include/d/a/b/d_a_b_girahimu_base.h

@@ -0,0 +1,17 @@
+#ifndef D_A_B_GIRAHIMU_BASE_H
+#define D_A_B_GIRAHIMU_BASE_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcGirahimuBase_c : public dAcEnBase_c {
+public:
+    dAcGirahimuBase_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcGirahimuBase_c() {}
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcGirahimuBase_c);
+};
+
+#endif

include/d/a/b/d_a_b_kr.h

@@ -0,0 +1,31 @@
+#ifndef D_A_B_KR_H
+#define D_A_B_KR_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcBkr_c : public dAcEnBase_c {
+public:
+    dAcBkr_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcBkr_c() {}
+
+    STATE_FUNC_DECLARE(dAcBkr_c, StartDemo);
+    STATE_FUNC_DECLARE(dAcBkr_c, UnderWater);
+    STATE_FUNC_DECLARE(dAcBkr_c, Appear);
+    STATE_FUNC_DECLARE(dAcBkr_c, Fight);
+    STATE_FUNC_DECLARE(dAcBkr_c, Attack);
+    STATE_FUNC_DECLARE(dAcBkr_c, AttackCrash);
+    STATE_FUNC_DECLARE(dAcBkr_c, LastFight);
+    STATE_FUNC_DECLARE(dAcBkr_c, LastDamage);
+    STATE_FUNC_DECLARE(dAcBkr_c, ArmDamage);
+    STATE_FUNC_DECLARE(dAcBkr_c, ArmDamage2);
+    STATE_FUNC_DECLARE(dAcBkr_c, CoreDamage);
+    STATE_FUNC_DECLARE(dAcBkr_c, SmallDamage);
+    STATE_FUNC_DECLARE(dAcBkr_c, ArmRecover);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcBkr_c);
+};
+
+#endif

include/d/a/b/d_a_b_kr_arm.h

@@ -0,0 +1,25 @@
+#ifndef D_A_B_KR_ARM_H
+#define D_A_B_KR_ARM_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcBkra_c : public dAcEnBase_c {
+public:
+    dAcBkra_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcBkra_c() {}
+
+    STATE_FUNC_DECLARE(dAcBkra_c, Wait);
+    STATE_FUNC_DECLARE(dAcBkra_c, InRoom);
+    STATE_FUNC_DECLARE(dAcBkra_c, InRoomDemo);
+    STATE_FUNC_DECLARE(dAcBkra_c, Escape);
+    STATE_FUNC_DECLARE(dAcBkra_c, AttackA);
+    STATE_FUNC_DECLARE(dAcBkra_c, AttackB);
+    STATE_FUNC_DECLARE(dAcBkra_c, Damage);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcBkra_c);
+};
+
+#endif

include/d/a/b/d_a_b_kr_hair.h

@@ -0,0 +1,21 @@
+#ifndef D_A_B_KR_HAIR_H
+#define D_A_B_KR_HAIR_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcBkrh_c : public dAcEnBase_c {
+public:
+    dAcBkrh_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcBkrh_c() {}
+
+    STATE_FUNC_DECLARE(dAcBkrh_c, Normal);
+    STATE_FUNC_DECLARE(dAcBkrh_c, Attack);
+    STATE_FUNC_DECLARE(dAcBkrh_c, Escape);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcBkrh_c);
+};
+
+#endif

include/d/a/b/d_a_b_lastboss.h

@@ -0,0 +1,32 @@
+#ifndef D_A_B_LASTBOSS_H
+#define D_A_B_LASTBOSS_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcBlastboss_c : public dAcEnBase_c {
+public:
+    dAcBlastboss_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcBlastboss_c() {}
+
+    STATE_FUNC_DECLARE(dAcBlastboss_c, Fight);
+    STATE_FUNC_DECLARE(dAcBlastboss_c, Guard);
+    STATE_FUNC_DECLARE(dAcBlastboss_c, GuardBreak);
+    STATE_FUNC_DECLARE(dAcBlastboss_c, Attack);
+    STATE_FUNC_DECLARE(dAcBlastboss_c, CounterAttack);
+    STATE_FUNC_DECLARE(dAcBlastboss_c, PunchAttack);
+    STATE_FUNC_DECLARE(dAcBlastboss_c, DashAttack);
+    STATE_FUNC_DECLARE(dAcBlastboss_c, SmallAttack);
+    STATE_FUNC_DECLARE(dAcBlastboss_c, ThunderAttack);
+    STATE_FUNC_DECLARE(dAcBlastboss_c, Damage);
+    STATE_FUNC_DECLARE(dAcBlastboss_c, SitDamage);
+    STATE_FUNC_DECLARE(dAcBlastboss_c, Down);
+    STATE_FUNC_DECLARE(dAcBlastboss_c, Stun);
+    STATE_FUNC_DECLARE(dAcBlastboss_c, ThunderWait);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcBlastboss_c);
+};
+
+#endif

include/d/a/b/d_a_b_mg.h

@@ -0,0 +1,34 @@
+#ifndef D_A_B_MG_H
+#define D_A_B_MG_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcBmg_c : public dAcEnBase_c {
+public:
+    dAcBmg_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcBmg_c() {}
+
+    STATE_FUNC_DECLARE(dAcBmg_c, Start);
+    STATE_FUNC_DECLARE(dAcBmg_c, DiveWait);
+    STATE_FUNC_DECLARE(dAcBmg_c, Dive);
+    STATE_FUNC_DECLARE(dAcBmg_c, DiveWalk);
+    STATE_FUNC_DECLARE(dAcBmg_c, Fight);
+    STATE_FUNC_DECLARE(dAcBmg_c, HandAttack);
+    STATE_FUNC_DECLARE(dAcBmg_c, TailAttack);
+    STATE_FUNC_DECLARE(dAcBmg_c, DiveAttack);
+    STATE_FUNC_DECLARE(dAcBmg_c, LostArm);
+    STATE_FUNC_DECLARE(dAcBmg_c, MiddleDemo);
+    STATE_FUNC_DECLARE(dAcBmg_c, ArmDamage);
+    STATE_FUNC_DECLARE(dAcBmg_c, CoreDamage);
+    STATE_FUNC_DECLARE(dAcBmg_c, EyeBind);
+    STATE_FUNC_DECLARE(dAcBmg_c, BombDamage);
+    STATE_FUNC_DECLARE(dAcBmg_c, VacuumDamage);
+    STATE_FUNC_DECLARE(dAcBmg_c, End);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcBmg_c);
+};
+
+#endif

include/d/a/b/d_a_b_nusi.h

@@ -0,0 +1,17 @@
+#ifndef D_A_B_NUSI_H
+#define D_A_B_NUSI_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcNusi_c : public dAcEnBase_c {
+public:
+    dAcNusi_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcNusi_c() {}
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcNusi_c);
+};
+
+#endif

include/d/a/b/d_a_b_nusi_bullet.h

@@ -0,0 +1,21 @@
+#ifndef D_A_B_NUSI_BULLET_H
+#define D_A_B_NUSI_BULLET_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcNusi_Bullet_c : public dAcEnBase_c {
+public:
+    dAcNusi_Bullet_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcNusi_Bullet_c() {}
+
+    STATE_FUNC_DECLARE(dAcNusi_Bullet_c, Move);
+    STATE_FUNC_DECLARE(dAcNusi_Bullet_c, Wait);
+    STATE_FUNC_DECLARE(dAcNusi_Bullet_c, Back);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcNusi_Bullet_c);
+};
+
+#endif

include/d/a/b/d_a_b_nusi_tentakle.h

@@ -0,0 +1,33 @@
+#ifndef D_A_B_NUSI_TENTAKLE_H
+#define D_A_B_NUSI_TENTAKLE_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcNusiTentakle_c : public dAcEnBase_c {
+public:
+    dAcNusiTentakle_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcNusiTentakle_c() {}
+
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, Hide);
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, Appear);
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, Wait);
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, HideWait);
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, Attack);
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, AppearDemo);
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, HideAppearDemo);
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, ScarfDamage);
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, Anger);
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, Down);
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, DownDamage);
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, LastDamage);
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, Recover);
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, Death);
+    STATE_FUNC_DECLARE(dAcNusiTentakle_c, CloseEye);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcNusiTentakle_c);
+};
+
+#endif

include/d/a/b/d_a_b_vd.h

@@ -0,0 +1,29 @@
+#ifndef D_A_B_VD_H
+#define D_A_B_VD_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcBvd_c : public dAcEnBase_c {
+public:
+    dAcBvd_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcBvd_c() {}
+
+    STATE_FUNC_DECLARE(dAcBvd_c, Opening);
+    STATE_FUNC_DECLARE(dAcBvd_c, Wait);
+    STATE_FUNC_DECLARE(dAcBvd_c, WaitPlayer);
+    STATE_FUNC_DECLARE(dAcBvd_c, Run);
+    STATE_FUNC_DECLARE(dAcBvd_c, FireAttack);
+    STATE_FUNC_DECLARE(dAcBvd_c, Eat);
+    STATE_FUNC_DECLARE(dAcBvd_c, Damage);
+    STATE_FUNC_DECLARE(dAcBvd_c, BombDamage);
+    STATE_FUNC_DECLARE(dAcBvd_c, BodyReverse);
+    STATE_FUNC_DECLARE(dAcBvd_c, InitMove);
+    STATE_FUNC_DECLARE(dAcBvd_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcBvd_c);
+};
+
+#endif

include/d/a/d_a_asura_bullet.h

@@ -0,0 +1,20 @@
+#ifndef D_A_ASURA_BULLET_H
+#define D_A_ASURA_BULLET_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcAsuraBullet_c : public dAcObjBase_c {
+public:
+    dAcAsuraBullet_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcAsuraBullet_c() {}
+
+    STATE_FUNC_DECLARE(dAcAsuraBullet_c, Attack);
+    STATE_FUNC_DECLARE(dAcAsuraBullet_c, Wait);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcAsuraBullet_c);
+};
+
+#endif

include/d/a/d_a_avater_bullet.h

@@ -0,0 +1,20 @@
+#ifndef D_A_AVATER_BULLET_H
+#define D_A_AVATER_BULLET_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcAvater_Bullet_c : public dAcObjBase_c {
+public:
+    dAcAvater_Bullet_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcAvater_Bullet_c() {}
+
+    STATE_FUNC_DECLARE(dAcAvater_Bullet_c, Move);
+    STATE_FUNC_DECLARE(dAcAvater_Bullet_c, Wait);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcAvater_Bullet_c);
+};
+
+#endif

include/d/a/d_a_avater_race_mng.h

@@ -0,0 +1,24 @@
+#ifndef D_A_AVATER_RACE_MNG_H
+#define D_A_AVATER_RACE_MNG_H
+
+#include <d/a/d_a_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAvater_Race_Mng_c : public dAcBase_c {
+public:
+    dAvater_Race_Mng_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAvater_Race_Mng_c() {}
+
+    STATE_FUNC_DECLARE(dAvater_Race_Mng_c, StartWait);
+    STATE_FUNC_DECLARE(dAvater_Race_Mng_c, Race);
+    STATE_FUNC_DECLARE(dAvater_Race_Mng_c, Hide);
+    STATE_FUNC_DECLARE(dAvater_Race_Mng_c, Finish);
+    STATE_FUNC_DECLARE(dAvater_Race_Mng_c, LevelUpDemo);
+    STATE_FUNC_DECLARE(dAvater_Race_Mng_c, Message);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAvater_Race_Mng_c);
+};
+
+#endif

include/d/a/d_a_bird.h

@@ -0,0 +1,33 @@
+#ifndef D_A_BIRD_H
+#define D_A_BIRD_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dBird_c : public dAcObjBase_c {
+public:
+    dBird_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dBird_c() {}
+
+    STATE_FUNC_DECLARE(dBird_c, Wait);
+    STATE_FUNC_DECLARE(dBird_c, PreMove);
+    STATE_FUNC_DECLARE(dBird_c, Move);
+    STATE_FUNC_DECLARE(dBird_c, Hide);
+    STATE_FUNC_DECLARE(dBird_c, RideDemo);
+    STATE_FUNC_DECLARE(dBird_c, FirstRideDemo);
+    STATE_FUNC_DECLARE(dBird_c, OutAreaDemo);
+    STATE_FUNC_DECLARE(dBird_c, RideOff);
+    STATE_FUNC_DECLARE(dBird_c, OnGround);
+    STATE_FUNC_DECLARE(dBird_c, Tornado);
+    STATE_FUNC_DECLARE(dBird_c, SaveStartDemo);
+    STATE_FUNC_DECLARE(dBird_c, MiniGameWait);
+    STATE_FUNC_DECLARE(dBird_c, MiniGameMove);
+    STATE_FUNC_DECLARE(dBird_c, MiniGameEnd);
+    STATE_FUNC_DECLARE(dBird_c, MiniGameLevelUpDemo);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dBird_c);
+};
+
+#endif

include/d/a/d_a_bird_kobunA.h

@@ -0,0 +1,24 @@
+#ifndef D_A_BIRD_KOBUNA_H
+#define D_A_BIRD_KOBUNA_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dBird_KobunA_c : public dAcObjBase_c {
+public:
+    dBird_KobunA_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dBird_KobunA_c() {}
+
+    STATE_FUNC_DECLARE(dBird_KobunA_c, Wait);
+    STATE_FUNC_DECLARE(dBird_KobunA_c, Chase);
+    STATE_FUNC_DECLARE(dBird_KobunA_c, FrontAttack);
+    STATE_FUNC_DECLARE(dBird_KobunA_c, PathMove);
+    STATE_FUNC_DECLARE(dBird_KobunA_c, LevelUpDemo);
+    STATE_FUNC_DECLARE(dBird_KobunA_c, BodyAttack);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dBird_KobunA_c);
+};
+
+#endif

include/d/a/d_a_bird_kobunB.h

@@ -0,0 +1,24 @@
+#ifndef D_A_BIRD_KOBUNB_H
+#define D_A_BIRD_KOBUNB_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dBird_KobunB_c : public dAcObjBase_c {
+public:
+    dBird_KobunB_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dBird_KobunB_c() {}
+
+    STATE_FUNC_DECLARE(dBird_KobunB_c, Wait);
+    STATE_FUNC_DECLARE(dBird_KobunB_c, Chase);
+    STATE_FUNC_DECLARE(dBird_KobunB_c, FrontAttack);
+    STATE_FUNC_DECLARE(dBird_KobunB_c, PathMove);
+    STATE_FUNC_DECLARE(dBird_KobunB_c, BodyAttack);
+    STATE_FUNC_DECLARE(dBird_KobunB_c, LevelUpDemo);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dBird_KobunB_c);
+};
+
+#endif

include/d/a/d_a_bird_mob.h

@@ -0,0 +1,19 @@
+#ifndef D_A_BIRD_MOB_H
+#define D_A_BIRD_MOB_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcBirdMob_c : public dAcObjBase_c {
+public:
+    dAcBirdMob_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcBirdMob_c() {}
+
+    STATE_FUNC_DECLARE(dAcBirdMob_c, Wait);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcBirdMob_c);
+};
+
+#endif

include/d/a/d_a_bird_npc.h

@@ -0,0 +1,21 @@
+#ifndef D_A_BIRD_NPC_H
+#define D_A_BIRD_NPC_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dBird_Npc_c : public dAcObjBase_c {
+public:
+    dBird_Npc_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dBird_Npc_c() {}
+
+    STATE_FUNC_DECLARE(dBird_Npc_c, Hide);
+    STATE_FUNC_DECLARE(dBird_Npc_c, Fly);
+    STATE_FUNC_DECLARE(dBird_Npc_c, Chase);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dBird_Npc_c);
+};
+
+#endif

include/d/a/d_a_bird_rival.h

@@ -0,0 +1,25 @@
+#ifndef D_A_BIRD_RIVAL_H
+#define D_A_BIRD_RIVAL_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dBird_Rival_c : public dAcObjBase_c {
+public:
+    dBird_Rival_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dBird_Rival_c() {}
+
+    STATE_FUNC_DECLARE(dBird_Rival_c, Wait);
+    STATE_FUNC_DECLARE(dBird_Rival_c, Chase);
+    STATE_FUNC_DECLARE(dBird_Rival_c, FrontAttack);
+    STATE_FUNC_DECLARE(dBird_Rival_c, BodyAttack);
+    STATE_FUNC_DECLARE(dBird_Rival_c, LevelUpDemo);
+    STATE_FUNC_DECLARE(dBird_Rival_c, CatchDemo);
+    STATE_FUNC_DECLARE(dBird_Rival_c, PathMove);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dBird_Rival_c);
+};
+
+#endif

include/d/a/d_a_bird_target.h

@@ -0,0 +1,23 @@
+#ifndef D_A_BIRD_TARGET_H
+#define D_A_BIRD_TARGET_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dBird_Target_c : public dAcObjBase_c {
+public:
+    dBird_Target_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dBird_Target_c() {}
+
+    STATE_FUNC_DECLARE(dBird_Target_c, Wait);
+    STATE_FUNC_DECLARE(dBird_Target_c, Move);
+    STATE_FUNC_DECLARE(dBird_Target_c, LevelUpDemo);
+    STATE_FUNC_DECLARE(dBird_Target_c, NpcWait);
+    STATE_FUNC_DECLARE(dBird_Target_c, NpcGlide);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dBird_Target_c);
+};
+
+#endif

include/d/a/d_a_bird_zelda_training.h

@@ -0,0 +1,21 @@
+#ifndef D_A_BIRD_ZELDA_TRAINING_H
+#define D_A_BIRD_ZELDA_TRAINING_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dBird_ZeldaTraining_c : public dAcObjBase_c {
+public:
+    dBird_ZeldaTraining_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dBird_ZeldaTraining_c() {}
+
+    STATE_FUNC_DECLARE(dBird_ZeldaTraining_c, Wait);
+    STATE_FUNC_DECLARE(dBird_ZeldaTraining_c, Chase);
+    STATE_FUNC_DECLARE(dBird_ZeldaTraining_c, Finish);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dBird_ZeldaTraining_c);
+};
+
+#endif

include/d/a/d_a_bombf.h

@@ -0,0 +1,19 @@
+#ifndef D_A_BOMBF_H
+#define D_A_BOMBF_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcBombf_c : public dAcObjBase_c {
+public:
+    dAcBombf_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcBombf_c() {}
+
+    STATE_FUNC_DECLARE(dAcBombf_c, Wait);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcBombf_c);
+};
+
+#endif

include/d/a/d_a_bullet_gue.h

@@ -0,0 +1,21 @@
+#ifndef D_A_BULLET_GUE_H
+#define D_A_BULLET_GUE_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcBulletGue_c : public dAcObjBase_c {
+public:
+    dAcBulletGue_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcBulletGue_c() {}
+
+    STATE_FUNC_DECLARE(dAcBulletGue_c, Wait);
+    STATE_FUNC_DECLARE(dAcBulletGue_c, Hold);
+    STATE_FUNC_DECLARE(dAcBulletGue_c, TakeOff);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcBulletGue_c);
+};
+
+#endif

include/d/a/d_a_bullet_maguppo.h

@@ -0,0 +1,19 @@
+#ifndef D_A_BULLET_MAGUPPO_H
+#define D_A_BULLET_MAGUPPO_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcBulletMaguppo_c : public dAcObjBase_c {
+public:
+    dAcBulletMaguppo_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcBulletMaguppo_c() {}
+
+    STATE_FUNC_DECLARE(dAcBulletMaguppo_c, Move);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcBulletMaguppo_c);
+};
+
+#endif

include/d/a/d_a_co_test.h

@@ -0,0 +1,19 @@
+#ifndef D_A_CO_TEST_H
+#define D_A_CO_TEST_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcCoTest : public dAcObjBase_c {
+public:
+    dAcCoTest() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcCoTest() {}
+
+    STATE_FUNC_DECLARE(dAcCoTest, Wait);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcCoTest);
+};
+
+#endif

include/d/a/d_a_col_stp.h

@@ -0,0 +1,14 @@
+#ifndef D_A_COL_STP_H
+#define D_A_COL_STP_H
+
+#include <d/a/obj/d_a_obj_base.h>
+
+class dAcColStp_c : public dAcObjBase_c {
+public:
+    dAcColStp_c();
+    virtual ~dAcColStp_c();
+
+private:
+};
+
+#endif

include/d/a/d_a_control.h

@@ -0,0 +1,25 @@
+#ifndef D_A_CONTROL_H
+#define D_A_CONTROL_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEnCl_c : public dAcObjBase_c {
+public:
+    dAcEnCl_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEnCl_c() {}
+
+    STATE_FUNC_DECLARE(dAcEnCl_c, pathMove);
+    STATE_FUNC_DECLARE(dAcEnCl_c, pathRoof);
+    STATE_FUNC_DECLARE(dAcEnCl_c, pathStop);
+    STATE_FUNC_DECLARE(dAcEnCl_c, rangeCheck_All);
+    STATE_FUNC_DECLARE(dAcEnCl_c, infinite);
+    STATE_FUNC_DECLARE(dAcEnCl_c, rangeMove);
+    STATE_FUNC_DECLARE(dAcEnCl_c, rangeSearch);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEnCl_c);
+};
+
+#endif

include/d/a/d_a_demo_npc_bird.h

@@ -0,0 +1,23 @@
+#ifndef D_A_DEMO_NPC_BIRD_H
+#define D_A_DEMO_NPC_BIRD_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcDemoNpcBird_c : public dAcObjBase_c {
+public:
+    dAcDemoNpcBird_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcDemoNpcBird_c() {}
+
+    STATE_FUNC_DECLARE(dAcDemoNpcBird_c, Hide);
+    STATE_FUNC_DECLARE(dAcDemoNpcBird_c, Call);
+    STATE_FUNC_DECLARE(dAcDemoNpcBird_c, Fly1);
+    STATE_FUNC_DECLARE(dAcDemoNpcBird_c, Fly2);
+    STATE_FUNC_DECLARE(dAcDemoNpcBird_c, Fly3);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcDemoNpcBird_c);
+};
+
+#endif

include/d/a/d_a_eel.h

@@ -0,0 +1,14 @@
+#ifndef D_A_EEL_H
+#define D_A_EEL_H
+
+#include <d/a/obj/d_a_obj_base.h>
+
+class dAcEel_c : public dAcObjBase_c {
+public:
+    dAcEel_c() {}
+    virtual ~dAcEel_c() {}
+
+private:
+};
+
+#endif

include/d/a/d_a_fish.h

@@ -0,0 +1,14 @@
+#ifndef D_A_FISH_H
+#define D_A_FISH_H
+
+#include <d/a/obj/d_a_obj_base.h>
+
+class dAcFish_c : public dAcObjBase_c {
+public:
+    dAcFish_c() {}
+    virtual ~dAcFish_c() {}
+
+private:
+};
+
+#endif

include/d/a/d_a_fish_mgr.h

@@ -0,0 +1,14 @@
+#ifndef D_A_FISH_MGR_H
+#define D_A_FISH_MGR_H
+
+#include <d/a/d_a_base.h>
+
+class dAcFishMgr_c : public dAcBase_c {
+public:
+    dAcFishMgr_c() {}
+    virtual ~dAcFishMgr_c() {}
+
+private:
+};
+
+#endif

include/d/a/d_a_fly_slb.h

@@ -0,0 +1,19 @@
+#ifndef D_A_FLY_SLB_H
+#define D_A_FLY_SLB_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcFlySlb_c : public dAcObjBase_c {
+public:
+    dAcFlySlb_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcFlySlb_c() {}
+
+    STATE_FUNC_DECLARE(dAcFlySlb_c, Fly);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcFlySlb_c);
+};
+
+#endif

include/d/a/d_a_girahimu_sword_beam.h

@@ -0,0 +1,20 @@
+#ifndef D_A_GIRAHIMU_SWORD_BEAM_H
+#define D_A_GIRAHIMU_SWORD_BEAM_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcGirahimuSwordBeam_c : public dAcObjBase_c {
+public:
+    dAcGirahimuSwordBeam_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcGirahimuSwordBeam_c() {}
+
+    STATE_FUNC_DECLARE(dAcGirahimuSwordBeam_c, BulletMove);
+    STATE_FUNC_DECLARE(dAcGirahimuSwordBeam_c, Damage);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcGirahimuSwordBeam_c);
+};
+
+#endif

include/d/a/d_a_heartf.h

@@ -0,0 +1,24 @@
+#ifndef D_A_HEARTF_H
+#define D_A_HEARTF_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcHeartf_c : public dAcObjBase_c {
+public:
+    dAcHeartf_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcHeartf_c() {}
+
+    STATE_FUNC_DECLARE(dAcHeartf_c, Wait);
+    STATE_FUNC_DECLARE(dAcHeartf_c, Wind);
+    STATE_FUNC_DECLARE(dAcHeartf_c, Break);
+    STATE_FUNC_DECLARE(dAcHeartf_c, Sync);
+    STATE_FUNC_DECLARE(dAcHeartf_c, Water);
+    STATE_FUNC_DECLARE(dAcHeartf_c, Spore);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcHeartf_c);
+};
+
+#endif

include/d/a/d_a_hidory_fire.h

@@ -0,0 +1,20 @@
+#ifndef D_A_HIDORY_FIRE_H
+#define D_A_HIDORY_FIRE_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcHidoryFire_c : public dAcObjBase_c {
+public:
+    dAcHidoryFire_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcHidoryFire_c() {}
+
+    STATE_FUNC_DECLARE(dAcHidoryFire_c, BulletMove);
+    STATE_FUNC_DECLARE(dAcHidoryFire_c, Damage);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcHidoryFire_c);
+};
+
+#endif

include/d/a/d_a_insect_ant.h

@@ -0,0 +1,24 @@
+#ifndef D_A_INSECT_ANT_H
+#define D_A_INSECT_ANT_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcInsectAnt_c : public dAcObjBase_c {
+public:
+    dAcInsectAnt_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcInsectAnt_c() {}
+
+    STATE_FUNC_DECLARE(dAcInsectAnt_c, Wait);
+    STATE_FUNC_DECLARE(dAcInsectAnt_c, Walk);
+    STATE_FUNC_DECLARE(dAcInsectAnt_c, Escape);
+    STATE_FUNC_DECLARE(dAcInsectAnt_c, Dig);
+    STATE_FUNC_DECLARE(dAcInsectAnt_c, Dead);
+    STATE_FUNC_DECLARE(dAcInsectAnt_c, Finalize);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcInsectAnt_c);
+};
+
+#endif

include/d/a/d_a_insect_beetle.h

@@ -0,0 +1,27 @@
+#ifndef D_A_INSECT_BEETLE_H
+#define D_A_INSECT_BEETLE_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcInsectBeetle_c : public dAcObjBase_c {
+public:
+    dAcInsectBeetle_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcInsectBeetle_c() {}
+
+    STATE_FUNC_DECLARE(dAcInsectBeetle_c, Wait);
+    STATE_FUNC_DECLARE(dAcInsectBeetle_c, Walk);
+    STATE_FUNC_DECLARE(dAcInsectBeetle_c, Escape);
+    STATE_FUNC_DECLARE(dAcInsectBeetle_c, Fly);
+    STATE_FUNC_DECLARE(dAcInsectBeetle_c, Fall);
+    STATE_FUNC_DECLARE(dAcInsectBeetle_c, Getup);
+    STATE_FUNC_DECLARE(dAcInsectBeetle_c, Finalize);
+    STATE_FUNC_DECLARE(dAcInsectBeetle_c, Dead);
+    STATE_FUNC_DECLARE(dAcInsectBeetle_c, EscapeChild);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcInsectBeetle_c);
+};
+
+#endif

include/d/a/d_a_insect_butterfly.h

@@ -0,0 +1,23 @@
+#ifndef D_A_INSECT_BUTTERFLY_H
+#define D_A_INSECT_BUTTERFLY_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcInsectButterfly_c : public dAcObjBase_c {
+public:
+    dAcInsectButterfly_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcInsectButterfly_c() {}
+
+    STATE_FUNC_DECLARE(dAcInsectButterfly_c, Move);
+    STATE_FUNC_DECLARE(dAcInsectButterfly_c, Escape);
+    STATE_FUNC_DECLARE(dAcInsectButterfly_c, Fly);
+    STATE_FUNC_DECLARE(dAcInsectButterfly_c, Finalize);
+    STATE_FUNC_DECLARE(dAcInsectButterfly_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcInsectButterfly_c);
+};
+
+#endif

include/d/a/d_a_insect_cicada.h

@@ -0,0 +1,22 @@
+#ifndef D_A_INSECT_CICADA_H
+#define D_A_INSECT_CICADA_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcInsectCicada_c : public dAcObjBase_c {
+public:
+    dAcInsectCicada_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcInsectCicada_c() {}
+
+    STATE_FUNC_DECLARE(dAcInsectCicada_c, Wait);
+    STATE_FUNC_DECLARE(dAcInsectCicada_c, Fly);
+    STATE_FUNC_DECLARE(dAcInsectCicada_c, Finalize);
+    STATE_FUNC_DECLARE(dAcInsectCicada_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcInsectCicada_c);
+};
+
+#endif

include/d/a/d_a_insect_dragonfly.h

@@ -0,0 +1,24 @@
+#ifndef D_A_INSECT_DRAGONFLY_H
+#define D_A_INSECT_DRAGONFLY_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcInsectDragonfly_c : public dAcObjBase_c {
+public:
+    dAcInsectDragonfly_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcInsectDragonfly_c() {}
+
+    STATE_FUNC_DECLARE(dAcInsectDragonfly_c, Wait);
+    STATE_FUNC_DECLARE(dAcInsectDragonfly_c, Move);
+    STATE_FUNC_DECLARE(dAcInsectDragonfly_c, Escape);
+    STATE_FUNC_DECLARE(dAcInsectDragonfly_c, Fly);
+    STATE_FUNC_DECLARE(dAcInsectDragonfly_c, Finalize);
+    STATE_FUNC_DECLARE(dAcInsectDragonfly_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcInsectDragonfly_c);
+};
+
+#endif

include/d/a/d_a_insect_firefly.h

@@ -0,0 +1,23 @@
+#ifndef D_A_INSECT_FIREFLY_H
+#define D_A_INSECT_FIREFLY_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcInsectFirefly_c : public dAcObjBase_c {
+public:
+    dAcInsectFirefly_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcInsectFirefly_c() {}
+
+    STATE_FUNC_DECLARE(dAcInsectFirefly_c, Move);
+    STATE_FUNC_DECLARE(dAcInsectFirefly_c, Escape);
+    STATE_FUNC_DECLARE(dAcInsectFirefly_c, Fly);
+    STATE_FUNC_DECLARE(dAcInsectFirefly_c, Finalize);
+    STATE_FUNC_DECLARE(dAcInsectFirefly_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcInsectFirefly_c);
+};
+
+#endif

include/d/a/d_a_insect_grasshopper.h

@@ -0,0 +1,24 @@
+#ifndef D_A_INSECT_GRASSHOPPER_H
+#define D_A_INSECT_GRASSHOPPER_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcInsectGrasshopper_c : public dAcObjBase_c {
+public:
+    dAcInsectGrasshopper_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcInsectGrasshopper_c() {}
+
+    STATE_FUNC_DECLARE(dAcInsectGrasshopper_c, Wait);
+    STATE_FUNC_DECLARE(dAcInsectGrasshopper_c, Walk);
+    STATE_FUNC_DECLARE(dAcInsectGrasshopper_c, Jump);
+    STATE_FUNC_DECLARE(dAcInsectGrasshopper_c, Fly);
+    STATE_FUNC_DECLARE(dAcInsectGrasshopper_c, Finalize);
+    STATE_FUNC_DECLARE(dAcInsectGrasshopper_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcInsectGrasshopper_c);
+};
+
+#endif

include/d/a/d_a_insect_ladybug.h

@@ -0,0 +1,24 @@
+#ifndef D_A_INSECT_LADYBUG_H
+#define D_A_INSECT_LADYBUG_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcInsectLadybug_c : public dAcObjBase_c {
+public:
+    dAcInsectLadybug_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcInsectLadybug_c() {}
+
+    STATE_FUNC_DECLARE(dAcInsectLadybug_c, Wait);
+    STATE_FUNC_DECLARE(dAcInsectLadybug_c, Walk);
+    STATE_FUNC_DECLARE(dAcInsectLadybug_c, Escape);
+    STATE_FUNC_DECLARE(dAcInsectLadybug_c, Fly);
+    STATE_FUNC_DECLARE(dAcInsectLadybug_c, Finalize);
+    STATE_FUNC_DECLARE(dAcInsectLadybug_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcInsectLadybug_c);
+};
+
+#endif

include/d/a/d_a_insect_scarab.h

@@ -0,0 +1,25 @@
+#ifndef D_A_INSECT_SCARAB_H
+#define D_A_INSECT_SCARAB_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcInsectScarab_c : public dAcObjBase_c {
+public:
+    dAcInsectScarab_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcInsectScarab_c() {}
+
+    STATE_FUNC_DECLARE(dAcInsectScarab_c, Wait);
+    STATE_FUNC_DECLARE(dAcInsectScarab_c, Walk);
+    STATE_FUNC_DECLARE(dAcInsectScarab_c, Escape);
+    STATE_FUNC_DECLARE(dAcInsectScarab_c, Fly);
+    STATE_FUNC_DECLARE(dAcInsectScarab_c, Finalize);
+    STATE_FUNC_DECLARE(dAcInsectScarab_c, Excrement);
+    STATE_FUNC_DECLARE(dAcInsectScarab_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcInsectScarab_c);
+};
+
+#endif

include/d/a/d_a_invisible.h

@@ -0,0 +1,19 @@
+#ifndef D_A_INVISIBLE_H
+#define D_A_INVISIBLE_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcInvisible : public dAcObjBase_c {
+public:
+    dAcInvisible() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcInvisible() {}
+
+    STATE_FUNC_DECLARE(dAcInvisible, Wait);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcInvisible);
+};
+
+#endif

include/d/a/d_a_kanban.h

@@ -0,0 +1,21 @@
+#ifndef D_A_KANBAN_H
+#define D_A_KANBAN_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcKanban_c : public dAcObjBase_c {
+public:
+    dAcKanban_c();
+    virtual ~dAcKanban_c();
+
+    STATE_FUNC_DECLARE(dAcKanban_c, Wait);
+    STATE_FUNC_DECLARE(dAcKanban_c, Message);
+    STATE_FUNC_DECLARE(dAcKanban_c, PullOut);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcKanban_c);
+};
+
+#endif

include/d/a/d_a_knight_leader_bird.h

@@ -0,0 +1,19 @@
+#ifndef D_A_KNIGHT_LEADER_BIRD_H
+#define D_A_KNIGHT_LEADER_BIRD_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcKnightLeaderBird_c : public dAcObjBase_c {
+public:
+    dAcKnightLeaderBird_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcKnightLeaderBird_c() {}
+
+    STATE_FUNC_DECLARE(dAcKnightLeaderBird_c, Wait);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcKnightLeaderBird_c);
+};
+
+#endif

include/d/a/d_a_little_bird.h

@@ -0,0 +1,32 @@
+#ifndef D_A_LITTLE_BIRD_H
+#define D_A_LITTLE_BIRD_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcLittleBird_c : public dAcObjBase_c {
+public:
+    dAcLittleBird_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcLittleBird_c() {}
+
+    STATE_FUNC_DECLARE(dAcLittleBird_c, Init);
+    STATE_FUNC_DECLARE(dAcLittleBird_c, Wait);
+    STATE_FUNC_DECLARE(dAcLittleBird_c, Scratch);
+    STATE_FUNC_DECLARE(dAcLittleBird_c, Hop);
+    STATE_FUNC_DECLARE(dAcLittleBird_c, Eat);
+    STATE_FUNC_DECLARE(dAcLittleBird_c, Sing);
+    STATE_FUNC_DECLARE(dAcLittleBird_c, PreEscape);
+    STATE_FUNC_DECLARE(dAcLittleBird_c, PreEscape2);
+    STATE_FUNC_DECLARE(dAcLittleBird_c, FlyReady);
+    STATE_FUNC_DECLARE(dAcLittleBird_c, FlyEscape);
+    STATE_FUNC_DECLARE(dAcLittleBird_c, FlyKakku);
+    STATE_FUNC_DECLARE(dAcLittleBird_c, FlyReturn);
+    STATE_FUNC_DECLARE(dAcLittleBird_c, LandOn);
+    STATE_FUNC_DECLARE(dAcLittleBird_c, LandReady);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcLittleBird_c);
+};
+
+#endif

include/d/a/d_a_little_bird_mgr.h

@@ -0,0 +1,24 @@
+#ifndef D_A_LITTLE_BIRD_MGR_H
+#define D_A_LITTLE_BIRD_MGR_H
+
+#include <d/a/d_a_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcLittleBirdMgr_c : public dAcBase_c {
+public:
+    dAcLittleBirdMgr_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcLittleBirdMgr_c() {}
+
+    STATE_FUNC_DECLARE(dAcLittleBirdMgr_c, Set);
+    STATE_FUNC_DECLARE(dAcLittleBirdMgr_c, Reset);
+    STATE_FUNC_DECLARE(dAcLittleBirdMgr_c, Safety);
+    STATE_FUNC_DECLARE(dAcLittleBirdMgr_c, Warning);
+    STATE_FUNC_DECLARE(dAcLittleBirdMgr_c, Danger);
+    STATE_FUNC_DECLARE(dAcLittleBirdMgr_c, Kill);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcLittleBirdMgr_c);
+};
+
+#endif

include/d/a/d_a_message.h

@@ -0,0 +1,14 @@
+#ifndef D_A_MESSAGE_H
+#define D_A_MESSAGE_H
+
+#include <d/a/obj/d_a_obj_base.h>
+
+class dAcMessage_c : public dAcObjBase_c {
+public:
+    dAcMessage_c() {}
+    virtual ~dAcMessage_c() {}
+
+private:
+};
+
+#endif

include/d/a/d_a_morita_test.h

@@ -0,0 +1,28 @@
+#ifndef D_A_MORITA_TEST_H
+#define D_A_MORITA_TEST_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcJtest_c : public dAcEnBase_c {
+public:
+    dAcJtest_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcJtest_c() {}
+
+    STATE_FUNC_DECLARE(dAcJtest_c, FishNormalSwim);
+    STATE_FUNC_DECLARE(dAcJtest_c, FishEscapeSwim);
+    STATE_FUNC_DECLARE(dAcJtest_c, EelNormalSwim);
+    STATE_FUNC_DECLARE(dAcJtest_c, EelEscapeSwim);
+    STATE_FUNC_DECLARE(dAcJtest_c, GunkanuoSwim);
+    STATE_FUNC_DECLARE(dAcJtest_c, SkyTailFly);
+    STATE_FUNC_DECLARE(dAcJtest_c, BirdFly);
+    STATE_FUNC_DECLARE(dAcJtest_c, Remly);
+    STATE_FUNC_DECLARE(dAcJtest_c, OctaGrass);
+    STATE_FUNC_DECLARE(dAcJtest_c, WaterDragon);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcJtest_c);
+};
+
+#endif

include/d/a/d_a_nusi_base.h

@@ -0,0 +1,17 @@
+#ifndef D_A_NUSI_BASE_H
+#define D_A_NUSI_BASE_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcNusiBase_c : public dAcEnBase_c {
+public:
+    dAcNusiBase_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcNusiBase_c() {}
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcNusiBase_c);
+};
+
+#endif

include/d/a/d_a_nusi_npc.h

@@ -0,0 +1,17 @@
+#ifndef D_A_NUSI_NPC_H
+#define D_A_NUSI_NPC_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcNusiNpc_c : public dAcEnBase_c {
+public:
+    dAcNusiNpc_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcNusiNpc_c() {}
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcNusiNpc_c);
+};
+
+#endif

include/d/a/d_a_or_cannon_bullet.h

@@ -0,0 +1,19 @@
+#ifndef D_A_OR_CANNON_BULLET_H
+#define D_A_OR_CANNON_BULLET_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcOrCannBullet_c : public dAcObjBase_c {
+public:
+    dAcOrCannBullet_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcOrCannBullet_c() {}
+
+    STATE_FUNC_DECLARE(dAcOrCannBullet_c, Wait);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcOrCannBullet_c);
+};
+
+#endif

include/d/a/d_a_pumpkin.h

@@ -0,0 +1,26 @@
+#ifndef D_A_PUMPKIN_H
+#define D_A_PUMPKIN_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcPumpkin_c : public dAcObjBase_c {
+public:
+    dAcPumpkin_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcPumpkin_c() {}
+
+    STATE_FUNC_DECLARE(dAcPumpkin_c, Stick);
+    STATE_FUNC_DECLARE(dAcPumpkin_c, Wait);
+    STATE_FUNC_DECLARE(dAcPumpkin_c, CarryGrab);
+    STATE_FUNC_DECLARE(dAcPumpkin_c, StickSword);
+    STATE_FUNC_DECLARE(dAcPumpkin_c, Throw);
+    STATE_FUNC_DECLARE(dAcPumpkin_c, Roll);
+    STATE_FUNC_DECLARE(dAcPumpkin_c, CarryBeetle);
+    STATE_FUNC_DECLARE(dAcPumpkin_c, CarryWhip);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcPumpkin_c);
+};
+
+#endif

include/d/a/d_a_shop_sample.h

@@ -0,0 +1,22 @@
+#ifndef D_A_SHOP_SAMPLE_H
+#define D_A_SHOP_SAMPLE_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcShopSample_c : public dAcObjBase_c {
+public:
+    dAcShopSample_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcShopSample_c() {}
+
+    STATE_FUNC_DECLARE(dAcShopSample_c, Wait);
+    STATE_FUNC_DECLARE(dAcShopSample_c, PickUp);
+    STATE_FUNC_DECLARE(dAcShopSample_c, PickingUp);
+    STATE_FUNC_DECLARE(dAcShopSample_c, PutBack);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcShopSample_c);
+};
+
+#endif

include/d/a/e/d_a_e_am.h

@@ -0,0 +1,29 @@
+#ifndef D_A_E_AM_H
+#define D_A_E_AM_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEAm_c : public dAcEnBase_c {
+public:
+    dAcEAm_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEAm_c() {}
+
+    STATE_FUNC_DECLARE(dAcEAm_c, Stop);
+    STATE_FUNC_DECLARE(dAcEAm_c, Appear);
+    STATE_FUNC_DECLARE(dAcEAm_c, StartWait);
+    STATE_FUNC_DECLARE(dAcEAm_c, Normal);
+    STATE_FUNC_DECLARE(dAcEAm_c, RetMove);
+    STATE_FUNC_DECLARE(dAcEAm_c, LongJump);
+    STATE_FUNC_DECLARE(dAcEAm_c, Wait);
+    STATE_FUNC_DECLARE(dAcEAm_c, Chance);
+    STATE_FUNC_DECLARE(dAcEAm_c, ChanceWait);
+    STATE_FUNC_DECLARE(dAcEAm_c, Damage);
+    STATE_FUNC_DECLARE(dAcEAm_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEAm_c);
+};
+
+#endif

include/d/a/e/d_a_e_battleshipfish.h

@@ -0,0 +1,26 @@
+#ifndef D_A_E_BATTLESHIPFISH_H
+#define D_A_E_BATTLESHIPFISH_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEbfish_c : public dAcEnBase_c {
+public:
+    dAcEbfish_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEbfish_c() {}
+
+    STATE_FUNC_DECLARE(dAcEbfish_c, Wait);
+    STATE_FUNC_DECLARE(dAcEbfish_c, Move);
+    STATE_FUNC_DECLARE(dAcEbfish_c, Find);
+    STATE_FUNC_DECLARE(dAcEbfish_c, Attack);
+    STATE_FUNC_DECLARE(dAcEbfish_c, Piyo);
+    STATE_FUNC_DECLARE(dAcEbfish_c, NoDamage);
+    STATE_FUNC_DECLARE(dAcEbfish_c, Dead);
+    STATE_FUNC_DECLARE(dAcEbfish_c, BirthWait);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEbfish_c);
+};
+
+#endif

include/d/a/e/d_a_e_bc.h

@@ -0,0 +1,53 @@
+#ifndef D_A_E_BC_H
+#define D_A_E_BC_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEbc_c : public dAcEnBase_c {
+public:
+    dAcEbc_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEbc_c() {}
+
+    STATE_FUNC_DECLARE(dAcEbc_c, Standby);
+    STATE_FUNC_DECLARE(dAcEbc_c, Home);
+    STATE_FUNC_DECLARE(dAcEbc_c, Normal);
+    STATE_FUNC_DECLARE(dAcEbc_c, Lantern);
+    STATE_FUNC_DECLARE(dAcEbc_c, Yagura);
+    STATE_FUNC_DECLARE(dAcEbc_c, Path);
+    STATE_FUNC_DECLARE(dAcEbc_c, LanternPath);
+    STATE_FUNC_DECLARE(dAcEbc_c, RopeWalk);
+    STATE_FUNC_DECLARE(dAcEbc_c, FightStart);
+    STATE_FUNC_DECLARE(dAcEbc_c, FindCall);
+    STATE_FUNC_DECLARE(dAcEbc_c, Fight);
+    STATE_FUNC_DECLARE(dAcEbc_c, Attack);
+    STATE_FUNC_DECLARE(dAcEbc_c, BigAttack);
+    STATE_FUNC_DECLARE(dAcEbc_c, StepAttack);
+    STATE_FUNC_DECLARE(dAcEbc_c, RockAttack);
+    STATE_FUNC_DECLARE(dAcEbc_c, CarryDamage);
+    STATE_FUNC_DECLARE(dAcEbc_c, Damage);
+    STATE_FUNC_DECLARE(dAcEbc_c, AirDamage);
+    STATE_FUNC_DECLARE(dAcEbc_c, Fire);
+    STATE_FUNC_DECLARE(dAcEbc_c, Fail);
+    STATE_FUNC_DECLARE(dAcEbc_c, Fall);
+    STATE_FUNC_DECLARE(dAcEbc_c, BombAction);
+    STATE_FUNC_DECLARE(dAcEbc_c, StabGuard);
+    STATE_FUNC_DECLARE(dAcEbc_c, Stun);
+    STATE_FUNC_DECLARE(dAcEbc_c, BeeDamage);
+    STATE_FUNC_DECLARE(dAcEbc_c, WhipCapture);
+    STATE_FUNC_DECLARE(dAcEbc_c, WakidasiWait);
+    STATE_FUNC_DECLARE(dAcEbc_c, SlopeSlide);
+    STATE_FUNC_DECLARE(dAcEbc_c, Drop);
+    STATE_FUNC_DECLARE(dAcEbc_c, MastDrop);
+    STATE_FUNC_DECLARE(dAcEbc_c, AStandby);
+    STATE_FUNC_DECLARE(dAcEbc_c, AFindCall);
+    STATE_FUNC_DECLARE(dAcEbc_c, APath);
+    STATE_FUNC_DECLARE(dAcEbc_c, AAttack);
+    STATE_FUNC_DECLARE(dAcEbc_c, ADamage);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEbc_c);
+};
+
+#endif

include/d/a/e/d_a_e_bc_arrow.h

@@ -0,0 +1,19 @@
+#ifndef D_A_E_BC_ARROW_H
+#define D_A_E_BC_ARROW_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEbcarrow_c : public dAcEnBase_c {
+public:
+    dAcEbcarrow_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEbcarrow_c() {}
+
+    STATE_FUNC_DECLARE(dAcEbcarrow_c, Move);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEbcarrow_c);
+};
+
+#endif

include/d/a/e/d_a_e_bcal.h

@@ -0,0 +1,27 @@
+#ifndef D_A_E_BCAL_H
+#define D_A_E_BCAL_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEbcaL_c : public dAcEnBase_c {
+public:
+    dAcEbcaL_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEbcaL_c() {}
+
+    STATE_FUNC_DECLARE(dAcEbcaL_c, Standby);
+    STATE_FUNC_DECLARE(dAcEbcaL_c, Attack);
+    STATE_FUNC_DECLARE(dAcEbcaL_c, Damage);
+    STATE_FUNC_DECLARE(dAcEbcaL_c, Hit);
+    STATE_FUNC_DECLARE(dAcEbcaL_c, Lead);
+    STATE_FUNC_DECLARE(dAcEbcaL_c, Stun);
+    STATE_FUNC_DECLARE(dAcEbcaL_c, AirDamage);
+    STATE_FUNC_DECLARE(dAcEbcaL_c, Fail);
+    STATE_FUNC_DECLARE(dAcEbcaL_c, StabGuard);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEbcaL_c);
+};
+
+#endif

include/d/a/e/d_a_e_bcal_arrow.h

@@ -0,0 +1,19 @@
+#ifndef D_A_E_BCAL_ARROW_H
+#define D_A_E_BCAL_ARROW_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEbcalarrow_c : public dAcEnBase_c {
+public:
+    dAcEbcalarrow_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEbcalarrow_c() {}
+
+    STATE_FUNC_DECLARE(dAcEbcalarrow_c, Move);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEbcalarrow_c);
+};
+
+#endif

include/d/a/e/d_a_e_bce.h

@@ -0,0 +1,33 @@
+#ifndef D_A_E_BCE_H
+#define D_A_E_BCE_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEbce_c : public dAcEnBase_c {
+public:
+    dAcEbce_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEbce_c() {}
+
+    STATE_FUNC_DECLARE(dAcEbce_c, Standby);
+    STATE_FUNC_DECLARE(dAcEbce_c, Home);
+    STATE_FUNC_DECLARE(dAcEbce_c, Normal);
+    STATE_FUNC_DECLARE(dAcEbce_c, Path);
+    STATE_FUNC_DECLARE(dAcEbce_c, FightStart);
+    STATE_FUNC_DECLARE(dAcEbce_c, Fight);
+    STATE_FUNC_DECLARE(dAcEbce_c, Attack);
+    STATE_FUNC_DECLARE(dAcEbce_c, StepAttack);
+    STATE_FUNC_DECLARE(dAcEbce_c, Damage);
+    STATE_FUNC_DECLARE(dAcEbce_c, AirDamage);
+    STATE_FUNC_DECLARE(dAcEbce_c, Fail);
+    STATE_FUNC_DECLARE(dAcEbce_c, BombAction);
+    STATE_FUNC_DECLARE(dAcEbce_c, StabGuard);
+    STATE_FUNC_DECLARE(dAcEbce_c, Stun);
+    STATE_FUNC_DECLARE(dAcEbce_c, Drop);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEbce_c);
+};
+
+#endif

include/d/a/e/d_a_e_bcz.h

@@ -0,0 +1,43 @@
+#ifndef D_A_E_BCZ_H
+#define D_A_E_BCZ_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEBcZ_c : public dAcEnBase_c {
+public:
+    dAcEBcZ_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEBcZ_c() {}
+
+    STATE_FUNC_DECLARE(dAcEBcZ_c, Arise);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, Wait);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, Walk);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, Find);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, Chase);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, HoldAttack);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, HoldStart);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, HoldWait);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, HoldScream);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, WhipTurn);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, WhipStagger);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, WindBlow);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, KeepAwayFromShield);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, Damage);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, Down);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, AriseFromTag);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, RopeSearch);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, RopeSearchWalk);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, RopeSearchWait);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, RopeWait);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, RopeMove);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, RopeHoldStart);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, RopeHoldWait);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, RopeHoldScream);
+    STATE_FUNC_DECLARE(dAcEBcZ_c, PoisonSwamp);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEBcZ_c);
+};
+
+#endif

include/d/a/e/d_a_e_beamos.h

@@ -0,0 +1,28 @@
+#ifndef D_A_E_BEAMOS_H
+#define D_A_E_BEAMOS_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEbeamos : public dAcEnBase_c {
+public:
+    dAcEbeamos() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEbeamos() {}
+
+    STATE_FUNC_DECLARE(dAcEbeamos, Attack);
+    STATE_FUNC_DECLARE(dAcEbeamos, Beetle);
+    STATE_FUNC_DECLARE(dAcEbeamos, Blow);
+    STATE_FUNC_DECLARE(dAcEbeamos, Damage);
+    STATE_FUNC_DECLARE(dAcEbeamos, Dead);
+    STATE_FUNC_DECLARE(dAcEbeamos, Rail);
+    STATE_FUNC_DECLARE(dAcEbeamos, Shock);
+    STATE_FUNC_DECLARE(dAcEbeamos, Stun);
+    STATE_FUNC_DECLARE(dAcEbeamos, Wait);
+    STATE_FUNC_DECLARE(dAcEbeamos, Watch);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEbeamos);
+};
+
+#endif

include/d/a/e/d_a_e_bs.h

@@ -0,0 +1,26 @@
+#ifndef D_A_E_BS_H
+#define D_A_E_BS_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEbs_c : public dAcEnBase_c {
+public:
+    dAcEbs_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEbs_c() {}
+
+    STATE_FUNC_DECLARE(dAcEbs_c, Standby);
+    STATE_FUNC_DECLARE(dAcEbs_c, StandbyB);
+    STATE_FUNC_DECLARE(dAcEbs_c, Fight);
+    STATE_FUNC_DECLARE(dAcEbs_c, FightB);
+    STATE_FUNC_DECLARE(dAcEbs_c, Attack);
+    STATE_FUNC_DECLARE(dAcEbs_c, Damage);
+    STATE_FUNC_DECLARE(dAcEbs_c, Fire);
+    STATE_FUNC_DECLARE(dAcEbs_c, Disappear);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEbs_c);
+};
+
+#endif

include/d/a/e/d_a_e_cactus.h

@@ -0,0 +1,14 @@
+#ifndef D_A_E_CACTUS_H
+#define D_A_E_CACTUS_H
+
+#include <d/a/e/d_a_en_base.h>
+
+class dAcEcactus_c : public dAcEnBase_c {
+public:
+    dAcEcactus_c() {}
+    virtual ~dAcEcactus_c() {}
+
+private:
+};
+
+#endif

include/d/a/e/d_a_e_captain.h

@@ -0,0 +1,36 @@
+#ifndef D_A_E_CAPTAIN_H
+#define D_A_E_CAPTAIN_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEcaptain_c : public dAcEnBase_c {
+public:
+    dAcEcaptain_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEcaptain_c() {}
+
+    STATE_FUNC_DECLARE(dAcEcaptain_c, Opening);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, Wait);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, BalanceWait);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, Walk);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, Run);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, AttackSW);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, AttackF);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, AttackSP);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, Guard);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, GuardJust);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, Damage);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, Dead);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, Demo1);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, Demo2);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, OpeningType2);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, DeadType2);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, Demo1Type2);
+    STATE_FUNC_DECLARE(dAcEcaptain_c, Demo2Type2);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEcaptain_c);
+};
+
+#endif

include/d/a/e/d_a_e_chaser_b.h

@@ -0,0 +1,22 @@
+#ifndef D_A_E_CHASER_B_H
+#define D_A_E_CHASER_B_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEChb_c : public dAcEnBase_c {
+public:
+    dAcEChb_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEChb_c() {}
+
+    STATE_FUNC_DECLARE(dAcEChb_c, Standby);
+    STATE_FUNC_DECLARE(dAcEChb_c, Chase);
+    STATE_FUNC_DECLARE(dAcEChb_c, Start);
+    STATE_FUNC_DECLARE(dAcEChb_c, Attack);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEChb_c);
+};
+
+#endif

include/d/a/e/d_a_e_eye.h

@@ -0,0 +1,23 @@
+#ifndef D_A_E_EYE_H
+#define D_A_E_EYE_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEEye_c : public dAcObjBase_c {
+public:
+    dAcEEye_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEEye_c() {}
+
+    STATE_FUNC_DECLARE(dAcEEye_c, Open);
+    STATE_FUNC_DECLARE(dAcEEye_c, Wait);
+    STATE_FUNC_DECLARE(dAcEEye_c, Close);
+    STATE_FUNC_DECLARE(dAcEEye_c, Chance);
+    STATE_FUNC_DECLARE(dAcEEye_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEEye_c);
+};
+
+#endif

include/d/a/e/d_a_e_ge.h

@@ -0,0 +1,19 @@
+#ifndef D_A_E_GE_H
+#define D_A_E_GE_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEge_c : public dAcEnBase_c {
+public:
+    dAcEge_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEge_c() {}
+
+    STATE_FUNC_DECLARE(dAcEge_c, Wait);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEge_c);
+};
+
+#endif

include/d/a/e/d_a_e_geko.h

@@ -0,0 +1,24 @@
+#ifndef D_A_E_GEKO_H
+#define D_A_E_GEKO_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEgeko_c : public dAcEnBase_c {
+public:
+    dAcEgeko_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEgeko_c() {}
+
+    STATE_FUNC_DECLARE(dAcEgeko_c, Wait);
+    STATE_FUNC_DECLARE(dAcEgeko_c, Move);
+    STATE_FUNC_DECLARE(dAcEgeko_c, Search);
+    STATE_FUNC_DECLARE(dAcEgeko_c, Shield);
+    STATE_FUNC_DECLARE(dAcEgeko_c, Reflect);
+    STATE_FUNC_DECLARE(dAcEgeko_c, Damage);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEgeko_c);
+};
+
+#endif

include/d/a/e/d_a_e_gerock.h

@@ -0,0 +1,26 @@
+#ifndef D_A_E_GEROCK_H
+#define D_A_E_GEROCK_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEgerock_c : public dAcEnBase_c {
+public:
+    dAcEgerock_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEgerock_c() {}
+
+    STATE_FUNC_DECLARE(dAcEgerock_c, Attack);
+    STATE_FUNC_DECLARE(dAcEgerock_c, Damage);
+    STATE_FUNC_DECLARE(dAcEgerock_c, FlyHome);
+    STATE_FUNC_DECLARE(dAcEgerock_c, Rail);
+    STATE_FUNC_DECLARE(dAcEgerock_c, Return);
+    STATE_FUNC_DECLARE(dAcEgerock_c, Shock);
+    STATE_FUNC_DECLARE(dAcEgerock_c, Stay);
+    STATE_FUNC_DECLARE(dAcEgerock_c, Vanish);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEgerock_c);
+};
+
+#endif

include/d/a/e/d_a_e_gue.h

@@ -0,0 +1,26 @@
+#ifndef D_A_E_GUE_H
+#define D_A_E_GUE_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEgue_c : public dAcEnBase_c {
+public:
+    dAcEgue_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEgue_c() {}
+
+    STATE_FUNC_DECLARE(dAcEgue_c, Attack);
+    STATE_FUNC_DECLARE(dAcEgue_c, Blow);
+    STATE_FUNC_DECLARE(dAcEgue_c, Damage);
+    STATE_FUNC_DECLARE(dAcEgue_c, FlyHome);
+    STATE_FUNC_DECLARE(dAcEgue_c, FlyPlayer);
+    STATE_FUNC_DECLARE(dAcEgue_c, Return);
+    STATE_FUNC_DECLARE(dAcEgue_c, Stay);
+    STATE_FUNC_DECLARE(dAcEgue_c, Stun);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEgue_c);
+};
+
+#endif

include/d/a/e/d_a_e_gumarm.h

@@ -0,0 +1,36 @@
+#ifndef D_A_E_GUMARM_H
+#define D_A_E_GUMARM_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcGumarm_c : public dAcEnBase_c {
+public:
+    dAcGumarm_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcGumarm_c() {}
+
+    STATE_FUNC_DECLARE(dAcGumarm_c, Hide);
+    STATE_FUNC_DECLARE(dAcGumarm_c, HideWait);
+    STATE_FUNC_DECLARE(dAcGumarm_c, HideWalk);
+    STATE_FUNC_DECLARE(dAcGumarm_c, HideMove);
+    STATE_FUNC_DECLARE(dAcGumarm_c, Wait);
+    STATE_FUNC_DECLARE(dAcGumarm_c, Walk);
+    STATE_FUNC_DECLARE(dAcGumarm_c, Appear);
+    STATE_FUNC_DECLARE(dAcGumarm_c, KeepRock);
+    STATE_FUNC_DECLARE(dAcGumarm_c, AttackMove);
+    STATE_FUNC_DECLARE(dAcGumarm_c, Attack);
+    STATE_FUNC_DECLARE(dAcGumarm_c, Lost);
+    STATE_FUNC_DECLARE(dAcGumarm_c, Find);
+    STATE_FUNC_DECLARE(dAcGumarm_c, FreezeStart);
+    STATE_FUNC_DECLARE(dAcGumarm_c, Freeze);
+    STATE_FUNC_DECLARE(dAcGumarm_c, FreezeEnd);
+    STATE_FUNC_DECLARE(dAcGumarm_c, Sink);
+    STATE_FUNC_DECLARE(dAcGumarm_c, KeepSink);
+    STATE_FUNC_DECLARE(dAcGumarm_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcGumarm_c);
+};
+
+#endif

include/d/a/e/d_a_e_gunho.h

@@ -0,0 +1,26 @@
+#ifndef D_A_E_GUNHO_H
+#define D_A_E_GUNHO_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEgunho_c : public dAcEnBase_c {
+public:
+    dAcEgunho_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEgunho_c() {}
+
+    STATE_FUNC_DECLARE(dAcEgunho_c, OpenClose);
+    STATE_FUNC_DECLARE(dAcEgunho_c, Wait);
+    STATE_FUNC_DECLARE(dAcEgunho_c, NormalMove);
+    STATE_FUNC_DECLARE(dAcEgunho_c, Search);
+    STATE_FUNC_DECLARE(dAcEgunho_c, AttackBullet);
+    STATE_FUNC_DECLARE(dAcEgunho_c, AttackBomb);
+    STATE_FUNC_DECLARE(dAcEgunho_c, Damage);
+    STATE_FUNC_DECLARE(dAcEgunho_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEgunho_c);
+};
+
+#endif

include/d/a/e/d_a_e_gunhob.h

@@ -0,0 +1,24 @@
+#ifndef D_A_E_GUNHOB_H
+#define D_A_E_GUNHOB_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEgunhob_c : public dAcEnBase_c {
+public:
+    dAcEgunhob_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEgunhob_c() {}
+
+    STATE_FUNC_DECLARE(dAcEgunhob_c, BulletMove);
+    STATE_FUNC_DECLARE(dAcEgunhob_c, BulletReflection);
+    STATE_FUNC_DECLARE(dAcEgunhob_c, BombWait);
+    STATE_FUNC_DECLARE(dAcEgunhob_c, BombMove);
+    STATE_FUNC_DECLARE(dAcEgunhob_c, BombDelete);
+    STATE_FUNC_DECLARE(dAcEgunhob_c, BombBomb);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEgunhob_c);
+};
+
+#endif

include/d/a/e/d_a_e_hb.h

@@ -0,0 +1,27 @@
+#ifndef D_A_E_HB_H
+#define D_A_E_HB_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEhb_c : public dAcEnBase_c {
+public:
+    dAcEhb_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEhb_c() {}
+
+    STATE_FUNC_DECLARE(dAcEhb_c, Under);
+    STATE_FUNC_DECLARE(dAcEhb_c, Appear);
+    STATE_FUNC_DECLARE(dAcEhb_c, Wait);
+    STATE_FUNC_DECLARE(dAcEhb_c, Attack);
+    STATE_FUNC_DECLARE(dAcEhb_c, Damage);
+    STATE_FUNC_DECLARE(dAcEhb_c, Blow);
+    STATE_FUNC_DECLARE(dAcEhb_c, Stun);
+    STATE_FUNC_DECLARE(dAcEhb_c, DeadMouth);
+    STATE_FUNC_DECLARE(dAcEhb_c, Avoid);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEhb_c);
+};
+
+#endif

include/d/a/e/d_a_e_hidokari.h

@@ -0,0 +1,35 @@
+#ifndef D_A_E_HIDOKARI_H
+#define D_A_E_HIDOKARI_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEhidokari_c : public dAcEnBase_c {
+public:
+    dAcEhidokari_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEhidokari_c() {}
+
+    STATE_FUNC_DECLARE(dAcEhidokari_c, Wait);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, Walk);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, Kyoro);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, Find);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, Run);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, Inside);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, Stun);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, WaitShell);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, RunShell);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, WalkShell);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, FireShell);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, RetShell);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, NoShell);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, Damage);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, GuradShell);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, Panic);
+    STATE_FUNC_DECLARE(dAcEhidokari_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEhidokari_c);
+};
+
+#endif

include/d/a/e/d_a_e_hidokaris.h

@@ -0,0 +1,21 @@
+#ifndef D_A_E_HIDOKARIS_H
+#define D_A_E_HIDOKARIS_H
+
+#include <d/a/obj/d_a_obj_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEhidokaris_c : public dAcObjBase_c {
+public:
+    dAcEhidokaris_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEhidokaris_c() {}
+
+    STATE_FUNC_DECLARE(dAcEhidokaris_c, Wait);
+    STATE_FUNC_DECLARE(dAcEhidokaris_c, BombWait);
+    STATE_FUNC_DECLARE(dAcEhidokaris_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEhidokaris_c);
+};
+
+#endif

include/d/a/e/d_a_e_hidory.h

@@ -0,0 +1,24 @@
+#ifndef D_A_E_HIDORY_H
+#define D_A_E_HIDORY_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEHidory_c : public dAcEnBase_c {
+public:
+    dAcEHidory_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEHidory_c() {}
+
+    STATE_FUNC_DECLARE(dAcEHidory_c, Wait);
+    STATE_FUNC_DECLARE(dAcEHidory_c, Hovering);
+    STATE_FUNC_DECLARE(dAcEHidory_c, Attack);
+    STATE_FUNC_DECLARE(dAcEHidory_c, Whip_Damage);
+    STATE_FUNC_DECLARE(dAcEHidory_c, Damage);
+    STATE_FUNC_DECLARE(dAcEHidory_c, Death);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEHidory_c);
+};
+
+#endif

include/d/a/e/d_a_e_hoc.h

@@ -0,0 +1,34 @@
+#ifndef D_A_E_HOC_H
+#define D_A_E_HOC_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEhoc_c : public dAcEnBase_c {
+public:
+    dAcEhoc_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEhoc_c() {}
+
+    STATE_FUNC_DECLARE(dAcEhoc_c, Fight);
+    STATE_FUNC_DECLARE(dAcEhoc_c, Attack);
+    STATE_FUNC_DECLARE(dAcEhoc_c, BigAttack);
+    STATE_FUNC_DECLARE(dAcEhoc_c, AttackAfter);
+    STATE_FUNC_DECLARE(dAcEhoc_c, Escape);
+    STATE_FUNC_DECLARE(dAcEhoc_c, Damage);
+    STATE_FUNC_DECLARE(dAcEhoc_c, Fire);
+    STATE_FUNC_DECLARE(dAcEhoc_c, Fail);
+    STATE_FUNC_DECLARE(dAcEhoc_c, StabGuard);
+    STATE_FUNC_DECLARE(dAcEhoc_c, Stun);
+    STATE_FUNC_DECLARE(dAcEhoc_c, DropOut);
+    STATE_FUNC_DECLARE(dAcEhoc_c, Return);
+    STATE_FUNC_DECLARE(dAcEhoc_c, DashReturn);
+    STATE_FUNC_DECLARE(dAcEhoc_c, Wait);
+    STATE_FUNC_DECLARE(dAcEhoc_c, Summon);
+    STATE_FUNC_DECLARE(dAcEhoc_c, AirDamage);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEhoc_c);
+};
+
+#endif

include/d/a/e/d_a_e_hp.h

@@ -0,0 +1,31 @@
+#ifndef D_A_E_HP_H
+#define D_A_E_HP_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEHp_c : public dAcEnBase_c {
+public:
+    dAcEHp_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEHp_c() {}
+
+    STATE_FUNC_DECLARE(dAcEHp_c, BobUpAndDown);
+    STATE_FUNC_DECLARE(dAcEHp_c, Chase);
+    STATE_FUNC_DECLARE(dAcEHp_c, Attack);
+    STATE_FUNC_DECLARE(dAcEHp_c, AtkWait);
+    STATE_FUNC_DECLARE(dAcEHp_c, Extract);
+    STATE_FUNC_DECLARE(dAcEHp_c, Petrify);
+    STATE_FUNC_DECLARE(dAcEHp_c, Fluster);
+    STATE_FUNC_DECLARE(dAcEHp_c, Escape);
+    STATE_FUNC_DECLARE(dAcEHp_c, Damage);
+    STATE_FUNC_DECLARE(dAcEHp_c, VcmDmg);
+    STATE_FUNC_DECLARE(dAcEHp_c, Stun);
+    STATE_FUNC_DECLARE(dAcEHp_c, Die);
+    STATE_FUNC_DECLARE(dAcEHp_c, Dummy);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEHp_c);
+};
+
+#endif

include/d/a/e/d_a_e_hydra.h

@@ -0,0 +1,29 @@
+#ifndef D_A_E_HYDRA_H
+#define D_A_E_HYDRA_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEhydra_c : public dAcEnBase_c {
+public:
+    dAcEhydra_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEhydra_c() {}
+
+    STATE_FUNC_DECLARE(dAcEhydra_c, Wait);
+    STATE_FUNC_DECLARE(dAcEhydra_c, Walk);
+    STATE_FUNC_DECLARE(dAcEhydra_c, Run);
+    STATE_FUNC_DECLARE(dAcEhydra_c, Ret);
+    STATE_FUNC_DECLARE(dAcEhydra_c, Attack);
+    STATE_FUNC_DECLARE(dAcEhydra_c, AttackWait);
+    STATE_FUNC_DECLARE(dAcEhydra_c, Recover);
+    STATE_FUNC_DECLARE(dAcEhydra_c, Stun);
+    STATE_FUNC_DECLARE(dAcEhydra_c, Damage);
+    STATE_FUNC_DECLARE(dAcEhydra_c, EtcDamage);
+    STATE_FUNC_DECLARE(dAcEhydra_c, Dead);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEhydra_c);
+};
+
+#endif

include/d/a/e/d_a_e_kg.h

@@ -0,0 +1,53 @@
+#ifndef D_A_E_KG_H
+#define D_A_E_KG_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEkg_c : public dAcEnBase_c {
+public:
+    dAcEkg_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEkg_c() {}
+
+    STATE_FUNC_DECLARE(dAcEkg_c, Wait);
+    STATE_FUNC_DECLARE(dAcEkg_c, Walk);
+    STATE_FUNC_DECLARE(dAcEkg_c, Find);
+    STATE_FUNC_DECLARE(dAcEkg_c, Chase);
+    STATE_FUNC_DECLARE(dAcEkg_c, Step);
+    STATE_FUNC_DECLARE(dAcEkg_c, Damage);
+    STATE_FUNC_DECLARE(dAcEkg_c, PlayerLost);
+    STATE_FUNC_DECLARE(dAcEkg_c, Return);
+    STATE_FUNC_DECLARE(dAcEkg_c, WindBlow);
+    STATE_FUNC_DECLARE(dAcEkg_c, Reverse);
+    STATE_FUNC_DECLARE(dAcEkg_c, BlowReturn);
+    STATE_FUNC_DECLARE(dAcEkg_c, JumpReady);
+    STATE_FUNC_DECLARE(dAcEkg_c, Jump);
+    STATE_FUNC_DECLARE(dAcEkg_c, JumpAttack_Hold);
+    STATE_FUNC_DECLARE(dAcEkg_c, Release);
+    STATE_FUNC_DECLARE(dAcEkg_c, Landing);
+    STATE_FUNC_DECLARE(dAcEkg_c, WallWait);
+    STATE_FUNC_DECLARE(dAcEkg_c, WallWalk);
+    STATE_FUNC_DECLARE(dAcEkg_c, WallFind);
+    STATE_FUNC_DECLARE(dAcEkg_c, WallStep);
+    STATE_FUNC_DECLARE(dAcEkg_c, WallJumpReady);
+    STATE_FUNC_DECLARE(dAcEkg_c, WallJump);
+    STATE_FUNC_DECLARE(dAcEkg_c, WindBlowAtWall);
+    STATE_FUNC_DECLARE(dAcEkg_c, HitAtWall);
+    STATE_FUNC_DECLARE(dAcEkg_c, DamageAtWall);
+    STATE_FUNC_DECLARE(dAcEkg_c, RoofWait);
+    STATE_FUNC_DECLARE(dAcEkg_c, RoofWalk);
+    STATE_FUNC_DECLARE(dAcEkg_c, RoofFall);
+    STATE_FUNC_DECLARE(dAcEkg_c, HangOn);
+    STATE_FUNC_DECLARE(dAcEkg_c, UnderWait);
+    STATE_FUNC_DECLARE(dAcEkg_c, UnderWalk);
+    STATE_FUNC_DECLARE(dAcEkg_c, UnderStep);
+    STATE_FUNC_DECLARE(dAcEkg_c, UnderJump);
+    STATE_FUNC_DECLARE(dAcEkg_c, SoundReaction);
+    STATE_FUNC_DECLARE(dAcEkg_c, SoundReactionAtWallRoof);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEkg_c);
+};
+
+#endif

include/d/a/e/d_a_e_ks.h

@@ -0,0 +1,32 @@
+#ifndef D_A_E_KS_H
+#define D_A_E_KS_H
+
+#include <d/a/e/d_a_en_base.h>
+#include <s/s_State.hpp>
+#include <s/s_StateMgr.hpp>
+
+class dAcEKs_c : public dAcEnBase_c {
+public:
+    dAcEKs_c() : mStateMgr(*this, sStateID::null) {}
+    virtual ~dAcEKs_c() {}
+
+    STATE_FUNC_DECLARE(dAcEKs_c, Wait);
+    STATE_FUNC_DECLARE(dAcEKs_c, WakeUp);
+    STATE_FUNC_DECLARE(dAcEKs_c, ReturnToWait);
+    STATE_FUNC_DECLARE(dAcEKs_c, WaitReady);
+    STATE_FUNC_DECLARE(dAcEKs_c, Move);
+    STATE_FUNC_DECLARE(dAcEKs_c, Chase);
+    STATE_FUNC_DECLARE(dAcEKs_c, ChaseAttack);
+    STATE_FUNC_DECLARE(dAcEKs_c, Fighting);
+    STATE_FUNC_DECLARE(dAcEKs_c, AttackReady);
+    STATE_FUNC_DECLARE(dAcEKs_c, Attack);
+    STATE_FUNC_DECLARE(dAcEKs_c, Damage);
+    STATE_FUNC_DECLARE(dAcEKs_c, Stun);
+    STATE_FUNC_DECLARE(dAcEKs_c, WindBlow);
+    STATE_FUNC_DECLARE(dAcEKs_c, PathMove);
+
+private:
+    /* 0x??? */ STATE_MGR_DECLARE(dAcEKs_c);
+};
+
+#endif