#pragma once

#include "ghs.h"
#include "actors.h"
#include "effects.h"
#include "nw4f.h"
#include "enums.h"

class Actor;
class Collider;
class StageActor;
class PhysicsActor;
class StateActor;
class Enemy;
class PlayableBase;
class Player;
class Yoshi;
class Physics;
class Profile;

/*************
 * STATES
 ******/
#define IMPORT_STATE(CLASS, NAME) static State<Class> StateID_##NAME

#define DECLARE_STATE(CLASS, NAME) \
    static State<CLASS> StateID_##NAME; \
    void beginState_##NAME(); \
    void executeState_##NAME(); \
    void endState_##NAME();

#define CREATE_STATE(CLASS, NAME) \
    State<CLASS> CLASS::StateID_##NAME \
        (&CLASS::beginState_##NAME, \
        &CLASS::executeState_##NAME, \
        &CLASS::endState_##NAME);

#define NINTENDO_STATE(Yoshi, DefaultState) extern static State<Yoshi> StateID_DefaultState;

/***********
 * CLASSES
 *******/

class LevelInfo : public sead::IDisposer {
    public:
        static LevelInfo *instance;
        u8 world;
        u8 level;
        u8 area;
        u8 entrance;
        u32 zone;
        u32 entranceType;
        u8 destWorld;
        u8 destLevel;
        u8 destArea;
        u8 destEntrance;
        u32 _20;
};

struct Location {
    u16 x;
    u16 y;
    u16 w;
    u16 h;
    u8 id;
};

class LevelArea {
    /* incomplete */
    public:
        Location *getLocationById(Rect *dst, u8 id);
};

class Level {
    public:
        static Level *instance;
        LevelArea *getArea(u8 areaNum);
};

struct ActorInfo {
    s32 xoffs;
    s32 yoffs;
    u32 _8;
    u32 _C;
    u32 _10;
    u32 _14;
    u16 _18;
    u16 _1A;
    u32 _1C;
    u16 flags;
    u16 _22;
};

struct ActorBuildInfo {
    u32 settings;
    u32 settings2;
    u32 parentId;
    Profile *profile;
    Vec3 position;
    u32 rotation;
    u8 layer;
    u8 Nybble3_4;
    u8 Nybble1_2;
    u8 _23;
    u8 movementId;
    u8 linkId;
    u8 spriteDataField14;
    u8 _27;
    u32 spriteRelated;
};

class Profile {
    public:
        Profile(Actor *(ActorBuildInfo *), Actors actorId, const char * name, const ActorInfo * info, u32);

        Actor *buildMethod;
        u32 profileId;
        ActorInfo *actorInfo;
        u8 resourceRelated;
        u8 _D;
        u8 _E;
        u8 _F;
        u32 _10;

        static Profile *Get(Actors);
};

class LevelCamera : public sead::IDisposer {
    public:
        static LevelCamera *instance;

        float _10;
        float _14;
        Rect zoneBox;
        Rect someRects[4];
        float cameraWidth;
        float cameraHeight;
        float cameraLeft;
        float cameraCenterX;
        float cameraRight;
        float cameraTop;
        float cameraCenterY;
        float cameraBottom;
        //.... zoom area, scroll limit, etc.
};
class LevelTimer : public sead::IDisposer {
    public:
        static LevelTimer *instance;
        u32 timeLimit;
        u32 startTimeLimit;
        bool hurryUp;
        bool _1D;
        bool _1E;
        bool _1F;

        ~LevelTimer();

        void addSeconds(u32 amount);
};

struct trigStuff {
    u8 stuff[0x30];
};

class ResFile {
    /* Incomplete */
    public:
    virtual void vf0C();
    virtual void vf14();
    virtual void vf1C();
    virtual void vf24();
    virtual void vf2C();
    virtual void vf34();
    virtual void vf3C();
    virtual void vf44();
    virtual void vf4C();
    virtual void vf54();
    virtual void vf5C();
    virtual void vf64();
    virtual void vf6C();
    virtual void vf74();
    virtual void vf7C(trigStuff *);
    virtual void vf84();
    virtual void vf8C(Vec3 *);
    /* ........ */
};

class ResArchive {
    /* Incomplete */
    public:
    ResFile * getResFile(sead::String filename, u32, u32, u32, u32, u32, u32, u32);
};

class ModelAnimBlarg {
    public:
    float _0;
    float _4;
    float _8;
    float _C;
    float frame;
    float _14;
    u32 flags;

    void loadAnim(ResArchive * archive, sead::String * filename);
    void playAnim(ResArchive * archive, sead::String * filename);
    void setRepeat(bool);
};

struct ModelAnimThing {
    u32 _0;
    ModelAnimBlarg **instances;
};

class Model {
    public:
    ResFile *resFile;
    u32 _4;
    ModelAnimThing anim;
    ModelAnimThing _10;
    ModelAnimThing _18;
    ModelAnimThing _20;
    ModelAnimThing _28;

    Model(ResFile * model, u32, u32, u32, u32, u32);
    void setup(ResArchive * archive, u32, u32);
    void update();
};

struct Model2Thing {
    float _0;
    float _4;
    float _8;
    float _C;
    u8 _10;
    u8 _11;
    u8 _12;
    u8 _13;
};

class Model2 : public Model {
    public:
    Model2Thing _30;
    u32 _44;

    Model2(ResFile * model, u32, u32, u32, u32, u32);
    void setup(ResArchive * archive, u32, u32);
    void update();
};

class CharacterModel {
    public:
        u32 _0;
        u32 _4;
        u32 _8;
        u32 _C;
        u32 *resArchive1;
        u32 *resArchive2;
        u32 *otherPtr;
        u32 _1C;
        u32 _20;
        u32 _24;
        u32 _28;
        u32 _2C;
        u32 _30;
        u32 _34;
        u32 _38;
        u32 _3C;
        u32 _40;
        u32 _44;
        u32 _48;
        u32 _4C;
        u32 _50;
        u32 _54;
        u32 _58;
        u32 _5C;
        u32 _60;
        u32 _64;
        u32 _68;
        u32 _6C;
        u32 _70;
        u32 _74;
        u32 _78;
        u32 _7C;
        u32 _80;
        u32 _84;
        u32 _88;
        u32 _8C;
        u32 _90;
        u32 _94;
        u32 _98;
        u32 _9C;
        u32 _A0;
        u32 _A4;
        u32 _A8;
        u32 _AC;
        u32 _B0;
        float _B4;
        float _B8;
        float _BC;
        float _C0;
        u32 _C4;
        u32 _C8;
        u32 _CC;
        u32 _D0;
        u32 _D4;
        u32 _D8;
        u32 _DC;
        u32 _E0;
        u32 _E4;
        u32 _E8;
        u32 _EC;
};

class YoshiModel : public CharacterModel {
    public:
        void loadAnimAndTexture(sead::String *texture, sead::String *anim);
        float _28DD234();
        u32 _28DDEAC(float floatarg);
        bool doSomeCheckRelatedToTongue();
};

class YoshiInteraction {
    public:
        u32 _0;
        u32 _4;
        u32 _8;
        u32 spitType;
        float _10;
        float _14;
        float _18;
        u32 _1C;
        u32 _20;

};

class AdditionalActorHeap : public sead::IDisposer {
    public:
    sead::Heap *heap;
    ~AdditionalActorHeap();
};

class PlatformModel {
    public:
        ResArchive *archive;
        Model *models[3];
        Model *models2[30];
        Vec3 position;
        Vec3 _94;
        Vec3 _A0;
        Vec3 _AC;
        Vec3 _B8;
        Vec3i rotation;
        float fwidth;
        float fwidth2;
        float _D8;
        u32 width;
        PlatformType type;
        float scale;
        u8 _E8;
        u8 _E9;
        u8 _EA;
        u8 _EB;

        void init();
        void update(Vec3 *pos, float width);
        void draw();

        inline PlatformModel() {
            scale = 1.0;
        }
};

class ResLoader {
    public:
        static ResLoader *instance;
        u8 _0[0x4428];

        ResArchive *getResArchive(sead::String filename);
};

class Drawer {
    public:
        static Drawer *instance;
        void drawModel(Model * model);
        void drawTile(u32 tileNumber, Vec3 *pos, u32 *zrot, Vec3 *scale);
};

typedef void (*collisionCallback)(Collider *one, Collider *two);

class EventMgr : sead::IDisposer {
    public:
        static EventMgr *instance;
        u64 events;
        u8 _18[0x940-0x18];
};

class TileMgr : public sead::IDisposer {
    public:
        static TileMgr *instance;

        void *d_bgchk_data;
        float liquidTop;
        float liquidTop2;
        float waveFloats[1280];
        float waveFloats2[1280];
        u8 waveType;
        u8 hasWaves;
        u8 _281E;
        u8 _281F;
        u32 liquidType;

        static u16 *getTilePointer(u16 x, u16 y, u8 layer, u32 *dstBlockIdx);
};

class CollThing {
    public:
        u8 _0[0x18];
        u32 _18;
        u32 _1C;

        CollThing();
};

class OtherColliderBase : public sead::IDisposer {
    public:
    u8 _10[0xC * 8];
    Rect rect;
    Vec2 _80;
    u32 _88;
    u32 _8C;
    u32 _90;
    u32 _94;
    u32 _98;
    u32 _9C;
    u32 _A0;
    u32 _A4;
    u32 _A8;
    Vec2 _AC[6];
    u8 _DC;
    u8 _DD;
    u8 _DE;
    u8 _DF;
    u32 _E0;
    float _E4[4];
    u32 zrot;
    u32 _F8;
    u8 _FC[0xC * 4];
    u32 _12C;
    u32 _130;
    u32 _134;
    u32 _138;
    u32 _13C;
    u32 _140;
    u32 _144;
    u32 _148;
    u32 _14C;
    u32 _150;
    u32 _154;

    OtherColliderBase();

    virtual ~OtherColliderBase();
    virtual bool checkDerivedRuntimeTypeInfo(void *);
    virtual void vf1C(); //deleted
    virtual bool vf24(u32 *, u32);
    virtual void vf2C(); //deleted
    virtual void vf34() = 0;
    virtual void updateMovement() = 0;
    virtual bool vf44(void *, u16 *, Vec2 *, Vec2 *, u32) = 0;
    virtual bool vf4C(void *, Vec2 *, Vec2 *, u32, void *) = 0;
    virtual bool vf54(u8 *, Vec2 *) = 0;
    virtual void vf5C() = 0; //pure, deleted by subclasses
    virtual void vf64();
    virtual void vf6C() = 0;
    virtual void vf74(u32 *) = 0; //u32[2]
    virtual bool vf7C(Vec2 *) = 0;
};

class CustomCollider : public OtherColliderBase {
    public:
    u8 _158[0x18];

    CustomCollider(u32, Vec2 *, CollThing *, CollThing *);

    ~CustomCollider();
    bool checkDerivedRuntimeTypeInfo(void *);
    //bool vf24(u32 *, u32);
    void vf34();
    void updateMovement();
    bool vf44(void *, u16 *, Vec2 *, Vec2 *, u32);
    bool vf4C(void *, Vec2 *, Vec2 *, u32, void *);
    bool vf54(u8 *, Vec2 *);
    void vf5C(); //deleted
    void vf64();
    void vf6C();
    void vf74(u32 *);
    bool vf7C(Vec2 *);
};

struct SolidCollisionInfo {
    float _0[4];
    float _10[4];
    u32 rot;
};

class SolidCollider : public CustomCollider {
    public:
    Vec2 _170[4];
    CollThing _190[4];
    CollThing _210[4];

    inline SolidCollider() : CustomCollider(4, _170, _190, _210) {}

    void init(StageActor *, SolidCollisionInfo *);

    ~SolidCollider();
    bool checkDerivedRuntimeTypeInfo(void *);
    //bool vf24(u32 *, u32);
    bool vf54(u8 *, Vec2 *);
};

struct SolidOnTopCollisionInfo {
    float _0[4];
    float *stuff;
    u32 rot;
};

class SolidOnTopCollider : public OtherColliderBase {
    public:
        u32 _158[2];
        u32 _160[2];
        u32 _168[2];
        u32 _16C;
        float _170;

        SolidOnTopCollider();

        void init(StageActor *, SolidOnTopCollisionInfo *, u32, u32);

        ~SolidOnTopCollider();
        bool checkDerivedRuntimeTypeInfo(void *);
        //bool vf24(u32 *, u32);
        void vf34();
        void updateMovement();
        bool vf44(void *, u16 *, Vec2 *, Vec2 *, u32);
        bool vf4C(void *, Vec2 *, Vec2 *, u32, void *);
        bool vf54(u8 *, Vec2 *);
        void vf5C(); //deleted
        void vf64();
        void vf6C();
        void vf74(u32 *);
        bool vf7C(Vec2 *);
};

class OtherCollisionMgr {
    public:
        static OtherCollisionMgr *instance;
        void add(OtherColliderBase *);
};

struct CollisionInfo {
    float x;
    float y;
    float w;
    float h;
    u32 someKindOfFlag;
    u32 _14;
    u32 _18;
    u32 _1C;
    u32 _20;
    u32 flags;
    collisionCallback callback;
};

class Collider : public sead::IDisposer {
    public:
        u8 _10[0x40 - 0x10];
        StageActor *owner;
        u32 somethingOwnerRelated;
        u32 _48;
        u32 _4C;
        u32 _50;
        Vec2 _54;
        u32 _5C;
        u32 _60;
        u32 _64;
        u32 _68;
        u8 stageActorField57;
        u8 layer;
        u8 flags;
        u8 _6F;
        u32 _70;
        CollisionInfo collisionInfo;
        u8 _A0[0x128 - 0xA0];

        void setup(StageActor *, const CollisionInfo *, u32);

        ~Collider();
};

class CollisionMgr : public sead::IDisposer {
    public:
        static CollisionMgr *instance;
        sead::PtrArrayImpl colliderList1;
        sead::PtrArrayImpl list2;
        sead::PtrArrayImpl list3;
        sead::PtrArrayImpl list4;

        void addCollider(Collider *);
};

class WeirdBase {
    public:
    u8 _0;
    u8 _1;
    u8 _2;
    u8 _3;
    u32 _4;
    u32 _8;
    u32 _C;
    sead::PtrArrayImpl someList;
    u32 someList_C;
    u8 someListBuffer[0xA * 4];
    u32 _48;
};

struct UsedByPhysics {
    u32 _0;
    Physics *physics;
    u32 _8;
};

struct UsedByPhysics2 {
    u32 _0;
    u32 _4;
};

struct UsedByPhysics3 {
    float max1;
    float max2;
    float min1;
    float min2;
};

struct UsedByPhysics4 {
    u8 _0[0x30];
};

class UsedByPhysics5b {
    public:
    u8 _0;
    u8 _1;
    u8 _2;
    u8 _3;
    u32 _4;
    u32 _8;
    Vec2 _C;
    Vec2 _14;
    u32 _1C;
    u32 _20;
    u32 _24;
    u32 _28;
    u32 _2C;
    float _30;
    u32 _34;
};

class UsedByPhysics5a {
    public:
    UsedByPhysics5b _0[6];
};

struct UsedByPhysics5 {
    UsedByPhysics5a _0[4];
};

class Physics : public WeirdBase {
    public:
    void *_4C;
    Physics *self;
    sead::PtrArrayImpl someList2;
    u8 someList2Buffer[0x200 * 4];
    UsedByPhysics _860[4];
    u32 _890;
    u32 _894;
    u32 _898;
    u32 _89C;
    u32 _8A0;
    u32 _8A4;
    u32 _8A8;
    CollisionFlags collisionFlags[2];
    UsedByPhysics3 _8B4[5];
    Vec2 _904;
    float _90C;
    u32 _910;
    u8 _914;
    u8 _915;
    u8 _916;
    u8 _917;
    u8 _918[0x10];
    UsedByPhysics4 _928[3];
    u8 _9B8[0x18];
    u16 _9D0;
    u16 _9D2;
    UsedByPhysics2 _9D4[4];
    u8 _9F4[0x10];
    u8 _A04[0x10];
    u32 _A14;
    UsedByPhysics5 _A18[2];
    u8 _1498[0x20];
    u8 _14B8[0x20];
    u32 _14D8;

    Physics();

    void init(StageActor *, Vec3 *, Vec3 *, Vec3 *);

    virtual void vf0C(); //deleted
    virtual void vf14(); //deleted
    virtual ~Physics();
    virtual void processCollisions();
    virtual void vf2C();
    virtual void vf34();
    virtual u32 vf3C(); //pure
    virtual u32 vf44(void *, u32); //pure
    virtual u32 vf4C(); //pure
    virtual void vf54();
    virtual void vf5C();
    virtual void vf64();
    virtual void vf6C(u32);
};

class ActorPhysics : public Physics {
    public:
    ActorPhysics();

    u32 vf3C();
    u32 vf44(void *, u32);
    u32 vf4C();
};

class PlayerPhysics : public Physics {
    public:
    PlayerPhysics();

    u32 _14E0;
    u32 _14E4;
    u32 _14E8;
    u8 _14EC;
    u8 _14ED;
    u16 _14EE;
    u8 _14F0;
    u8 _14F1;
    u8 _14F2;
    u8 _14F3;
    u32 _14F4;
    u32 _14F8;
    float _14FC;
    float _1500;
    float _1504;
    float _1508;
    float _150C;
    float _1510;
    float _1514;
    float _1518;
    float _151C;
    float _1520;
    u32 _1524;
    UsedByPhysics5b _1528;
    UsedByPhysics5b _1560;
    u32 _1598;
    u32 _159C;

    ~PlayerPhysics();
    void processCollisions();
    void vf2C();
    void vf34();
    u32 vf3C();
    u32 vf44(void *, u32);
    u32 vf4C();
};

extern u32 CurrentStateID;

class StateBase {
    public:
    u32 id;

    virtual ~StateBase();
    virtual u32 getStateId();
};

template <class TOwner>
class State : public StateBase {
    public:
    typedef void (TOwner::*funcptr)();
    State(funcptr begin, funcptr execute, funcptr end) {
        id = ++CurrentStateID;
        beginState = begin;
        executeState = execute;
        endState = end;
    };

    funcptr beginState;
    funcptr executeState;
    funcptr endState;
};

template <class TOwner>
class StateMgrVirt {
    virtual void vf0C(); //deleted;
    virtual void *beginState(State<TOwner> *);
    virtual void endState();
    virtual void *changeState(State<TOwner> *);
    virtual void clearState(void *);
    virtual void beginRelated(void *);
};

template <class TOwner> class StateMgr;

class StateClass {
    public:
    void *stateMgr;
    u32 beginSomething;
    u32 executeSomething;
    u32 defaultSomething;

    void executeState();
};

template <class TOwner>
class StateMgrBase : public StateMgrVirt<TOwner> {
    public:
    void * executeRelated;
    TOwner *owner;
    u32 _C;
    StateClass stateClass;
    u32 _20;
};

template <class TOwner>
class StateMgr : public StateMgrBase<TOwner> {
    public:
        void *_24;
};

class ActorList {
    public:
        u32 maxCount;
        Actor **first;
        u32 usedCount;
        Actor **last;
        u32 actorId;
        u32 _14;

        Actor *findActorById(u32 * id);
};

class ActorMgr : public sead::IDisposer {
    public:
        static ActorMgr *instance;

        void *playerUnitHeap;
        void *actorUnitHeap;
        u8 _18[0x5988-0x18];
        sead::ListImpl createList;
        sead::ListImpl deleteList;
        sead::ListImpl activeActors;
        sead::ListImpl drawnActors;
        u8 _59C8[0x6A20-0x59C8];
        ActorList actorList;
        u8 _6A38[0x6A44-0x6A38];

        Actor *createActor(ActorBuildInfo *, u32);
        Actor **findActorByType(Actors actorId, Actor **);
};

class MovementHandler {
    public:
        Vec3 position;
        Vec3 _C;
        Vec3 _18;
        Vec3 _24;
        u8 _30[8];
        u32 _38;
        u8 _3C[20];
        u32 zRotation;
        u8 _54[12];
        u8 _60[8];
        u8 _68[8];
        u32 _70;
        u32 _74;
        u32 _78;
        u32 _7C;
        u32 _80;
        u8 _84[0x1C];
        u32 _A0;
        u32 _A4;
        u32 _A8;
        u8 _AC[24];
        u8 _C4[12];
        u32 _D0;
        StateMgrBase<MovementHandler> state;

        MovementHandler();

        u32 getMaskForMovementType(MovementType type);
        void linkToMovementController(Vec3 *actorPos, u32 typeMask, u8 movementId);
        void execute();
};

class Actor {
    public:
        void * heap;
        u32 id;
        Profile *profile;
        bool wasNotDefered;
        bool isSprite;
        bool created;
        bool deleted;
        u32 settings;       // Nybble 5 - 12
        u32 settings2;      // Nybble 13 - 20
        u8 movementId;      // Nybble 21 - 22
        u8 linkId;          // Nybble 23 - 24
        u8 initStateFlag;   // Spritedata + 0x14
        sead::ListImpl childList;
        sead::ListNode childNode;
        Actor *parent;
        sead::ListNode actorListNode;
        sead::ListNode drawListNode;
        u32 _48;

        Actor(ActorBuildInfo *);

        void removeChild(Actor *);

        virtual bool checkDerivedRuntimeTypeInfo(void *);
        virtual void vf14(); //deleted
        virtual ~Actor();

        virtual int beforeCreate();
        virtual int onCreate();
        virtual void afterCreate(int);

        virtual int beforeExecute();
        virtual int onExecute();
        virtual void afterExecute(int);
        virtual void finalExecute();

        virtual int beforeDraw();
        virtual int onDraw();
        virtual void afterDraw(int);

        virtual int beforeDelete();
        virtual int onDelete();
        virtual void afterDelete(int);
};

class StageActor : public Actor {
    public:
        Direction direction;
        u8 playerId;
        u8 _55;
        u8 layer;
        u8 _57;
        float XSpeed;
        float TargetXspeed_maybe;
        float Fallspeed;
        float gravity;
        float XAccel;
        Vec3 position;
        Vec3 speed;
        Vec3 maxSpeed;
        Vec3 scale;
        Vec3i rotation;
        u32 _A8;
        u32 _AC;
        u32 _B0;
        Vec2 posDelta;
        Collider collider;
        Rect rect;
        float _1F4;
        float _1F8;
        u32 _1FC;
        u32 _200;
        u32 _204;
        u32 _208;
        u8 zone;
        PlayerType playerType;
        u8 isActive;
        u8 isVisible;
        u8 _210;
        u8 _211;
        u8 _212;
        u8 eventID_3_4;
        u8 eventID_1_2;
        u8 _215;
        u8 actorInfoFlags;
        u8 _217;
        u32 _218;
        u32 _21C;
        u32 _220;
        u32 _224;
        u32 _228;
        u32 _22C;
        u32 profile0x10;
        Vec3 sizeRelated;
        Vec3 position2;
        Vec3 position3;
        Vec3 position4;
        YoshiInteraction *yoshiInteraction;
        u32 _268;
        u32 _26C;
        u32 _270;
        u32 _274;
        u8 *_278;

        StageActor(ActorBuildInfo *);

        Direction getDirectionToPlayer(Vec3 *);

        bool checkDerivedRuntimeTypeInfo(void *);
        ~StageActor();
        void afterCreate(int);
        int beforeExecute();
        void afterExecute(int);
        int beforeDraw();

        virtual void setPlayerId(u8);
        virtual void removeColliders();
        virtual void addColliders();
        virtual Physics * getPhysics();
        virtual void vfAC();
        virtual u32 vfB4();
        virtual void vfBC();
        virtual void vfC4();
        virtual void vfCC();
        virtual void vfD4();
        virtual void splashWater(Vec3);
        virtual void splashLava(Vec3);
        virtual void splashLava2(Vec3);
        virtual void splashPoison(Vec3);
        virtual bool isOffScreen();
        virtual void vf104();
};

class PhysicsActor : public StageActor {
    public:
    u32 _27C;
    ActorPhysics physics;
    u32 _1760;
    u32 _1764;
    Vec3 * positionPtr;
    u8 _176C;
    u8 _176D;
    u8 _176E;
    u8 _176F;
    u32 mightBeTileRelated;
    u32 _1774;
    u32 _1778;
    u32 _177C;
    u32 _1780;
    u32 _1784;
    float maxYSpeed;
    float minYSpeed;
    float pgravity;
    u8 _1794;
    u8 _1795;
    bool hasYSpeedLimitation;
    u8 _1797;
    u8 _1798;
    u8 _1799;
    u8 _179A;
    u8 _179B;
    u32 _179C;

    PhysicsActor(ActorBuildInfo *);

    void applyGravity();

    bool checkDerivedRuntimeTypeInfo(void *);
    ~PhysicsActor();
    void afterCreate(int);
    int beforeExecute();
    void afterExecute(int);
    int onDelete();

    void setPlayerId(u8);
    Physics *getPhysics();
    void vfAC();
    u32 vfB4();
    void vfBC();
    void vfC4();
    void vfCC();
    void vf104();

    virtual void vf10C(u8);
    virtual void vf114(); //deleted
    virtual void vf11C();
    virtual void vf124();
    virtual u32 vf12C();
    virtual void vf134(); //deleted
    virtual u32 vf13C();
    virtual void vf144();
    virtual void vf14C();
    virtual u32 vf154();
    virtual void move(Vec2 *);
    virtual void setYSpeed(float);
    virtual u32 vf16C();
    virtual u32 vf174();
    virtual void getRect(Rect *);

};

class StateActor : public PhysicsActor {
    public:
    StateMgr<StateActor> stateMgr;

    StateActor(ActorBuildInfo *);

    bool checkDerivedRuntimeTypeInfo(void *);
    ~StateActor();

    void setPlayerId(u8);
    Physics *getPhysics();
    void vfAC();
    u32 vfB4();
    void vfBC();
    void vfC4();
    void vfCC();
    void vf104();

    void vf10C(u8);
    void vf11C();
    void vf124();
    u32 vf12C();
    u32 vf154();
    void move(Vec2 *);
    void setYSpeed(float);
    u32 vf16C();
    u32 vf174();
    void getRect(Rect *);

    virtual void doStateChange(StateBase *);
};

struct IceInfo {
    u32 _0;
    float X;
    float Y;
    float Z;
    float _10;
    float _14;
    float _18;
    u32 _1C;
};

class IceActorMgr {
    public:
    u32 _0;
    u32 _4[0xC];
    u8 _34;
    u8 _35;
    u8 _36;
    u8 _37;
    u32 _38;
    Enemy *owner;
    u16 _40;
    u16 _42;
    u8 _44;
    u8 _45;
    u8 _46;
    u8 _47;
    u8 _48;
    u8 _49;
    u8 _4A;
    u8 _4B;
    u8 _4C;
    u8 _4D;
    u8 _4E;
    u8 _4F;

    bool freezeActor(IceInfo *, u32);
};

class EnemyClass2Base {
    public:
    Enemy *owner;
    u32 _4;
    u32 _8;
    u32 _C;
    u32 _10;
    u32 _14;
    void *_18;

    virtual void vf0C(u32); //calls vf35C on parent
    virtual void vf14(u32); //calls vf364 on parent
    virtual void vf1C(u32); //calls vf36C on parent
    virtual void vf24(u32);    //calls vf374 on parent
};

class EnemyClass2 : public EnemyClass2Base {
    public:
    void vf0C(u32);
    void vf14(u32);
    void vf1C(u32);
    void vf24(u32);
};

class Enemy : public StateActor {
    public:
    u32 _17C8;
    u32 _17CC;
    float _17D0;
    float _17D4;
    u32 _17D8;
    u32 _17DC;
    u8 _17E0;
    u8 _17E1;
    u8 _17E2;
    u8 _17E3;
    u16 _17E4[4];
    u32 _17EC;
    IceActorMgr iceMgr;
    EnemyClass2 _1840;
    Enemy *self;
    void *_1864;
    u8 _1868;
    u8 _1869;
    u8 _186A;
    u8 _186B;
    u16 _186C;
    u16 _186E;
    u32 _1870;
    u8 _1874;
    u8 _1875;
    u8 _1876;
    u8 _1877;
    u32 _1878;
    u8 _187C;
    u8 _187D;
    u8 _187E;
    u8 _187F;

    static void collisionCallback(Collider *, Collider *);

    void killWithPlayer(Player *, Vec2 *, State<Enemy> *);
    void spinJumpKill(Player *);
    void killWithYoshi(Yoshi *);
    HitType processHit(u32, Collider *);
    void updatePosition();

    Enemy(ActorBuildInfo *);

    bool checkDerivedRuntimeTypeInfo(void *);
    ~Enemy();
    int beforeExecute();

    void setPlayerId(u8);
    Physics *getPhysics();
    void vfAC();
    u32 vfB4();
    void vfBC();
    void vfC4();
    void vfCC();
    void vf104();

    void vf10C(u8);
    void vf11C();
    void vf124();
    u32 vf12C();
    void vf14C();
    u32 vf154();
    void move(Vec2 *);
    void setYSpeed(float);
    u32 vf16C();
    u32 vf174();
    void getRect(Rect *);

    void doStateChange(StateBase *);

    virtual u32 vf18C();
    virtual void playerCollision8A4(u32, Collider *);
    virtual bool vf19C(u8); //Uses _1878
    virtual bool freezeActor();
    virtual void vf1AC(); //nullsub
    virtual void vf1B4(); //nullsub
    virtual void vf1BC();
    virtual void vf1C4(); //nullsub
    virtual u32 vf1CC();
    virtual bool vf1D4(u32, void *); //calls hitEnemyKameDown
    virtual bool playerRelated(void *, void *);
    virtual bool vf1E4(u32, u32, void *);
    virtual void vf1EC(); //nullsub
    virtual bool vf1F4(void *, void *);
    virtual bool vf1FC(void *, void *);
    virtual bool vf204(void *, void *);
    virtual void vf20C(); //nullsub
    virtual void playerCollision(u32, Collider *);
    virtual void yoshiCollision(u32, Collider *);
    virtual void vf224(); //nullsub
    virtual void vf22C(); //calls vf2CC
    virtual bool hitJump(Collider *, Collider *);
    virtual bool collidesSomething(Collider *, Collider *); //calls playDownSoundHpdp and vf344
    virtual bool hitEnemyDown(Collider *, Collider *);
    virtual bool hitGroundPound(Collider *, Collider *);
    virtual bool hitYoshi(Collider *, Collider *);
    virtual bool hitEnemyKame2(Collider *, Collider *);
    virtual bool hitEnemyKame3(Collider *, Collider *);
    virtual bool callsHitJump(Collider *, Collider *);
    virtual bool hitEnemyKameDown(Collider *, Collider *);
    virtual bool vf27C(); //calls playDownSound;
    virtual bool vf284();
    virtual bool hitNormal(Collider *, Collider *); //calls playDownSound
    virtual bool hitEnemyKame4(Collider *, Collider *);
    virtual u32 vf29C();
    virtual u32 goldYoshiHit(Collider *self, Collider *other);
    virtual void calls_vf2CC_2();
    virtual bool vf2B4(u8 *);
    virtual void hitEx();
    virtual void vf2C4();
    virtual bool hitEnemyKame5(Collider *, Collider *); //calls vf8DC
    virtual bool isGrounded();
    virtual void playDownSound();
    virtual void playDownSoundHpdp();
    virtual void vf2EC(u32);
    virtual void vf2F4();
    virtual void vf2FC(u32); //calls vf2EC
    virtual void calls_vf2F4();
    virtual void vf30C(u32);
    virtual void playFumuSound();
    virtual void playerHit(PlayableBase *);
    virtual void playDownSpinSound();
    virtual void playMameStepSound();
    virtual void vf334(); //nullsub
    virtual void playYoshiFumuSound();
    virtual void spawnHipDropHitEffect();
    virtual void increaseYSpeed();
    virtual bool positionRelated();
    virtual void vf35C(void *);
    virtual void vf364(void *);
    virtual void vf36C(void *);
    virtual void vf374(); //nullsub
    virtual void beginState_JumpKill();
    virtual void executeState_JumpKill();
    virtual void endState_JumpKill(); //nullsub
    virtual void beginState_FireballKill(); //calls physicsRelated
    virtual void executeState_FireballKill();
    virtual void endState_FireballKill(); //nullsub
    virtual void beginState_YoshiStamp();
    virtual void executeState_YoshiStamp();
    virtual void endState_YoshiStamp(); //nullsub
    virtual void beginState_EnemyState11();
    virtual void executeState_EnemyState11();
    virtual void endState_EnemyState11(); //nullsub
    virtual void beginState_EnemyState12();
    virtual void executeState_EnemyState12();
    virtual void endState_EnemyState12(); //nullsub
    virtual void beginState_EnemyState13();
    virtual void executeState_EnemyState13(); //nullsub
    virtual void endState_EnemyState13(); //nullsub
    virtual void beginState_ChallengeRelated(); //calls vf94 and deletes itself
    virtual void executeState_ChallengeRelated(); //nullsub
    virtual void endState_ChallengeRelated(); //nullsub
    virtual void beginState_EnemyState2();
    virtual void executeState_EnemyState2();
    virtual void endState_EnemyState2(); //nullsub
    virtual void beginState_EnemyState3(); //nullsub
    virtual void executeState_EnemyState3(); //nullsub
    virtual void endState_EnemyState3(); //nullsub
    virtual void beginState_EnemyState4(); //nullsub
    virtual void executeState_EnemyState4(); //nullsub
    virtual void endState_EnemyState4(); //nullsub
    virtual void beginState_EnemyState5();
    virtual void executeState_EnemyState5(); //switches to EnemyState6
    virtual void endState_EnemyState5(); //nullsub
    virtual void beginState_EnemyState6(); //nullsub
    virtual void executeState_EnemyState6(); //nullsub
    virtual void endState_EnemyState6(); //nullsub
    virtual void beginState_EnemyState7(); //nullsub
    virtual void executeState_EnemyState7(); //nullsub
    virtual void endState_EnemyState7(); //nullsub
    virtual void beginState_EnemyState8(); //nullsub
    virtual void executeState_EnemyState8(); //nullsub
    virtual void endState_EnemyState8(); //nullsub
    virtual void beginState_PenguinIceHit();
    virtual void executeState_PenguinIceHit();
    virtual void endState_PenguinIceHit();

    static State<Enemy> StateID_JumpKill;
    static State<Enemy> StateID_FireballKill;
    static State<Enemy> StateID_YoshiStamp;
    static State<Enemy> StateID_EnemyState11;
    static State<Enemy> StateID_EnemyState12;
    static State<Enemy> StateID_EnemyState13;
    static State<Enemy> StateID_ChallengeRelated;

    static State<Enemy> StateID_EnemyState2;
    static State<Enemy> StateID_EnemyState3;
    static State<Enemy> StateID_EnemyState4;
    static State<Enemy> StateID_EnemyState5;
    static State<Enemy> StateID_EnemyState6;
    static State<Enemy> StateID_EnemyState7;
    static State<Enemy> StateID_EnemyState8;
    static State<Enemy> StateID_PenguinIceHit;
};

class SomeKindOfSoundRelatedClass {
    /* incomplete */
    public:
    u8 _[0x11C];
};

class Boss : public Enemy {
    public:
    u32 _1880;
    u32 _1884;
    u32 _1888;
    u8 _188C;
    u8 _188D;
    u8 _188E;
    u8 _188F;
    u8 _1890[0x10];
    SomeKindOfSoundRelatedClass _18A0;
    u16 _19BC;
    u16 _19BE;
    u8 _19C0[0x2C]; //class sub_200C94C
    Vec3 _19EC;
    float _19F8;
    u32 _19FC;
    u32 _1A00;
    u32 _1A04;
    void * _1A08;
    Collider _1A0C;
    void * _1B34; //some kind of vtable
    Vec3 _1B38;
    Vec3 _1B44;
    Vec3 _1B50;
    Vec3 _1B5C;
    float _1B68;
    float _1B6C;
    u32 _1B70;
    u32 _1B74;

    Boss(ActorBuildInfo *);

    bool checkDerivedRuntimeTypeInfo(void *);
    ~Boss();
    int onCreate();
    int beforeExecute();
    void afterExecute(int);
    int onDelete();

    void setPlayerId(u8);
    void removeColliders();
    void addColliders();
    Physics *getPhysics();
    void vfAC();
    u32 vfB4();
    void vfBC();
    void vfC4();
    void vfCC();

    void vf10C(u8);
    void vf11C();
    void vf124();
    u32 vf12C();
    u32 vf154();
    void move(Vec2 *);
    void setYSpeed(float);
    u32 vf16C();
    u32 vf174();
    void getRect(Rect *);

    u32 vf18C();
    bool freezeActor();
    void vf1BC();
    void vf1C4(); //Calls vf7E4
    void playerCollision(u32, Collider *);
    void yoshiCollision(u32, Collider *);
    void vf22C();
    bool hitJump(Collider *, Collider *);
    bool collidesSomething(Collider *, Collider *);
    bool hitEnemyDown(Collider *, Collider *);
    bool hitGroundPound(Collider *, Collider *);
    bool hitEnemyKame2(Collider *, Collider *);
    bool hitEnemyKameDown(Collider *, Collider *);
    bool vf27C(); //plays "SE_OBJ_FIREBALL_DISAPP"
    bool vf284();
    void hitEx();
    void vf2C4();
    bool isGrounded();
    void vf2F4();
    void beginState_JumpKill();
    void executeState_JumpKill();
    void endState_JumpKill();

    virtual void beginState_BossState1(); //calls JumpKill methods
    virtual void executeState_BossState1();
    virtual void endState_BossState1();
    virtual void beginState_BossState2(); //calls JumpKill methods
    virtual void executeState_BossState2();
    virtual void endState_BossState2();
    virtual void beginState_BossState3(); //calls JumpKill methods
    virtual void executeState_BossState3();
    virtual void endState_BossState3();
    virtual void beginState_BossState4(); //calls JumpKill methods
    virtual void executeState_BossState4();
    virtual void endState_BossState4();
    virtual void beginState_BossState5(); //calls JumpKill methods
    virtual void executeState_BossState5();
    virtual void endState_BossState5();
    virtual void vf55C(); //enables flag 188D
    virtual void vf564(); //disables flag 188D
    virtual void vf56C(); //nullsub
    virtual void vf574();
    virtual void vf57C(); //nullsub
    virtual void vf584(); //deleted
    virtual u8 vf58C();
    virtual void vf594();
    virtual void vf59C(); //deleted
    virtual void vf5A4(); //deleted
    virtual void vf5AC(); //deleted
    virtual u32 vf5B4();
    virtual void vf5BC(u32); //subtracts arg1 from field_1880
    virtual u32 vf5C4() = 0;
    virtual u32 vf5CC() = 0;
    virtual u32 vf5D4() = 0;
    virtual u32 vf5DC() = 0;
    virtual u32 vf5E4() = 0;
    virtual u32 vf5EC() = 0;
    virtual u32 vf5F4() = 0;
    virtual u32 vf5FC() = 0;
    virtual void vf604(); //nullsub
    virtual void vf60C(); //nullsub
    virtual void vf614(); //nullsub
    virtual u32 vf61C(); //returns 0x18
    virtual void vf624(); //deleted
    virtual u32 vf62C(); //returns 0x18
    virtual void vf634(StageActor *);
    virtual void vf63C(StageActor *);
    virtual void vf644(); //Searches actor "Register for Fever -" and calls vfD4 on it
    virtual void vf64C(u32); //Calls lots of virtual functions
    virtual void vf654(); //nullsub
    virtual void changeState_JumpKill();
    virtual void vf664(); //nullsub
    virtual void changeState_State1();
    virtual void vf674(); //calls vf654
    virtual void vf67C(); //calls changeState_JumpKill
    virtual void vf684(); //deleted
    virtual void vf68C(); //deleted
    virtual void vf694(); //deleted
    virtual void vf69C(); //deleted
    virtual void vf6A4(); //nullsub
    virtual void changeState_State5();
    virtual void vf6B4(); //nullsub
    virtual void changeState_State3();
    virtual void vf6C4(); //deleted
    virtual void vf6CC(); //deleted
    virtual u32 vf6D4();
    virtual void vf6DC(); //nullsub
    virtual void vf6E4(); //calls vf574
    virtual u32 vf6EC();
    virtual u32 vf6F4();
    virtual u32 vf6FC();
    virtual u32 vf704();
    virtual void vf70C(); //deleted
    virtual void vf714(); //deleted
    virtual void vf71C(); //deleted
    virtual u32 vf724(); //nullsub
    virtual u32 vf72C(); //nullsub
    virtual u32 vf734(); //nullsub
    virtual void vf73C(); //deleted
    virtual u32 vf744(); //nullsub
    virtual void stomp();
    virtual void lastStomp();
    virtual void vf75C(); //deleted
    virtual void damageStar();
    virtual void vf76C(); //deleted
    virtual void damageLast();
    virtual void damageFire();
    virtual void damageFireLast();
    virtual void damageFire2();
    virtual void damageFireLast2();
    virtual void damageStarDef();
    virtual void damageLast2();
    virtual void vf7AC(); //nullsub
    virtual void vf7B4(); //deleted
    virtual void vf7BC(); //deleted
    virtual void vf7C4(); //does some position stuff
    virtual u32 vf7CC();
    virtual void initBossCollider();
    virtual void initModels();
    virtual void vf7E4();
    virtual void vf7EC();
    virtual void vf7F4();
    virtual int onBossCreate();

    static State<Boss> StateID_JumpKill;

    static State<Boss> StateID_BossState1;
    static State<Boss> StateID_BossState2;
    static State<Boss> StateID_BossState3;
    static State<Boss> StateID_BossState4;
    static State<Boss> StateID_BossState5;
};

class SoundActor : public nw::snd::SoundActor {
    public:
    u32 _64;
    u32 _68;
    u32 _6C;
    u32 _70;
};

class UsedBySoundRelatedClass : public sead::IDisposer {
    public:
    u32 _10;
    float _14;
};

class SoundRelatedClass : public SoundActor {
    public:
    float _74;
    u32 _78;
    float _7C;
    float _80;
    UsedBySoundRelatedClass _84[6];
    u32 _114[2];
};

class UnknownClass : sead::IDisposer {
    u32 _10;
    Vec2 _14;
    u32 _1C;
    u32 _20;
    u32 _24;
    u32 _28;
};

class UnknownClass2 : sead::IDisposer {
    u8 blarg[0x68 - 0x10];
};

template <u32 count>
class PlayableBaseList {
    public:
    u32 * pointerToField10;
    u32 countOfField10;
    u32 _8;
    u32 _C;
    u32 _10[count];
};

class UsedByPlayableBase {
    public:
    u32 _0;
    u32 _4;
    u32 _8;
    u32 _C;
    PlayableBaseList<10> _10;
    PlayableBaseList<10> _48;
    u32 _80;
    u32 _84;
    u8 _88;
    u8 _89;
    u8 _8A;
    u8 _8B;
    u32 _8C;
    u32 _90;
};

class UsedByPlayableBase2 {
    u8 _0[8];
    Vec3 _8;
    u8 _14;
    u8 _15;
    u8 _16;
    u8 _17;
};

class UsedByPlayableBase3 {
    u8 _0[0x30];
    u32 _30;
    u32 _34;
    u32 _38;
    u32 _3C;
};

class PlayableBase : public StageActor {
    public:
        u32 _27C;
        u32 modelRelated;
        Vec3 _284;
        u32 _290;
        u32 _294;
        Vec3 playerPos;
        u32 _2A4;
        UsedByPlayableBase _2A8;
        SoundRelatedClass _33C;
        u32 _458;
        u32 _45C;
        u8 _460;
        u8 _461;
        u8 _462;
        u8 _463;
        UnknownClass _464;
        u8 _490[0x24];
        float _4B4;
        u32 _4B8;
        Vec3 _4BC;
        Vec3 _4C8;
        u32 _4D4;
        u32 _4D8;
        u32 _4DC;
        u32 _4E0;
        float _4E4;
        u8 _4E8;
        u8 _4E9;
        u8 _4EA;
        u8 _4EB;
        Vec3 _4EC;
        u8 _4F8;
        u8 _4F9;
        u8 _4FA;
        u8 _4FB;
        u32 nybble10;
        Powerup powerup;
        u32 _504;
        PlayerPhysics physics;
        u8 _1AA8[0xC];
        u8 _1AB4[0xC];
        u8 _1AC0[0xC];
        u8 _1ACC[0xC];
        u8 _1AD8[0xC];
        u8 _1AE4[0x28];
        float _1B0C;
        float _1B10;
        u32 _1B14;
        u32 _1B18;
        u32 _1B1C;
        u32 _1B20;
        u32 _1B24;
        Vec3 _1B28;
        u32 terrainType;
        u32 _1B38;
        float _1B3C;
        float _1B40;
        u32 _1B44;
        u32 _1B48;
        Vec3 _1B4C;
        u32 _1B58;
        float _1B5C;
        Vec2 _1B60;
        Vec2 _1B68;
        float _1B70;
        float _1B74;
        u8 _1B78;
        u8 _1B79;
        u8 _1B7A;
        u8 _1B7B;
        u32 _1B7C;
        PlayableBaseList<2> _1B80;
        u32 _1B98;
        u32 _1B9C;
        u32 _1BA0;
        float _1BA4;
        float _1BA8;
        float _1BAC;
        float _1BB0;
        u32 _1BB4;
        Collider _1BB8;
        Collider _1CE0;
        Collider _1E08;
        Collider _1F30;
        void *_2058; //vtable of some kind
        u32 _205C;
        u32 _2060;
        u32 _2064;
        u32 _2068;
        u32 _206C;
        u32 _2070;
        float _2074;
        float _2078;
        float _207C;
        float _2080;
        u8 _2084;
        u8 _2085;
        u8 _2086;
        u8 _2087;
        u32 _2088;
        u32 _208C;
        u32 _2090;
        u32 _2094;
        float _2098;
        u32 _209C;
        u32 _20A0;
        u8 _20A4[8];
        u8 _20AC[8];
        StateMgrBase<PlayableBase> state1;
        u32 _20D8;
        u32 _20DC;
        u32 _20E0;
        u32 _20E4;
        u32 _20E8;
        u32 _20EC;
        u32 _20F0;
        u32 _20F4;
        u32 _20F8;
        u32 _20FC;
        u8 _2100[8];
        u8 _2108[8];
        Vec3 playerPos2;
        u8 _211C;
        u8 _211D;
        u8 _211E;
        u8 _211F;
        float _2120;
        float _2124;
        u32 _2128;
        u32 _212C;
        float _2130;
        u32 _2134;
        u32 _2138;
        u8 _213C[0xC];
        u32 _2148;
        u32 _214C;
        u32 _2150;
        u8 _2154[0xC];
        u8 _2160[0xC];
        u8 _216C[8];
        u32 _2174;
        float _2178;
        float _217C;
        u32 _2180;
        u32 _2184;
        u32 _2188;
        u8 _218C;
        u8 _218D;
        u8 _218E;
        u8 _218F;
        float _2190;
        u32 _2194;
        u8 _2198;
        u8 _2199;
        u8 _219A;
        u8 _219B;
        StateMgrBase<PlayableBase> state2;
        u32 _21C0;
        u32 _21C4;
        u32 _21C8;
        u32 _21CC;
        u32 _21D0;
        u32 yoshiActorId;
        u32 _21D8;
        u32 _21DC;
        u32 _21E0;
        u32 _21E4;
        u32 _21E8;
        u32 _21EC;
        Vec2 _21F0;
        float _21F8;
        u8 _21FC[0xC];
        u8 _2208[0xC];
        u32 _2214;
        float _2218;
        u32 _221C;
        u32 _2220;
        u32 _2224;
        u32 _2228;
        UnknownClass2 _222C;
        UnknownClass2 _2294;
        UnknownClass2 _22FC;
        UnknownClass2 _2364;
        UnknownClass2 _23CC;
        u8 _2434[0x30];
        u8 _2464[0x10];
        u8 _2474[0xC];
        UsedByPlayableBase2 _2480;
        UnknownClass2 _2498;
        UnknownClass2 _2500;
        u8 _2568[0x30];
        u8 _2598[0x10];
        u8 _25A8[0x30];
        u8 _25D8[0x10];
        u32 _25E8;
        u8 _25EC;
        u8 _25ED;
        u8 _25EE;
        u8 _25EF;
        u32 _25F0;
        UnknownClass2 _25F4;
        u32 _265C;
        u32 _2660;
        UsedByPlayableBase3 _2664[3];
        StateMgrBase<PlayableBase> state3;
        u32 _2748;
        u8 _274C;
        u8 _274D;
        u8 _274E;
        u8 _274F;

        bool usedByGoalPole();

        PlayableBase(ActorBuildInfo *);

        bool checkDerivedRuntimeTypeInfo(void *);
        ~PlayableBase();
        int onCreate();
        int beforeExecute();
        int onExecute();
        void afterExecute(int);
        int beforeDraw();

        void setPlayerId(u8);
        Physics * getPhysics();
        void vfAC();
        u32 vfB4();
        void vfBC();
        void vfC4();
        void vfCC();
        void vf104();
        // TODO: more virtual methods

        void playSound(char *name, bool unk);
        void handleGroundPound();
        void playLandSound();

        void _28C12C8();
        void _28C17A0();
        void _28C1878();
        void _291F218();

};

class Player : public PlayableBase {
    // Incomplete
    public:
        u8 unkblob[0x34D8-0x2750];
};

class Yoshi : public PlayableBase {
    // Incomplete
    public:
        u32 actorIdInMouth;
        u32 _2754;
        YoshiModel *yoshiModel;

        // A bunch of unknowns
        u32 _275C;
        u32 _2760;
        u32 _2764;
        u32 _2768;
        u32 _276C;
        u32 _2770;
        u32 _2774;
        u32 _2778;
        u32 _277C;
        u32 _2780;
        u32 _2784;
        u32 _2788;
        u32 _278C;
        s32 _2790;
        Direction _2794;
        u32 tongueState;
        u32 _279C;
        float _27A0;
        float _27A4;
        u32 _27A8;
        u32 _27AC;
        u32 _27B0;
        u32 _27B4;
        u8 _27B8;
        u8 _27B9;
        u8 _27BA;
        u8 _27BB;
        u32 _27BC;
        u8 _27C0;
        u8 _27C1;
        u8 _27C2;
        u8 _27C3;
        u32 _27C4;
        float _27C8;
        u8 _27CC;
        u8 _27CD;
        u8 _27CE;
        u8 _27CF;
        u32 _27D0;
        u32 _27D4;
        u8 _27D8;
        u8 _27D9;
        u8 _27DA;
        u8 _27DB;
        u32 _27DC;
        u8 _27E0;
        u8 _27E1;
        u8 _27E2;
        u8 _27E3;
        u32 _27E4;
        u32 _27E8;
        u32 _27EC;
        u32 _27F0;
        u32 _27F4;
        u32 _27F8;
        u32 _27FC;
        u32 _2800;
        u32 _2804;
        u32 _2808;
        u32 _280C;
        u32 _2810;
        u32 _2814;
        u32 _2818;
        u32 _281C;
        u32 _2820;
        u32 _2824;
        u32 _2828;
        u32 _282C;
        u32 _2830;
        u32 _2834;
        u32 _2838;
        u32 _283C;
        u32 _2840;
        u32 _2844;
        u32 _2848;
        u32 _284C;
        u32 _2850;
        u32 _2854;
        u32 _2858;
        u32 _285C;
        u32 _2860;
        u32 _2864;
        u32 _2868;
        u32 _286C;
        u32 _2870;
        u32 _2874;
        u32 _2878;
        u32 _287C;
        u32 _2880;
        u32 _2884;
        u32 _2888;
        u32 _288C;
        u32 _2890;
        u32 _2894;
        u32 _2898;
        u32 _289C;
        u32 _28A0;
        u32 _28A4;
        u32 _28A8;
        u32 _28AC;
        u32 _28B0;
        u32 _28B4;
        u32 _28B8;
        u32 _28BC;
        u32 _28C0;
        u32 _28C4;
        u32 _28C8;
        u32 _28CC;
        u32 _28D0;
        u32 _28D4;
        u32 _28D8;
        u32 _28DC;
        u32 _28E0;
        u32 _28E4;
        u32 _28E8;
        u32 _28EC;
        u32 _28F0;
        u32 _28F4;
        u32 _28F8;
        u32 _28FC;
        u32 _2900;
        u32 _2904;
        u32 _2908;
        u32 _290C;
        u32 _2910;
        u32 _2914;
        u32 _2918;
        u32 _291C;
        /*** ADDED FIELDS START ***/
        u8 stompCount;
        bool hasYellowShell;
        /*** ADDED FIELDS END ***/

        void scheduleSpawnBall(bool ice); // Iceball if true, Fireball if false
        u32 getActorIdInMouth();
        void changeState(State<Yoshi> *state);
        StageActor *getMouthContents();

        // Tongue functions
        void extendTongue();
        void handleUnknown();
        void handleTongueExtend();
        void handleScreableBeingEaten();
        void handleEdibleBeingEaten();
        void handleBerryBeingEaten();
        void handleTongueContract();

        void hideActorInMouth();

        void vf5EC();
        void vf604();
        void vf64C();
        void vf694();

        static State<Yoshi> StateID_DefaultState;
};

class YoshiEgg : public StateActor {
    // Incomplete
    public:
        u8 _17C8[0x30];
        u32 colour;
};

class TerrainEffects {
    // Incomplete
    public:
    void *renderer;
    u32 _4;
    Vec3 position;
    u8 _14[12];
    Vec3 _20;
    u8 _2C[48];
    u8 _5C[48];
    u32 width;
    u32 _90;
    u32 _94;
    u32 _98;
    u32 _9C;
    u32 _A0;
    u32 _A4;
    u32 _A8;
    u32 _AC;
    u32 _B0;
    u32 _B4;
    u32 _B8;
    u32 _BC;
    u32 _C0;
    u32 waveSpeed;
    u32 waveAnimSpeed;
    u32 _CC;
    u32 _D0;
    u32 waveWidth;
    u32 waveType;
    u32 waveHeight;
    u32 waveEffectHeight;
    TerrainType type;
    u8 noLocation;
    u8 _E6;
    u8 _E7;
    u8 data[0xF8F4 + 0x658 - 0xE8];

    void init(Vec3 *pos, float width, bool noLoc, bool layer0, TerrainType type, sead::Heap *heap);
    void setWaveValues(u32 h, u32 eftHeight, u32 spd, u32 anmSpeed, u32 w, u32 eft);
    void checkMarioWaveHit();
    void updateWaveCollisions();
};

class EnvTerrain : public StateActor {
    public:
        u32 _17C8;
        u32 _17CC;
        Vec3 _17D0;
        Vec3 _17DC;
        SolidCollider collision;
        u8 _1A78[4 * 8];
        u32 _1A98;
        Vec2 _1A9C;
        u32 _1AA4;
        u32 _1AA8;
        float _1AAC;
        float _1AB0;
        float riseTop;
        float _1AB8;
        float _1ABC;
        float _1AC0;
        float risingSpeed;
        float _1AC8;
        float currentHeight;
        u32 _1AD0;
        u32 _1AD4;
        u16 _1AD8;
        u16 loweringDelay;
        bool onlyRenderWaves;
        u8 _1ADD;
        u8 _1ADE;
        u8 _1ADF;
        u32 _1AE0;
        TerrainEffects terrain;

        sead::IDisposer disposer;
        sead::Heap *additionalHeap;
        u32 _11A44;
        u64 eventMask;
        u32 _11A50;
        u32 _11A54;
        u64 eventMask2;
        u32 _11A60;
        float risingHeight;
        float _11A68;
        u32 _11A6C;
        u32 _11A70;
        u32 _11A74;

        EnvTerrain(ActorBuildInfo *);

        void setTop(float top);

        /*** Added hacks ***/
        DECLARE_STATE(EnvTerrain, FollowRaft)
        /*** *** *** *** ***/
};

class PlayerMgr : public sead::IDisposer {
    public:
        static PlayerMgr *instance;

        u8 _10[0x20 - 0x10];
        Player *players[4];
        /* incomplete */
};

class EnemyCounter {
    /* incomplete */
    public:
        static EnemyCounter *instance;

        void killEnemiesGoal();
};

class BasicSoundActor {
    /* incomplete */
    public:
        static BasicSoundActor *instance;

        void playSound(const char *, Vec2 *, u32);
};

class SoundSystem {
    /* incomplete */
    public:
        static SoundSystem *instance;

        void playSound(const char *, u32);
};

extern u8 fileCounts[];
extern const sead::String *fileLists[];
extern u32 directionToRotationList[];
extern Actors spriteToActorList[];

void trigRelated(trigStuff *, Vec3i *, Vec3 *);
void mapPosToScreen(Vec2 *, Vec2 *);
void spawnEffect(Effects effect, Vec3 *pos, Vec3 *rot, Vec3 *scale);

// Unkown functions
u32 unknown0(u32 yoshi_actorIdInMouth);
u32 unknown1(u32 yoshi_actorIdInMouth);

void handleKoopaBeingEaten(Yoshi *yoshi);