mirror of
https://github.com/zeldaret/ss
synced 2026-05-30 00:46:41 -04:00
elijah-thomas774
434 lines
13 KiB
C++
434 lines
13 KiB
C++
#ifndef D_A_NPC_H
|
|
#define D_A_NPC_H
|
|
|
|
#include "common.h"
|
|
#include "d/a/d_a_base.h"
|
|
#include "d/a/d_a_itembase.h"
|
|
#include "d/a/obj/d_a_obj_base.h"
|
|
#include "d/d_message.h"
|
|
#include "libms/flowfile.h"
|
|
#include "m/m3d/m_mdl.h"
|
|
#include "m/m_angle.h"
|
|
#include "m/m_mtx.h"
|
|
#include "m/m_quat.h"
|
|
#include "m/m_vec.h"
|
|
#include "s/s_State.hpp"
|
|
#include "s/s_StateInterfaces.hpp"
|
|
#include "toBeSorted/d_d3d.h"
|
|
|
|
class dAcNpc_c;
|
|
|
|
// NPC-specific mdl callback stuff
|
|
class dNpcMdlCallbackBase_c {
|
|
protected:
|
|
/* 0x00 */ u32 mNodeId;
|
|
/* 0x04 */ mAng field_0x04;
|
|
/* 0x06 */ mAng field_0x06;
|
|
/* 0x08 */ bool mForceCalc;
|
|
|
|
dNpcMdlCallbackBase_c() : mNodeId(-1), field_0x04(0), field_0x06(0), mForceCalc(false) {}
|
|
|
|
public:
|
|
u32 getNodeId() const {
|
|
return mNodeId;
|
|
}
|
|
|
|
void loadNodeId(d3d::AnmMdlWrapper *mdl, const char *nodeName);
|
|
|
|
// vtable at 0xC
|
|
/* 0x08 */ virtual void apply(mMtx_c *result) const = 0;
|
|
/* 0x0C */ virtual void calc() = 0;
|
|
/* 0x10 */ virtual bool isDone() = 0;
|
|
/* 0x14 */ virtual void timingA(nw4r::g3d::ChrAnmResult *result);
|
|
/* 0x18 */ virtual void timingB(mMtx_c *result);
|
|
};
|
|
|
|
/**
|
|
* A mdl callback commonly used for controlling NPC head movement.
|
|
* NPCs will look at Link or certain objects of interest (e.g. a Bomb held by Link).
|
|
* This class smoothly interpolates the additive rotation of its node (head, neck, spine).
|
|
*/
|
|
class dNpcMdlCallbackAng_c : public dNpcMdlCallbackBase_c {
|
|
protected:
|
|
/* 0x10 */ mAng3_c mTarget;
|
|
/* 0x16 */ s16 mNumSteps;
|
|
/* 0x18 */ mAng mMaxStepSizeYZ;
|
|
/* 0x1A */ mAng mMinStepSizeYZ;
|
|
/* 0x1C */ mAng mMaxStepSizeX;
|
|
/* 0x1E */ mAng mMinStepSizeX;
|
|
/* 0x20 */ s32 mScaleZ;
|
|
/* 0x24 */ s32 mScaleX;
|
|
/* 0x28 */ s32 mScaleY;
|
|
/* 0x2C */ mAng3_c mCurrent;
|
|
|
|
s32 getScaleX() const {
|
|
return mScaleX;
|
|
}
|
|
|
|
s32 getScaleY() const {
|
|
return mScaleY;
|
|
}
|
|
|
|
s32 getScaleZ() const {
|
|
return mScaleZ;
|
|
}
|
|
|
|
public:
|
|
dNpcMdlCallbackAng_c();
|
|
/* 0x1C */ virtual ~dNpcMdlCallbackAng_c() {}
|
|
|
|
void setMinMaxStepSize(const mAng &max, const mAng &min);
|
|
void setMinMaxStepSizeX(const mAng &max, const mAng &min);
|
|
void reset();
|
|
void resetTarget();
|
|
void setTarget(const mAng3_c &target);
|
|
void setTargetNow(const mAng3_c &target);
|
|
void finishTarget();
|
|
|
|
/* 0x0C */ virtual void calc() override;
|
|
/* 0x10 */ virtual bool isDone() override {
|
|
return mCurrent == mTarget;
|
|
}
|
|
/* 0x20 */ virtual void vt_0x20(const dAcBase_c *) {}
|
|
};
|
|
|
|
/**
|
|
* Used by dAcOrdinaryNpc - applies rotation in YXZ order.
|
|
*/
|
|
class dNpcMdlCallbackYXZ_c : public dNpcMdlCallbackAng_c {
|
|
public:
|
|
dNpcMdlCallbackYXZ_c() {}
|
|
|
|
/* 0x08 */ virtual void apply(mMtx_c *result) const override;
|
|
/* 0x1C */ virtual ~dNpcMdlCallbackYXZ_c() {}
|
|
};
|
|
|
|
/**
|
|
* Used by Salesman, Terry, Rescue Bird applies rotation in YXZ order,
|
|
* but makes sure to restore translation after applying.
|
|
*/
|
|
class dNpcMdlCallbackYXZFixed_c : public dNpcMdlCallbackAng_c {
|
|
private:
|
|
/* 0x32 */ mAng3_c mActorRotation;
|
|
|
|
public:
|
|
dNpcMdlCallbackYXZFixed_c() {}
|
|
|
|
/* 0x08 */ virtual void apply(mMtx_c *result) const override;
|
|
// /* 0x1C */ virtual ~dNpcMdlCallbackYXZFixed_c() {}
|
|
/* 0x20 */ virtual void vt_0x20(const dAcBase_c *) override;
|
|
};
|
|
|
|
/**
|
|
* Unused - applies rotation in YZX order, with X and Z swapped.
|
|
*/
|
|
class dNpcMdlCallbackYZX_c : public dNpcMdlCallbackAng_c {
|
|
public:
|
|
dNpcMdlCallbackYZX_c() {}
|
|
|
|
/* 0x08 */ virtual void apply(mMtx_c *result) const override;
|
|
// /* 0x1C */ virtual ~dNpcMdlCallbackYZX_c() {}
|
|
};
|
|
|
|
/**
|
|
* Unused - applies rotation in XZY order, with X, Y, Z swizzled aroumd.
|
|
*/
|
|
class dNpcMdlCallbackXZY_c : public dNpcMdlCallbackAng_c {
|
|
public:
|
|
dNpcMdlCallbackXZY_c() {}
|
|
|
|
/* 0x08 */ virtual void apply(mMtx_c *result) const override;
|
|
// /* 0x1C */ virtual ~dNpcMdlCallbackXZY_c() {}
|
|
};
|
|
|
|
/**
|
|
* Quat - used for Kikwis.
|
|
*/
|
|
class dNpcMdlCallbackQuat_c : public dNpcMdlCallbackBase_c {
|
|
protected:
|
|
/* 0x10 */ f32 mSlerpFactor;
|
|
/* 0x14 */ f32 mRatio;
|
|
/* 0x18 */ f32 mMaxStepSize;
|
|
/* 0x1C */ f32 mMinStepSize;
|
|
/* 0x20 */ mAng *mActorRotY;
|
|
/* 0x24 */ mQuat_c mStart;
|
|
/* 0x34 */ mQuat_c mTarget;
|
|
|
|
public:
|
|
dNpcMdlCallbackQuat_c() {}
|
|
/* 0x1C */ virtual ~dNpcMdlCallbackQuat_c() {}
|
|
|
|
/* 0x08 */ virtual void apply(mMtx_c *result) const override;
|
|
/* 0x0C */ virtual void calc() override;
|
|
/* 0x10 */ virtual bool isDone() override {
|
|
return std::fabsf(mSlerpFactor - 1.0f) < 0.001;
|
|
}
|
|
};
|
|
|
|
struct dNpcMdlCallbackNode {
|
|
/* 0x00 */ dNpcMdlCallbackBase_c *mpCallback;
|
|
/* 0x04 */ dNpcMdlCallbackNode *mpNext;
|
|
};
|
|
|
|
/**
|
|
* Since a mdl can only have one callback, this is a generic
|
|
* mechanism with which multiple callbacks can be registered.
|
|
*/
|
|
class dNpcMdlCallbackMulti_c : public m3d::callback_c {
|
|
public:
|
|
virtual ~dNpcMdlCallbackMulti_c() {
|
|
clearList();
|
|
}
|
|
virtual void timingA(u32, nw4r::g3d::ChrAnmResult *, nw4r::g3d::ResMdl) override;
|
|
virtual void timingB(u32, nw4r::g3d::WorldMtxManip *, nw4r::g3d::ResMdl) override;
|
|
|
|
bool addCallback(dNpcMdlCallbackBase_c *callback);
|
|
|
|
private:
|
|
dNpcMdlCallbackNode *newCallbackNode();
|
|
bool createCallbackNode(dNpcMdlCallbackBase_c *cb);
|
|
void clearList();
|
|
|
|
/* 0x04 */ dNpcMdlCallbackNode *mpHead;
|
|
/* 0x08 */ dNpcMdlCallbackNode *mpTail;
|
|
/* 0x0C */ s32 mNumNodes;
|
|
};
|
|
|
|
// NPC-specific "flow" / MSBF code
|
|
class dFlowNpc_c : public dFlow_c {
|
|
public:
|
|
dFlowNpc_c(dAcNpc_c *owner) : mpOwner(owner) {}
|
|
virtual ~dFlowNpc_c() {}
|
|
|
|
/* vt 0x0C */ virtual void triggerEntryPoint(s32 labelPart1, s32 labelPart2) override;
|
|
/* vt 0x10 */ virtual void triggerEntryPoint(const char *) override;
|
|
/* vt 0x1C */ virtual bool handleEventInternal(const MsbFlowInfo *element) override;
|
|
/* vt 0x34 */ virtual void vt_0x34() override {}
|
|
/* vt 0x38 */ virtual bool vt_0x38() const override {
|
|
return true;
|
|
}
|
|
/* vt 0x3C */ virtual u16 getSwitchChoice(const MsbFlowInfo *element, u16 param) const override;
|
|
/* vt 0x40 */ virtual bool triggerEntryPointChecked(s32 labelPart1, s32 labelPart2) override;
|
|
|
|
private:
|
|
void extract2xU16Params(const MsbFlowInfo *element, u16 *p1, u16 *p2);
|
|
void extract4xU8Params(const MsbFlowInfo *element, u8 *p1, u8 *p2, u8 *p3, u8 *p4);
|
|
|
|
void setupActorRefs();
|
|
|
|
/* 0x064 */ dAcNpc_c *mpOwner;
|
|
// exact type isn't known but this Makes Sense
|
|
/* 0x068 */ dAcRef_c<dAcObjBase_c> mObjRefs[16];
|
|
/* 0x128 */ UNKWORD field_0x128[4];
|
|
/* 0x138 */ UNKWORD field_0x138;
|
|
/* 0x13C */ UNKWORD field_0x13C;
|
|
};
|
|
|
|
// This is the NPC base. Most npcs actually use dAcOrdinaryNpc, but this just is a simpler one?
|
|
|
|
// Ghidra: ActorNpcBase
|
|
// size: 0x6e4
|
|
// official name
|
|
class dAcNpc_c : public dAcObjBase_c {
|
|
public:
|
|
dAcNpc_c();
|
|
virtual ~dAcNpc_c();
|
|
|
|
/* vt 0x080 */ virtual bool giveItem(u8 param, ITEM_ID item_id);
|
|
/* vt 0x084 */ virtual void getPosCopy3(mVec3_c &outResult) {
|
|
outResult.copyFrom(mPositionCopy3);
|
|
}
|
|
/* vt 0x088 */ virtual void acNpc_vt_0x88() {}
|
|
/* vt 0x08C */ virtual void acNpc_vt_0x8C() {}
|
|
/* vt 0x090 */ virtual int acNpc_vt_0x90() {
|
|
return 1;
|
|
}
|
|
/* vt 0x094 */ virtual int acNpc_vt_0x94() {
|
|
return 1;
|
|
}
|
|
/* vt 0x098 */ virtual int acNpc_vt_0x98() {
|
|
return 1;
|
|
}
|
|
/* vt 0x09C */ virtual void acNpc_vt_0x9C();
|
|
/* vt 0x0A0 */ virtual void acNpc_vt_0xA0();
|
|
/* vt 0x0A4 */ virtual void acNpc_vt_0xA4();
|
|
/* vt 0x0A8 */ virtual void acNpc_vt_0xA8();
|
|
/* vt 0x0AC */ virtual void acNpc_vt_0xAC();
|
|
/* vt 0x0B0 */ virtual void acNpc_vt_0xB0();
|
|
/* vt 0x0B4 */ virtual void acNpc_vt_0xB4();
|
|
/* vt 0x0B8 */ virtual void acNpc_vt_0xB8();
|
|
/* vt 0x0BC */ virtual void acNpc_vt_0xBC();
|
|
/* vt 0x0C0 */ virtual u16 eventFlowSwitch1(u32 arg) {
|
|
return 0;
|
|
}
|
|
/* vt 0x0C4 */ virtual u16 eventFlowSwitch2(u32 arg) {
|
|
return 0;
|
|
}
|
|
/* vt 0x0C8 */ virtual u16 eventFlowSwitch3(u32 arg) {
|
|
return 0;
|
|
}
|
|
/* vt 0x0CC */ virtual void acNpc_vt_0xCC();
|
|
/* vt 0x0D0 */ virtual int acNpc_vt_0xD0();
|
|
/* vt 0x0D4 */ virtual void acNpc_vt_0xD4();
|
|
/* vt 0x0D8 */ virtual int acNpc_vt_0xD8();
|
|
/* vt 0x0DC */ virtual int acNpc_vt_0xDC() {
|
|
return 0;
|
|
}
|
|
/* vt 0x0E0 */ virtual int acNpc_vt_0xE0() {
|
|
return 0;
|
|
}
|
|
/* vt 0x0E4 */ virtual int acNpc_vt_0xE4() {
|
|
return 1;
|
|
}
|
|
/* vt 0x0E8 */ virtual void acNpc_vt_0xE8();
|
|
|
|
/* vt 0x074 */ virtual void *getObjectListEntry() override {
|
|
return &mActorListEntry;
|
|
}
|
|
|
|
/* vt 0x0EC */ virtual int acNpc_vt_0xEC() {
|
|
return 0;
|
|
}
|
|
|
|
/* vt 0x0F0 */ virtual bool isInState(const sStateIDIf_c &otherState) const {
|
|
return *mStateMgr.getStateID() == otherState;
|
|
}
|
|
|
|
/* vt 0x0F4 */ virtual void setState(const sStateIDIf_c &otherState) {
|
|
// Result is discarded
|
|
(void)isInState(StateID_Demo);
|
|
mStateMgr.changeState(otherState);
|
|
}
|
|
|
|
/* vt 0xF8 */ virtual void executeState() {
|
|
mStateMgr.executeState();
|
|
}
|
|
|
|
STATE_VIRTUAL_FUNC_DECLARE(dAcNpc_c, Wait);
|
|
STATE_VIRTUAL_FUNC_DECLARE(dAcNpc_c, Demo);
|
|
|
|
/* vt 0x114 */ virtual int acNpc_vt_0x114() {
|
|
return 0;
|
|
}
|
|
|
|
/* vt 0x118 */ virtual int acNpc_vt_0x118() {
|
|
return 0;
|
|
}
|
|
/* vt 0x11C */ virtual void acNpc_vt_0x11C();
|
|
/* vt 0x120 */ virtual void acNpc_vt_0x120() {}
|
|
/* vt 0x124 */ virtual void acNpc_vt_0x124() {}
|
|
/* vt 0x128 */ virtual int acNpc_vt_0x128() {
|
|
return 0;
|
|
}
|
|
/* vt 0x12C */ virtual int acNpc_vt_0x12C() {
|
|
return 0;
|
|
}
|
|
/* vt 0x130 */ virtual void acNpc_vt_0x130();
|
|
/* vt 0x134 */ virtual void acNpc_vt_0x134();
|
|
/* vt 0x138 */ virtual void acNpc_vt_0x138();
|
|
/* vt 0x13C */ virtual void acNpc_vt_0x13C();
|
|
/* vt 0x140 */ virtual void acNpc_vt_0x140();
|
|
/* vt 0x144 */ virtual void acNpc_vt_0x144();
|
|
/* vt 0x148 */ virtual void acNpc_vt_0x148();
|
|
/* vt 0x14C */ virtual int acNpc_vt_0x14C() {
|
|
return 0;
|
|
}
|
|
/* vt 0x150 */ virtual int acNpc_vt_0x150() {
|
|
return 1;
|
|
}
|
|
/* vt 0x154 */ virtual void acNpc_vt_0x154() {}
|
|
/* vt 0x158 */ virtual void acNpc_vt_0x158() {}
|
|
/* vt 0x15C */ virtual void acNpc_vt_0x15C() {}
|
|
/* vt 0x160 */ virtual void acNpc_vt_0x160() {}
|
|
/* vt 0x164 */ virtual void acNpc_vt_0x164();
|
|
/* vt 0x168 */ virtual int acNpc_vt_0x168() {
|
|
return 0;
|
|
}
|
|
/* vt 0x16C */ virtual void acNpc_vt_0x16C();
|
|
/* vt 0x170 */ virtual void acNpc_vt_0x170();
|
|
/* vt 0x174 */ virtual void acNpc_vt_0x174();
|
|
/* vt 0x178 */ virtual void acNpc_vt_0x178();
|
|
/* vt 0x17C */ virtual void acNpc_vt_0x17C();
|
|
/* vt 0x180 */ virtual void acNpc_vt_0x180();
|
|
/* vt 0x184 */ virtual void acNpc_vt_0x184();
|
|
/* vt 0x188 */ virtual void acNpc_vt_0x188();
|
|
/* vt 0x18C */ virtual void acNpc_vt_0x18C();
|
|
/* vt 0x190 */ virtual void acNpc_vt_0x190();
|
|
/* vt 0x194 */ virtual void acNpc_vt_0x194();
|
|
/* vt 0x198 */ virtual void acNpc_vt_0x198();
|
|
/* vt 0x19C */ virtual void acNpc_vt_0x19C();
|
|
/* vt 0x1A0 */ virtual void acNpc_vt_0x1A0();
|
|
/* vt 0x1A4 */ virtual void acNpc_vt_0x1A4();
|
|
/* vt 0x1A8 */ virtual void acNpc_vt_0x1A8();
|
|
/* vt 0x1AC */ virtual void acNpc_vt_0x1AC();
|
|
/* vt 0x1B0 */ virtual void acNpc_vt_0x1B0();
|
|
/* vt 0x1B4 */ virtual void acNpc_vt_0x1B4();
|
|
/* vt 0x1B8 */ virtual void acNpc_vt_0x1B8();
|
|
/* vt 0x1BC */ virtual void acNpc_vt_0x1BC();
|
|
/* vt 0x1C0 */ virtual void acNpc_vt_0x1C0();
|
|
/* vt 0x1C4 */ virtual void acNpc_vt_0x1C4();
|
|
/* vt 0x1C8 */ virtual void acNpc_vt_0x1C8();
|
|
/* vt 0x1CC */ virtual void acNpc_vt_0x1CC();
|
|
/* vt 0x1D0 */ virtual void acNpc_vt_0x1D0();
|
|
/* vt 0x1D4 */ virtual void acNpc_vt_0x1D4();
|
|
/* vt 0x1D8 */ virtual void acNpc_vt_0x1D8();
|
|
/* vt 0x1DC */ virtual void acNpc_vt_0x1DC();
|
|
/* vt 0x1E0 */ virtual void acNpc_vt_0x1E0();
|
|
/* vt 0x1E4 */ virtual void acNpc_vt_0x1E4();
|
|
/* vt 0x1E8 */ virtual int acNpc_vt_0x1E8() {
|
|
return 1;
|
|
}
|
|
/* vt 0x1EC */ virtual int acNpc_vt_0x1EC() {
|
|
return 1;
|
|
}
|
|
/* vt 0x1F0 */ virtual void *acNpc_vt_0x1F0() {
|
|
return &mFlow;
|
|
}
|
|
/* vt 0x1F4 */ virtual int acNpc_vt_0x1F4() {
|
|
return 1;
|
|
}
|
|
/* vt 0x1F8 */ virtual bool acNpc_vt_0x1F8() {
|
|
return !acNpc_vt_0x1F4();
|
|
}
|
|
/* vt 0x1FC */ virtual bool acNpc_vt_0x1FC() {
|
|
return field_0x684 == 1;
|
|
}
|
|
/* vt 0x200 */ virtual bool acNpc_vt_0x200() {
|
|
return !acNpc_vt_0x1FC();
|
|
}
|
|
/* vt 0x204 */ virtual int acNpc_vt_0x204() {
|
|
return 0;
|
|
}
|
|
|
|
bool doGiveItem(u8 id, s32 item);
|
|
u16 doFlowSwitch1(u32 arg);
|
|
u16 doFlowSwitch2(u32 arg);
|
|
u16 doFlowSwitch3(u32 arg);
|
|
|
|
protected:
|
|
void npcExecute();
|
|
static mVec3_c getLinkPos();
|
|
static bool addHeadNeckSpineCallbacks(
|
|
d3d::AnmMdlWrapper *mdl, dNpcMdlCallbackMulti_c *multi, dNpcMdlCallbackBase_c *head,
|
|
dNpcMdlCallbackBase_c *neck, dNpcMdlCallbackBase_c *spine
|
|
);
|
|
|
|
static const char *sHeadNodeName;
|
|
static const char *sNeckNodeName;
|
|
static const char *sSpine2NodeName;
|
|
|
|
private:
|
|
/* 0x330 */ u8 field_0x330[0x358 - 0x330];
|
|
/* 0x358 */ fLiNdBa_c mActorListEntry;
|
|
/* 0x364 */ dFlowNpc_c mFlow;
|
|
/* 0x4A4 */ u8 field_0x4A4[0x4C0 - 0x4A4];
|
|
/* 0x4C0 */ STATE_MGR_DECLARE(dAcNpc_c);
|
|
/* 0x4FC */ u8 field_0x4FC[0x684 - 0x4FC];
|
|
/* 0x684 */ u8 field_0x684;
|
|
/* 0x685 */ u8 field_0x685[0x6E4 - 0x685];
|
|
|
|
static fLiMgBa_c NPC_ACTOR_LIST;
|
|
};
|
|
|
|
#endif
|