diff options
Diffstat (limited to 'include')
45 files changed, 4370 insertions, 296 deletions
diff --git a/include/JSystem/J3DGraphAnimator/J3DAnimation.h b/include/JSystem/J3DGraphAnimator/J3DAnimation.h index 184cd1a2d7..183b45b14a 100644 --- a/include/JSystem/J3DGraphAnimator/J3DAnimation.h +++ b/include/JSystem/J3DGraphAnimator/J3DAnimation.h @@ -7,11 +7,11 @@ class J3DFrameCtrl { public: void init(s16); - void checkPass(f32); + BOOL checkPass(f32); void update(); ~J3DFrameCtrl(); - float getRate() { return mRate; } + float getRate() const { return mRate; } void setAttribute(u8 pAttr) { mAttribute = pAttr; } void setEnd(s16 pEnd) { mEnd = pEnd; } void setRate(float pRate) { mRate = pRate; } diff --git a/include/JSystem/J3DGraphAnimator/J3DModel.h b/include/JSystem/J3DGraphAnimator/J3DModel.h index d4828ac555..af644741c0 100644 --- a/include/JSystem/J3DGraphAnimator/J3DModel.h +++ b/include/JSystem/J3DGraphAnimator/J3DModel.h @@ -1,6 +1,93 @@ #ifndef J3DMODEL_H #define J3DMODEL_H +#include "JSystem/J3DGraphAnimator/J3DModelData.h" +#include "dolphin/mtx/mtxvec.h" #include "dolphin/types.h" +class J3DModel; +struct J3DSkinDeform { + /* 8032C9B0 */ void initSkinInfo(J3DModelData*); + /* 8032CF44 */ void initMtxIndexArray(J3DModelData*); + /* 8032D378 */ void changeFastSkinDL(J3DModelData*); + /* 8032D738 */ void transformVtxPosNrm(J3DModelData*); + /* 8032DFDC */ void deform(J3DModel*); +}; + +struct J3DDeformData { + /* 8032E230 */ void offAllFlag(u32); + /* 8032E274 */ void deform(J3DModel*); +}; + +class J3DMtxBuffer { +public: + /* 80326214 */ void initialize(); + /* 80326258 */ void create(J3DModelData*, u32); + /* 803268D4 */ void calcWeightEnvelopeMtx(); + /* 80326ACC */ void calcDrawMtx(u32, Vec const&, f32 const (&)[3][4]); + /* 80326D3C */ void calcNrmMtx(); + /* 80326EF0 */ void calcBBoardMtx(); + /* 803283B4 */ ~J3DMtxBuffer(); + + Mtx* getAnmMtx(int p1) { + Mtx* tmp = mMatrices[0]; + return tmp + (p1); + } + + /* 0x00 */ void* mJointTree; + /* 0x04 */ u32 field_0x4; + /* 0x08 */ u32 field_0x8; + /* 0x0C */ Mtx* mMatrices[5]; +}; + +class J3DModel { +public: + /* 800CFFF4 */ void setBaseTRMtx(f32 (*)[4]); + /* 80327100 */ void initialize(); + /* 80327184 */ void entryModelData(J3DModelData*, u32, u32); + /* 80327300 */ void createShapePacket(J3DModelData*); + /* 803273CC */ void createMatPacket(J3DModelData*, u32); + /* 803275FC */ void newDifferedDisplayList(u32); + /* 8032767C */ void lock(); + /* 803276B4 */ void unlock(); + /* 803276EC */ void calcMaterial(); + /* 80327858 */ void calcDiffTexMtx(); + /* 803279A0 */ void diff(); + /* 80327A2C */ void setDeformData(J3DDeformData*, u32); + /* 80327AA0 */ void setSkinDeform(J3DSkinDeform*, u32); + /* 80327BD4 */ void calcAnmMtx(); + /* 80327C58 */ void calcWeightEnvelopeMtx(); + /* 80327CA4 */ void update(); + /* 80327CF0 */ void calc(); + /* 80327E4C */ void entry(); + /* 80327F40 */ void viewCalc(); + /* 80328190 */ void calcNrmMtx(); + /* 803281B4 */ void calcBumpMtx(); + /* 803282B8 */ void calcBBoardMtx(); + /* 803282EC */ void prepareShapePackets(); + /* 80328350 */ ~J3DModel(); + Mtx* getAnmMtx(int p1); + + // better way to handle inlines with same name as non-inlines? + Mtx* i_getAnmMtx(int p1) { return mMtxBuffer->getAnmMtx(p1); } + + /* 0x00 */ void* vtable; + /* 0x04 */ J3DModelData* mModelData; + /* 0x08 */ u32 mFlags; + /* 0x0C */ u32 field_0x0c; + /* 0x10 */ int field_0x10; + /* 0x14 */ int mUserData; + /* 0x18 */ Vec mPosition; + /* 0x24 */ Mtx mBaseTransformMtx; + /* 0x54 */ Mtx mInternalView; + /* 0x84 */ J3DMtxBuffer* mMtxBuffer; + /* 0x88 */ void* mVertexBuffer; + /* 0xC0 */ void* mMaterialPacket; + /* 0xC4 */ void* mShapePacket; + /* 0xC8 */ void* mDeformData; + /* 0xCC */ void* mSkinDeform; + /* 0xD0 */ void* mVtxColorCalc; + /* 0xD4 */ u8 field_0xd4[8]; +}; + #endif /* J3DMODEL_H */ diff --git a/include/JSystem/J3DGraphAnimator/J3DModelData.h b/include/JSystem/J3DGraphAnimator/J3DModelData.h index 84e10af0fb..76d4b40ab7 100644 --- a/include/JSystem/J3DGraphAnimator/J3DModelData.h +++ b/include/JSystem/J3DGraphAnimator/J3DModelData.h @@ -3,4 +3,16 @@ #include "dolphin/types.h" +class J3DModelData { + /* 80325D88 */ void clear(); + /* 80325DA0 */ J3DModelData(); + /* 80325E14 */ void newSharedDisplayList(u32); + /* 80325EC8 */ void indexToPtr(); + /* 80325F94 */ void makeSharedDL(); + /* 8032600C */ void simpleCalcMaterial(u16, f32 (*)[4]); + /* 803260CC */ void syncJ3DSysPointers() const; + /* 803260F8 */ void syncJ3DSysFlags() const; + /* 8032617C */ ~J3DModelData(); +}; + #endif /* J3DMODELDATA_H */ diff --git a/include/JSystem/J3DGraphBase/J3DMatBlock.h b/include/JSystem/J3DGraphBase/J3DMatBlock.h index 65b37695a1..ff5235ef2d 100644 --- a/include/JSystem/J3DGraphBase/J3DMatBlock.h +++ b/include/JSystem/J3DGraphBase/J3DMatBlock.h @@ -1,6 +1,14 @@ #ifndef J3DMATBLOCK_H #define J3DMATBLOCK_H +#include "dolphin/gx/GXTexture.h" #include "dolphin/types.h" +class J3DGXColorS10 { +public: + /* 8000E460 */ J3DGXColorS10(); + + _GXColorS10 mColor; +}; + #endif /* J3DMATBLOCK_H */ diff --git a/include/JSystem/J3DGraphBase/J3DPacket.h b/include/JSystem/J3DGraphBase/J3DPacket.h index 09e3a7c739..1b2cee8aa5 100644 --- a/include/JSystem/J3DGraphBase/J3DPacket.h +++ b/include/JSystem/J3DGraphBase/J3DPacket.h @@ -51,9 +51,10 @@ public: virtual ~J3DPacket(); public: - J3DPacket* mpNextSibling; - J3DPacket* mpFirstChild; -}; + /* 0x04 */ J3DPacket* mpNextSibling; + /* 0x08 */ J3DPacket* mpFirstChild; + /* 0x0C */ void* mpUserData; +}; // Size = 0x10 class J3DDrawPacket : public J3DPacket { public: @@ -64,7 +65,6 @@ public: virtual void draw(); public: - void* mpUserData; int mFlags; char mPad0[0x0C]; // unk J3DDisplayListObj* mpDisplayListObj; diff --git a/include/JSystem/JAudio2/JAISound.h b/include/JSystem/JAudio2/JAISound.h index a8cec58208..265bd2dfc8 100644 --- a/include/JSystem/JAudio2/JAISound.h +++ b/include/JSystem/JAudio2/JAISound.h @@ -1,6 +1,170 @@ #ifndef JAISOUND_H #define JAISOUND_H +#include "JSystem/JGeometry.h" #include "dolphin/types.h" +#include "global.h" + +class JAISoundID { +public: + operator u32() const { return this->mId; } + + JAISoundID(u32 pId) : mId(pId) {} + + JAISoundID(JAISoundID const& other); + +private: + u32 mId; +}; + +struct JASSoundParams {}; + +struct JAISoundParams { + /* 802A2280 */ void mixOutAll(JASSoundParams const&, JASSoundParams*, f32); + + float field_0x0; + float field_0x4; + float field_0x8; + float field_0xc; + float field_0x10; + float field_0x14; + float field_0x18; + float field_0x1c; +}; + +struct JASTrack { + /* 80291444 */ void setChannelMgrCount(u32); + /* 802919F4 */ void assignExtBuffer(u32, JASSoundParams*); + /* 80291C30 */ void openChild(u32); + /* 80292918 */ void writePort(u32, u16); + /* 8029297C */ void readPort(u32); +}; + +class JAISoundHandle; +class JAIAudible; +class JAIAudience; +class JAISound { +public: + /* 802A21A0 */ void releaseHandle(); + /* 802A21BC */ void attachHandle(JAISoundHandle*); + /* 802A22F8 */ JAISound(); + /* 802A2328 */ void start_JAISound_(JAISoundID, JGeometry::TVec3<f32> const*, JAIAudience*); + /* 802A244C */ void acceptsNewAudible() const; + /* 802A2474 */ void newAudible(JGeometry::TVec3<f32> const&, JGeometry::TVec3<f32> const*, u32, + JAIAudience*); + /* 802A2598 */ void stop(); + /* 802A24DC */ void stop(u32 fadeout); + /* 802A25D8 */ bool asSe(); + /* 802A25E0 */ bool asSeq(); + /* 802A25E8 */ bool asStream(); + /* 802A25F0 */ void die_JAISound_(); + /* 802A266C */ void increasePrepareCount_JAISound_(); + /* 802A26B8 */ void calc_JAISound_(); + /* 802A29DC */ void initTrack_JAISound_(JASTrack*); + + JAISoundID getID() const { return JAISoundID((u32)this->sound_id); } + u32 getUserData() const { return user_data; } + + // TODO: do proper struct later + void* __vt; + struct JAISoundHandle* handle; + struct JAIAudible* audible; + struct JAIAudience* audience; + s32 field_0xc; + s32 num_prepare_steps; + struct JAISoundID sound_id; + u8 field_0x18; + u8 field_0x19; + u8 field_0x1a; + u8 field_0x1b; + u32 user_data; + float field_0x20; + float field_0x24; + float field_0x28; + s32 field_0x2c; + s32 audience_priority; + s32 field_0x34; + struct JAISoundParams params; + u8 field_0x58; + u8 field_0x59; + u8 field_0x5a; + u8 field_0x5b; + u8 field_0x5c; + u8 field_0x5d; + u8 field_0x5e; + u8 field_0x5f; + u8 field_0x60; + u8 field_0x61; + u8 field_0x62; + u8 field_0x63; + u8 field_0x64; + u8 field_0x65; + u8 field_0x66; + u8 field_0x67; + u8 field_0x68; + u8 field_0x69; + u8 field_0x6a; + u8 field_0x6b; + u8 field_0x6c; + u8 field_0x6d; + u8 field_0x6e; + u8 field_0x6f; + u8 field_0x70; + u8 field_0x71; + u8 field_0x72; + u8 field_0x73; + u8 field_0x74; + u8 field_0x75; + u8 field_0x76; + u8 field_0x77; + u8 field_0x78; + u8 field_0x79; + u8 field_0x7a; + u8 field_0x7b; + u8 field_0x7c; + u8 field_0x7d; + u8 field_0x7e; + u8 field_0x7f; + u8 field_0x80; + u8 field_0x81; + u8 field_0x82; + u8 field_0x83; + u8 field_0x84; + u8 field_0x85; + u8 field_0x86; + u8 field_0x87; + u8 field_0x88; + u8 field_0x89; + u8 field_0x8a; + u8 field_0x8b; + u8 field_0x8c; + u8 field_0x8d; + u8 field_0x8e; + u8 field_0x8f; + u8 field_0x90; + u8 field_0x91; + u8 field_0x92; + u8 field_0x93; +}; + +class JAISoundHandle { +public: + JAISoundHandle(); // noninline in JAUClusterSound.cpp + ~JAISoundHandle(); + + bool isSoundAttached() const { return mSound != NULL; } + + JAISound* operator->() const { + JUT_ASSERT(mSound != NULL); + return mSound; + } + + operator bool() const { return isSoundAttached(); } + + void releaseSound(); + +private: + JAISound* mSound; +}; #endif /* JAISOUND_H */ diff --git a/include/JSystem/JGeometry.h b/include/JSystem/JGeometry.h new file mode 100644 index 0000000000..e4848569cb --- /dev/null +++ b/include/JSystem/JGeometry.h @@ -0,0 +1,25 @@ +#ifndef JGEOMETRY_H +#define JGEOMETRY_H + +#include "dolphin/types.h" + +namespace JGeometry { + +template <typename T> +struct TVec3 { + T x; + T y; + T z; +}; +/* +template <> +struct TVec3<f32> { + TVec3(Vec& v) { + + } +}; + */ + +} // namespace JGeometry + +#endif
\ No newline at end of file diff --git a/include/JSystem/JParticle/JPAParticle.h b/include/JSystem/JParticle/JPAParticle.h index 0255cb0d41..01887531c1 100644 --- a/include/JSystem/JParticle/JPAParticle.h +++ b/include/JSystem/JParticle/JPAParticle.h @@ -3,4 +3,23 @@ #include "dolphin/types.h" +class JPABaseParticle; +struct _GXTexMapID {}; + +struct JPABaseEmitter { + /* 8027EB60 */ void createChild(JPABaseParticle*); + /* 8027EA40 */ void createParticle(); + /* 8027EF30 */ void getCurrentCreateNumber() const; + /* 8027EF40 */ void getDrawCount() const; + /* 8027EF50 */ void loadTexture(u8, _GXTexMapID); +}; + +class JPAParticleCallBack { +public: + virtual void temp(); // temp to build OK, remove later + ~JPAParticleCallBack(); + virtual void draw(JPABaseEmitter*, JPABaseParticle*); + virtual void execute(JPABaseEmitter*, JPABaseParticle*); +}; + #endif /* JPAPARTICLE_H */ diff --git a/include/JSystem/JUtility/JUTTexture.h b/include/JSystem/JUtility/JUTTexture.h index 16ce279d94..ad657caffb 100644 --- a/include/JSystem/JUtility/JUTTexture.h +++ b/include/JSystem/JUtility/JUTTexture.h @@ -3,4 +3,31 @@ #include "dolphin/types.h" +struct ResTIMG { /* Acts as the header to image data. Usually texture data immediately follows it, + so any pointer arithmetic to go past the end of this structure is so that a + variable sized allocated buffer can be accessed. */ + u8 texture_format; + bool is_alpha_enabled; + u16 texture_width; + u16 texture_height; + u8 wrap_s; + u8 wrap_t; + bool is_palettes_enabled; + u8 palette_format; + u16 palette_count; + u32 palette_offset; + bool is_mip_map_enabled; + bool do_edge_lod; + bool bias_clamp; + u8 max_anisotropy; + u8 min_filter; + u8 mag_filter; + u8 min_lod; + u8 max_lod; + u8 num_mipmaps; + u8 unknown; + u16 lod_bias; + u32 texture_data_offset; +}; + #endif /* JUTTEXTURE_H */ diff --git a/include/SSystem/SComponent/c_bg_s_chk.h b/include/SSystem/SComponent/c_bg_s_chk.h index 2e379ef228..e544c3be4c 100644 --- a/include/SSystem/SComponent/c_bg_s_chk.h +++ b/include/SSystem/SComponent/c_bg_s_chk.h @@ -5,9 +5,9 @@ class cBgS_Chk { private: - /* 0x0 */ u32 unk_0x00; - /* 0x4 */ u32 unk_0x04; - /* 0x8 */ u32 unk_0x08; + /* 0x0 */ u32 mPolyPassChk; + /* 0x4 */ u32 mGrpPassChk; + /* 0x8 */ u32 mActorPid; /* 0xC */ u8 unk_0x0C; /* 0x10 */ // __vtable__ public: diff --git a/include/SSystem/SComponent/c_bg_s_gnd_chk.h b/include/SSystem/SComponent/c_bg_s_gnd_chk.h index 61531fd6b2..8b03e38b5e 100644 --- a/include/SSystem/SComponent/c_bg_s_gnd_chk.h +++ b/include/SSystem/SComponent/c_bg_s_gnd_chk.h @@ -2,12 +2,18 @@ #define C_BG_S_GND_CHK_H #include "SSystem/SComponent/c_bg_s_chk.h" +#include "SSystem/SComponent/c_bg_s_poly_info.h" #include "SSystem/SComponent/c_xyz.h" #include "dolphin/types.h" class cBgS_GndChk : public cBgS_Chk { private: - // poly info + /* 0x14 */ cBgS_PolyInfo mPolyInfo; + /* 0x24 */ cXyz m_pos; + /* 0x30 */ int field_0x30; + /* 0x34 */ float mNowY; + /* 0x38 */ void* mWallPrecheck; + public: cBgS_GndChk(void); virtual ~cBgS_GndChk(void); diff --git a/include/SSystem/SComponent/c_bg_s_lin_chk.h b/include/SSystem/SComponent/c_bg_s_lin_chk.h index 8462b1c88d..60944d6b62 100644 --- a/include/SSystem/SComponent/c_bg_s_lin_chk.h +++ b/include/SSystem/SComponent/c_bg_s_lin_chk.h @@ -1,10 +1,25 @@ #ifndef C_BG_S_LIN_CHK_H #define C_BG_S_LIN_CHK_H +#include "SSystem/SComponent/c_bg_s_chk.h" +#include "SSystem/SComponent/c_bg_s_poly_info.h" +#include "SSystem/SComponent/c_m3d_g_lin.h" #include "SSystem/SComponent/c_xyz.h" #include "dolphin/types.h" class cBgS_LinChk { +private: + /* 0x000 */ cBgS_Chk mChk; + /* 0x014 */ cBgS_PolyInfo mPolyInfo; + /* 0x024 */ cM3dGLin mLin; + /* 0x040 */ cXyz field_0x40; + /* 0x04C */ int field_0x4c; + /* 0x050 */ u8 mPreWallChk; + /* 0x051 */ u8 mPreGroundChk; + /* 0x052 */ u8 mPreRoofChk; + /* 0x053 */ u8 mFrontFlag; + /* 0x054 */ u8 mBackFlag; + public: cBgS_LinChk(void); ~cBgS_LinChk(void); diff --git a/include/SSystem/SComponent/c_m3d_g_pla.h b/include/SSystem/SComponent/c_m3d_g_pla.h index e72ece1ded..25f7cf8978 100644 --- a/include/SSystem/SComponent/c_m3d_g_pla.h +++ b/include/SSystem/SComponent/c_m3d_g_pla.h @@ -9,6 +9,7 @@ class cM3dGPla { public: cXyz mNormal; f32 mD; + cM3dGPla(); cM3dGPla(const cXyz*, f32); virtual ~cM3dGPla(); bool crossInfLin(const cXyz&, const cXyz&, cXyz&) const; diff --git a/include/SSystem/SComponent/c_m3d_g_sph.h b/include/SSystem/SComponent/c_m3d_g_sph.h index 5e8dce121b..e03e026fa4 100644 --- a/include/SSystem/SComponent/c_m3d_g_sph.h +++ b/include/SSystem/SComponent/c_m3d_g_sph.h @@ -16,6 +16,8 @@ public: cXyz mCenter; f32 mRadius; + virtual void test(); // temp to build OK, remove later + virtual ~cM3dGSph(); void SetC(const cXyz&); void Set(const cXyz&, f32); void Set(const cM3dGSphS&); diff --git a/include/Z2AudioLib/Z2Creature.h b/include/Z2AudioLib/Z2Creature.h index 6cbb0564b3..94f95f326b 100644 --- a/include/Z2AudioLib/Z2Creature.h +++ b/include/Z2AudioLib/Z2Creature.h @@ -1,6 +1,109 @@ #ifndef Z2CREATURE_H #define Z2CREATURE_H +#include "SSystem/SComponent/c_xyz.h" +#include "Z2AudioLib/Z2SoundObject.h" #include "dolphin/types.h" +class Z2Creature { +public: + Z2Creature(); + ~Z2Creature(); + + void init(Vec*, Vec*, u8, u8); + void init(Vec*, Vec*, Vec*, u8, u8, u8); + void initAnime(void*, bool, f32, f32); + void updateAnime(f32, f32); + void stopAnime(); + + virtual void deleteObject(); + virtual void setSoundStarter(Z2SoundStarter*); + virtual void framework(u32, s8); + virtual void startCreatureSound(JAISoundID, u32, s8); + virtual void startCreatureSoundLevel(JAISoundID, u32, s8); + virtual void startCreatureVoice(JAISoundID, s8); + virtual void startCreatureVoiceLevel(JAISoundID, s8); + virtual void startCreatureExtraSound(JAISoundID, u32, s8); + virtual void startCreatureExtraSoundLevel(JAISoundID, u32, s8); + virtual void startCollisionSE(u32, u32); + +private: + /* 0x04 */ int field_0x04; + /* 0x08 */ Z2SoundObjAnime mSoundObjAnime; + /* 0x50 */ Z2SoundObjSimple mSoundObjSimple1; + /* 0x70 */ Z2SoundObjSimple mSoundObjSimple2; +}; + +struct Z2LinkSoundStarter : public Z2SoundStarter { + Z2LinkSoundStarter(void); + ~Z2LinkSoundStarter(); + /* 802C4928 */ void startSound(JAISoundID, JAISoundHandle*, JGeometry::TVec3<f32> const*, u32, + f32, f32, f32, f32, f32, u32); +}; + +#pragma pack(push, 1) +class Z2CreatureLink : public Z2Creature { +public: + Z2CreatureLink(void); + ~Z2CreatureLink(); + + void setLinkState(u8); + void setLinkGroupInfo(u8); + void setLinkHp(s32, s32); + void setLinkSwordType(s32, s32); + void setLinkShieldType(s32, s32); + void setLinkBootsType(s32); + void deleteObject(); + void init(Vec*, Vec*, Vec*); + void initKantera(Vec*); + void deleteKantera(void); + void setKanteraState(u8); + void framework(u32, s8); + void setSinkDepth(s8); + void setRiding(bool); + void setMagnetized(bool); + void setWolfEyeOpen(bool); + void startLinkSound(JAISoundID, u32, s8); + void startLinkSoundLevel(JAISoundID, u32, s8); + void startLinkVoice(JAISoundID, s8); + void startLinkVoiceLevel(JAISoundID, s8); + void startLinkSwordSound(JAISoundID, u32, s8); + void startCollisionSE(u32, u32); + int startHitItemSE(u32, u32, Z2SoundObjBase*, float); + void setResumeAttack(bool); + + static Z2CreatureLink* mLinkPtr; + +private: + /* 0x90 */ Z2LinkSoundStarter mLinkSoundStarter; + /* 0x94 */ Z2SoundObjSimple mSoundObjSimple; + /* 0xB4 */ cXyz field_0xb4; + /* 0xC0 */ u8 mLinkState; + /* 0xC1 */ u8 unk193; + /* 0xC2 */ u8 unk194; + /* 0xC3 */ u8 mLinkHp; + /* 0xC4 */ u8 mBootsType; + /* 0xC5 */ u8 mLanternState; + /* 0xC6 */ u8 unk198; + /* 0xC7 */ u8 unk199; + /* 0xC8 */ u8 unk200; + /* 0xC9 */ u8 unk201; + /* 0xCA */ u8 mSinkDepth; + /* 0xCB */ u8 flags1; + /* 0xCC */ u8 flags2; +}; +#pragma pack(pop) + +class Z2CreatureRide { +public: + void setLinkRiding(bool); + +private: + /* 0x00 */ void* vtable; + /* 0x04 */ u8 Z2Creature_members[140]; + /* 0x90 */ u8 Z2RideSoundStarter[8]; + /* 0x98 */ bool mLinkRiding; + /* 0x99 */ u8 padding[3]; +}; + #endif /* Z2CREATURE_H */ diff --git a/include/Z2AudioLib/Z2SoundHandles.h b/include/Z2AudioLib/Z2SoundHandles.h index 4a5dc4f5ff..51414f3d70 100644 --- a/include/Z2AudioLib/Z2SoundHandles.h +++ b/include/Z2AudioLib/Z2SoundHandles.h @@ -1,6 +1,35 @@ #ifndef Z2SOUNDHANDLES_H #define Z2SOUNDHANDLES_H +#include "JSystem/JAudio2/JAISound.h" +#include "JSystem/JSupport/JSUList.h" #include "dolphin/types.h" +class Z2SoundHandlePool : public JAISoundHandle, JSULink<Z2SoundHandlePool> {}; + +class Z2SoundHandles : protected JSUList<Z2SoundHandlePool> { +public: + Z2SoundHandles(); + ~Z2SoundHandles(); + + void initHandlesPool(u8 pNumHandles); + void deleteHandlesPool(); + void getFreeHandle(); + void getLowPrioSound(JAISoundID); + + bool isActive() const; + + JAISoundHandle* getHandleSoundID(JAISoundID pSoundId); + JAISoundHandle* getHandleUserData(u32 pUserData); + + void stopAllSounds(u32 fadeout); + + void setPos(const JGeometry::TVec3<f32>& pos); + + u32 getNumHandles() const { return this->getNumLinks(); } + +private: + u8 mNumHandles; +}; + #endif /* Z2SOUNDHANDLES_H */ diff --git a/include/Z2AudioLib/Z2SoundObject.h b/include/Z2AudioLib/Z2SoundObject.h index 07153b82ff..9c156c5246 100644 --- a/include/Z2AudioLib/Z2SoundObject.h +++ b/include/Z2AudioLib/Z2SoundObject.h @@ -1,6 +1,87 @@ #ifndef Z2SOUNDOBJECT_H #define Z2SOUNDOBJECT_H +#include "Z2AudioLib/Z2SoundHandles.h" +#include "Z2AudioLib/Z2SoundStarter.h" +#include "dolphin/mtx/mtxvec.h" #include "dolphin/types.h" +struct JAUSoundAnimationSound {}; + +class Z2SoundObjBase : protected Z2SoundHandles { +public: + Z2SoundObjBase(); + ~Z2SoundObjBase(); + + void deleteObject(); + void startCollisionSE(u32, u32, Z2SoundObjBase*); + + bool isAlive() const { return mIsInitialized; } + + virtual void temp(); // temp to build OK, remove later + virtual void framework(u32, s8); + virtual void dispose(); + virtual bool stopOK(Z2SoundHandlePool& pool); + virtual void init(Vec* pSoundPos, u8 pNumHandles); + virtual void startSound(JAISoundID, u32, s8); + virtual void startLevelSound(JAISoundID, u32, s8); + + // Z2SoundObjBase_vtable* vtable; + /* 0x14 */ Z2SoundStarter* mSoundStarter; + /* 0x18 */ Vec* mSoundPos; + /* 0x1C */ u16 field_0x1c; + /* 0x1E */ u8 field_0x1e; + /* 0x1F */ bool mIsInitialized; +}; + +class Z2SoundObjSimple : protected Z2SoundObjBase { +public: + Z2SoundObjSimple(); + + virtual void temp(); // temp to build OK, remove later + virtual void init(Vec* pSoundPos, u8 pNumHandles); + virtual void startSound(JAISoundID, u32, s8); + virtual void startLevelSound(JAISoundID, u32, s8); +}; + +class Z2SoundObjAnime : protected Z2SoundObjBase { +public: + /* 802BEB94 */ Z2SoundObjAnime(); + /* 802BEBFC */ void initAnime(void*, bool, f32, f32); + /* 802BED68 */ void ageSounds_(); + /* 802BEED4 */ void updateAnime(f32, f32); + /* 802BF304 */ void updateSoundLifeTime_(f32, f32); + /* 802BF660 */ void startSoundInner(JGeometry::TVec3<f32> const&, f32, Z2SoundStarter*, u32, + s8); + /* 802BF890 */ void getSoundID(JAUSoundAnimationSound const*, JGeometry::TVec3<f32> const&, + f32); + /* 802BF898 */ void playsSound(JAUSoundAnimationSound const*, JGeometry::TVec3<f32> const&, + f32); + + virtual void temp(); // temp to build OK, remove later + /* 802BEBDC */ virtual void init(Vec*, u8); + + /* 0x20 */ void* field_0x20; // JAUSoundAnimation* + /* 0x24 */ int field_0x24; + /* 0x28 */ float field_0x28; + /* 0x2C */ float field_0x2c; + /* 0x30 */ float field_0x30; + /* 0x34 */ int field_0x34; + /* 0x38 */ int field_0x38; + /* 0x3C */ int field_0x3c; + /* 0x40 */ int field_0x40; + /* 0x44 */ bool field_0x44; +}; + +class Z2DopplerSoundObjBase : protected Z2SoundHandles { + Z2DopplerSoundObjBase(); + ~Z2DopplerSoundObjBase(); + + virtual void temp(); // temp to build OK, remove later + virtual void framework(u32, s8); + virtual void init(Vec*, u8); + virtual void startSound(JAISoundID, u32, s8); + virtual void startLevelSound(JAISoundID, u32, s8); +}; + #endif /* Z2SOUNDOBJECT_H */ diff --git a/include/Z2AudioLib/Z2SoundStarter.h b/include/Z2AudioLib/Z2SoundStarter.h index 6b1c5dba04..3024f2dff0 100644 --- a/include/Z2AudioLib/Z2SoundStarter.h +++ b/include/Z2AudioLib/Z2SoundStarter.h @@ -1,6 +1,29 @@ #ifndef Z2SOUNDSTARTER_H #define Z2SOUNDSTARTER_H +#include "JSystem/JAudio2/JAISound.h" #include "dolphin/types.h" +struct Z2SoundStarter_vtable { + void* field_0x0; + void* field_0x4; + void* dtor; + void* startSound1; + void* startSound2; +}; + +struct Z2SoundStarter { + // Z2SoundStarter_vtable* vtable; + + Z2SoundStarter(bool); + virtual ~Z2SoundStarter(); + + virtual void startSound(JAISoundID, JAISoundHandle*, JGeometry::TVec3<f32> const*); + virtual void startSound(JAISoundID, JAISoundHandle*, JGeometry::TVec3<f32> const*, u32, float, + float, float, float, float, u32); + + void setPortData(JAISoundHandle*, u32, u16, s8); + void getPortData(JAISoundHandle*, u32, s8); +}; + #endif /* Z2SOUNDSTARTER_H */ diff --git a/include/Z2AudioLib/Z2WolfHowlMgr.h b/include/Z2AudioLib/Z2WolfHowlMgr.h index c6f1d6daa4..df241f8be4 100644 --- a/include/Z2AudioLib/Z2WolfHowlMgr.h +++ b/include/Z2AudioLib/Z2WolfHowlMgr.h @@ -1,6 +1,76 @@ #ifndef Z2WOLFHOWLMGR_H #define Z2WOLFHOWLMGR_H +#include "Z2AudioLib/Z2SoundObject.h" #include "dolphin/types.h" +struct Z2WolfHowlData {}; + +class Z2WolfHowlMgr { +public: + Z2WolfHowlMgr(); + + void resetState(); + void calcVolumeMod(float); + void getNowPitch(); + void getNowInputValue(); + void calcPitchMod(float, float); + void startWolfHowlSound(float, float, bool, float); + void setCorrectData(s8, Z2WolfHowlData*); + void getCorrectLine(u8); + void getCorrectLineNum(); + void checkLine(); + void getOnLineNum(); + void startWindStoneSound(s8, Vec*); + void startGuideMelody(bool); + void skipCorrectDemo(); + +private: + /* 0x00 */ JAISoundHandle* field_0x00; + /* 0x04 */ JAISoundHandle* field_0x04; + /* 0x08 */ JAISoundHandle* field_0x08; + /* 0x0C */ Z2WolfHowlData* field_0x0c; + /* 0x10 */ void* field_0x10; + /* 0x14 */ float mNowInputValue; + /* 0x18 */ float field_0x18; + /* 0x1C */ float field_0x1c; + /* 0x20 */ float field_0x20; + /* 0x24 */ float field_0x24; + /* 0x28 */ float field_0x28; + /* 0x2C */ u8 field_0x2c[4]; + /* 0x30 */ float field_0x30; + /* 0x34 */ float field_0x34; + /* 0x38 */ float field_0x38; + /* 0x3C */ float field_0x3c; + /* 0x40 */ float field_0x40; + /* 0x44 */ float field_0x44; + /* 0x48 */ float field_0x48; + /* 0x4C */ float field_0x4c; + /* 0x50 */ float field_0x50; + /* 0x54 */ float field_0x54; + /* 0x58 */ float field_0x58; + /* 0x5C */ float field_0x5c; + /* 0x60 */ float field_0x60; + /* 0x64 */ float field_0x64; + /* 0x68 */ float field_0x68; + /* 0x6C */ float field_0x6c; + /* 0x70 */ float field_0x70; + /* 0x74 */ float field_0x74; + /* 0x78 */ float field_0x78; + /* 0x7C */ float field_0x7c; + /* 0x80 */ float field_0x80; + /* 0x84 */ float field_0x84; + /* 0x88 */ void* mTimer; + /* 0x8C */ u8 mReleaseTimer; + /* 0x8D */ u8 field_0x8d; + /* 0x8E */ u8 mCorrectCurveID; + /* 0x8F */ u8 field_0x8f; + /* 0x90 */ s16 field_0x90; + /* 0x92 */ u8 field_0x92[20]; + /* 0xA6 */ u8 field_0xa6[0x14]; + /* 0xBA */ u8 field_0xba; + /* 0xBB */ u8 field_0xbb; + /* 0xBC */ u8 field_0xbc; +}; + #endif /* Z2WOLFHOWLMGR_H */ diff --git a/include/d/a/d_a_alink.h b/include/d/a/d_a_alink.h index 66ddcdf9d0..8aee3e817e 100644 --- a/include/d/a/d_a_alink.h +++ b/include/d/a/d_a_alink.h @@ -1,6 +1,2940 @@ #ifndef D_A_D_A_ALINK_H #define D_A_D_A_ALINK_H +#include "JSystem/J3DGraphBase/J3DMatBlock.h" +#include "Z2AudioLib/Z2Creature.h" +#include "Z2AudioLib/Z2WolfHowlMgr.h" +#include "d/a/d_a_player.h" +#include "d/bg/d_bg_s.h" +#include "d/cc/d_cc_d.h" +#include "d/cc/d_cc_mass_s.h" +#include "d/d_attention.h" +#include "d/d_drawlist.h" +#include "d/d_eye_hl.h" +#include "d/d_jnt_col.h" +#include "d/kankyo/d_kankyo.h" +#include "d/meter/d_meter2_info.h" +#include "d/msg/d_msg_flow.h" +#include "d/particle/d_particle.h" +#include "d/particle/d_particle_copoly.h" #include "dolphin/types.h" -#endif /* D_A_D_A_ALINK_H */ +class fopEn_enemy_c; +class daAlinkHIO_anm_c; +class J3DAnmTevRegKey; +class dCcG_At_Spl; +class dDemo_actor_c; + +class J2DScreen; +class J2DPane; +class J2DAnmBase; + +class daAlink_lockCursor_c : public dDlst_base_c { +public: + /* 80125F14 */ void create(); + /* 80126358 */ void update(); + virtual void temp(); // temp to build OK, remove later + /* 80126424 */ virtual void draw(); + /* 800CFE68 */ virtual ~daAlink_lockCursor_c(); + +private: + /* 0x04 */ bool field_0x4; + /* 0x05 */ u8 field_0x5[3]; + /* 0x08 */ J2DScreen* field_0x8; + /* 0x0C */ J2DPane* field_0xc; + /* 0x10 */ J2DPane* field_0x10; + /* 0x14 */ J2DPane* field_0x14; + /* 0x18 */ J2DPane* field_0x18; + /* 0x1C */ J2DAnmBase* field_0x1c; + /* 0x20 */ J2DAnmBase* field_0x20; + /* 0x24 */ J2DAnmBase* field_0x24; + /* 0x28 */ J2DAnmBase* field_0x28; + /* 0x2C */ float field_0x2c; + /* 0x30 */ float field_0x30; + /* 0x34 */ float field_0x34; + /* 0x38 */ float field_0x38; +}; + +class daAlink_sight_c : public daPy_sightPacket_c { +public: + /* 80126650 */ void create(); + virtual void test(); // temp to build OK, remove later + /* 801266C0 */ virtual void draw(); + /* 800CFDF4 */ virtual ~daAlink_sight_c(); + /* 80126710 */ void onLockFlg(); + +private: + /* 0x4C */ bool mLockFlag; + /* 0x4D */ u8 field_0x4d[3]; + /* 0x50 */ daAlink_lockCursor_c field_0x50; +}; + +class daAlink_blur_c : public J3DPacket { +public: + /* 801256EC */ void initBlur(f32, int, cXyz const*, cXyz const*, cXyz const*); + /* 8012589C */ void copyBlur(cXyz const*, cXyz const*, cXyz const*); + /* 80125B0C */ void traceBlur(cXyz const*, cXyz const*, s16); + virtual void temp(); // temp to build OK, remove later + /* 80125BF4 */ virtual void draw(); + /* 800CFD58 */ virtual ~daAlink_blur_c(); + +private: + /* 0x010 */ u8 field_0x10[4]; + /* 0x014 */ int field_0x14; + /* 0x018 */ u8 field_0x18[4]; + /* 0x01C */ int field_0x1c; + /* 0x020 */ u8 field_0x20[4]; + /* 0x024 */ float field_0x24; + /* 0x028 */ u8 field_0x28[4]; + /* 0x02C */ cXyz field_0x2c; + /* 0x038 */ cXyz field_0x38[0x3C]; + /* 0x308 */ cXyz field_0x308[0x3C]; +}; // Size = 0x5D8 + +class dAlink_bottleWaterPcallBack_c : public JPAParticleCallBack { +public: + virtual void temp(); // temp to build OK, remove later + /* 800CFCF8 */ virtual ~dAlink_bottleWaterPcallBack_c(); + /* 80124A2C */ virtual void execute(JPABaseEmitter*, JPABaseParticle*); + +private: + /* 0x04 */ s16 mHitFlg; + /* 0x06 */ s16 mAppearFlg; + /* 0x08 */ float mKeepMinY; + /* 0x0C */ cXyz mHitPos; +}; // Size = 0x18 + +class daAlink_footData_c { +public: + /* 800CFCB8 */ ~daAlink_footData_c(); + /* 800CFCF4 */ daAlink_footData_c(); + +private: + u8 field_0x00[0xa4]; +}; + +class daAlink_c : public daPy_py_c { +public: + enum daAlink_ANM { + GANON_FINISH = 408 // name probably wrong, fix later + }; + + enum daAlink_UPPER { + Unk0, + Unk1, + UPPER_NOW // needs better name. main upper anmheap idx checked for actions + }; + + enum daAlink_UNDER {}; + enum daAlink_FTANM {}; + enum daAlink_WARP_MAT_MODE {}; + enum daAlink_WANM {}; + + enum MODE_FLG { + PLAYER_FLY = 0x70852, + }; + + enum daAlink_PROC { + PREACTION_UNEQUIP, + SERVICE_WAIT, + HUMAN_WAIT = 3, + HUMAN_SIDESTEP = 10, + HUMAN_SIDESTEP_LAND, + HUMAN_SLIDE, + FRONT_ROLL = 14, + FRONT_ROLL_CRASH, + HUMAN_KNOCKBACK, + SIDE_ROLL, + BACK_JUMP, + BACK_JUMP_LAND, + SLIP, + HUMAN_AUTOJUMP, + DIVE_JUMP, + ROLL_JUMP, + FALL, + LAND, + SMALL_JUMP, + STEP_MOVE, + GUARD_SLIP = 29, + GUARD_ATTACK, + GUARD_BREAK, + TURN_MOVE, + CUT_NORMAL, + CUT_FINISH, + CUT_FINISH_JUMP_UP, + CUT_FINISH_JUMP_UP_LAND, + CUT_REVERSE, + CUT_JUMP, + CUT_JUMP_LAND, + COMBO_CUT_TURN, + CUT_CHARGE, + CUT_TURN_MOVE, + CUT_DOWN, + CUT_DOWN_LAND, + CUT_HEAD, + CUT_HEAD_LAND, + CUT_LARGE_JUMP_CHARGE, + CUT_LARGE_JUMP, + CUT_LARGE_JUMP_LAND, + DAMAGE, + LAND_DAMAGE = 52, + CRAWL_START, + CRAWL_MOVE, + CRAWL_AUTOMOVE, + CRAWL_END, + PULL_MOVE, + HORSE_RIDE, + HORSE_GETOFF, + HORSE_TURN = 61, + HORSE_JUMP, + HORSE_LAND, + HORSE_SUBJECTIVITY, + HORSE_CUT, + HORSE_CUT_CHARGE_READY, + HORSE_CUT_TURN, + HORSE_DAMAGE, + RIDE_BOW_READY, + HORSE_BOTTLE_DRINK = 76, + HORSE_KANDELAAR_POUR = 78, + HORSE_RUN, + HORSE_HANG, + BOAR_RUN = 83, + HANG_START = 85, + HANG_FALL_START, + HANG_UP, + HANG_WAIT, + HANG_MOVE, + COPY_ROD_SWING = 101, + GRAB_READY = 108, + GRAB_UP, + GRAB_THROW = 111, + GRAB_DOWN, + GRAB_REBOUND = 114, + GRAB_STAND, + INSECT_CATCH, + PICK_UP, + PICK_PUT, + HUMAN_ST_ESCAPE, + CLIMB_MOVE_VERTICAL = 130, + CLIMB_MOVE_HORIZONTAL, + CANOE_RIDE = 140, + CANOE_JUMP_RIDE, + CANOE_GETOFF, + CANOE_ROW = 144, + CANOE_PADDLE_SHIFT, + CANOE_PADDLE_PUT, + CANOE_PADDLE_GRAB, + CANOE_ROD_GRAB, + CANOE_FISHING_REEL = 150, + CANOE_FISHING_GET, + CANOE_SUBJECTIVITY, + CANOE_BOTTLE_DRINK = 160, + CANOE_KANDELAAR_POUR, + FISHING_FOOD = 163, + BOARD_CUT_TURN = 173, + FM_CHAIN_UP, + BOTTLE_DRINK = 179, + EMPTY_BOTTLE_SWING = 181, + GRASS_WHISTLE = 186, + HAWK_WAIT = 188, + FLOOR_DOWN_REBOUND = 189, + GORON_RIDE_WAIT, + GOAT_THROW = 192, + GOAT_STROKE, + MAGNE_BOOTS_FLY = 204, + BOOTS_EQUIP, + SUMOU_PUSH = 207, + SUMOU_SIDE_MOVE, + SUMOU_ACTION, + SUMOU_STAGGER, + SUMOU_WIN_LOSE, + BOSS_ENEMY_HANG = 220, + SCREAM_WAIT = 222, + DUNGEON_WARP_READY = 234, + WOLF_HOWL = 237, + WOLF_WAIT = 241, + WOLF_DASH = 243, + WOLF_KNOCKBACK = 244, + WOLF_SIDESTEP = 247, + WOLF_AUTOJUMP = 252, + WOLF_RSIT = 255, + WOLF_DAMAGE = 263, + WOLF_SLIDE = 271, + WOLF_ROPE_HANG = 275, + WOLF_TAGLOCK_JUMP = 280, + WOLF_TAGLOCK_LAND, + WOLF_DOWNATTACK_PULLOUT = 291, + WOLF_JUMPATTACK = 284, + WOLF_ST_ESCAPE = 289, + WOLF_CHAIN = 305, + WOLF_DIG, + WOLF_ENEMY_HANG_BITE = 310, + SUBJECTIVITY = 318, + POLY_DAMAGE = 321, + ELEC_DAMAGE, + PUSH_PULL_WAIT, + PUSH_MOVE, + TRESURE_STAND = 328, + METAMORPHOSE = 333, + DEAD = 336, + LARGE_DAMAGE = 345, + LARGE_DAMAGE_WALL, + }; + + // this might be one of the above enums, but not clear yet + enum UPPER_ANM { + ANM_SMALL_GUARD = 22, + ANM_HUMAN_CHAIN_GRAB = 98, + ANM_WOLF_CHAIN_GRAB = 672, + ANM_WOLF_ENEMY_THROW_LEFT = 701, + ANM_WOLF_ENEMY_THROW_RIGHT, + }; + + class firePointEff_c { + /* 800CFC3C */ ~firePointEff_c(); + /* 800CFC78 */ firePointEff_c(); + /* 0x00 */ u8 field_0x0[0xc]; + /* 0x0C */ cXyz field_0xc; + /* 0x18 */ cXyz field_0x18; + /* 0x24 */ cXyz field_0x24; + }; + + class hsChainShape_c { + /* 800D0CDC */ ~hsChainShape_c(); + /* 80107900 */ void draw(); + }; + + /* 8009D87C */ bool getE3Zhint(); + /* 8009D884 */ char* getAlinkArcName(); + /* 8009DA60 */ bool checkStageName(char const*); + /* 8009DA98 */ void tgHitCallback(fopAc_ac_c*, dCcD_GObjInf*, dCcD_GObjInf*); + /* 8009DB64 */ void coHitCallback(fopAc_ac_c*, dCcD_GObjInf*); + /* 8009DC6C */ void setMatrixWorldAxisRot(f32 (*)[4], s16, s16, s16, int, cXyz const*); + /* 8009DD90 */ void jointControll(int); + /* 8009E7B8 */ void setUpperFront(); + /* 8009E91C */ void changeBlendRate(int); + /* 8009EB18 */ void resetRootMtx(); + /* 8009EB58 */ void modelCallBack(int); + /* 8009ECA0 */ void headModelCallBack(int); + /* 8009EF7C */ void wolfModelCallBack(int); + /* 8009F034 */ void setHatAngle(); + /* 8009FFF8 */ void calcHairAngle(s16*); + /* 800A002C */ void setHairAngle(cXyz*, f32, f32); + /* 800A0744 */ void setLookPosFromOut(cXyz*); + /* 800A07D8 */ void checkAttentionPosAngle(cXyz*); + /* 800A0868 */ void checkActorPosAngle(fopAc_ac_c*, cXyz**); + /* 800A093C */ void getNeckAimPos(cXyz*, int*, int); + /* 800A142C */ void getNeckAimAngle(cXyz*, s16*, s16*, s16*, s16*); + /* 800A1AEC */ void setEyeMove(cXyz*, s16, s16); + /* 800A1F90 */ void setNeckAngle(); + /* 800A2198 */ void commonLineCheck(cXyz*, cXyz*); + /* 800A21E0 */ void getMoveBGActorName(cBgS_PolyInfo&, int); + /* 800A2280 */ void checkGoronRide(); + /* 800A22E8 */ void setMoveSlantAngle(); + /* 800A2710 */ void setArmMatrix(); + /* 800A29DC */ void setFootMatrix(); + /* 800A2C24 */ void setMatrixOffset(f32*, f32); + /* 800A2CE0 */ void setLegAngle(f32, daAlink_footData_c*, s16*, s16*, int); + /* 800A3430 */ void footBgCheck(); + /* 800A39B8 */ void handBgCheck(); + /* 800A3C8C */ void setItemHeap(); + /* 800A3CE4 */ void setIdxMask(u16*, u16*); + /* 800A3D0C */ void getAnimeResource(daPy_anmHeap_c*, u16, u32); + /* 800A3D7C */ void initModel(J3DModelData*, u32, u32); + /* 800A3E30 */ void initModel(u16, u32); + /* 800A3E98 */ void initModelEnv(u16, u32); + /* 800A3F00 */ void initDemoModel(J3DModel**, char const*, u32); + /* 800A3F98 */ void initDemoBck(mDoExt_bckAnm**, char const*); + /* 800A4068 */ void createHeap(); + /* 800A4910 */ void setSelectEquipItem(int); + /* 800A4BC8 */ void checkBoarStart(); + /* 800A4C40 */ void checkCanoeStart(); + /* 800A4CB4 */ void playerInit(); + /* 800A54F4 */ BOOL checkHorseStart(u32, int); + /* 800A551C */ void setStartProcInit(); + /* 800A5CC8 */ void create(); + /* 800A662C */ void setRoomInfo(); + /* 800A67E0 */ void setShapeAngleOnGround(); + /* 800A6B0C */ void setStepsOffset(); + /* 800A6DCC */ void iceSlipBgCheck(); + /* 800A7050 */ void setIceSlipSpeed(); + /* 800A7358 */ void setPolygonSpeed(); + /* 800A7950 */ void checkWindSpeedOnAngle() const; + /* 800A79EC */ void checkWindSpeedOnAngleAnime(int) const; + /* 800A7A5C */ void checkDashAnime() const; + /* 800A7ABC */ void checkWindWallRate(cXyz const&); + /* 800A7CB0 */ void setWindSpeed(); + /* 800A8310 */ void setBodyPartPos(); + /* 800A87F8 */ void setAttentionPos(); + /* 800A8CE4 */ void setMatrix(); + /* 800A9248 */ void simpleAnmPlay(J3DAnmBase*); + /* 800A92F0 */ void setSwordPos(); + /* 800A9450 */ void setItemMatrix(int); + /* 800A9F4C */ void setWolfItemMatrix(); + /* 800AA2BC */ void setHandIndex(daAlink_c::daAlink_ANM); + /* 800AA2E0 */ void setSwordAtCollision(int); + /* 800AA5E8 */ void checkNoCollisionCorret(); + /* 800AA6B4 */ void decSwordBlur(); + /* 800AA714 */ void resetWolfAtCollision(); + /* 800AA7EC */ void setWolfAtCollision(); + /* 800AA9DC */ void resetAtCollision(int); + /* 800AAABC */ void setAtCollision(); + /* 800AB878 */ void setWolfCollisionPos(); + /* 800ABAE0 */ void initLockAt(); + /* 800ABB28 */ void cancelLockAt(); + /* 800ABB84 */ void setCollisionPos(); + /* 800ABDB8 */ void setCollision(); + /* 800AC394 */ void setFrameCtrl(daPy_frameCtrl_c*, u8, s16, s16, f32, f32); + /* 800AC450 */ void getMainBckData(daAlink_c::daAlink_ANM) const; + /* 800AC558 */ void checkUnderMove0BckNoArc(daAlink_c::daAlink_ANM) const; + /* 800AC5B4 */ void checkUnderMove1BckNoArc(daAlink_c::daAlink_ANM) const; + /* 800AC610 */ void getUnderUpperAnime(daAlink_c::daAlink_ANM, J3DAnmTransform**, + J3DAnmTransform**, int, u32); + /* 800AC738 */ void setDoubleAnimeBlendRatio(f32); + /* 800AC754 */ void commonDoubleAnime(J3DAnmTransform*, J3DAnmTransform*, J3DAnmTransform*, + J3DAnmTransform*, f32, f32, f32, int); + /* 800ACA14 */ void setDoubleAnime(f32, f32, f32, daAlink_c::daAlink_ANM, + daAlink_c::daAlink_ANM, int, f32); + /* 800ACD40 */ void commonSingleAnime(J3DAnmTransform*, J3DAnmTransform*, f32, f32, s16); + /* 800ACF80 */ void setSingleAnimeBase(daAlink_c::daAlink_ANM); + /* 800ACFB0 */ void setSingleAnimeBaseMorf(daAlink_c::daAlink_ANM, f32); + /* 800ACFE0 */ void setSingleAnimeBaseSpeed(daAlink_c::daAlink_ANM, f32, f32); + /* 800AD00C */ void setSingleAnime(daAlink_c::daAlink_ANM, f32, f32, s16, f32); + /* 800AD0F4 */ void setSingleAnimeParam(daAlink_c::daAlink_ANM, daAlinkHIO_anm_c const*); + /* 800AD128 */ void animePlay(J3DAnmTransform*, daPy_frameCtrl_c*); + /* 800AD170 */ void allAnimePlay(); + /* 800AD2D8 */ void setUpperAnimeMorf(f32); + /* 800AD340 */ void setUpperAnimeBase(u16); + /* 800AD374 */ void setUpperAnimeBaseMorf(u16, f32); + /* 800AD3A8 */ void setUpperAnimeBaseSpeed(u16, f32, f32); + /* 800AD3D8 */ void setUpperAnime(u16, daAlink_c::daAlink_UPPER, f32, f32, s16, f32); + /* 800AD6F0 */ void setUpperAnimeParam(u16, daAlink_c::daAlink_UPPER, daAlinkHIO_anm_c const*); + /* 800AD724 */ void resetUpperAnime(daAlink_c::daAlink_UPPER, f32); + /* 800AD8F4 */ void setUnderAnimeMorf(f32); + /* 800AD964 */ void setUnderAnime(u16, daAlink_c::daAlink_UNDER, f32, f32, s16, f32); + /* 800ADAB8 */ void setUnderAnimeParam(u16, daAlink_c::daAlink_UNDER, daAlinkHIO_anm_c const*); + /* 800ADAEC */ void resetUnderAnime(daAlink_c::daAlink_UNDER, f32); + /* 800ADB78 */ void setOldRootQuaternion(s16, s16, s16); + /* 800ADC50 */ void checkAtnLeftAnime(); + /* 800ADCEC */ void checkAtnRightAnime(); + /* 800ADD88 */ void getMoveGroundAngleSpeedRate(); + /* 800ADE14 */ void setBlendMoveAnime(f32); + /* 800AEA70 */ void setBlendAtnMoveAnime(f32); + /* 800AF11C */ void setBlendAtnBackMoveAnime(f32); + /* 800AF4B0 */ void setFaceBck(u16, int, u16); + /* 800AF61C */ void setFaceBtp(u16, int, u16); + /* 800AF7D0 */ void setFaceBtk(u16, int, u16); + /* 800AF8A0 */ void setFaceBasicTexture(daAlink_c::daAlink_FTANM); + /* 800AF9A8 */ void setFaceBasicAnime(daAlink_c::daAlink_ANM); + /* 800AFAA8 */ void setFacePriTexture(daAlink_c::daAlink_FTANM); + /* 800AFB14 */ void setFacePriAnime(daAlink_c::daAlink_ANM); + /* 800AFB74 */ void resetFacePriBck(); + /* 800AFBD0 */ void resetFacePriBtp(); + /* 800AFC2C */ void resetFacePriBtk(); + /* 800AFC88 */ void resetFacePriTexture(); + /* 800AFCBC */ void resetFacePriAnime(); + /* 800AFCF0 */ void playFaceTextureAnime(); + /* 800B0098 */ void getGroundAngle(cBgS_PolyInfo*, s16); + /* 800B0150 */ void getRoofAngle(cBgS_PolyInfo*, s16); + /* 800B01FC */ void getWallEdgePos(cXyz const&, cM3dGPla*, cM3dGPla*, cXyz*, int); + /* 800B02BC */ void setFrontWallType(); + /* 800B1488 */ void checkWaterPolygonUnder(); + /* 800B14B4 */ void setWaterY(); + /* 800B154C */ void setHangWaterY(); + /* 800B172C */ void setSandDownBgCheckWallH(); + /* 800B1770 */ void setBgCheckParam(); + /* 800B1B28 */ void checkNotJumpSinkLimit(); + /* 800B1B68 */ void checkNotItemSinkLimit(); + /* 800B1BAC */ void setSandShapeOffset(); + /* 800B1FB8 */ bool checkLv2MiddleBossBgRide(s16); + /* 800B1FD8 */ void getSlidePolygon(cM3dGPla*); + /* 800B21EC */ void checkSlope() const; + /* 800B25CC */ u32 itemTriggerCheck(u8); + /* 800B25E8 */ u32 itemButtonCheck(u8); + /* 800B2604 */ void itemButton(); + /* 800B2634 */ void itemTrigger(); + /* 800B2664 */ void spActionButton(); + /* 800B2688 */ void spActionTrigger(); + /* 800B26AC */ u32 midnaTalkTrigger() const; + /* 800B26B8 */ void swordSwingTrigger(); + /* 800B26DC */ void setItemActionButtonStatus(u8); + /* 800B26FC */ void itemActionTrigger(); + /* 800B271C */ void setStickData(); + /* 800B2EA4 */ void setAtnList(); + /* 800B3220 */ void setRStatus(u8); + /* 800B3238 */ void setRStatusEmphasys(u8); + /* 800B3250 */ void setDoStatus(u8); + /* 800B3268 */ void setDoStatusEmphasys(u8); + /* 800B3280 */ void setDoStatusContinuation(u8); + /* 800B3298 */ void setBStatus(u8); + /* 800B32B0 */ void checkAtnWaitAnime(); + /* 800B3358 */ void setTiredVoice(daPy_frameCtrl_c*); + /* 800B33E4 */ void checkRestHPAnime(); + /* 800B3494 */ void getDirectionFromAngle(s16); + /* 800B3500 */ void checkAttentionState(); + /* 800B3630 */ void getShapeAngleYAtnActor(); + /* 800B3734 */ void setShapeAngleToAtnActor(int); + /* 800B3844 */ void initServiceWaitTime(); + /* 800B3904 */ void checkZeroSpeedF() const; + /* 800B3924 */ void setNormalSpeedF(f32, f32); + /* 800B3F2C */ void getStickAngleDistanceRate(); + /* 800B3FD4 */ void setSpeedAndAngleNormal(); + /* 800B444C */ void setSpeedAndAngleAtn(); + /* 800B477C */ void checkRequestTalkActor(dAttList_c*, fopAc_ac_c*); + /* 800B47B4 */ void checkServiceWaitMode(); + /* 800B48D0 */ void setJumpMode(); + /* 800B4908 */ float getMetamorphoseNearDis() const; + /* 800B4918 */ float getMetamorphoseFarDis() const; + /* 800B4928 */ s16 getMetamorphoseFarAngle() const; + /* 800B4938 */ void setMidnaMsg(); + /* 800B4950 */ void notTalk(); + /* 800B4A08 */ void setTalkStatus(); + /* 800B4B2C */ void getFrontRollRate(); + /* 800B4B7C */ void decideCommonDoStatus(); + /* 800B5284 */ void decideDoStatus(); + /* 800B58EC */ void checkWaitAction(); + /* 800B5BC0 */ void setFallVoice(); + /* 800B5C34 */ void setLandPassiveData(); + /* 800B5C64 */ void setStepLandVibration(); + /* 800B5CCC */ void checkLandAction(int); + /* 800B5F6C */ void checkSlideAction(); + /* 800B607C */ void checkAutoJumpAction(); + /* 800B69CC */ void checkCutJumpInFly(); + /* 800B6A30 */ BOOL checkFrontWallTypeAction(); + /* 800B6F28 */ void checkItemActionInitStart(); + /* 800B7090 */ void checkItemChangeAutoAction(); + /* 800B7168 */ void setFastShotTimer(); + /* 800B7190 */ void cancelItemUseQuake(int); + /* 800B71EC */ void cancelUpperItemReadyAnime(int); + /* 800B72E4 */ void checkItemActorPointer(); + /* 800B7390 */ void checkSwordTwirlAction(); + /* 800B74B4 */ void checkUpperItemActionFly(); + /* 800B7528 */ void checkItemButtonChange(); + /* 800B75EC */ void checkUpperItemAction(); + /* 800B7B7C */ void orderPeep(); + /* 800B7BF8 */ void orderTalk(int); + /* 800B80C4 */ void orderZTalk(); + /* 800B8374 */ void checkNormalAction(); + /* 800B8930 */ void checkReadyItem(); + /* 800B8988 */ void checkItemAction(); + /* 800B9010 */ bool checkRAction(); + /* 800B9018 */ void checkMoveDoAction(); + /* 800B9148 */ void checkSideRollAction(int); + /* 800B9254 */ void checkNoUpperAnime() const; + /* 800B92D0 */ void checkOneHandItemEquipAnime() const; + /* 800B92F8 */ void checkItemEquipAnime() const; + /* 800B9340 */ void checkEquipAnime() const; + /* 800B9398 */ void checkWindDashAnime() const; + /* 800B93CC */ void checkSwordTwirlAnime() const; + /* 800B93F4 */ void swordEquip(int); + /* 800B9580 */ void swordUnequip(); + /* 800B9640 */ void itemEquip(u16); + /* 800B96A4 */ void itemUnequip(u16, f32); + /* 800B97EC */ void checkFastUnequip(); + /* 800B983C */ void allUnequip(int); + /* 800B994C */ void checkItemChangeFromButton(); + /* 800B9D2C */ void checkNextActionFromButton(); + /* 800B9F50 */ void checkGroundSpecialMode(); + /* 800BA09C */ void commonCheckNextAction(int); + /* 800BA0D0 */ int checkNextAction(int); + /* 800BA6A0 */ void commonChangeItem(); + /* 800BA914 */ void setItemAction(); + /* 800BAF08 */ void checkNextActionFromCrouch(int); + /* 800BAF80 */ void checkUpperReadyThrowAnime() const; + /* 800BB020 */ void getBodyAngleXBasePos(cXyz*); + /* 800BB084 */ void getBodyAngleXAtnActor(int); + /* 800BB2B0 */ void setBodyAngleXReadyAnime(int); + /* 800BB324 */ void setMagicArmorBrk(int); + /* 800BB408 */ void checkMagicArmorHeavy() const; + /* 800BB4B8 */ void checkHeavyStateOn(int, int); + /* 800BB644 */ void initGravity(); + /* 800BB770 */ void setSpecialGravity(f32, f32, int); + /* 800BB7A0 */ void transAnimeProc(cXyz*, f32, f32); + /* 800BBD40 */ void setFootSpeed(); + /* 800BBF68 */ void posMove(); + /* 800BD6FC */ void autoGroundHit(); + /* 800BDD70 */ void startPeepChange(); + /* 800BDE20 */ void setLastSceneDamage(int, u32*); + /* 800BDE48 */ void setLastSceneMode(u32*); + /* 800BDF60 */ void startRestartRoom(u32, int, int, int); + /* 800BE26C */ void checkCoachGuardGame(); + /* 800BE2C0 */ void checkRoofRestart(); + /* 800BE3E4 */ void checkRestartRoom(); + /* 800BE9D4 */ void getSceneExitMoveAngle(); + /* 800BEAF8 */ void checkSceneChange(int); + /* 800BF0B8 */ void voiceStartLevel(u32); + /* 800BF0EC */ void seStartSwordCut(u32); + /* 800BF194 */ void seStartMapInfo(u32); + /* 800BF1CC */ void seStartMapInfoLevel(u32); + /* 800BF204 */ void setBasAnime(daAlink_c::daAlink_UNDER); + /* 800BF37C */ void initBasAnime(); + /* 800BF4E0 */ void resetBasAnime(); + /* 800BF500 */ void checkSightLine(f32, cXyz*); + /* 800BF79C */ void setMetamorphoseModel(int); + /* 800BF854 */ void keepItemData(); + /* 800BF884 */ void returnKeepItemData(); + /* 800BF8D0 */ void setItemModel(); + /* 800BF9F0 */ void setItemActor(); + /* 800BFD74 */ void makeItemType(); + /* 800BFDB0 */ void checkZoraWearAbility() const; + /* 800BFDFC */ void checkMagicArmorWearAbility() const; + /* 800BFE48 */ void loadAramBmd(u16, u32); + /* 800BFF04 */ void loadAram(u16, u32); + /* 800BFF70 */ void loadAramItemBrk(u16, J3DModel*); + /* 800BFFCC */ void loadAramItemBtk(u16, J3DModel*); + /* 800C0028 */ void loadAramItemBtp(u16, J3DModel*); + /* 800C0084 */ void changeItemBck(u16, f32); + /* 800C0114 */ void checkGroupItem(int, int) const; + /* 800C0164 */ void checkSetItemTrigger(int); + /* 800C0208 */ void checkItemSetButton(int); + /* 800C0284 */ void checkField(); + /* 800C02C8 */ void checkBossRoom(); + /* 800C0310 */ void checkDungeon(); + /* 800C0358 */ bool checkCastleTown(); + /* 800C03A0 */ void checkCloudSea(); + /* 800C03E8 */ void checkRoomOnly(); + /* 800C044C */ void checkLv2DungeonRoomSpecial(); + /* 800C04B4 */ void checkRoomSpecial(); + /* 800C0520 */ bool checkRoom(); + /* 800C0594 */ bool checkNotBattleStage(); + /* 800C05DC */ void checkNotHeavyBootsStage(); + /* 800C0630 */ void checkNotAutoJumpStage(); + /* 800C0678 */ void checkCastleTownUseItem(u16); + /* 800C077C */ void changeItemTriggerKeepProc(u8, int); + /* 800C0A9C */ void checkNewItemChange(u8); + /* 800C12DC */ void deleteEquipItem(int, int); + /* 800C1704 */ void setLight(); + /* 800C1CEC */ void setFrontRollCrashShock(u8); + /* 800C1E0C */ void changeWarpMaterial(daAlink_c::daAlink_WARP_MAT_MODE); + /* 800C1F6C */ void commonProcInit(daAlink_c::daAlink_PROC); + /* 800C2DA4 */ BOOL commonProcInitNotSameProc(daAlink_PROC); + /* 800C2DDC */ void procPreActionUnequipInit(int, fopAc_ac_c*); + /* 800C2EAC */ void procPreActionUnequip(); + /* 800C3098 */ bool procServiceWaitInit(); + /* 800C30F0 */ void procServiceWait(); + /* 800C3224 */ void procTiredWaitInit(); + /* 800C3338 */ void procTiredWait(); + /* 800C33B8 */ void procWaitInit(); + /* 800C3504 */ void procWait(); + /* 800C36CC */ void procMoveInit(); + /* 800C3730 */ void procMove(); + /* 800C3810 */ void procAtnMoveInit(); + /* 800C3868 */ bool procAtnMove(); + /* 800C38CC */ void procAtnActorWaitInit(); + /* 800C397C */ void procAtnActorWait(); + /* 800C39EC */ void procAtnActorMoveInit(); + /* 800C3A44 */ void procAtnActorMove(); + /* 800C3A94 */ void procWaitTurnInit(); + /* 800C3B1C */ void procWaitTurn(); + /* 800C3C3C */ void procMoveTurnInit(int); + /* 800C3D38 */ void procMoveTurn(); + /* 800C3DA0 */ void procSideStepInit(int); + /* 800C3F60 */ void procSideStep(); + /* 800C40F0 */ void procSideStepLandInit(); + /* 800C4278 */ void procSideStepLand(); + /* 800C4378 */ void procSlideInit(s16); + /* 800C4514 */ void procSlide(); + /* 800C47AC */ void procSlideLandInit(int); + /* 800C4894 */ void procSlideLand(); + /* 800C494C */ void procFrontRollInit(); + /* 800C4B40 */ void procFrontRoll(); + /* 800C4F14 */ void procFrontRollCrashInit(); + /* 800C4FFC */ void procFrontRollCrash(); + /* 800C5160 */ void procFrontRollSuccessInit(); + /* 800C5240 */ void procFrontRollSuccess(); + /* 800C5328 */ void procSideRollInit(int); + /* 800C5484 */ void procSideRoll(); + /* 800C5700 */ void backJumpSpeedDec(); + /* 800C57A4 */ void procBackJumpInit(int); + /* 800C5964 */ void procBackJump(); + /* 800C5A54 */ void procBackJumpLandInit(int); + /* 800C5AF0 */ void procBackJumpLand(); + /* 800C5C28 */ void procSlipInit(); + /* 800C5CA4 */ void procSlip(); + /* 800C5E68 */ void procAutoJumpInit(int); + /* 800C61EC */ void procAutoJump(); + /* 800C66DC */ void procDiveJumpInit(); + /* 800C6798 */ void procDiveJump(); + /* 800C6850 */ void procRollJumpInit(); + /* 800C692C */ void procRollJump(); + /* 800C6A48 */ void procFallInit(int, f32); + /* 800C6D20 */ void procFall(); + /* 800C6F18 */ void procLandInit(f32); + /* 800C6FE4 */ void procLand(); + /* 800C70F8 */ void procSmallJumpInit(int); + /* 800C72D4 */ void procSmallJump(); + /* 800C74D4 */ void procStepMoveInit(); + /* 800C755C */ void procStepMove(); + /* 800C7690 */ void procCrouchInit(); + /* 800C76F8 */ void procCrouch(); + /* 800C77F4 */ void procCoMetamorphoseInit(); + /* 800C7C64 */ void procCoMetamorphose(); + /* 800C82E8 */ void procCoMetamorphoseOnlyInit(); + /* 800C83A0 */ void procCoMetamorphoseOnly(); + /* 800C8460 */ void procFloorDownReboundInit(); + /* 800C84D0 */ void procFloorDownRebound(); + /* 800C854C */ void procGoronRideWaitInit(fopAc_ac_c*); + /* 800C85D8 */ void procGoronRideWait(); + /* 800C8700 */ void execute(); + /* 800CAFC8 */ void setDrawHand(); + /* 800CB480 */ void checkSwordDraw(); + /* 800CB53C */ void checkShieldDraw(); + /* 800CB5F8 */ void checkItemDraw(); + /* 800CB694 */ void initShadowScaleLight(); + /* 800CBA38 */ void moveShadowScaleLight(); + /* 800CBC18 */ void shadowDraw(); + /* 800CC25C */ void modelCalc(J3DModel*); + /* 800CC298 */ void basicModelDraw(J3DModel*); + /* 800CC2E0 */ void modelDraw(J3DModel*, int); + /* 800CC364 */ void setWaterDropColor(J3DGXColorS10 const*); + /* 800CC7DC */ void initTevCustomColor(); + /* 800CC7FC */ void draw(); + /* 800CD7AC */ ~daAlink_c(); + /* 800CE294 */ void checkNoSubjectModeCamera(); + /* 800CE468 */ void acceptSubjectModeChange(); + /* 800CE628 */ void checkSubjectAction(); + /* 800CE728 */ void checkBodyAngleX(s16); + /* 800CE8A0 */ void setBodyAngleToCamera(); + /* 800CEAF4 */ void setSubjectMode(); + /* 800CEB58 */ void subjectCancelTrigger(); + /* 800CEBD8 */ void checkSubjectEnd(int); + /* 800CECE4 */ void searchPeepObj(fopAc_ac_c*, void*); + /* 800CED84 */ void procCoSubjectivityInit(); + /* 800CEE08 */ void procCoSubjectivity(); + /* 800CEF70 */ void procCoSwimSubjectivityInit(); + /* 800CF018 */ void procCoSwimSubjectivity(); + /* 800CF100 */ void procCoPeepSubjectivityInit(); + /* 800CF1B8 */ void procCoPeepSubjectivity(); + /* 800CF380 */ daAlink_c(); + /* 800CFEB0 */ BOOL checkRideOn() const; + /* 800CFF4C */ BOOL checkAttentionLock(); + /* 800D0020 */ BOOL checkFmChainGrabAnime() const; + /* 800D0048 */ BOOL checkSmallUpperGuardAnime() const; + /* 800D00EC */ BOOL checkReinRide() const; + /* 800D0110 */ BOOL checkWolfEnemyThrowAnime() const; + /* 800D0138 */ u16 checkSpecialDemoMode() const; + /* 800D014C */ void setMidnaTalkStatus(u8); + /* 800D0164 */ void set3DStatus(u8, u8); + /* 800D018C */ u32 checkModeFlg(u32) const; + /* 800D2684 */ void checkCutTurnCharge(); + /* 800D07A4 */ void checkCutJumpCancelTurn() const; + /* 800D0E08 */ void checkLightSwordMtrl(); + /* 800D0E98 */ void checkSwordEquipAnime() const; + /* 800D0ECC */ void checkCutDashAnime() const; + /* 800D0EFC */ void checkCutDashEnemyHit(dCcD_GObjInf&); + /* 800D0F5C */ void getSwordAtType(); + /* 800D0F90 */ void initCutTurnAt(f32, int); + /* 800D102C */ void checkCutFinishJumpUp(); + /* 800D1088 */ void changeCutFast(); + /* 800D10E0 */ void checkCutFastReady(); + /* 800D1268 */ void setSwordModel(); + /* 800D1310 */ void offSwordModel(); + /* 800D13AC */ void checkCutTypeNoBlur() const; + /* 800D13E4 */ void checkCutTurnInput() const; + /* 800D1424 */ void getCutTurnDirection() const; + /* 800D1430 */ void resetCombo(int); + /* 800D1454 */ void checkComboCnt(); + /* 800D152C */ void setCutType(u8); + /* 800D1540 */ void setCylAtParam(u32, dCcG_At_Spl, u8, u8, int, f32, f32); + /* 800D1688 */ void setSwordAtParam(dCcG_At_Spl, u8, u8, int, f32, f32); + /* 800D1788 */ void notSwordHitVibActor(fopAc_ac_c*); + /* 800D17EC */ void setSwordHitVibration(dCcD_GObjInf*); + /* 800D1920 */ void checkAtShieldHit(dCcD_GObjInf&); + /* 800D1978 */ void checkCutReverseAt(dCcD_GObjInf*); + /* 800D19C8 */ void changeCutReverseProc(daAlink_c::daAlink_ANM); + /* 800D1E1C */ void setCutDash(int, int); + /* 800D20B4 */ void checkForceSwordSwing(); + /* 800D20FC */ void setComboReserb(); + /* 800D2188 */ void checkComboReserb(); + /* 800D21D0 */ void commonCutAction(); + /* 800D2284 */ void setSwordVoiceSe(u32); + /* 800D22BC */ void setSwordChargeVoiceSe(); + /* 800D2304 */ void setSwordComboVoice(); + /* 800D2368 */ void checkCutTurnInputTrigger(); + /* 800D23C0 */ void checkCutAction(); + /* 800D26EC */ void getCutDirection(); + /* 800D2760 */ void checkCutCancelNextMode(int); + /* 800D27E4 */ void checkDoCutAction(); + /* 800D2890 */ void checkCutBackState(); + /* 800D28F4 */ void checkCutHeadState(); + /* 800D29D4 */ void checkDownAttackState(); + /* 800D2ABC */ void checkCutLargeTurnState() const; + /* 800D2B88 */ void cancelCutCharge(); + /* 800D2BFC */ void initCutAtnActorSearch(); + /* 800D2C54 */ void checkCutAtnActorChange(); + /* 800D2C78 */ void setCutJumpSpeed(int); + /* 800D2F58 */ void procCutNormalInit(int); + /* 800D31B8 */ void procCutNormal(); + /* 800D34D8 */ void procCutFinishInit(int); + /* 800D382C */ void procCutFinish(); + /* 800D3ADC */ void procCutFinishJumpUpInit(); + /* 800D3CCC */ void procCutFinishJumpUp(); + /* 800D3DD8 */ void procCutFinishJumpUpLandInit(); + /* 800D3ECC */ void procCutFinishJumpUpLand(); + /* 800D4068 */ void procCutReverseInit(daAlink_c::daAlink_ANM); + /* 800D41FC */ void procCutReverse(); + /* 800D42FC */ void procCutJumpInit(int); + /* 800D43F8 */ void procCutJump(); + /* 800D452C */ void procCutJumpLandInit(int); + /* 800D4684 */ void procCutJumpLand(); + /* 800D47DC */ void procCutTurnInit(int, int); + /* 800D4A74 */ void procCutTurn(); + /* 800D4C68 */ void procCutTurnChargeInit(); + /* 800D4D04 */ void procCutTurnCharge(); + /* 800D4DDC */ void procCutTurnMoveInit(int); + /* 800D4EFC */ void procCutTurnMove(); + /* 800D53C8 */ void procCutDownInit(); + /* 800D57F8 */ void procCutDown(); + /* 800D58A0 */ void procCutDownLandInit(fopEn_enemy_c*); + /* 800D5ADC */ void procCutDownLand(); + /* 800D5C88 */ void procCutHeadInit(); + /* 800D5FC8 */ void procCutHead(); + /* 800D6130 */ void procCutHeadLandInit(); + /* 800D618C */ void procCutHeadLand(); + /* 800D6238 */ void procCutLargeJumpChargeInit(); + /* 800D62A0 */ void procCutLargeJumpCharge(); + /* 800D6374 */ void procCutLargeJumpInit(); + /* 800D6484 */ void procCutLargeJump(); + /* 800D66C0 */ void procCutLargeJumpLandInit(int); + /* 800D67FC */ void procCutLargeJumpLand(); + /* 800D698C */ void procSwordUnequipSpInit(); + /* 800D6A38 */ void procSwordUnequipSp(); + /* 800D6D94 */ void getFreezeR() const; + /* 800D6DA4 */ void getFreezeG() const; + /* 800D6DB4 */ void getFreezeB() const; + /* 800D6DC4 */ void checkMiddleBossGoronRoom(); + /* 800D6E24 */ void freezeTimerDamage(); + /* 800D6F2C */ void checkNoLandDamageSlidePolygon(); + /* 800D6FE0 */ void checkCutLandDamage(); + /* 800D70A0 */ void checkCaughtEscapeCutTurn(); + /* 800D7208 */ void damageMagnification(int, int); + /* 800D72BC */ void setDamagePoint(int, int, int, int); + /* 800D7478 */ void setDamagePointNormal(int); + /* 800D74A4 */ void setLandDamagePoint(int); + /* 800D74F4 */ void getDamageVec(dCcD_GObjInf*); + /* 800D76C4 */ void setDashDamage(); + /* 800D7768 */ void checkIcePolygonDamage(cBgS_PolyInfo*); + /* 800D77C8 */ void checkMagicArmorNoDamage(); + /* 800D7820 */ void checkPolyDamage(); + /* 800D7A98 */ void checkElecReturnDamage(dCcD_GObjInf&, fopAc_ac_c**); + /* 800D7B18 */ void damageTimerCount(); + /* 800D7BE8 */ void checkHugeAttack(int) const; + /* 800D7C14 */ void checkLargeAttack(int) const; + /* 800D7C40 */ void checkDamageAction(); + /* 800D8F3C */ void procDamageInit(dCcD_GObjInf*, int); + /* 800D9514 */ void procDamage(); + /* 800D96DC */ void procCoLargeDamageInit(int, int, s16, s16, dCcD_GObjInf*, int); + /* 800D9E88 */ void procCoLargeDamage(); + /* 800DA180 */ void procLargeDamageUpInit(int, int, s16, s16); + /* 800DA554 */ void procLargeDamageUp(); + /* 800DA82C */ void procCoLargeDamageWallInit(int, int, s16, s16); + /* 800DAC28 */ void procCoLargeDamageWall(); + /* 800DAC84 */ void procCoPolyDamageInit(); + /* 800DAD90 */ void procCoPolyDamage(); + /* 800DAE10 */ void procLandDamageInit(int); + /* 800DB060 */ void procLandDamage(); + /* 800DB140 */ void procCoElecDamageInit(fopAc_ac_c*, dCcD_GObjInf*, int); + /* 800DB418 */ void procCoElecDamage(); + /* 800DB5B0 */ void procStEscapeInit(); + /* 800DB610 */ void procStEscape(); + /* 800DB6A4 */ void procDkCaughtInit(unsigned int); + /* 800DB860 */ void procDkCaught(); + /* 800DBC98 */ void setScreamWaitAnime(); + /* 800DBD1C */ void procScreamWaitInit(); + /* 800DBDA4 */ void procScreamWait(); + /* 800DBE00 */ void procCoSandWallHitInit(); + /* 800DBE74 */ void procCoSandWallHit(); + /* 800DBED8 */ void procCoLavaReturnInit(int); + /* 800DC214 */ void procCoLavaReturn(); + /* 800DC278 */ void procCoSwimFreezeReturnInit(); + /* 800DC474 */ void procCoSwimFreezeReturn(); + /* 800DC548 */ void checkEnemyGroup(fopAc_ac_c*); + /* 800DC5A4 */ void checkSpecialNpc(fopAc_ac_c*); + /* 800DC5DC */ void checkShieldAttackEmphasys(); + /* 800DC678 */ void checkGuardActionChange(); + /* 800DC79C */ void stickArrowIncrement(int); + /* 800DC8C4 */ void setArrowShieldActor(fopAc_ac_c*, int); + /* 800DCA2C */ void checkWoodShieldEquipNotIronBall() const; + /* 800DCA80 */ void getArrowShieldOffset(cXyz const*, csXyz const*, cXyz*, cXyz*) const; + /* 800DCD74 */ void setArrowShieldPos(cXyz*, csXyz*, cXyz const*, cXyz const*) const; + /* 800DCDF0 */ void checkUpperGuardAnime() const; + /* 800DCF04 */ void checkPlayerGuardAndAttack() const; + /* 800DCF64 */ void checkGuardAccept(); + /* 800DD008 */ void setUpperGuardAnime(f32); + /* 800DD018 */ void setShieldGuard(); + /* 800DD114 */ void setGuardSe(dCcD_GObjInf*); + /* 800DD1D4 */ void setSmallGuard(dCcD_GObjInf*); + /* 800DD3E4 */ void procGuardSlipInit(int, dCcD_GObjInf*); + /* 800DD894 */ void procGuardSlip(); + /* 800DDA10 */ void procGuardAttackInit(); + /* 800DDBA8 */ void procGuardAttack(); + /* 800DDE58 */ void procGuardBreakInit(); + /* 800DDF2C */ void procGuardBreak(); + /* 800DE008 */ void procTurnMoveInit(int); + /* 800DE380 */ void procTurnMove(); + /* 800DE64C */ void getArrowFlyData(f32*, f32*, int) const; + /* 800DE740 */ void getArrowIncAtR() const; + /* 800DE750 */ void getBombArrowFlyExplodeTime() const; + /* 800DE760 */ void getArrowIncAtMaxStart() const; + /* 800DE770 */ void getArrowIncAtMax() const; + /* 800DE780 */ void checkBowAndSlingItem(int); + /* 800DE7D4 */ void setSlingModel(); + /* 800DE884 */ void checkBowCameraArrowPosP(s16*, s16*); + /* 800DE9B8 */ void checkBowReadyAnime() const; + /* 800DE9E8 */ void checkBowAnime() const; + /* 800DEA3C */ void makeArrow(); + /* 800DEAE4 */ void deleteArrow(); + /* 800DEB8C */ void setBowOrSlingStatus(); + /* 800DEBC8 */ void changeArrowType(); + /* 800DED88 */ void cancelBowMoveRideNotAtn(); + /* 800DEE1C */ void cancelBowMove(); + /* 800DEEDC */ void setBowReadyAnime(); + /* 800DEFB8 */ void setBowReloadAnime(); + /* 800DF0BC */ void checkUpperItemActionBow(); + /* 800DF798 */ void checkUpperItemActionBowFly(); + /* 800DF814 */ void checkNextActionBow(); + /* 800DFAE8 */ void setBowModel(); + /* 800DFBC8 */ void checkBowGrabLeftHand() const; + /* 800DFC28 */ void setBowHangAnime(); + /* 800DFC70 */ void setBowNormalAnime(); + /* 800DFCD8 */ void setBowSight(); + /* 800DFD6C */ void procBowSubjectInit(); + /* 800DFDDC */ void procBowSubject(); + /* 800DFE3C */ void procBowMoveInit(); + /* 800DFEC0 */ void procBowMove(); + /* 800DFFE0 */ void checkBoomerangLockAccept(); + /* 800E0010 */ void getBoomSpeed(); + /* 800E00B0 */ void getBoomCatchSpeed() const; + /* 800E00C0 */ void getBoomFlyMax() const; + /* 800E011C */ void getBoomLockMax(); + /* 800E0190 */ void getBoomBgThroughTime() const; + /* 800E01A0 */ void checkBossBabaRoom(); + /* 800E01CC */ void cancelBoomerangLock(fopAc_ac_c*); + /* 800E0210 */ void getBoomerangActor(); + /* 800E0244 */ void checkBoomerangChargeEnd(); + /* 800E02B8 */ void checkBoomerangCarry(fopAc_ac_c*); + /* 800E03D0 */ void initBoomerangUpperAnimeSpeed(int); + /* 800E0440 */ void checkBoomerangAnime() const; + /* 800E04AC */ void checkBoomerangThrowAnime() const; + /* 800E04E8 */ void setBoomerangReadyQuake(); + /* 800E055C */ void setBoomerangReadyAnime(); + /* 800E05E8 */ void setThrowBoomerangAnime(); + /* 800E0630 */ void setBoomerangCatchAnime(); + /* 800E06B8 */ void throwBoomerang(); + /* 800E08C4 */ void returnBoomerang(int); + /* 800E0A9C */ void checkUpperItemActionBoomerang(); + /* 800E0B58 */ void checkUpperItemActionBoomerangFly(); + /* 800E0BE4 */ void checkNextActionBoomerang(); + /* 800E0D8C */ void checkBoomerangCatchAction(); + /* 800E0E64 */ void setBoomerangSight(); + /* 800E0F10 */ void procBoomerangSubjectInit(); + /* 800E0FA0 */ void procBoomerangSubject(); + /* 800E1060 */ void procBoomerangMoveInit(); + /* 800E10F4 */ void procBoomerangMove(); + /* 800E11D8 */ void procBoomerangCatchInit(); + /* 800E1248 */ void procBoomerangCatch(); + /* 800E12E0 */ void checkLv6BossRoom(); + /* 800E1310 */ void getCopyRodBallSpeed() const; + /* 800E1320 */ void getCopyRodBallReturnSpeed() const; + /* 800E1330 */ void getCopyRodBallDisMax() const; + /* 800E1374 */ void getCopyRodControllActor(); + /* 800E1390 */ void getCopyRodCameraActor(); + /* 800E13AC */ void initCopyRodUpperAnimeSpeed(int); + /* 800E1408 */ void checkForestOldCentury(); + /* 800E1530 */ void checkCopyRodAnime() const; + /* 800E158C */ void setCopyRodControllAnime(); + /* 800E15FC */ void setCopyRodControllUpperSpeedRate(); + /* 800E1748 */ void setCopyRodModel(); + /* 800E1840 */ void setCopyRodReadyAnime(); + /* 800E191C */ void throwCopyRod(); + /* 800E1A30 */ void returnCopyRod(); + /* 800E1ADC */ void checkUpperItemActionCopyRod(); + /* 800E1BB4 */ void checkUpperItemActionCopyRodFly(); + /* 800E1C44 */ void checkNextActionCopyRod(); + /* 800E1D6C */ void setCopyRodSight(); + /* 800E1E20 */ void procCopyRodSubjectInit(); + /* 800E1EB0 */ void procCopyRodSubject(); + /* 800E1F68 */ void procCopyRodMoveInit(); + /* 800E1FFC */ void procCopyRodMove(); + /* 800E20C8 */ void procCopyRodSwingInit(); + /* 800E21FC */ void procCopyRodSwing(); + /* 800E2308 */ void procCopyRodReviveInit(); + /* 800E23A4 */ void procCopyRodRevive(); + /* 800E23FC */ void concatMagneBootMtx(); + /* 800E243C */ void concatMagneBootInvMtx(); + /* 800E247C */ void multVecMagneBootInvMtx(cXyz*); + /* 800E24B0 */ void commonMagneLineCheck(cXyz*, cXyz*); + /* 800E251C */ void checkBootsMoveAnime(int); + /* 800E2580 */ void setHeavyBoots(int); + /* 800E2738 */ void getMagneBootsLocalAngleY(s16, int); + /* 800E2808 */ void setMagneBootsMtx(cBgS_PolyInfo*, int); + /* 800E2DC4 */ void cancelMagneBootsOn(); + /* 800E2F88 */ void checkMagneBootsFly(); + /* 800E3048 */ void procBootsEquipInit(); + /* 800E30DC */ void procBootsEquip(); + /* 800E3218 */ void procMagneBootsFlyInit(); + /* 800E3454 */ void procMagneBootsFly(); + /* 800E3760 */ void getBombExplodeTime() const; + /* 800E3770 */ void getBombGravity() const; + /* 800E3780 */ void getBombMaxFallSpeed() const; + /* 800E3790 */ void getBombBoundRate() const; + /* 800E37A0 */ void getBombStopSpeedY() const; + /* 800E37B0 */ void getBombMaxSpeedY() const; + /* 800E37C0 */ void getBombEffScale() const; + /* 800E37D0 */ void getBombAtR() const; + /* 800E37E0 */ void getEnemyBombColorR() const; + /* 800E37F0 */ void getBombWaterGravity() const; + /* 800E3800 */ void getBombWaterMaxFallSpeed() const; + /* 800E3810 */ void getBombExplodeWaterEffectLimit() const; + /* 800E3820 */ void getBombInsectLimitAngle() const; + /* 800E38EC */ void checkGrabLineCheck(); + + /* 800E3BCC */ void getGrabThrowRate(); + /* 800E3C1C */ void checkGrabThrowAnime() const; + /* 800E3C6C */ void checkGrabAnime() const; + /* 800E3C9C */ void checkGrabAnimeAndThrow() const; + /* 800E3CF4 */ void checkGrabCarryActor(); + /* 800E3D1C */ void checkGrabSlowMoveActor(); + /* 800E3D6C */ void checkGrabHeavyActor(); + /* 800E3D94 */ void checkGrabSideActor(); + /* 800E3DBC */ void setGrabUpperAnime(f32); + /* 800E3F20 */ void checkGrabRooster(); + /* 800E3F50 */ void setGrabItemPos(); + /* 800E4BD4 */ void freeGrabItem(); + /* 800E4DEC */ void setGrabUpperSpeedRate(); + /* 800E4FA8 */ void setCarryArmAngle(f32, f32); + /* 800E5150 */ void checkGrabNotThrow(); + /* 800E5170 */ void checkNextActionGrab(); + /* 800E53AC */ void initGrabNextMode(); + /* 800E53F8 */ void setGrabItemThrow(); + /* 800E57AC */ void checkUpperGrabItemThrow(f32); + /* 800E5830 */ void putObjLineCheck(dBgS_LinChk&, cXyz*, fopAc_ac_c*); + /* 800E5B6C */ void grabLineCheck(cXyz*, cXyz*); + /* 800E5BB4 */ void setGrabItemActor(fopAc_ac_c*); + /* 800E5CBC */ void procGrabReadyInit(); + /* 800E5EC8 */ void procGrabReady(); + /* 800E5FD0 */ void procGrabUpInit(); + /* 800E6230 */ void procGrabUp(); + /* 800E637C */ void procGrabMiss(); + /* 800E63F0 */ void procGrabThrowInit(int); + /* 800E65F8 */ void procGrabThrow(); + /* 800E672C */ void procGrabPutInit(); + /* 800E6914 */ void procGrabPut(); + /* 800E6A9C */ void procGrabWaitInit(); + /* 800E6C34 */ void procGrabWait(); + /* 800E6D6C */ void procGrabReboundInit(int); + /* 800E6E0C */ void procGrabRebound(); + /* 800E6EEC */ void procGrabStandInit(); + /* 800E6FE0 */ void procGrabStand(); + /* 800E70C0 */ bool checkInsectActorName(fopAc_ac_c*); + /* 800E70FC */ void procInsectCatchInit(); + /* 800E71D4 */ bool procInsectCatch(); + /* 800E7254 */ void procPickUpInit(); + /* 800E7460 */ void procPickUp(); + /* 800E75EC */ void procPickPutInit(int); + /* 800E76E0 */ void procPickPut(); + /* 800E7894 */ void checkSetChainPullAnime(s16); + /* 800E794C */ s16 getChainStickAngleY(s16) const; + /* 800E7994 */ void checkChainEmphasys(); + /* 800E79F8 */ void searchFmChainPos(); + /* 800E7AEC */ void setFmChainPosFromOut(fopAc_ac_c*, cXyz*, int); + /* 800E7C30 */ void procFmChainUpInit(); + /* 800E7CC0 */ void procFmChainUp(); + /* 800E7DD8 */ void procFmChainStrongPullInit(); + /* 800E7E50 */ void procFmChainStrongPull(); + /* 800E7ED0 */ void setWallGrabStatus(u8, u8); + /* 800E7EE4 */ void getWallGrabStatus(); + /* 800E7EF4 */ void wallGrabTrigger(); + /* 800E7F18 */ void wallGrabButton(); + /* 800E7F3C */ void setPushPullKeepData(dBgW_Base::PushPullLabel, int); + /* 800E80A4 */ void checkPushPullTurnBlock(); + /* 800E8148 */ void checkPullBehindWall(); + /* 800E8298 */ void offGoatStopGame(); + /* 800E82B0 */ BOOL checkGoatCatchActor(fopAc_ac_c*); + /* 800E8314 */ float getGoatCatchDistance2(); + /* 800E8334 */ void endPushPull(); + /* 800E8354 */ void getPushPullAnimeSpeed(); + /* 800E8428 */ void procCoPushPullWaitInit(int); + /* 800E857C */ void procCoPushPullWait(); + /* 800E875C */ void procCoPushMoveInit(int, int); + /* 800E89F0 */ void procCoPushMove(); + /* 800E8D1C */ void procPullMoveInit(int); + /* 800E8F44 */ void procPullMove(); + /* 800E9210 */ void setGoatStopGameFail(fopAc_ac_c*); + /* 800E9344 */ void procGoatMoveInit(); + /* 800E9434 */ void procGoatMove(); + /* 800E9894 */ void procGoatCatchInit(fopAc_ac_c*, f32); + /* 800E9BD0 */ void procGoatCatch(); + /* 800EA2A8 */ void procGoatStrokeInit(); + /* 800EA3AC */ void procGoatStroke(); + /* 800EA3F4 */ void procGoronMoveInit(); + /* 800EA4CC */ void procGoronMove(); + /* 800EA844 */ void checkSumouVsActor(); + /* 800EA8D0 */ void cancelSumouMode(); + /* 800EA908 */ void sumouPunchTrigger(); + /* 800EA92C */ void setSumouPunchStatus(); + /* 800EA950 */ void procSumouReadyInit(); + /* 800EAA28 */ void procSumouReady(); + /* 800EAC4C */ void procSumouMoveInit(); + /* 800EAD84 */ void procSumouMove(); + /* 800EB208 */ void procSumouSideMoveInit(); + /* 800EB2BC */ void procSumouSideMove(); + /* 800EB624 */ void procSumouActionInit(int, int, int); + /* 800EBCE0 */ void procSumouAction(); + /* 800EC0F8 */ void procSumouStaggerInit(); + /* 800EC170 */ void procSumouStagger(); + /* 800EC20C */ void procSumouWinLoseInit(); + /* 800EC3D8 */ void procSumouWinLose(); + /* 800EC538 */ void procSumouShikoInit(); + /* 800EC5F4 */ void procSumouShiko(); + /* 800EC76C */ void checkHorseZeldaBowMode(); + /* 800EC7B0 */ void setHorseZeldaDamage(); + /* 800EC7DC */ bool checkHorseDashAccept(); + /* 800EC814 */ void checkCowGame(); + /* 800EC87C */ void getReinRideDirection(); + /* 800EC8F8 */ void checkReinRideBgCheck(); + /* 800ECA3C */ void commonInitForceRideRein(); + /* 800ECAAC */ void initForceRideBoar(); + /* 800ECB58 */ void initForceRideHorse(); + /* 800ECBD0 */ void rideGetOff(); + /* 800ECD90 */ void checkHorseNotDamageReaction() const; + /* 800ECDC4 */ void checkHorseWaitLashAnime() const; + /* 800ECDEC */ void checkHorseReinLeftOnly() const; + /* 800ECE10 */ void getReinHandType() const; + /* 800ECF04 */ void checkHorseLieAnime() const; + /* 800ECF5C */ void checkHorseSubjectivity() const; + /* 800ECF9C */ void setHorseSwordUpAnime(); + /* 800ECFF4 */ void setHorseTurnUpperAnime(int); + /* 800ED074 */ void checkHorseNoUpperAnime() const; + /* 800ED0D4 */ void getHorseReinHandPos(cXyz*, cXyz*); + /* 800ED1F0 */ void checkHorseNotGrab() const; + /* 800ED310 */ void setHorseStirrup(); + /* 800ED4B8 */ void changeBoarRunRide(); + /* 800ED4DC */ void setSyncHorsePos(); + /* 800ED78C */ void setSyncBoarPos(); + /* 800ED90C */ void setSyncBoarRunPos(); + /* 800EDA24 */ void setSyncRidePos(); + /* 800EDA78 */ void setHorseTurnAnime(); + /* 800EDB48 */ void getBaseHorseAnime(daAlink_c::daAlink_ANM*); + /* 800EDD6C */ void checkHorseSpecialProc(); + /* 800EDE8C */ void checkHorseServiceWaitAnime(); + /* 800EDEEC */ void setSyncHorse(int); + /* 800EE64C */ void setSyncBoar(int); + /* 800EE918 */ void setSyncRide(int); + /* 800EEAE8 */ void setBaseHorseAnimeFrame(); + /* 800EEC98 */ void setBaseBoarAnime(); + /* 800EED98 */ void setBaseRideAnime(); + /* 800EEE30 */ void checkHorseSwordUpSpped(); + /* 800EEE5C */ void setHorseSwordUp(int); + /* 800EEF30 */ void setRideSubjectAngle(s16); + /* 800EF050 */ void setBodyAngleRideReadyAnime(); + /* 800EF0E8 */ void checkHorseGetOffWallCheck(cXyz*, cXyz*, s16); + /* 800EF198 */ void checkHorseGetOffDirection(); + /* 800EF35C */ void boarForceGetOff(); + /* 800EF394 */ void horseGetOffEnd(); + /* 800EF450 */ void checkNextActionHorse(); + /* 800EF598 */ void checkHorseGetOff(); + /* 800EF6B0 */ void checkHorseGetOffAndSetDoStatus(); + /* 800EF884 */ void setHorseGetOff(int); + /* 800EF95C */ void procHorseRideInit(); + /* 800EFDC4 */ void procHorseRide(); + /* 800F038C */ void procHorseGetOffInit(int); + /* 800F0620 */ void procHorseGetOff(); + /* 800F0980 */ void procHorseWaitInit(); + /* 800F0AA4 */ void procHorseWait(); + /* 800F0C6C */ void procHorseTurnInit(); + /* 800F0CE4 */ void procHorseTurn(); + /* 800F1060 */ void procHorseJumpInit(); + /* 800F10F8 */ void procHorseJump(); + /* 800F1188 */ void procHorseLandInit(); + /* 800F1204 */ void procHorseLand(); + /* 800F1294 */ void procHorseSubjectivityInit(); + /* 800F12F8 */ void procHorseSubjectivity(); + /* 800F13D8 */ void procHorseCutInit(); + /* 800F1688 */ void procHorseCut(); + /* 800F1894 */ void procHorseCutChargeReadyInit(); + /* 800F194C */ void procHorseCutChargeReady(); + /* 800F1AAC */ void procHorseCutTurnInit(); + /* 800F1BA4 */ void procHorseCutTurn(); + /* 800F1D18 */ void procHorseDamageInit(dCcD_GObjInf*); + /* 800F2028 */ void procHorseDamage(); + /* 800F2150 */ void procHorseBowSubjectInit(); + /* 800F21B4 */ void procHorseBowSubject(); + /* 800F224C */ void procHorseBowMoveInit(); + /* 800F22A8 */ void procHorseBowMove(); + /* 800F2334 */ void procHorseGrabMoveInit(); + /* 800F2390 */ void procHorseGrabMove(); + /* 800F2454 */ void procHorseBoomerangSubjectInit(); + /* 800F24C8 */ void procHorseBoomerangSubject(); + /* 800F25B4 */ void procHorseBoomerangMoveInit(); + /* 800F2628 */ void procHorseBoomerangMove(); + /* 800F26F4 */ void procHorseHookshotSubjectInit(); + /* 800F2770 */ void procHorseHookshotSubject(); + /* 800F2824 */ void procHorseHookshotMoveInit(); + /* 800F2898 */ void procHorseHookshotMove(); + /* 800F2934 */ void procHorseBottleDrinkInit(u16); + /* 800F2AD8 */ void procHorseBottleDrink(); + /* 800F2B4C */ void procHorseKandelaarPourInit(); + /* 800F2C78 */ void procHorseKandelaarPour(); + /* 800F2D84 */ void procHorseComebackInit(); + /* 800F2DE4 */ void procHorseComeback(); + /* 800F2EE0 */ void procHorseRunInit(); + /* 800F2F98 */ void procHorseRun(); + /* 800F3430 */ void procHorseHangInit(dCcD_GObjInf*, int); + /* 800F3580 */ void procHorseHang(); + /* 800F36E4 */ void procHorseGetKeyInit(); + /* 800F3754 */ void procHorseGetKey(); + /* 800F3818 */ void procHorseLookDownInit(); + /* 800F3894 */ void procHorseLookDown(); + /* 800F38E8 */ void procBoarRunInit(); + /* 800F3998 */ void procBoarRun(); + /* 800F3BB0 */ void getCanoeMaxSpeed() const; + /* 800F3BDC */ void getCanoeBackMaxSpeed() const; + /* 800F3BEC */ void getCanoeCres() const; + /* 800F3C18 */ void getCanoeSpeedRate() const; + /* 800F3C44 */ void getCanoeMaxRotSpeed() const; + /* 800F3CCC */ void getCanoeLocalPaddleTop(); + /* 800F3CF8 */ void checkCanoeRideTandem(); + /* 800F3D58 */ void checkFishingRodAndLureItem() const; + /* 800F3DA0 */ void initFishingRodHand(); + /* 800F3DFC */ void getCanoePaddleMatrix(); + /* 800F3E4C */ void checkFishingRodGrab(fopAc_ac_c*) const; + /* 800F3EB8 */ void checkCanoePaddleGrab(fopAc_ac_c*) const; + /* 800F3F38 */ void checkCanoeFishingRodGrabOrPut() const; + /* 800F3FC4 */ void initCanoeRide(); + /* 800F4008 */ void checkCanoeJumpRide(); + /* 800F40E4 */ void setArmReelAnime(); + /* 800F4140 */ void setFishingWaitAction(); + /* 800F4490 */ void setFishGetFace(); + /* 800F4564 */ void setRideCanoeBasePos(fopAc_ac_c*); + /* 800F459C */ void setSyncCanoePos(); + /* 800F47D8 */ void canoeCommon(); + /* 800F4924 */ void checkNextActionCanoe(); + /* 800F4A50 */ void procCanoeRideInit(); + /* 800F4B90 */ void procCanoeRide(); + /* 800F4C78 */ void procCanoeJumpRideInit(fopAc_ac_c*); + /* 800F4D84 */ void procCanoeJumpRide(); + /* 800F4DF8 */ void procCanoeGetOffInit(); + /* 800F5048 */ void procCanoeGetOff(); + /* 800F51E4 */ void procCanoeWaitInit(int); + /* 800F542C */ void procCanoeWait(); + /* 800F571C */ void procCanoeRowInit(int); + /* 800F5A1C */ void procCanoeRow(); + /* 800F5D04 */ void procCanoePaddleShiftInit(int); + /* 800F5DB8 */ void procCanoePaddleShift(); + /* 800F5EA8 */ void procCanoePaddlePutInit(int); + /* 800F5FEC */ void procCanoePaddlePut(); + /* 800F6140 */ void procCanoePaddleGrabInit(); + /* 800F6188 */ void procCanoePaddleGrab(); + /* 800F6320 */ void procCanoeRodGrabInit(); + /* 800F6394 */ void procCanoeRodGrab(); + /* 800F6464 */ void procCanoeFishingWaitInit(); + /* 800F659C */ void procCanoeFishingWait(); + /* 800F67C0 */ void procCanoeFishingReelInit(); + /* 800F6874 */ void procCanoeFishingReel(); + /* 800F69D4 */ void procCanoeFishingGetInit(); + /* 800F6A70 */ void procCanoeFishingGet(); + /* 800F6BEC */ void procCanoeSubjectivityInit(); + /* 800F6C30 */ void procCanoeSubjectivity(); + /* 800F6D10 */ void procCanoeBowSubjectInit(); + /* 800F6D64 */ void procCanoeBowSubject(); + /* 800F6DF0 */ void procCanoeBowMoveInit(); + /* 800F6E44 */ void procCanoeBowMove(); + /* 800F6EB0 */ void procCanoeGrabMoveInit(); + /* 800F6EFC */ void procCanoeGrabMove(); + /* 800F6FA4 */ void procCanoeBoomerangSubjectInit(); + /* 800F7010 */ void procCanoeBoomerangSubject(); + /* 800F70F0 */ void procCanoeBoomerangMoveInit(); + /* 800F715C */ void procCanoeBoomerangMove(); + /* 800F7208 */ void procCanoeHookshotSubjectInit(); + /* 800F7274 */ void procCanoeHookshotSubject(); + /* 800F731C */ void procCanoeHookshotMoveInit(); + /* 800F7388 */ void procCanoeHookshotMove(); + /* 800F7404 */ void procCanoeBottleDrinkInit(u16); + /* 800F7550 */ void procCanoeBottleDrink(); + /* 800F75BC */ void procCanoeKandelaarPourInit(); + /* 800F7684 */ void procCanoeKandelaarPour(); + /* 800F7708 */ void setGroundFishingRodActor(); + /* 800F7760 */ void procFishingCastInit(); + /* 800F7814 */ void procFishingCast(); + /* 800F7988 */ void procFishingFoodInit(); + /* 800F7AA8 */ void procFishingFood(); + /* 800F7C50 */ void getCrawlMoveAnmSpeed(); + /* 800F7C74 */ void getCrawlMoveSpeed(); + /* 800F7CE8 */ void setCrawlMoveDirectionArrow(); + /* 800F7E48 */ void changeCrawlAutoMoveProc(cXyz*); + /* 800F81C0 */ void getCrawlMoveVec(cXyz*, cXyz*, cXyz*, int, int, u8*); + /* 800F85C0 */ void crawlBgCheck(cXyz*, cXyz*, int); + /* 800F8700 */ void checkCrawlSideWall(cXyz*, cXyz*, cXyz*, cXyz*, s16*, s16*); + /* 800F88F8 */ void decideCrawlDoStatus(); + /* 800F89E0 */ void checkNotCrawlStand(cXyz*); + /* 800F8A50 */ void checkNotCrawlStand(cXyz*, cXyz*); + /* 800F8B00 */ void checkCrawlInHoll(cXyz*, cXyz*, cXyz*, int); + /* 800F8D04 */ void setCrawlMoveHoll(); + /* 800F8DBC */ void setCrawlMoveAngle(); + /* 800F8F08 */ void stopHalfMoveAnime(f32); + /* 800F8F84 */ void setCrawlAutoMoveAimPos(); + /* 800F9210 */ void procCrawlStartInit(); + /* 800F9384 */ void procCrawlStart(); + /* 800F9474 */ void procCrawlMoveInit(s16, s16); + /* 800F95B8 */ void procCrawlMove(); + /* 800F99FC */ void procCrawlAutoMoveInit(int, cXyz*); + /* 800F9ABC */ void procCrawlAutoMove(); + /* 800F9D7C */ void procCrawlEndInit(int, s16, s16); + /* 800F9F30 */ void procCrawlEnd(); + /* 800F9FDC */ void getHangMoveAnmSpeed(); + /* 800F9FFC */ void getHangDirectionFromAngle(); + /* 800FA070 */ void hangMoveBgCheck(s16, cXyz*); + /* 800FA338 */ void changeHangMoveProc(int); + /* 800FA5C8 */ void checkHangFootWall(); + /* 800FA6E4 */ void setHangGroundY(); + /* 800FA78C */ void changeHangEndProc(); + /* 800FA85C */ void checkHangStartSideWall(s16); + /* 800FAA7C */ void procHangStartInit(); + /* 800FAE14 */ void procHangStart(); + /* 800FAECC */ void procHangFallStartInit(cM3dGPla*); + /* 800FB1A4 */ void procHangFallStart(); + /* 800FB2A0 */ void procHangUpInit(int); + /* 800FB328 */ void procHangUp(); + /* 800FB43C */ void procHangWaitInit(); + /* 800FB544 */ void procHangWait(); + /* 800FB650 */ void procHangMoveInit(int); + /* 800FB790 */ void procHangMove(); + /* 800FBBC8 */ void procHangClimbInit(f32); + /* 800FBCD4 */ void procHangClimb(); + /* 800FBE04 */ void procHangWallCatchInit(); + /* 800FC0D8 */ void procHangWallCatch(); + /* 800FC178 */ void procHangReadyInit(); + /* 800FC240 */ void procHangReady(); + /* 800FC2F4 */ void procHangLeverDownInit(); + /* 800FC390 */ void procHangLeverDown(); + /* 800FC5A4 */ void setDragonHangPos(); + /* 800FC6B4 */ void setOctaIealHangPos(); + /* 800FC748 */ void setBossBodyHangPos(); + /* 800FC77C */ void procBossBodyHangInit(fopAc_ac_c*); + /* 800FC870 */ void procBossBodyHang(); + /* 800FCF58 */ void getLadderUnitCount() const; + /* 800FCF84 */ void setLadderInit(); + /* 800FD048 */ void setLadderPosInit(); + /* 800FD1F0 */ void setLadderPos(int); + /* 800FD288 */ void getLadderMoveAnmSpeed(); + /* 800FD2AC */ void changeLadderMoveProc(int); + /* 800FD4A8 */ void setMoveBGLadderCorrect(); + /* 800FD5E4 */ void checkLadderFall(); + /* 800FD648 */ void procLadderUpStartInit(); + /* 800FD7B0 */ void procLadderUpStart(); + /* 800FD824 */ void procLadderUpEndInit(int); + /* 800FD8E8 */ void procLadderUpEnd(); + /* 800FD9CC */ void procLadderDownStartInit(); + /* 800FDB74 */ void procLadderDownStart(); + /* 800FDC18 */ void procLadderDownEndInit(int); + /* 800FDCCC */ void procLadderDownEnd(); + /* 800FDD90 */ void procLadderMoveInit(int, int, cXyz*); + /* 800FDF50 */ void procLadderMove(); + /* 800FE010 */ void getClimbMoveUpDownAnmSpeed(); + /* 800FE034 */ void getClimbMoveSideAnmSpeed(); + /* 800FE058 */ void checkClimbCode(cBgS_PolyInfo&); + /* 800FE114 */ void setClimbInit(); + /* 800FE174 */ void setClimbShapeOffset(); + /* 800FE3C4 */ void getClimbDirectionFromAngle(); + /* 800FE438 */ void changeClimbMoveProc(int); + /* 800FE5A0 */ void checkClimbMoveUpDownProc(int); + /* 800FE6E8 */ void checkClimbMoveSideProc(int); + /* 800FE868 */ void setMoveBGClimbCorrect(); + /* 800FEB90 */ void checkBgCorrectClimbMove(cXyz*, cXyz*); + /* 800FEC70 */ void checkClimbRoof(f32); + /* 800FED50 */ void checkClimbGround(cXyz*, f32); + /* 800FEEC0 */ void checkBgClimbMove(int); + /* 800FF28C */ void setClimbStartNotGround(); + /* 800FF450 */ void procClimbUpStartInit(int); + /* 800FF704 */ void procClimbUpStart(); + /* 800FF818 */ void procClimbDownStartInit(s16); + /* 800FF9A8 */ void procClimbDownStart(); + /* 800FFAB0 */ void procClimbMoveUpDownInit(int); + /* 800FFC58 */ void procClimbMoveUpDown(); + /* 800FFDB0 */ void procClimbMoveSideInit(); + /* 800FFF4C */ void procClimbMoveSide(); + /* 801000F8 */ void procClimbWaitInit(int, int); + /* 80100258 */ void procClimbWait(); + /* 801003E4 */ void procClimbToRoofInit(); + /* 80100464 */ void procClimbToRoof(); + /* 801005CC */ void getRoofHangFMoveAnmSpeed() const; + /* 801005F0 */ void getRoofHangSMoveAnmSpeed() const; + /* 80100614 */ void setRoofHangHandOnSE(cBgS_PolyInfo*); + /* 80100668 */ void checkRoofHangMovePos(); + /* 80100770 */ void commonRoofHangProc(); + /* 801008EC */ void checkNextActionRoofHang(); + /* 80100A10 */ void procRoofHangStartInit(cBgS_PolyInfo const&, cXyz const&, int); + /* 80100AE4 */ void procRoofHangStart(); + /* 80100BB4 */ void procRoofHangWaitInit(int); + /* 80100D38 */ void procRoofHangWait(); + /* 80100DA4 */ void procRoofHangFrontMoveInit(); + /* 80100EEC */ void procRoofHangFrontMove(); + /* 8010121C */ void procRoofHangSideMoveInit(); + /* 80101308 */ void procRoofHangSideMove(); + /* 801013B8 */ void procRoofHangTurnInit(); + /* 80101534 */ void procRoofHangTurn(); + /* 8010163C */ void setRoofHangSwitch(); + /* 801016AC */ void procRoofSwitchHangInit(fopAc_ac_c*); + /* 801017AC */ void procRoofSwitchHang(); + /* 80101890 */ void checkZoraWearMaskDraw(); + /* 801018E4 */ void checkAcceptUseItemInWater(u16) const; + /* 80101934 */ void swimDeleteItem(); + /* 801019B8 */ void getZoraSwim() const; + /* 80101A18 */ void getSwimFrontMaxSpeed() const; + /* 80101AA8 */ void getSwimMaxFallSpeed() const; + /* 80101B44 */ void checkOxygenTimer(); + /* 80101C94 */ void offOxygenTimer(); + /* 80101CB8 */ void checkPossibleWaterInMode() const; + /* 80101CF4 */ void setWaterInAnmRate(daPy_frameCtrl_c*, f32); + /* 80101D70 */ void swimBgCheck(f32); + /* 801023E4 */ void setSpeedAndAngleSwim(); + /* 801029C8 */ void checkNextActionSwim(); + /* 80102B1C */ void checkSwimAction(int); + /* 80103058 */ void checkSwimUpAction(); + /* 801032C8 */ void swimOutAfter(int); + /* 80103398 */ void checkSwimFall(); + /* 801033CC */ void checkSwimOutAction(); + /* 80103698 */ void setSwimMoveAnime(); + /* 80103EE0 */ void checkSwimButtonAccept(); + /* 80103F08 */ void checkUpSwimButtonAccept(); + /* 80103F24 */ void checkSwimButtonMove(); + /* 80103F94 */ void checkZoraSwimMove(); + /* 80103FE8 */ void checkSwimNeckUpDown() const; + /* 80104034 */ void setSwimUpDownOffset(); + /* 801040F8 */ void procSwimUpInit(); + /* 801041E8 */ void procSwimUp(); + /* 801042F8 */ void procSwimWaitInit(int); + /* 801044B4 */ void procSwimWait(); + /* 80104670 */ void procSwimMoveInit(); + /* 801047B8 */ void procSwimMove(); + /* 80104958 */ void procSwimDiveInit(); + /* 80104AA0 */ void procSwimDive(); + /* 80104C50 */ void procSwimHookshotSubjectInit(); + /* 80104D7C */ void procSwimHookshotSubject(); + /* 80104EB8 */ void procSwimHookshotMoveInit(); + /* 80104FC4 */ void procSwimHookshotMove(); + /* 8010519C */ void procSwimDamageInit(dCcD_GObjInf*); + /* 80105728 */ void procSwimDamage(); + /* 801058A0 */ void procOctaIealSpitInit(); + /* 80105A00 */ void procOctaIealSpit(); + /* 80105A98 */ void checkSnowCode() const; + /* 80105ABC */ void checkSnowCodePolygon(cBgS_PolyInfo&); + /* 80105B10 */ void checkBoardRestart(); + /* 80105B58 */ void boardCommon(int); + /* 80106534 */ void setCommonBoardAnime(int); + /* 8010658C */ void checkNextActionBoard(); + /* 80106618 */ void checkBoardSwordTriggerAction(); + /* 80106650 */ void commonProcBoardInit(daAlink_c::daAlink_PROC); + /* 801066B8 */ void getBoardRowAnmSpeed(); + /* 801066EC */ void setBoardLandAnime(); + /* 80106774 */ void procBoardRideInit(); + /* 801069D0 */ void procBoardRide(); + /* 80106A38 */ void procBoardWaitInit(fopAc_ac_c*); + /* 80106BCC */ void procBoardWait(); + /* 80106E88 */ void procBoardRowInit(); + /* 80106F00 */ void procBoardRow(); + /* 80107060 */ void procBoardTurnInit(); + /* 801070DC */ void procBoardTurn(); + /* 80107218 */ void procBoardJumpInit(f32, int); + /* 80107300 */ void procBoardJump(); + /* 801073D0 */ void procBoardSubjectivityInit(); + /* 80107418 */ void procBoardSubjectivity(); + /* 801074AC */ void procBoardCutInit(); + /* 8010755C */ void procBoardCut(); + /* 801075D4 */ void procBoardCutTurnInit(); + /* 80107744 */ void procBoardCutTurn(); + /* 801083C8 */ void hookshotAtHitCallBack(dCcD_GObjInf*, fopAc_ac_c*, dCcD_GObjInf*); + /* 801086DC */ void resetHookshotMode(); + /* 8010871C */ void setEnemyBombHookshot(fopAc_ac_c*); + /* 80108784 */ void checkLv7BossRoom(); + /* 801087B0 */ void checkHookshotStickBG(cBgS_PolyInfo&); + /* 80108828 */ void cancelHookshotCarry(); + /* 80108864 */ void changeHookshotDrawModel(); + /* 801088A0 */ void checkHookshotRoofLv7Boss(); + /* 801088C8 */ void checkChaseHookshot(); + /* 80108980 */ void checkOctaIealSpecialCollect(); + /* 801089E8 */ void checkBossOctaIealRoom(); + /* 80108A18 */ void checkHookshotWait() const; + /* 80108A3C */ void setHookshotCatchNow(); + /* 80108B34 */ void setHookshotModel(); + /* 80108DB4 */ void setHookshotSight(); + /* 80108EEC */ void cancelHookshotShot(); + /* 80108F64 */ void cancelHookshotMove(); + /* 8010903C */ void checkHookshotReadyMaterialOffMode() const; + /* 80109070 */ void setHookshotReadyMaterial(); + /* 801090EC */ void initHookshotUpperAnimeSpeed(int); + /* 80109170 */ void initHookshotReady(); + /* 801091E4 */ void setHookshotReadyAnime(); + /* 80109284 */ void checkUpperItemActionHookshot(); + /* 801095C8 */ void checkNextActionHookshot(); + /* 801097A0 */ void setHookshotReturnEnd(); + /* 80109890 */ void setHookshotHangMoveBGCollect(); + /* 80109AAC */ void setHookshotTopPosFly(); + /* 80109BDC */ void setHookshotPos(); + /* 8010B2DC */ void setHookshotRoofWaitAnime(); + /* 8010B35C */ void setHookshotWallWaitAnime(); + /* 8010B3AC */ void hookshotRoofTurn(); + /* 8010B644 */ void initHookshotRoofWaitActor(fopAc_ac_c*); + /* 8010B720 */ void checkNextHookPoint(); + /* 8010B84C */ void checkLandHookshotHang(); + /* 8010B96C */ void commonHookshotRoofWait(); + /* 8010BA6C */ void commonHookshotWallWait(); + /* 8010BAA8 */ void procHookshotSubjectInit(); + /* 8010BB48 */ void procHookshotSubject(); + /* 8010BC08 */ void procHookshotMoveInit(); + /* 8010BCA4 */ void procHookshotMove(); + /* 8010BD90 */ void procHookshotFlyInit(); + /* 8010BEF0 */ void procHookshotFly(); + /* 8010C830 */ void procHookshotRoofWaitInit(int, fopAc_ac_c*, int); + /* 8010C9F4 */ void procHookshotRoofWait(); + /* 8010CC80 */ void procHookshotRoofShootInit(fopAc_ac_c*); + /* 8010CD60 */ void procHookshotRoofShoot(); + /* 8010CF6C */ void procHookshotRoofBootsInit(fopAc_ac_c*); + /* 8010D034 */ void procHookshotRoofBoots(); + /* 8010D174 */ void procHookshotWallWaitInit(int, s16, int); + /* 8010D38C */ void procHookshotWallWait(); + /* 8010D5F4 */ void procHookshotWallShootInit(); + /* 8010D6CC */ void procHookshotWallShoot(); + /* 8010D93C */ void getSpinnerGravity() const; + /* 8010D94C */ void getSpinnerMaxFallSpeed() const; + /* 8010D95C */ void getSpinnerJumpRate() const; + /* 8010D96C */ void getSpinnerRideMoveTime(); + /* 8010D9B0 */ void getSpinnerRideSpeedF(); + /* 8010D9F4 */ void getSpinnerRideDecSpeedMax() const; + /* 8010DA04 */ void getSpinnerRideDecSpeedMin() const; + /* 8010DA14 */ void getSpinnerRideDecSpeedRate() const; + /* 8010DA24 */ void getSpinnerRideRotAngleMax() const; + /* 8010DA34 */ void getSpinnerRideRotAngleMin() const; + /* 8010DAFC */ void checkLv4BossRoom(); + /* 8010DBC8 */ void setSpinnerSyncPos(); + /* 8010DC64 */ void procSpinnerReadyInit(); + /* 8010DDCC */ void procSpinnerReady(); + /* 8010DE64 */ void setSpinnerStatus(u8, u8); + /* 8010DE78 */ void procSpinnerWaitInit(); + /* 8010DF4C */ void procSpinnerWait(); + /* 8010E48C */ void bottleModelCallBack(); + /* 8010E584 */ void checkOilBottleItemNotGet(u16); + /* 8010E5D8 */ void setBottleModel(u16); + /* 8010EAC4 */ void commonBottleDrink(int); + /* 8010F45C */ void makeFairy(cXyz*, u32); + /* 8010F54C */ void procBottleDrinkInit(u16); + /* 8010F698 */ void procBottleDrink(); + /* 8010F6F4 */ void procBottleOpenInit(u16); + /* 8010F8E4 */ void procBottleOpen(); + /* 8010FC38 */ void procBottleSwingInit(fopAc_ac_c*, int); + /* 8010FF58 */ void procBottleSwing(); + /* 801102D0 */ void procBottleGetInit(int); + /* 80110518 */ void procBottleGet(); + /* 8011078C */ void checkWaterInKandelaarOffset(f32); + /* 801107BC */ void checkWaterInKandelaar(f32); + /* 80110840 */ void offKandelaarModel(); + /* 801108EC */ void kandelaarModelCallBack(); + /* 80110C6C */ void checkKandelaarEquipAnime() const; + /* 80110C94 */ void preKandelaarDraw(); + /* 80110E84 */ void setKandelaarModel(); + /* 80110F88 */ void resetOilBottleModel(); + /* 80110FE0 */ void commonKandelaarPourInit(); + /* 801110B8 */ void commonKandelaarPour(int); + /* 8011130C */ void initKandelaarSwing(); + /* 80111440 */ void procKandelaarSwingInit(); + /* 801115CC */ void procKandelaarSwing(); + /* 8011167C */ void procKandelaarPourInit(); + /* 80111724 */ void procKandelaarPour(); + /* 80111784 */ void setGrassWhistleModel(int); + /* 8011181C */ void setHorseWhistleModel(); + /* 80111894 */ void procGrassWhistleGetInit(); + /* 801119D8 */ void procGrassWhistleGet(); + /* 80111A9C */ void procGrassWhistleWaitInit(int, int, int, s16, cXyz*); + /* 80111CA4 */ void procGrassWhistleWait(); + /* 80111FF0 */ void procCoHorseCallWaitInit(int); + /* 801120C8 */ void procCoHorseCallWait(); + /* 801121B4 */ void procHawkCatchInit(); + /* 80112220 */ void procHawkCatch(); + /* 80112278 */ void procHawkSubjectInit(); + /* 80112304 */ void procHawkSubject(); + /* 80112474 */ void checkIronBallThrowMode() const; + /* 801124B4 */ void checkIronBallThrowReturnMode() const; + /* 80112568 */ void setIronBallWaitUpperAnime(int); + /* 80112628 */ void checkIronBallDelete(); + /* 801126F8 */ void setIronBallReturn(int); + /* 80112768 */ void setIronBallBgCheckPos(); + /* 801127F0 */ void setIronBallModel(); + /* 80112C84 */ void setIronBallGroundVec(cXyz const*, cXyz*); + /* 80112E7C */ void setIronBallChainPos(); + /* 80113CA0 */ void checkIronBallReturnChange(); + /* 80113D58 */ void setIronBallPos(); + /* 801150E4 */ void checkIronBallAnime() const; + /* 8011510C */ void setIronBallReadyAnime(); + /* 801151E0 */ void setIronBallBaseAnime(); + /* 80115254 */ void checkUpperItemActionIronBall(); + /* 801153F8 */ void checkNextActionIronBall(); + /* 801154E4 */ void procIronBallSubjectInit(); + /* 80115564 */ void procIronBallSubject(); + /* 801155EC */ void procIronBallMoveInit(); + /* 80115674 */ void procIronBallMove(); + /* 8011577C */ void procIronBallThrowInit(); + /* 80115860 */ void procIronBallThrow(); + /* 801159F0 */ void procIronBallReturnInit(); + /* 80115AA0 */ void procIronBallReturn(); + /* 80115C20 */ void checkEventRun() const; + /* 80115C50 */ void createNpcTks(cXyz*, int, u32); + /* 80115EC0 */ void checkDemoAction(); + /* 80116E60 */ void checkDemoMoveMode(u32) const; + /* 80116E9C */ void setDemoMoveData(u32*, cXyz const*); + /* 80117064 */ void setNoDrawSwordShield(int, u16); + /* 801171F4 */ void setDemoData(); + /* 80117B90 */ void resetDemoBck(); + /* 80117C34 */ void endHighModel(); + /* 80117C90 */ void resetSpecialEvent(); + /* 80117CF8 */ void endDemoMode(); + /* 801180EC */ void getDemoLookActor(); + /* 80118170 */ void checkFlyAtnWait(); + /* 801181A0 */ void setGetItemFace(u16); + /* 801182D4 */ void checkGrabTalkActor(fopAc_ac_c*); + /* 80118308 */ void setTalkStartBack(cXyz*); + /* 8011856C */ void setShapeAngleToTalkActor(); + /* 80118654 */ void setTalkAnime(); + /* 801186D4 */ void setTradeItemAnime(); + /* 80118778 */ void setTradeItemOutHand(); + /* 801187B4 */ void checkEndMessage(u32); + /* 80118840 */ void setDemoRightHandIndex(u16); + /* 801188B0 */ void setDemoLeftHandIndex(u16); + /* 8011894C */ void setDemoRide(u16); + /* 801189F8 */ void setDemoBodyBck(dDemo_actor_c*, u16); + /* 80118AD0 */ void checkFinalBattle(); + /* 80118B34 */ void checkRestartDead(int, int); + /* 80118BF4 */ void setDeadRideSyncPos(); + /* 80118C98 */ void checkDeadHP(); + /* 80118D7C */ void checkDeadAction(int); + /* 80118FF8 */ void setHighModelBck(mDoExt_bckAnm*, u16); + /* 801190A4 */ void setHighModelFaceBtk(u16); + /* 80119134 */ void setDemoBrk(J3DAnmTevRegKey**, J3DModel*, u16); + /* 801191C4 */ void setStickAnmData(J3DAnmBase*, int, int, u16, int); + /* 801195C0 */ void procDemoCommon(); + /* 801195F8 */ void procCoToolDemoInit(); + /* 801196D8 */ void procCoToolDemo(); + /* 80119D98 */ void procCoTalkInit(); + /* 80119F64 */ void procCoTalk(); + /* 8011A214 */ void procCoOpenTreasureInit(); + /* 8011A42C */ void procCoOpenTreasure(); + /* 8011A4C0 */ void procCoUnequipInit(); + /* 8011A5CC */ void procCoUnequip(); + /* 8011A688 */ void setGetSubBgm(int); + /* 8011A798 */ void procCoGetItemInit(); + /* 8011AC28 */ void procCoGetItem(); + /* 8011B3F0 */ void procCoTurnBackInit(); + /* 8011B46C */ void procCoTurnBack(); + /* 8011B57C */ void procDoorOpenInit(); + /* 8011B71C */ void procDoorOpen(); + /* 8011B914 */ void procCoLookWaitInit(); + /* 8011BA20 */ void procCoLookWait(); + /* 8011BABC */ void procCoDemoPushPullWaitInit(); + /* 8011BB40 */ void procCoDemoPushMoveInit(); + /* 8011BC14 */ void setMonkeyMoveAnime(); + /* 8011BC74 */ void procMonkeyMoveInit(); + /* 8011BD18 */ void procMonkeyMove(); + /* 8011BD6C */ void procDemoBoomerangCatchInit(); + /* 8011BDF0 */ void procDemoBoomerangCatch(); + /* 8011BE54 */ void procCoDeadInit(int); + /* 8011C1B4 */ void procCoDead(); + /* 8011C62C */ void procCoLookAroundInit(); + /* 8011C760 */ void procCoLookAround(); + /* 8011C81C */ void procBossAtnWaitInit(); + /* 8011C890 */ void procCoQuakeWaitInit(); + /* 8011C904 */ void procCoCaughtInit(); + /* 8011C9D0 */ void procLookUpInit(); + /* 8011CA4C */ void procLookUp(); + /* 8011CA98 */ void procLookUpToGetItemInit(); + /* 8011CB20 */ void procLookUpToGetItem(); + /* 8011CBD4 */ void procHandPatInit(); + /* 8011CCA8 */ void procHandPat(); + /* 8011CDE0 */ void procCoFogDeadInit(); + /* 8011CF60 */ void procCoFogDead(); + /* 8011D0A0 */ void procWolfSmellWaitInit(); + /* 8011D110 */ void procCoNodInit(); + /* 8011D1F4 */ void procCoNod(); + /* 8011D268 */ void procCoEyeAwayInit(); + /* 8011D304 */ void procCoGlareInit(); + /* 8011D3CC */ void procCoGlare(); + /* 8011D474 */ void procGoatStopReadyInit(); + /* 8011D4D4 */ void procGoatStopReady(); + /* 8011D544 */ void procCoGetReadySitInit(); + /* 8011D64C */ void procCoGetReadySit(); + /* 8011D6D0 */ void procCoTwGateInit(); + /* 8011D7D4 */ void procCoTwGate(); + /* 8011D82C */ void procWolfSnowEscapeInit(); + /* 8011D8F8 */ void procWolfSnowEscape(); + /* 8011DB04 */ void procZoraMoveInit(); + /* 8011DB9C */ void procZoraMove(); + /* 8011DDD4 */ void procLookAroundTurnInit(); + /* 8011DED8 */ void procLookAroundTurn(); + /* 8011DF68 */ void procTradeItemOutInit(); + /* 8011E060 */ void procTradeItemOut(); + /* 8011E3D8 */ void checkLetterItem(int); + /* 8011E448 */ void procNotUseItemInit(int); + /* 8011E57C */ void procNotUseItem(); + /* 8011E6E0 */ void procSwordReadyInit(); + /* 8011E748 */ void procSwordReady(); + /* 8011E83C */ void setSwordPushAnime(); + /* 8011E8E0 */ void procSwordPushInit(); + /* 8011E960 */ void procSwordPush(); + /* 8011E9F8 */ void procGanonFinishInit(); + /* 8011EA78 */ bool procGanonFinish(); + /* 8011EAE8 */ void procCutFastReadyInit(); + /* 8011EB8C */ void procCutFastReady(); + /* 8011EBDC */ void procMasterSwordStickInit(); + /* 8011EC60 */ void procMasterSwordStick(); + /* 8011ED18 */ bool procMasterSwordPullInit(); + /* 8011ED8C */ void procMasterSwordPull(); + /* 8011EE40 */ void checkLv7DungeonShop(); + /* 8011EE94 */ void procDungeonWarpReadyInit(); + /* 8011EFB8 */ void procDungeonWarpReady(); + /* 8011F084 */ void procDungeonWarpInit(); + /* 8011F0F4 */ void procDungeonWarp(); + /* 8011F360 */ void procDungeonWarpSceneStartInit(); + /* 8011F460 */ void procDungeonWarpSceneStart(); + /* 8011F658 */ void checkAcceptWarp(); + /* 8011F7D8 */ void dungeonReturnWarp(); + /* 8011F9EC */ void checkWarpStart(); + /* 8011FBC0 */ void warpModelTexScroll(); + /* 8011FD4C */ void procCoWarpInit(int, int); + /* 80120124 */ void procCoWarp(); + /* 80120440 */ void commonWaitTurnInit(); + /* 80120474 */ void commonGrabPutInit(); + /* 80120500 */ void commonLargeDamageUpInit(int, int, s16, s16); + /* 80120534 */ void commonFallInit(int); + /* 80120580 */ void setEmitter(u32*, u16, cXyz const*, csXyz const*); + /* 80120634 */ void setEmitterPolyColor(u32*, u16, cBgS_PolyInfo&, cXyz const*, csXyz const*); + /* 801206C4 */ void setEmitterColor(u32*, u16, cXyz const*, csXyz const*); + /* 80120778 */ void stopDrawParticle(u32); + /* 801207BC */ void setEffectFrontRollParam(); + /* 80120880 */ void setEffectSlipParam(); + /* 80120B00 */ void setEffectRunParam(); + /* 80120DB0 */ void setEffectSmallLandParam(); + /* 80121000 */ void setEffectLandParam(); + /* 80121004 */ void setEffectSumouParam(); + /* 801211C0 */ void setFootEffectProcType(int); + /* 80121214 */ void setWolfFootOn(int); + /* 80121304 */ void setFootMark(cXyz*, u16, int); + /* 80121388 */ void setEffect(); + /* 801221F0 */ void setSumouEffect(); + /* 801225E8 */ void setWaterfallEffect(cXyz const*, u32*); + /* 80122654 */ void setWaterfallEffect(); + /* 8012277C */ void setMagneBootsEffect(); + /* 801228F4 */ void setSwordChargeEffect(); + /* 80122BBC */ void setElecDamageEffect(); + /* 80122F18 */ void clearCutTurnEffectID(); + /* 80122F78 */ void setCutTurnEffect(); + /* 801233A4 */ void setHorseCutTurnEffect(); + /* 80123434 */ void setCutLargeJumpLandEffect(); + /* 801236BC */ void setBootsLightEffect(); + /* 801237A8 */ void setLightningSwordEffect(); + /* 801238FC */ void setWolfRollAttackEffect(); + /* 801239B0 */ void setWolfDigEffect(); + /* 80123BF0 */ void setWolfSwimEndEffect(JPABaseEmitter**, JPABaseEmitter**); + /* 80123C8C */ void setWolfLockAttackEffect(); + /* 80123D88 */ void setWolfJumpAttackEffect(); + /* 80123ED0 */ void setWolfBarrierHitEffect(dBgS_LinChk&); + /* 80124144 */ void setCutWaterDropEffect(); + /* 801241E0 */ void setWaterDropEffect(); + /* 801244E4 */ void setSwordUpColorEffect(); + /* 801245EC */ void setSwordCutSplash(); + /* 80124738 */ void setMetamorphoseEffectStartLink(); + /* 801247A8 */ void setMetamorphoseEffect(); + /* 801248A8 */ void setRunSplash(); + /* 80124B68 */ void resetFairyEffect(); + /* 80124BA4 */ void setBottleEffect(); + /* 80124E28 */ void clearFirePointDamageEffect(int); + /* 80124EA8 */ void initFirePointDamageEffectAll(); + /* 80124FA4 */ void initFirePointDamageEffect(cXyz const*, dCcD_GObjInf*); + /* 80125128 */ void setFirePointDamageEffect(); + /* 80125338 */ void setFreezeEffect(); + /* 80125524 */ void setWoodShieldBurnEffect(); + /* 801255BC */ void clearWoodShieldBurnEffect(); + /* 80125628 */ void setWoodShieldBurnOutEffect(); + /* 80126740 */ void changeCommon(); + /* 80126928 */ void changeWolf(); + /* 80126F3C */ void changeLink(int); + /* 80127C54 */ void onWolfEyeUp(); + /* 80127CAC */ void offWolfEyeUp(); + /* 80127CF0 */ void wolfSenseTrigger(); + /* 80127D14 */ void setWolfSenceStatus(u8); + /* 80127D2C */ void wolfClawTrigger(); + /* 80127D50 */ void setWolfDigStatus(u8); + /* 80127D68 */ BOOL checkWolfShapeReverse() const; + /* 80127DC4 */ void checkWolfSideStep() const; + /* 80127E08 */ void setWolfTailAngle(); + /* 80127F20 */ void checkWolfSlowDash(); + /* 80127F50 */ void setSpeedAndAngleWolf(); + /* 80128478 */ void setSpeedAndAngleWolfAtn(); + /* 80128798 */ void checkWolfAtnWait(); + /* 8012880C */ void checkUnderMove0BckNoArcWolf(daAlink_c::daAlink_WANM) const; + /* 80128844 */ void setBlendWolfMoveAnime(f32); + /* 80128F0C */ void checkWolfAtnMoveBack(s16); + /* 80128F5C */ void setWolfAtnMoveDirection(); + /* 80129114 */ void setBlendWolfAtnMoveAnime(f32); + /* 8012933C */ void setBlendWolfAtnBackMoveAnime(f32); + /* 8012948C */ void setDoubleAnimeWolf(f32, f32, f32, daAlink_c::daAlink_WANM, + daAlink_c::daAlink_WANM, int, f32); + /* 80129678 */ void setSingleAnimeWolfBase(daAlink_c::daAlink_WANM); + /* 801296A8 */ void setSingleAnimeWolfBaseMorf(daAlink_c::daAlink_WANM, f32); + /* 801296D8 */ void setSingleAnimeWolfBaseSpeed(daAlink_c::daAlink_WANM, f32, f32); + /* 80129704 */ void setSingleAnimeWolf(daAlink_c::daAlink_WANM, f32, f32, s16, f32); + /* 80129848 */ void setSingleAnimeWolfParam(daAlink_c::daAlink_WANM, daAlinkHIO_anm_c const*); + /* 8012987C */ void checkWolfLandAction(int); + /* 80129958 */ void checkMidnaUseAbility() const; + /* 801299A8 */ void checkWolfUseAbility(); + /* 80129A80 */ void checkWolfGroundSpecialMode(); + /* 80129B44 */ void checkNextActionWolf(int); + /* 8012A02C */ void wolfSideBgCheck(s16); + /* 8012A228 */ void checkWolfAttackReverse(int); + /* 8012A330 */ void checkWolfBarrierHitReverse(); + /* 8012A41C */ void checkWolfBarrierWallHit(cBgS_PolyInfo&); + /* 8012A498 */ void wolfBgCheck(); + /* 8012ACCC */ void changeWolfBlendRate(int); + /* 8012AD1C */ void setWolfFootMatrix(); + /* 8012B724 */ void wolfFootBgCheck(); + /* 8012BFA8 */ void checkWolfWaitSlipPolygon(); + /* 8012C1F4 */ void setWolfWaitSlip(); + /* 8012C308 */ void checkWolfAtnDoCharge(); + /* 8012C30C */ void setWolfChainPos(); + /* 8012CB0C */ void setWolfAnmVoice(); + /* 8012CBE4 */ void procWolfServiceWaitInit(int); + /* 8012CD28 */ void procWolfServiceWait(); + /* 8012CF68 */ void procWolfTiredWaitInit(); + /* 8012CFEC */ void procWolfTiredWait(); + /* 8012D050 */ void procWolfMidnaRideShockInit(); + /* 8012D104 */ void procWolfMidnaRideShock(); + /* 8012D1A8 */ void procWolfWaitInit(); + /* 8012D2A8 */ void procWolfWait(); + /* 8012D380 */ void procWolfMoveInit(); + /* 8012D3E4 */ void procWolfMove(); + /* 8012D474 */ void procWolfDashInit(); + /* 8012D590 */ void procWolfDash(); + /* 8012D8C0 */ void procWolfDashReverseInit(int); + /* 8012DA5C */ void procWolfDashReverse(); + /* 8012DBA8 */ void procWolfAtnActorMoveInit(); + /* 8012DC44 */ void procWolfAtnActorMove(); + /* 8012DD08 */ void procWolfWaitTurnInit(); + /* 8012DDB4 */ void procWolfWaitTurn(); + /* 8012DEC8 */ void procWolfSideStepInit(int); + /* 8012E0AC */ void procWolfSideStep(); + /* 8012E1E8 */ void procWolfSideStepLandInit(s16); + /* 8012E2DC */ void procWolfSideStepLand(); + /* 8012E398 */ void procWolfBackJumpInit(int); + /* 8012E508 */ void procWolfBackJump(); + /* 8012E5F4 */ void procWolfBackJumpLandInit(s16, s16); + /* 8012E684 */ void procWolfBackJumpLand(); + /* 8012E754 */ void procWolfHowlInit(int); + /* 8012E83C */ void procWolfHowl(); + /* 8012E9C8 */ void procWolfAutoJumpInit(int); + /* 8012EB94 */ void procWolfAutoJump(); + /* 8012EDD0 */ void procWolfFallInit(int, f32); + /* 8012EFB8 */ void procWolfFall(); + /* 8012F138 */ void procWolfLandInit(); + /* 8012F1F0 */ void procWolfLand(); + /* 8012F278 */ void procWolfSitInit(int); + /* 8012F358 */ void procWolfSit(); + /* 8012F41C */ void procWolfStepMoveInit(); + /* 8012F500 */ void procWolfStepMove(); + /* 8012F634 */ void procWolfSlipInit(); + /* 8012F6EC */ void procWolfSlip(); + /* 8012F840 */ void procWolfSlipTurnInit(int); + /* 8012F9C0 */ void procWolfSlipTurn(); + /* 8012FB18 */ void procWolfSlipTurnLandInit(); + /* 8012FBB4 */ void procWolfSlipTurnLand(); + /* 8012FC38 */ void procWolfSlideReadyInit(s16, int); + /* 8012FD2C */ void procWolfSlideReady(); + /* 8012FE80 */ void procWolfSlideInit(s16, int); + /* 8012FFA4 */ void procWolfSlide(); + /* 801300D4 */ void procWolfSlideLandInit(); + /* 80130138 */ void procWolfSlideLand(); + /* 801301E4 */ void procWolfWaitSlipInit(); + /* 80130268 */ void procWolfWaitSlip(); + /* 80130440 */ void procWolfSlopeStartInit(int); + /* 801304D4 */ void procWolfSlopeStart(); + /* 80130654 */ void setWolfHowlNotHappen(int); + /* 80130700 */ void procWolfHowlDemoInit(); + /* 80130BC4 */ void procWolfHowlDemo(); + /* 80131450 */ void checkWolfRopeHit(dCcD_GObjInf*, cXyz const*, int) const; + /* 80131628 */ void checkWolfRopeJumpHang(); + /* 801316A4 */ void getWolfRopeMoveSpeed(); + /* 80131718 */ void setWolfRopePosY(); + /* 801319F0 */ void initWolfRopeShapeAngle(); + /* 80131A6C */ void wolfRopeSwingInc(f32); + /* 80131AFC */ void setWolfRopeOffsetY(int); + /* 80131C00 */ void getDirectionRopeMove() const; + /* 80131C74 */ void procWolfRopeMoveInit(int, int); + /* 80131DA0 */ void procWolfRopeMove(); + /* 80132738 */ void procWolfRopeHangInit(int); + /* 80132914 */ void procWolfRopeHang(); + /* 80132D68 */ void procWolfRopeTurnInit(); + /* 80132E88 */ void procWolfRopeTurn(); + /* 80133054 */ void procWolfRopeStaggerInit(int); + /* 80133164 */ void procWolfRopeStagger(); + /* 8013384C */ void procWolfRopeSubjectivityInit(); + /* 80133930 */ void procWolfRopeSubjectivity(); + /* 80133D6C */ void getWolfTagJumpTime() const; + /* 80133EF0 */ void checkMidnaLockJumpPoint() const; + /* 80134000 */ void procWolfTagJumpInit(fopAc_ac_c*); + /* 80134838 */ void procWolfTagJump(); + /* 80134DB8 */ void procWolfTagJumpLandInit(fopAc_ac_c*); + /* 80134EBC */ void procWolfTagJumpLand(); + /* 80135160 */ void procWolfGiantPuzzleInit(); + /* 801351F8 */ void procWolfGiantPuzzle(); + /* 80135458 */ void setWolfHangGroundY(); + /* 801354C8 */ void changeWolfHangEndProc(); + /* 801355EC */ void procWolfHangReadyInit(); + /* 80135668 */ void procWolfHangReady(); + /* 801356F0 */ void procWolfHangWallCatchInit(int); + /* 80135AF4 */ void procWolfHangWallCatch(); + /* 80135CD8 */ void procWolfHangFallStartInit(cM3dGPla*); + /* 80135F00 */ void procWolfHangFallStart(); + /* 80136064 */ void setWolfHeadDamage(); + /* 801360EC */ void procWolfDamageInit(dCcD_GObjInf*); + /* 80136508 */ void procWolfDamage(); + /* 80136624 */ void procWolfLargeDamageUpInit(int, int, s16, s16); + /* 801369E4 */ void procWolfLargeDamageUp(); + /* 80136C18 */ void procWolfLandDamageInit(int); + /* 80136DE4 */ void procWolfLandDamage(); + /* 80136EC4 */ void setWolfScreamWaitAnime(); + /* 80136F54 */ void procWolfScreamWaitInit(); + /* 80136FF8 */ void procWolfScreamWait(); + /* 801370E4 */ void getWolfLieMoveAnmSpeed(); + /* 8013712C */ void getWolfLieMoveSpeed(); + /* 801371A0 */ void checkMidnaDisappearMode() const; + /* 801371FC */ void checkWolfLieContinue(int); + /* 801372B4 */ void checkNextActionWolfFromLie(); + /* 80137330 */ void setWolfLieMoveVoice(int); + /* 801373F8 */ void checkWolfLieCode(); + /* 80137420 */ void procWolfLieStartInit(int); + /* 8013753C */ void procWolfLieStart(); + /* 80137634 */ void procWolfLieMoveInit(int); + /* 801377F0 */ void procWolfLieMove(); + /* 80137C90 */ void procWolfLieAutoMoveInit(int, cXyz*); + /* 80137D4C */ void procWolfLieAutoMove(); + /* 80138000 */ void setSpeedAndAngleSwimWolf(); + /* 80138188 */ void getWolfSwimMoveAnmSpeed(); + /* 801381F8 */ void decideDoStatusSwimWolf(); + /* 801383D8 */ void procWolfSwimUpInit(); + /* 80138484 */ void procWolfSwimUp(); + /* 8013852C */ void procWolfSwimWaitInit(int); + /* 80138644 */ void procWolfSwimWait(); + /* 8013871C */ void procWolfSwimMoveInit(); + /* 801387A0 */ void procWolfSwimMove(); + /* 8013890C */ void procWolfSwimEndWaitInit(int); + /* 80138A18 */ void procWolfSwimEndWait(); + /* 80138C04 */ void resetWolfEnemyBiteAll(); + /* 80138C44 */ void checkWolfEnemyThrowAction(); + /* 80138CB8 */ void setWolfLockDomeModel(); + /* 80138DC0 */ void setWolfBallModel(); + /* 80138F18 */ void resetWolfBallGrab(); + /* 80139048 */ void checkWolfLockData(); + /* 801391DC */ void getWolfLockActorEnd(); + /* 801391E4 */ void searchWolfLockEnemy(fopAc_ac_c*, void*); + /* 801392E4 */ void checkWolfComboCnt(); + /* 801393A4 */ void checkWolfAttackAction(); + /* 801395B4 */ void setWolfEnemyThrowUpperAnime(daAlink_c::daAlink_WANM, f32); + /* 80139600 */ void setWolfEnemyHangBitePos(fopEn_enemy_c*); + /* 801396F8 */ void setWolfBiteDamage(fopEn_enemy_c*); + /* 801397A4 */ void checkWolfLockAttackChargeState(); + /* 801398A8 */ void procWolfRollAttackChargeInit(); + /* 80139908 */ void procWolfRollAttackCharge(); + /* 801399C4 */ void procWolfRollAttackMoveInit(); + /* 80139A70 */ void procWolfRollAttackMove(); + /* 80139DE0 */ void procWolfJumpAttackInit(int); + /* 8013A4F8 */ void procWolfJumpAttack(); + /* 8013A7EC */ void procWolfJumpAttackKickInit(); + /* 8013A8A0 */ void procWolfJumpAttackKick(); + /* 8013A8FC */ void procWolfJumpAttackSlideLandInit(int, int, int); + /* 8013AAC4 */ void procWolfJumpAttackSlideLand(); + /* 8013AC44 */ void procWolfJumpAttackNormalLandInit(int); + /* 8013ACF4 */ void procWolfJumpAttackNormalLand(); + /* 8013ADF0 */ void procWolfWaitAttackInit(int); + /* 8013AFC0 */ void procWolfWaitAttack(); + /* 8013B2A0 */ void procWolfRollAttackInit(int, int); + /* 8013B424 */ void procWolfRollAttack(); + /* 8013B528 */ void procWolfDownAttackInit(); + /* 8013B808 */ void procWolfDownAttack(); + /* 8013B964 */ void procWolfDownAtLandInit(fopEn_enemy_c*); + /* 8013BA44 */ void procWolfDownAtLand(); + /* 8013BC94 */ void procWolfDownAtMissLandInit(); + /* 8013BD54 */ void procWolfDownAtMissLand(); + /* 8013BE24 */ void procWolfLockAttackInit(int); + /* 8013C3E4 */ void procWolfLockAttack(); + /* 8013C630 */ void procWolfLockAttackTurnInit(int); + /* 8013C7A4 */ void procWolfLockAttackTurn(); + /* 8013C8C8 */ void procWolfAttackReverseInit(); + /* 8013C9EC */ void procWolfAttackReverse(); + /* 8013CB48 */ void procWolfEnemyThrowInit(int); + /* 8013CC5C */ void procWolfEnemyThrow(); + /* 8013CCF4 */ void procWolfEnemyHangBiteInit(); + /* 8013CDEC */ void procWolfEnemyHangBite(); + /* 8013D0D4 */ void procWolfGrabUpInit(); + /* 8013D3FC */ void procWolfGrabUp(); + /* 8013D588 */ void procWolfGrabPutInit(); + /* 8013D65C */ void procWolfGrabPut(); + /* 8013D818 */ void procWolfGrabThrowInit(); + /* 8013D86C */ void procWolfGrabThrow(); + /* 8013D930 */ void procWolfPushInit(); + /* 8013DA8C */ void procWolfPush(); + /* 8013DB6C */ void procWolfCargoCarryInit(); + /* 8013DC5C */ void procWolfCargoCarry(); + /* 8013DDF8 */ void procWolfChainUpInit(); + /* 8013DE70 */ void procWolfChainUp(); + /* 8013DF30 */ void procWolfGanonCatchInit(); + /* 8013E034 */ void procWolfGanonCatch(); + /* 8013E240 */ void procWolfChainReadyInit(); + /* 8013E2A8 */ void procWolfChainReady(); + /* 8013E6C0 */ void procWolfChainWaitInit(); + /* 8013E80C */ void procWolfChainWait(); + /* 8013ED44 */ void procWolfDigInit(); + /* 8013F1F0 */ void procWolfDig(); + /* 8013F4A8 */ void procWolfDigThroughInit(int); + /* 8013F7C4 */ void procWolfDigThrough(); + /* 8013F90C */ void setSmellSave(); + /* 8013FA14 */ void procWolfGetSmellInit(); + /* 8013FC24 */ void procWolfGetSmell(); + /* 8013FF28 */ void setArcName(int); + /* 8013FF90 */ void setShieldArcName(); + /* 8013FFD8 */ void setOriginalHeap(JKRExpHeap**, u32); + /* 80140064 */ void setShieldChange(); + /* 80140070 */ void loadModelDVD(); + /* 801401F8 */ void setShieldModel(); + /* 80140274 */ void loadShieldModelDVD(); + /* 80140338 */ void changeModelDataDirect(int); + /* 80140550 */ void changeModelDataDirectWolf(int); + /* 801406A8 */ void initStatusWindow(); + /* 80140888 */ void statusWindowExecute(cXyz const*, s16); + /* 80140984 */ void statusWindowDraw(); + /* 80140AC8 */ void resetStatusWindow(); + + virtual void unk(); + virtual bool getMidnaAtnPos(void) const; + virtual void setMidnaMsgNum(fopAc_ac_c*, u16); + virtual Mtx* getModelMtx(void); + virtual Mtx* getInvMtx(void); + virtual cXyz* getShadowTalkAtnPos(void); + virtual float getGroundY(); + virtual Mtx* getLeftItemMatrix(void); + virtual Mtx* getRightItemMatrix(void); + virtual Mtx* getLeftHandMatrix(void); + virtual Mtx* getRightHandMatrix(void); + virtual Mtx* getLinkBackBone1Matrix(void); + virtual Mtx* getWolfMouthMatrix(void); + virtual Mtx* getWolfBackbone2Matrix(void); + virtual bool getBottleMtx(void); + virtual bool checkPlayerGuard(void) const; + virtual u32 checkPlayerFly() const; + virtual BOOL checkFrontRoll() const; + virtual bool checkWolfDash() const; + virtual bool checkAutoJump(void) const; + virtual bool checkSideStep(void) const; + virtual bool checkWolfTriggerJump(void) const; + virtual bool checkGuardBreakMode(void) const; + virtual bool checkLv3Slide(void) const; + virtual bool checkWolfHowlDemoMode(void) const; + virtual bool checkChainBlockPushPull(void); + virtual bool checkElecDamage(void) const; + virtual bool checkEmptyBottleSwing(void) const; + virtual bool checkBottleSwingMode(void) const; + virtual bool checkHawkWait(void) const; + virtual bool checkGoatThrow(void) const; + virtual bool checkGoatThrowAfter(void) const; + virtual bool checkWolfTagLockJump(void) const; + virtual bool checkWolfTagLockJumpLand(void) const; + virtual bool checkWolfRope(void); + virtual bool checkWolfRopeHang(void) const; + virtual bool checkRollJump(void) const; + virtual bool checkGoronRideWait(void) const; + virtual bool checkWolfChain(void) const; + virtual bool checkWolfWait(void) const; + virtual bool checkWolfJumpAttack(void) const; + virtual bool checkWolfRSit(void) const; + virtual bool checkBottleDrinkEnd(void) const; + virtual bool checkWolfDig(void) const; + virtual bool checkCutCharge(void) const; + virtual BOOL checkCutTurnCharge(void) const; + virtual bool checkCutLargeJumpCharge(void) const; + virtual bool checkComboCutTurn(void) const; + virtual bool checkClimbMove(void) const; + virtual bool checkGrassWhistle(void) const; + virtual bool checkBoarRun(void) const; + virtual float getBaseAnimeFrameRate(void) const; + virtual float getBaseAnimeFrame(void) const; + virtual void setAnimeFrame(float); + virtual bool checkWolfLock(fopAc_ac_c*) const; + virtual bool cancelWolfLock(fopAc_ac_c*); + virtual s32 getAtnActorID(void) const; + virtual s32 getItemID(void) const; + virtual s32 getGrabActorID(void) const; + virtual bool exchangeGrabActor(fopAc_ac_c*); + virtual bool setForceGrab(fopAc_ac_c*, int, int); + virtual void setForcePutPos(cXyz const&); + virtual bool checkPlayerNoDraw(void); + virtual void voiceStart(u32); + virtual void seStartOnlyReverb(u32); + virtual void seStartOnlyReverbLevel(u32); + virtual void setOutPower(float, short, int); + virtual void setGrabCollisionOffset(float, float, cBgS_PolyInfo*); + virtual void onFrollCrashFlg(u8, int); + virtual Mtx* getModelJointMtx(u16); + virtual bool getHeadMtx(void); + virtual bool setHookshotCarryOffset(unsigned int, cXyz const*); + virtual bool checkIronBallReturn(void) const; + virtual bool checkIronBallGroundStop(void) const; + virtual bool checkSingleBoarBattleSecondBowReady(void) const; + virtual void setClothesChange(int); + virtual void setPlayerPosAndAngle(float (*)[4]); + virtual void setPlayerPosAndAngle(cXyz const*, csXyz const*); + virtual void setPlayerPosAndAngle(cXyz const*, short, int); + virtual bool setThrowDamage(short, float, float, int, int, int); + virtual bool checkSetNpcTks(cXyz*, int, int); + virtual bool setRollJump(float, float, short); + virtual void playerStartCollisionSE(u32, u32); + virtual void cancelDungeonWarpReadyNeck(void); + virtual void onSceneChangeArea(u8, u8, fopAc_ac_c*); + virtual void onSceneChangeAreaJump(u8, u8, fopAc_ac_c*); + virtual void onSceneChangeDead(u8, int); + virtual u32 checkHorseRide() const; + virtual u32 checkBoarRide() const; + virtual u32 checkCanoeRide() const; + virtual u32 checkBoardRide() const; + virtual u32 checkSpinnerRide() const; + virtual fopAc_ac_c* getSpinnerActor(void); + virtual bool checkHorseRideNotReady(void) const; + virtual bool checkArrowChargeEnd(void) const; + virtual void getSearchBallScale(void) const; + virtual bool checkFastShotTime(void); + virtual bool checkNoEquipItem(void) const; + virtual bool checkKandelaarSwing(int) const; + virtual bool getBoardCutTurnOffsetAngleY(void) const; + virtual cXyz* getMagneBootsTopVec(void); + virtual bool getKandelaarFlamePos(); + virtual bool checkUseKandelaar(int); + virtual void setDkCaught(fopAc_ac_c*); + virtual void onPressedDamage(cXyz const&, short); + virtual bool checkPriActorOwn(fopAc_ac_c const*) const; + virtual bool onWolfEnemyBiteAll(fopAc_ac_c*, daPy_FLG2); + virtual bool checkWolfEnemyBiteAllOwn(fopAc_ac_c const*) const; + virtual void setWolfEnemyHangBiteAngle(short); + virtual void setKandelaarMtx(float (*)[4], int, int); + virtual bool getStickAngleFromPlayerShape(short*) const; + virtual bool checkSpinnerPathMove(void); + virtual bool checkSpinnerTriggerAttack(void); + virtual void onSpinnerPathForceRemove(void); + virtual bool getIronBallBgHit(void) const; + virtual bool getIronBallCenterPos(void); + virtual bool checkCanoeFishingGetLeft(void) const; + virtual bool checkCanoeFishingGetRight(void) const; + virtual bool checkBeeChildDrink(void) const; + virtual void skipPortalObjWarp(void); + virtual bool checkTreasureRupeeReturn(int) const; + virtual void setSumouReady(fopAc_ac_c*); + virtual void checkAcceptDungeonWarpAlink(int); + virtual s16 getSumouCounter(void) const; + virtual s16 checkSumouWithstand(void) const; + virtual void cancelGoronThrowEvent(void); + virtual void setSumouGraspCancelCount(int); + virtual void setSumouPushBackDirection(short); + virtual void setSumouLoseHeadUp(void); + virtual s16 getGiantPuzzleAimAngle(void) const; + virtual void setGoronSideMove(fopAc_ac_c*); + virtual void setCargoCarry(fopAc_ac_c*); + virtual bool getHookshotTopPos(void); + virtual bool checkHookshotReturnMode(void) const; + virtual bool checkHookshotShootReturnMode(void) const; + virtual bool checkOctaIealHang(void) const; + virtual void cancelOctaIealHang(void); + virtual void cancelDragonHangBackJump(void); + virtual void setOctaIealWildHang(void); + virtual bool checkDragonHangRide(void) const; + virtual void changeDragonActor(fopAc_ac_c*); + virtual u8 getClothesChangeWaitTimer(void) const; + virtual u8 getShieldChangeWaitTimer(void) const; + virtual bool getSwordChangeWaitTimer(void) const; + virtual bool checkMetamorphose(void) const; + virtual bool checkWolfDownAttackPullOut(void) const; + virtual bool checkBootsOrArmorHeavy(void) const; + virtual s32 getBottleOpenAppearItem(void) const; + virtual bool checkItemSwordEquip(void) const; + virtual float getSinkShapeOffset(void) const; + virtual bool checkSinkDead(void) const; + virtual bool checkHorseStart(void); + virtual bool getWolfHowlMgrP(void); + virtual bool checkWolfHowlSuccessAnime(void) const; + virtual bool checkCopyRodTopUse(void); + virtual bool checkCopyRodEquip(void) const; + virtual bool checkCutJumpMode(void) const; + + // inlined version of checkModeFlg + u32 i_checkModeFlg(u32 pFlag) const { return mModeFlg & pFlag; } + bool checkUpperAnime(u16 pIdx) const { return mUpperAnime[UPPER_NOW].getIdx() == pIdx; } + + static u8 const m_mainBckShield[80]; + static u8 const m_mainBckSword[20]; + static u8 const m_mainBckFishing[112]; + static u8 const m_anmDataTable[4968]; + static void* const m_wlAnmDataTable[294]; + static u8 const m_faceTexDataTable[652]; + static u8 const m_handLeftOutSidePos[12]; + static u8 const m_handRightOutSidePos[12]; + static u8 const m_handLeftInSidePos[12]; + static u8 const m_handRightInSidePos[12]; + static u8 m_procInitTable[5632]; + static u8 m_demoInitTable[1140]; + static u8 m_fEffParamProc[72]; + +private: + /* 0x0062C */ void* field_0x062C; + /* 0x00630 */ void* field_0x0630; + /* 0x00634 */ void* field_0x0634; + /* 0x00638 */ JKRExpHeap** field_0x0638; + /* 0x0063C */ void* field_0x063C; + /* 0x00640 */ void* field_0x0640; + /* 0x00644 */ void* field_0x0644; + /* 0x00648 */ JKRExpHeap** field_0x0648; + /* 0x0064C */ J3DModelData* field_0x064C; + /* 0x00650 */ J3DModel* field_0x0650; + /* 0x00654 */ J3DModel* field_0x0654; + /* 0x00658 */ J3DModel* field_0x0658; + /* 0x0065C */ J3DModel* field_0x065c; + /* 0x00660 */ J3DModel* field_0x0660; + /* 0x00664 */ J3DModel* field_0x0664; + /* 0x00668 */ J3DModel* field_0x0668; + /* 0x0066C */ J3DModel* field_0x066c; + /* 0x00670 */ J3DModel* field_0x0670; + /* 0x00674 */ J3DModel* field_0x0674; + /* 0x00678 */ J3DModel* field_0x0678; + /* 0x0067C */ J3DAnmBase* field_0x067c; + /* 0x00680 */ J3DAnmBase* field_0x0680; + /* 0x00684 */ J3DModel* field_0x0684; + /* 0x00688 */ J3DModel* field_0x0688; + /* 0x0068C */ J3DAnmBase* field_0x068c; + /* 0x00690 */ mDoExt_baseAnm** field_0x0690; + /* 0x00694 */ void* field_0x0694; // J3DDeformData + /* 0x00698 */ void* field_0x0698; + /* 0x0069C */ void* field_0x069c; + /* 0x006A0 */ J3DModel* field_0x06a0; + /* 0x006A4 */ mDoExt_bckAnm* field_0x06a4; + /* 0x006A8 */ J3DModel* field_0x06a8; + /* 0x006AC */ mDoExt_bckAnm* field_0x06ac; + /* 0x006B0 */ mDoExt_bckAnm* field_0x06b0; + /* 0x006B4 */ J3DAnmTransform* field_0x06b4; + /* 0x006B8 */ J3DModel* field_0x06b8; + /* 0x006BC */ J3DModel* field_0x06bc; + /* 0x006C0 */ J3DModelData* field_0x06c0; + /* 0x006C4 */ J3DAnmBase* field_0x06c4; + /* 0x006C8 */ J3DAnmBase* field_0x06c8; + /* 0x006CC */ J3DAnmBase* field_0x06cc; + /* 0x006D0 */ void* field_0x06d0; + /* 0x006D4 */ void* field_0x06d4; + /* 0x006D8 */ void* field_0x06d8; + /* 0x006DC */ void* field_0x06dc; + /* 0x006E0 */ void* field_0x06e0; + /* 0x006E4 */ void* field_0x06e4; + /* 0x006E8 */ void* field_0x06e8; + /* 0x006EC */ void* field_0x06ec; + /* 0x006F0 */ void* field_0x06f0; + /* 0x006F4 */ J3DAnmBase* field_0x06f4; + /* 0x006F8 */ J3DAnmBase* field_0x06f8; + /* 0x006FC */ J3DModel* field_0x06fc; + /* 0x00700 */ J3DModel* field_0x0700; + /* 0x00704 */ J3DAnmBase* field_0x0704; + /* 0x00708 */ J3DModel* field_0x0708; + /* 0x0070C */ J3DModel* field_0x070c; + /* 0x00710 */ J3DModel* field_0x0710; + /* 0x00714 */ J3DModel* field_0x0714; + /* 0x00718 */ J3DAnmBase* field_0x0718; + /* 0x0071C */ J3DAnmBase* field_0x071c; + /* 0x00720 */ J3DAnmBase* field_0x0720; + /* 0x00724 */ J3DAnmBase* field_0x0724; + /* 0x00728 */ J3DAnmBase* field_0x0728; + /* 0x0072C */ J3DAnmBase* field_0x072c; + /* 0x00730 */ mDoExt_bckAnm field_0x730; + /* 0x0074C */ mDoExt_bckAnm field_0x74C; + /* 0x00768 */ u8 field_0x0768[0x5C]; + /* 0x007C4 */ daPy_actorKeep_c field_0x07C4[10]; + /* 0x00814 */ dCcD_Stts field_0x814; + /* 0x00850 */ dCcD_Cyl field_0x850[3]; + /* 0x00C04 */ dCcD_Cyl field_0xC04[3]; + /* 0x00FB8 */ dCcD_Sph field_0xFB8; + /* 0x010F0 */ dCcD_Cyl field_0x10F0; + /* 0x0122C */ dCcD_Cps field_0x122C[3]; + /* 0x015F8 */ dCcD_Cps field_0x15F8; + /* 0x0173C */ dCcD_Stts field_0x173c; + /* 0x01778 */ dCcD_Sph field_0x1778; + /* 0x018B0 */ dBgS_AcchCir field_0x18B0[3]; + /* 0x01970 */ dBgS_LinkAcch mLinkAcch; + /* 0x01B48 */ dBgS_LinkLinChk mLinkLinChk; + /* 0x01BB8 */ dBgS_RopeLinChk mRopeLinChk; + /* 0x01C28 */ dBgS_BoomerangLinChk mBoomerangLinChk; + /* 0x01C98 */ dBgS_ArrowLinChk mArrowLinChk; + /* 0x01D08 */ dBgS_LinkGndChk mLinkGndChk; + /* 0x01D5C */ dBgS_LinkRoofChk mLinkRoofChk; + /* 0x01DAC */ dBgS_LinkLinChk mLinkLinChk2; + /* 0x01E1C */ cBgS_PolyInfo mPolyInfo1; + /* 0x01E2C */ cBgS_PolyInfo mPolyInfo2; + /* 0x01E3C */ cBgS_PolyInfo mPolyInfo3; + /* 0x01E4C */ cBgS_PolyInfo mPolyInfo4; + /* 0x01E5C */ dBgS_ObjLinChk mObjLinChk; + /* 0x01ECC */ dBgS_ObjGndChk mObjGndChk; + /* 0x01F20 */ u8 field_0x1f20[8]; + /* 0x01F28 */ mDoExt_AnmRatioPack field_0x1f28[3]; + /* 0x01F40 */ mDoExt_AnmRatioPack field_0x1f40[3]; + /* 0x01F58 */ daPy_anmHeap_c mUnderAnime[3]; + /* 0x01F94 */ daPy_anmHeap_c mUpperAnime[3]; + /* 0x01FD0 */ daPy_frameCtrl_c mFrameCtrl1[3]; + /* 0x02018 */ daPy_frameCtrl_c mFrameCtrl2[3]; + /* 0x02060 */ void* field_0x2060; // mDoExt_MtxCalcOldFrame* + /* 0x02064 */ daAlink_sight_c mSight; + /* 0x020F0 */ daPy_anmHeap_c mAnmHeap3; + /* 0x02104 */ daPy_anmHeap_c mAnmHeap4; + /* 0x02118 */ daPy_anmHeap_c mAnmHeap5; + /* 0x0212C */ daPy_anmHeap_c mAnmHeap6; + /* 0x02140 */ daPy_anmHeap_c mAnmHeap7; + /* 0x02154 */ mDoExt_bckAnm field_0x2154; + /* 0x02170 */ u8 field_0x2170[0x18]; + /* 0x02188 */ dEyeHL_c mEyeHL1; + /* 0x0219C */ dEyeHL_c mEyeHL2; + /* 0x021B0 */ daPy_anmHeap_c mAnmHeap8[2]; + /* 0x021D8 */ daPy_anmHeap_c mAnmHeap9; + /* 0x021EC */ u8 field_0x21ec[4]; + /* 0x021F0 */ daAlink_blur_c mBlur; + /* 0x027C8 */ dAlink_bottleWaterPcallBack_c field_0x27c8; + /* 0x027E0 */ dAttention_c* mAttention; + /* 0x027E4 */ dAttList_c* mAttList; + /* 0x027E8 */ dAttList_c* mAttList2; + /* 0x027EC */ fopAc_ac_c* mTargetedActor; + /* 0x027F0 */ fopAc_ac_c* field_0x27f0; + /* 0x027F4 */ fopAc_ac_c* field_0x27f4; + /* 0x027F8 */ fopAc_ac_c* field_0x27f8; + /* 0x027FC */ fopAc_ac_c* field_0x27fc; + /* 0x02800 */ fopAc_ac_c* field_0x2800; + /* 0x02804 */ fopAc_ac_c* field_0x2804; + /* 0x02808 */ fopAc_ac_c* field_0x2808; + /* 0x0280C */ daPy_actorKeep_c field_0x280c; + /* 0x02814 */ daPy_actorKeep_c mRideActor; // daspinnerc? + /* 0x0281C */ daPy_actorKeep_c field_0x281c; + /* 0x02824 */ daPy_actorKeep_c mItemActor; // name might be wrong + /* 0x0282C */ daPy_actorKeep_c field_0x282c; + /* 0x02834 */ daPy_actorKeep_c field_0x2834; + /* 0x0283C */ daPy_actorKeep_c field_0x283c; + /* 0x02844 */ daPy_actorKeep_c field_0x2844; + /* 0x0284C */ daPy_actorKeep_c field_0x284c; + /* 0x02854 */ daPy_actorKeep_c field_0x2854; + /* 0x0285C */ daPy_actorKeep_c field_0x285c; + /* 0x02864 */ dMsgFlow_c mMsgFlow; + /* 0x028B0 */ u8 field_0x28b0[0x40]; + /* 0x028F0 */ int field_0x28f0; + /* 0x028F4 */ int mAtnActorID; + /* 0x028F8 */ int field_0x28f8; + /* 0x028FC */ int field_0x28fc; + /* 0x02900 */ void* field_0x2900; + /* 0x02904 */ daAlink_footData_c mFootData1[2]; + /* 0x02A4C */ daAlink_footData_c mFootData2[2]; + /* 0x02B94 */ float* field_0x2b94; + /* 0x02B98 */ float* field_0x2b98; + /* 0x02B98 */ float* field_0x2b9c; + /* 0x02BA0 */ float* field_0x2ba0; + /* 0x02BA4 */ float* field_0x2ba4; + /* 0x02BA8 */ float* field_0x2ba8; + /* 0x02BAC */ cXyz field_0x2bac; + /* 0x02BB8 */ Mtx mInvMtx; + /* 0x02BE8 */ Mtx field_0x2be8; + /* 0x02C18 */ Mtx field_0x2c18; + /* 0x02C48 */ Mtx field_0x2c48; + /* 0x02C78 */ Mtx field_0x2c78; + /* 0x02CA8 */ Z2CreatureLink mZ2Link; + /* 0x02D75 */ u8 field_0x2d75[3]; // padding? + /* 0x02D78 */ void* field_0x2d78; + /* 0x02D7C */ daPy_frameCtrl_c* field_0x2d7c; + /* 0x02D80 */ int field_0x2d80; + /* 0x02D84 */ Z2WolfHowlMgr mZ2WolfHowlMgr; + /* 0x02E44 */ dJntCol_c field_0x2e44; + /* 0x02E54 */ dPaPo_c field_0x2e54; + /* 0x02E8C */ u8 field_0x2e8c[0x90]; + /* 0x02F1C */ dPaPo_c* field_0x2f1c; + /* 0x02F20 */ dPa_hermiteEcallBack_c field_0x2f20; + /* 0x02F38 */ dPa_hermiteEcallBack_c field_0x2f38; + /* 0x02F50 */ Vec* field_0x2f50; + /* 0x02F54 */ Vec* field_0x2f54; + /* 0x02F58 */ u16* field_0x2f58; + /* 0x02F5C */ LIGHT_INFLUENCE field_0x2f5c; + /* 0x02F7C */ u8 field_0x2f7c[16]; + /* 0x02F8C */ u8 field_0x2f8c; + /* 0x02F8D */ u8 mItemTrigger; + /* 0x02F8E */ u8 mItemButton; + /* 0x02F8F */ u8 field_0x2f8f; + /* 0x02F90 */ u8 field_0x2f90; + /* 0x02F91 */ u8 field_0x2f91; + /* 0x02F92 */ u8 field_0x2f92; + /* 0x02F93 */ u8 field_0x2f93; + /* 0x02F94 */ u8 field_0x2f94; + /* 0x02F95 */ u8 field_0x2f95; + /* 0x02F96 */ u8 field_0x2f96; + /* 0x02F97 */ u8 field_0x2f97; + /* 0x02F98 */ u8 field_0x2f98; + /* 0x02F99 */ u8 field_0x2f99; + /* 0x02F9A */ s8 field_0x2f9a; + /* 0x02F9B */ u8 field_0x2f9b; + /* 0x02F9C */ u8 mSelectItemId; + /* 0x02F9D */ u8 field_0x2f9d; + /* 0x02F9E */ u8 field_0x2f9e; + /* 0x02F9F */ u8 field_0x2f9f; + /* 0x02FA0 */ u8 field_0x2fa0; + /* 0x02FA1 */ u8 field_0x2fa1; + /* 0x02FA2 */ u8 field_0x2fa2; + /* 0x02FA3 */ u8 field_0x2fa3; + /* 0x02FA4 */ u8 field_0x2fa4; + /* 0x02FA5 */ u8 field_0x2fa5; + /* 0x02FA6 */ u8 field_0x2fa6; + /* 0x02FA7 */ u8 field_0x2fa7; + /* 0x02FA8 */ u8 field_0x2fa8; + /* 0x02FA9 */ u8 field_0x2fa9; + /* 0x02FAA */ u8 mRideStatus; + /* 0x02FAB */ u8 field_0x2fab; + /* 0x02FAC */ u8 field_0x2fac; + /* 0x02FAD */ u8 field_0x2fad; + /* 0x02FAE */ u8 field_0x2fae; + /* 0x02FAF */ u8 field_0x2faf; + /* 0x02FB0 */ u8 field_0x2fb0; + /* 0x02FB1 */ u8 field_0x2fb1; + /* 0x02FB2 */ u8 field_0x2fb2; + /* 0x02FB3 */ u8 field_0x2fb3; + /* 0x02FB4 */ u8 field_0x2fb4; + /* 0x02FB5 */ u8 field_0x2fb5; + /* 0x02FB6 */ u8 field_0x2fb6; + /* 0x02FB7 */ u8 field_0x2fb7; + /* 0x02FB8 */ u8 field_0x2fb8; + /* 0x02FB9 */ u8 field_0x2fb9; + /* 0x02FBA */ u8 field_0x2fba; + /* 0x02FBB */ u8 field_0x2fbb; + /* 0x02FBC */ u8 field_0x2fbc; + /* 0x02FBD */ u8 field_0x2fbd; + /* 0x02FBE */ u8 field_0x2fbe; + /* 0x02FBF */ u8 mClothesChangeWaitTimer; + /* 0x02FC0 */ u8 field_0x2fc0; + /* 0x02FC1 */ u8 field_0x2fc1; + /* 0x02FC2 */ u8 field_0x2fc2; + /* 0x02FC3 */ u8 field_0x2fc3; + /* 0x02FC4 */ u8 field_0x2fc4; + /* 0x02FC5 */ u8 field_0x2fc5; + /* 0x02FC6 */ u8 field_0x2fc6; + /* 0x02FC7 */ u8 field_0x2fc7; + /* 0x02FC8 */ u8 field_0x2fc8; + /* 0x02FC9 */ u8 field_0x2fc9; + /* 0x02FCA */ u8 field_0x2fca; + /* 0x02FCB */ u8 field_0x2fcb; + /* 0x02FCC */ u8 field_0x2fcc; + /* 0x02FCD */ u8 field_0x2fcd; + /* 0x02FCE */ u8 field_0x2fce; + /* 0x02FCF */ u8 field_0x2fcf; + /* 0x02FD0 */ u8 field_0x2fd0; + /* 0x02FD1 */ u8 mShieldChangeWaitTimer; + /* 0x02FD2 */ u8 field_0x2fd2; + /* 0x02FD3 */ u8 field_0x2fd3; + /* 0x02FD4 */ u8 field_0x2fd4; + /* 0x02FD5 */ u8 field_0x2fd5; + /* 0x02FD6 */ u8 field_0x2fd6; + /* 0x02FD7 */ u8 field_0x2fd7; + /* 0x02FD8 */ u8 field_0x2fd8; + /* 0x02FD9 */ u8 field_0x2fd9[3]; + /* 0x02FDC */ u16 field_0x2fdc; + /* 0x02FDE */ u16 field_0x2fde; + /* 0x02FE0 */ u16 field_0x2fe0; + /* 0x02FE2 */ s16 field_0x2fe2; + /* 0x02FE4 */ s16 field_0x2fe4; + /* 0x02FE6 */ s16 field_0x2fe6; + /* 0x02FE8 */ u16 mActionID; + /* 0x02FEA */ u16 field_0x2fea; + /* 0x02FEC */ s16 field_0x2fec; + /* 0x02FEE */ s16 field_0x2fee; + /* 0x02FF0 */ s16 field_0x2ff0; + /* 0x02FF2 */ s16 field_0x2ff2; + /* 0x02FF4 */ s16 field_0x2ff4; + /* 0x02FF6 */ s16 field_0x2ff6; + /* 0x02FF8 */ s16 field_0x2ff8; + /* 0x02FFA */ s16 field_0x2ffa; + /* 0x02FFC */ s16 field_0x2ffc; + /* 0x02FFE */ s16 field_0x2ffe; + /* 0x03000 */ s16 field_0x3000; + /* 0x03002 */ s16 field_0x3002; + /* 0x03004 */ s16 field_0x3004; + /* 0x03006 */ s16 field_0x3006; + /* 0x03008 */ s16 field_0x3008; + /* 0x0300A */ s16 field_0x300a; + /* 0x0300C */ s16 mCommonCounter; // might need more accurate name + /* 0x0300E */ s16 field_0x300e; + /* 0x03010 */ s16 field_0x3010; + /* 0x03012 */ s16 field_0x3012; + /* 0x03014 */ s16 field_0x3014; + /* 0x03016 */ u8 field_0x3016[2]; + /* 0x03018 */ s16 field_0x3018; + /* 0x0301A */ s16 field_0x301a; + /* 0x0301C */ s16 field_0x301c; + /* 0x0301E */ s16 field_0x301e; + /* 0x03020 */ s16 field_0x3020; + /* 0x03022 */ s16 field_0x3022; + /* 0x03024 */ s16 field_0x3024; + /* 0x03026 */ s16 field_0x3026; + /* 0x03028 */ s16 field_0x3028; + /* 0x0302A */ u8 field_0x302a[2]; + /* 0x0302C */ s16 field_0x302c; + /* 0x0302E */ s16 field_0x302e; + /* 0x03030 */ s16 field_0x3030; + /* 0x03032 */ s16 field_0x3032; + /* 0x03034 */ s16 field_0x3034; + /* 0x03036 */ s16 field_0x3036; + /* 0x03038 */ u8 field_0x3038[2]; + /* 0x0303A */ s16 field_0x303a; + /* 0x0303C */ u8 field_0x303c[4]; + /* 0x03040 */ s16 field_0x3040; + /* 0x03042 */ s16 field_0x3042; + /* 0x03044 */ s16 field_0x3044; + /* 0x03046 */ s16 field_0x3046; + /* 0x03048 */ s16 field_0x3048; + /* 0x0304A */ s16 field_0x304a; + /* 0x0304C */ u8 field_0x304c[2]; + /* 0x0304E */ s16 field_0x304e; + /* 0x03050 */ u8 field_0x3050[4]; + /* 0x03054 */ s16 field_0x3054; + /* 0x03056 */ s16 field_0x3056; + /* 0x03058 */ u8 field_0x3058[2]; + /* 0x0305A */ s16 field_0x305a; + /* 0x0305C */ s16 field_0x305c; + /* 0x0305E */ u8 field_0x305e[2]; + /* 0x03060 */ s16 field_0x3060; + /* 0x03062 */ s16 field_0x3062; + /* 0x03064 */ s16 field_0x3064; + /* 0x03066 */ s16 field_0x3066; + /* 0x03068 */ u8 field_0x3068[4]; + /* 0x0306C */ s16 field_0x306c; + /* 0x0306E */ s16 field_0x306e; + /* 0x03070 */ s16 field_0x3070; + /* 0x03072 */ s16 field_0x3072; + /* 0x03074 */ s16 field_0x3074; + /* 0x03076 */ s16 field_0x3076; + /* 0x03078 */ s16 field_0x3078; + /* 0x0307A */ s16 field_0x307a; + /* 0x0307C */ s16 field_0x307c; + /* 0x0307E */ s16 field_0x307e; + /* 0x03080 */ s16 field_0x3080; + /* 0x03082 */ s16 field_0x3082; + /* 0x03084 */ u16 field_0x3084; + /* 0x03086 */ u16 field_0x3086; + /* 0x03088 */ s16 field_0x3088; + /* 0x0308A */ s16 field_0x308a; + /* 0x0308C */ s16 field_0x308c; + /* 0x0308E */ s16 field_0x308e; + /* 0x03090 */ s16 field_0x3090; + /* 0x03092 */ s16 field_0x3092; + /* 0x03094 */ s16 field_0x3094; + /* 0x03096 */ u8 field_0x3096[4]; + /* 0x0309A */ s16 field_0x309a; + /* 0x0309C */ u8 field_0x309c[4]; + /* 0x030A0 */ s16 field_0x30a0; + /* 0x030A2 */ s16 field_0x30a2; + /* 0x030A4 */ s16 field_0x30a4; + /* 0x030A6 */ s16 field_0x30a6; + /* 0x030A8 */ u16 field_0x30a8; + /* 0x030AA */ u16 field_0x30aa; + /* 0x030AC */ s16 field_0x30ac; + /* 0x030AE */ u16 field_0x30ae; + /* 0x030B0 */ s16 field_0x30b0; + /* 0x030B2 */ s16 field_0x30b2; + /* 0x030B4 */ u16 field_0x30b4; + /* 0x030B6 */ u16 field_0x30b6; + /* 0x030B8 */ u16 field_0x30b8; + /* 0x030BA */ u16 field_0x30ba; + /* 0x030BC */ u16 field_0x30bc; + /* 0x030BE */ u16 field_0x30be; + /* 0x030C0 */ u16 field_0x30c0; + /* 0x030C2 */ u16 field_0x30c2; + /* 0x030C4 */ u16 field_0x30c4; + /* 0x030C6 */ u16 field_0x30c6; + /* 0x030C8 */ s16 field_0x30c8; + /* 0x030CA */ s16 field_0x30ca; + /* 0x030CC */ s16 field_0x30cc; + /* 0x030CE */ u16 field_0x30ce; + /* 0x030D0 */ s16 field_0x30d0; + /* 0x030D2 */ s16 field_0x30d2; + /* 0x030D4 */ u16 field_0x30d4; + /* 0x030D6 */ s16 field_0x30d6; + /* 0x030D8 */ u8 field_0x30d8[0x14]; + /* 0x030EC */ s16 field_0x30ec; + /* 0x030EE */ s16 field_0x30ee; + /* 0x030F0 */ u16 field_0x30f0; + /* 0x030F2 */ u8 field_0x30f2[2]; + /* 0x030F4 */ s16 field_0x30f4; + /* 0x030F6 */ s16 field_0x30f6; + /* 0x030F8 */ s16 field_0x30f8; + /* 0x030FA */ s16 field_0x30fa; + /* 0x030FC */ u16 field_0x30fc; + /* 0x030FE */ u16 field_0x30fe; + /* 0x03100 */ u16 field_0x3100; + /* 0x03102 */ s16 field_0x3102; + /* 0x03104 */ s16 field_0x3104; + /* 0x03106 */ u16 field_0x3106; + /* 0x03108 */ s16 field_0x3108; + /* 0x0310A */ s16 field_0x310a; + /* 0x0310C */ s16 field_0x310c; + /* 0x0310E */ s16 field_0x310e; + /* 0x03110 */ s16 field_0x3110; + /* 0x03112 */ u16 field_0x3112; + /* 0x03114 */ s16 field_0x3114; + /* 0x03116 */ s16 field_0x3116; + /* 0x03118 */ s16 field_0x3118; + /* 0x0311A */ s16 field_0x311a; + /* 0x0311C */ s16 field_0x311c; + /* 0x0311E */ s16 field_0x311e; + /* 0x03120 */ u16 mMidnaMsgNum; + /* 0x03122 */ s16 field_0x3122; + /* 0x03124 */ s16 field_0x3124; + /* 0x03126 */ s16 field_0x3126; + /* 0x03128 */ s16 field_0x3128; + /* 0x0312A */ csXyz field_0x312a[2]; + /* 0x03136 */ csXyz field_0x3136[2]; + /* 0x03142 */ csXyz field_0x3142[4]; + /* 0x0315A */ csXyz field_0x315a; + /* 0x03160 */ csXyz field_0x3160; + /* 0x03166 */ csXyz field_0x3166; + /* 0x0316C */ csXyz field_0x316c; + /* 0x03172 */ u8 field_0x3172[2]; + /* 0x03174 */ int field_0x3174; + /* 0x03178 */ int field_0x3178; + /* 0x0317C */ dAttention_c* field_0x317c; + /* 0x03180 */ int field_0x3180; + /* 0x03184 */ int field_0x3184; + /* 0x03184 */ int field_0x3188; + /* 0x0318C */ int field_0x318c; + /* 0x03190 */ int field_0x3190; + /* 0x03194 */ int field_0x3194; + /* 0x03198 */ int field_0x3198; + /* 0x0319C */ int field_0x319c; + /* 0x031A0 */ u32 mModeFlg; + /* 0x031A4 */ int field_0x31a4; + /* 0x031A8 */ u8 field_0x31a8[8]; + /* 0x031B0 */ int field_0x31b0; + /* 0x031B4 */ u8 field_0x31b4[8]; + /* 0x031BC */ u32 field_0x31bc; + /* 0x031C0 */ u32 field_0x31c0; + /* 0x031C4 */ u32 field_0x31c4; + /* 0x031C8 */ u32 field_0x31c8; + /* 0x031CC */ u32 field_0x31cc; + /* 0x031D0 */ u32 field_0x31d0; + /* 0x031D4 */ u32 field_0x31d4; + /* 0x031D8 */ u8 field_0x31d8[12]; + /* 0x031E4 */ u32 field_0x31e4; + /* 0x031E8 */ u8 field_0x31e8[16]; + /* 0x031F8 */ u32 field_0x31f8; + /* 0x031FC */ u32 field_0x31fc; + /* 0x03200 */ u32 field_0x3200; + /* 0x03204 */ u32 field_0x3204; + /* 0x03208 */ u32 field_0x3208; + /* 0x0320C */ u8 field_0x320c[16]; + /* 0x0321C */ u32 field_0x321c; + /* 0x03220 */ u32 field_0x3220; + /* 0x03224 */ u32 field_0x3224; + /* 0x03228 */ u8 field_0x3228[24]; + /* 0x03240 */ u32 field_0x3240; + /* 0x03244 */ u8 field_0x3244[20]; + /* 0x03258 */ u32 field_0x3258; + /* 0x0325C */ u32 field_0x325c; + /* 0x03260 */ u8 field_0x3260[40]; + /* 0x03288 */ u32 field_0x3288; + /* 0x0328C */ u32 field_0x328c; + /* 0x03290 */ u32 field_0x3290; + /* 0x03294 */ u32 field_0x3294; + /* 0x03298 */ u8 field_0x3298[8]; + /* 0x032A0 */ J3DGXColorS10 field_0x32a0[2]; + /* 0x032B0 */ J3DGXColorS10 field_0x32b0[2]; + /* 0x032C0 */ s16 field_0x32c0; + /* 0x032C2 */ u8 field_0x32c2[2]; + /* 0x032C4 */ u16 field_0x32c4; + /* 0x032C6 */ u16 field_0x32c6; + /* 0x032C8 */ u32 field_0x32c8; + /* 0x032CC */ u32 field_0x32cc; + /* 0x032D0 */ u32 field_0x32d0; + /* 0x032D4 */ u32 field_0x32d4; + /* 0x032D8 */ firePointEff_c field_0x32d8[4]; + /* 0x03398 */ float mNormalSpeed; + /* 0x0339C */ float mSpeedModifier; + /* 0x033A0 */ float field_0x33a0; + /* 0x033A4 */ float field_0x33a4; + /* 0x033A8 */ float field_0x33a8; + /* 0x033AC */ float field_0x33ac; + /* 0x033B0 */ float field_0x33b0; + /* 0x033B4 */ float field_0x33b4; + /* 0x033B8 */ float field_0x33b8; + /* 0x033BC */ float field_0x33bc; + /* 0x033C0 */ float field_0x33c0; + /* 0x033C4 */ float field_0x33c4; + /* 0x033C8 */ float field_0x33c8; + /* 0x033CC */ float field_0x33cc; + /* 0x033D0 */ float field_0x33d0; + /* 0x033D4 */ float field_0x33d4; + /* 0x033D8 */ float field_0x33d8; + /* 0x033DC */ float field_0x33dc; + /* 0x033E0 */ float field_0x33e0; + /* 0x033E4 */ float field_0x33e4; + /* 0x033E8 */ float field_0x33e8; + /* 0x033EC */ float field_0x33ec; + /* 0x033F0 */ float field_0x33f0; + /* 0x033F4 */ float field_0x33f4; + /* 0x033F8 */ float field_0x33f8; + /* 0x033FC */ float field_0x33fc; + /* 0x03400 */ float field_0x3400; + /* 0x03404 */ float field_0x3404; + /* 0x03408 */ float field_0x3408; + /* 0x0340C */ float field_0x340c; + /* 0x03410 */ float field_0x3410; + /* 0x03414 */ float field_0x3414; + /* 0x03418 */ float field_0x3418; + /* 0x0341C */ float field_0x341c; + /* 0x03420 */ float field_0x3420; + /* 0x03424 */ float field_0x3424; + /* 0x03428 */ float field_0x3428; + /* 0x0342C */ float field_0x342c; + /* 0x03430 */ float field_0x3430; + /* 0x03434 */ float mHeavySpeedMultiplier; + /* 0x03438 */ float field_0x3438; + /* 0x0343C */ float field_0x343c; + /* 0x03440 */ float field_0x3440; + /* 0x03444 */ float field_0x3444; + /* 0x03448 */ float field_0x3448; + /* 0x0344C */ float field_0x344c; + /* 0x03450 */ u8 field_0x3450[4]; + /* 0x03454 */ float field_0x3454; + /* 0x03458 */ float field_0x3458; + /* 0x0345C */ float field_0x345c; + /* 0x03460 */ float field_0x3460; + /* 0x03464 */ float field_0x3464; + /* 0x03468 */ float field_0x3468; + /* 0x0346C */ float field_0x346c; + /* 0x03470 */ float field_0x3470; + /* 0x03474 */ float field_0x3474; + /* 0x03478 */ float field_0x3478; + /* 0x0347C */ float field_0x347c; + /* 0x03480 */ float field_0x3480; + /* 0x03484 */ float field_0x3484; + /* 0x03488 */ float field_0x3488; + /* 0x0348C */ float field_0x348c; + /* 0x03490 */ float field_0x3490; + /* 0x03494 */ float field_0x3494; + /* 0x03498 */ cXyz field_0x3498; + /* 0x034A4 */ cXyz field_0x34a4; + /* 0x034B0 */ cXyz field_0x34b0; + /* 0x034BC */ cXyz field_0x34bc; + /* 0x034C8 */ cXyz field_0x34c8; + /* 0x034D4 */ cXyz field_0x34d4; + /* 0x034E0 */ cXyz field_0x34e0; + /* 0x034EC */ cXyz field_0x34ec; + /* 0x034F8 */ cXyz field_0x34f8; + /* 0x03504 */ cXyz field_0x3504; + /* 0x03510 */ cXyz field_0x3510; + /* 0x0351C */ cXyz field_0x351c; + /* 0x03528 */ cXyz field_0x3528; + /* 0x03534 */ cXyz field_0x3534; + /* 0x03540 */ cXyz field_0x3540; + /* 0x0354C */ cXyz field_0x354c[4]; + /* 0x0357C */ cXyz mLookPosFromOut; + /* 0x03588 */ cXyz field_0x3588; + /* 0x03594 */ cXyz field_0x3594; + /* 0x035A0 */ cXyz field_0x35a0; + /* 0x035AC */ cXyz field_0x35ac; + /* 0x035B8 */ cXyz field_0x35b8; + /* 0x035C4 */ cXyz field_0x35c4; + /* 0x035D0 */ cXyz field_0x35d0; + /* 0x035DC */ cXyz field_0x35dc; + /* 0x035E8 */ cXyz field_0x35e8; + /* 0x035F4 */ cXyz mMidnaAtnPos; + /* 0x03600 */ cXyz field_0x3600; + /* 0x0360C */ cXyz field_0x360c; + /* 0x03618 */ cXyz field_0x3618; + /* 0x03624 */ cXyz field_0x3624; + /* 0x03630 */ cXyz field_0x3630; + /* 0x0363C */ cXyz field_0x363c[4]; + /* 0x0366C */ cXyz field_0x366c[4]; + /* 0x0369C */ cXyz field_0x369c; + /* 0x036A8 */ cXyz field_0x36a8; + /* 0x036B4 */ cXyz field_0x36b4; + /* 0x036C0 */ cXyz field_0x36c0[4]; + /* 0x036F0 */ cXyz field_0x36f0[4]; + /* 0x03720 */ cXyz field_0x3720; + /* 0x0372C */ cXyz field_0x372c; + /* 0x03738 */ cXyz field_0x3738; + /* 0x03744 */ cXyz field_0x3744; + /* 0x03750 */ cXyz field_0x3750; + /* 0x0375C */ cXyz field_0x375c; + /* 0x03768 */ cXyz field_0x3768; + /* 0x03774 */ cXyz mForcePutPos; + /* 0x03780 */ cXyz field_0x3780; + /* 0x0378C */ cXyz field_0x378c; + /* 0x03798 */ cXyz field_0x3798; + /* 0x037A4 */ cXyz field_0x37a4; + /* 0x037B0 */ cXyz field_0x37b0[2]; + /* 0x037C8 */ cXyz field_0x37c8; + /* 0x037D4 */ cXyz field_0x37d4; + /* 0x037E0 */ cXyz field_0x37e0; + /* 0x037EC */ cXyz field_0x37ec; + /* 0x037F8 */ cXyz field_0x37f8; + /* 0x03804 */ cXyz field_0x3804; + /* 0x03810 */ cXyz field_0x3810; + /* 0x0381C */ cXyz field_0x381c; + /* 0x03828 */ cXyz field_0x3828; + /* 0x03834 */ cXyz field_0x3834; + /* 0x03840 */ cXyz* mIronBallChainPos; + /* 0x03844 */ csXyz* mIronBallChainAngle; + /* 0x03848 */ void* field_0x3848; + /* 0x0384C */ float* field_0x384c; +}; + +struct daAlinkHIO_anm_c { + /* 0x00 */ s16 field_0x00; + /* 0x04 */ f32 field_0x04; + /* 0x08 */ f32 field_0x08; + /* 0x0C */ f32 field_0x0c; + /* 0x10 */ f32 field_0x10; +}; // size = 0x14 + +struct daAlinkHIO_basic_c1 { + /* 0x00 */ s16 field_0x00; + /* 0x02 */ s16 mNeckAimAngleX; + /* 0x04 */ s16 mNeckAimAngleY; + /* 0x06 */ s16 mNeckAimAngleZ; + /* 0x08 */ s16 field_0x08; + /* 0x0A */ s16 field_0x0a; + /* 0x0C */ s16 field_0x0c; + /* 0x0E */ s16 field_0x0e; + /* 0x10 */ s16 mMetamorphoseFarAngle; + /* 0x14 */ f32 field_0x14; + /* 0x18 */ f32 mAnmBlendFactor; + /* 0x1C */ f32 mWaitTurnSpeed; + /* 0x20 */ f32 field_0x20; + /* 0x24 */ f32 field_0x24; + /* 0x28 */ f32 field_0x28; + /* 0x2C */ f32 field_0x2c; + /* 0x30 */ f32 field_0x30; + /* 0x34 */ f32 field_0x34; + /* 0x38 */ f32 field_0x38; + /* 0x3C */ f32 field_0x3c; + /* 0x40 */ f32 field_0x40; + /* 0x44 */ f32 field_0x44; + /* 0x48 */ f32 field_0x48; + /* 0x4C */ f32 field_0x4c; + /* 0x50 */ f32 mMetamorphoseNearDis; + /* 0x54 */ f32 mMetamorphoseFarDis; +}; + +class daAlinkHIO_basic_c0 { +public: + static daAlinkHIO_basic_c1 const m; +}; + +class daAlinkHIO_autoJump_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c field_0x00; + /* 0x14 */ daAlinkHIO_anm_c field_0x14; + /* 0x28 */ daAlinkHIO_anm_c field_0x28; + /* 0x3C */ daAlinkHIO_anm_c field_0x3c; + /* 0x50 */ u8 field_0x50; + /* 0x52 */ s16 field_0x52; + /* 0x54 */ s16 field_0x54; + /* 0x56 */ s16 field_0x56; + /* 0x58 */ s16 field_0x58; + /* 0x5C */ f32 field_0x5c; + /* 0x60 */ f32 field_0x60; + /* 0x64 */ f32 field_0x64; + /* 0x68 */ f32 field_0x68; + /* 0x6C */ f32 field_0x6c; + /* 0x70 */ f32 field_0x70; + /* 0x74 */ f32 field_0x74; + /* 0x78 */ f32 field_0x78; + /* 0x7C */ f32 field_0x7c; + /* 0x80 */ f32 field_0x80; + /* 0x84 */ f32 field_0x84; + /* 0x88 */ f32 field_0x88; + /* 0x8C */ f32 field_0x8c; + /* 0x90 */ f32 field_0x90; + /* 0x94 */ f32 field_0x94; + /* 0x98 */ f32 field_0x98; + /* 0x9C */ f32 field_0x9c; + /* 0xA0 */ f32 field_0xa0; + /* 0xA4 */ f32 field_0xa4; + /* 0xA8 */ f32 field_0xa8; + /* 0xAC */ f32 field_0xac; + /* 0xB0 */ f32 field_0xb0; +}; // size = 0xB4 + +class daAlinkHIO_autoJump_c0 { +public: + static daAlinkHIO_autoJump_c1 const m; +}; + +class daAlinkHIO_wlAutoJump_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c field_0x00; + /* 0x14 */ daAlinkHIO_anm_c field_0x14; + /* 0x28 */ daAlinkHIO_anm_c field_0x28; + /* 0x3C */ u8 field_0x3c; + /* 0x3E */ s16 field_0x3e; + /* 0x40 */ s16 field_0x40; + /* 0x42 */ s16 field_0x42; + /* 0x44 */ f32 field_0x44; + /* 0x48 */ f32 field_0x48; + /* 0x4C */ f32 field_0x4c; + /* 0x50 */ f32 field_0x50; + /* 0x54 */ f32 field_0x54; + /* 0x58 */ f32 field_0x58; + /* 0x5C */ f32 field_0x5c; + /* 0x60 */ f32 field_0x60; + /* 0x64 */ f32 field_0x64; + /* 0x68 */ f32 field_0x68; + /* 0x6C */ f32 field_0x6c; + /* 0x70 */ f32 field_0x70; + /* 0x74 */ f32 field_0x74; + /* 0x78 */ f32 field_0x78; +}; // size = 0x7C + +class daAlinkHIO_wlAutoJump_c0 { +public: + static daAlinkHIO_wlAutoJump_c1 const m; +}; + +class daHorse_c { +public: + fopAc_ac_c* getZeldaActor(); + +private: + /* 0x0000 */ fopAc_ac_c mActor; + /* 0x0538 */ u8 field_0x538[0xD1C]; + /* 0x1254 */ daPy_actorKeep_c mZeldaActorKeep; +}; + +class daMidna_c { +public: + enum daMidna_ERFLG0 { + NoServiceWait = 128, + ForcePanic = 8, + }; + enum daMidna_FLG1 { ForceNormalColor = 8, ForceTiredColor = 4 }; + + void onForcePanic(void); + u32 checkForceNormalColor(void) const; + u32 checkForceTiredColor(void) const; + bool checkMidnaTired(void); + void onNoServiceWait(void); + + void onEndResetStateFlg0(daMidna_ERFLG0 pFlg) { mEndResetStateFlg0 |= pFlg; } + u32 checkStateFlg1(daMidna_FLG1 pFlg) const { return mStateFlg1 & pFlg; } + +private: + /* 0x0000 */ fopAc_ac_c mActor; + /* 0x0538 */ u8 field_0x538[0x35C]; + /* 0x0894 */ u32 mStateFlg1; + /* 0x0898 */ u32 mEndResetStateFlg0; +}; + +#endif /* D_A_D_A_ALINK_H */
\ No newline at end of file diff --git a/include/d/a/d_a_horse_static.h b/include/d/a/d_a_horse_static.h index b4a2ed987e..e38dc4bb05 100644 --- a/include/d/a/d_a_horse_static.h +++ b/include/d/a/d_a_horse_static.h @@ -1,6 +1,33 @@ #ifndef D_A_D_A_HORSE_STATIC_H #define D_A_D_A_HORSE_STATIC_H +#include "Z2AudioLib/Z2Creature.h" #include "dolphin/types.h" +class e_wb_class { +public: + BOOL checkWait(void); + void setPlayerRideNow(void); + void setPlayerRide(void); + void getOff(void); + BOOL checkDownDamage(void); + u8 checkNormalRideMode(void) const; + void setRunRideMode(void); + +private: + u8 unk0[0x5b4]; + s16 unk1460; + u8 unk1462[0x36]; + Z2CreatureRide mZ2Ride; + u8 unk1673[7]; + s16 unk1680; + u16 unk1682; + u8 unk1684[0x2a]; + u16 unk1726; +}; + +class daTagHstop_c { + static daTagHstop_c* m_top; +}; + #endif /* D_A_D_A_HORSE_STATIC_H */ diff --git a/include/d/a/d_a_player.h b/include/d/a/d_a_player.h index 99a8b27a47..deed7b2ec8 100644 --- a/include/d/a/d_a_player.h +++ b/include/d/a/d_a_player.h @@ -2,24 +2,51 @@ #define D_A_D_A_PLAYER_H #include "JSystem/J3DGraphAnimator/J3DAnimation.h" +#include "JSystem/JUtility/JUTTexture.h" +#include "SSystem/SComponent/c_bg_s_poly_info.h" +#include "d/d_drawlist.h" #include "d/d_resorce.h" +#include "d/d_stage.h" #include "d/save/d_save.h" #include "dolphin/types.h" #include "f_op/f_op_actor.h" +class daPy_sightPacket_c { + /* 80140CDC */ ~daPy_sightPacket_c(); + virtual void test(); // temp to build OK, remove later + /* 8015F1A0 */ virtual void draw(); + /* 8015F2FC */ void setSight(); + /* 8015F384 */ void setSightImage(ResTIMG*); + +private: + /* 0x04 */ bool mDrawFlag; + /* 0x05 */ u8 field_0x5[3]; + /* 0x08 */ cXyz mPos; + /* 0x14 */ Mtx field_0x14; + /* 0x44 */ ResTIMG* field_0x44; + /* 0x48 */ ResTIMG* field_0x48; +}; + +struct daPy_boomerangMove_c { + /* 8015E5B0 */ void initOffset(cXyz const*); + /* 8015E654 */ void posMove(cXyz*, s16*, fopAc_ac_c*, s16); + /* 8015E87C */ void bgCheckAfterOffset(cXyz const*); +}; + class daPy_anmHeap_c { public: enum daAlinkHEAP_TYPE {}; + /* 80140DCC */ void __defctor(); daPy_anmHeap_c(u32); ~daPy_anmHeap_c(); void initData(); void mallocBuffer(); void createHeap(daPy_anmHeap_c::daAlinkHEAP_TYPE); - void loadData(u16); - void loadDataIdx(u16); - void loadDataPriIdx(u16); - void loadDataDemoRID(u16, u16); + J3DAnmBase* loadData(u16); + J3DAnmBase* loadDataIdx(u16); + J3DAnmBase* loadDataPriIdx(u16); + J3DAnmBase* loadDataDemoRID(u16, u16); void setAnimeHeap(); u16 getIdx() const { return mIdx; } @@ -56,6 +83,8 @@ private: #pragma pack(push, 1) class daPy_frameCtrl_c : public J3DFrameCtrl { public: + /* 80140D24 */ ~daPy_frameCtrl_c(); + /* 80140D80 */ daPy_frameCtrl_c(); bool checkAnmEnd(void); void updateFrame(void); void setFrameCtrl(u8, short, short, float, float); @@ -78,6 +107,11 @@ private: class daPy_demo_c { public: + void setSpecialDemoType(); + + void setDemoType(u16 pType) { mDemoType = pType; } + u16 getDemoType() const { return mDemoType; } + private: /* 0x00 */ u16 mDemoType; /* 0x02 */ s16 mDemoMoveAngle; @@ -91,7 +125,7 @@ private: }; // Size = 0x24 class daPy_py_c : public fopAc_ac_c { -private: +public: /* 0x0538 */ u8 field_0x538[0x32]; /* 0x056A */ u8 field_0x56a; /* 0x056B */ u8 field_0x56b[5]; @@ -116,16 +150,26 @@ private: /* 0x0604 */ daPy_demo_c mDemo; public: - enum daPy_FLG0 { EquipHeavyBoots = 0x2000000 }; - enum daPy_FLG2 {}; + enum daPy_FLG0 { + EquipHeavyBoots = 0x2000000, + MagneBootsOn = 0x1000, + UnkFrollCrashFlg2 = 0x10, + UnkFrollCrashFlg1 = 0x8 + }; + enum daPy_FLG1 { Wolf = 0x2000000, ThrowDamage = 0x4000 }; + enum daPy_FLG2 { BoarSingleBattle = 0x1800000, UnkArmor = 0x80000, Unk = 1 }; + enum daPy_FLG3 { CopyRodThrowAfter = 0x40000 }; enum daPy_ERFLG0 {}; + enum daPy_ERFLG1 { GanonFinish = 0x80000000, UnkForcePutPos = 0x2000 }; + enum daPy_ERFLG2 {}; + enum daPy_RFLG0 {}; void setParamData(int, int, int, int); - void checkFishingRodItem(int); + int checkFishingRodItem(int); void checkBombItem(int); void checkBottleItem(int); void checkDrinkBottleItem(int); - void checkOilBottleItem(int); + int checkOilBottleItem(int); void checkOpenBottleItem(int); void checkBowItem(int); void checkHookshotItem(int); @@ -156,23 +200,38 @@ public: void setMidnaFaceNum(int); int checkNoResetFlg0(daPy_FLG0) const; int checkEquipHeavyBoots() const; - u32 checkBoarSingleBattle(void) const; - u32 checkEndResetFlg0(daPy_ERFLG0) const; + int checkBoarSingleBattle(void) const; + int checkEndResetFlg0(daPy_ERFLG0) const; + void onNoResetFlg2(daPy_py_c::daPy_FLG2); + void offNoResetFlg0(daPy_py_c::daPy_FLG0); + int checkEndResetFlg2(daPy_py_c::daPy_ERFLG2) const; + bool getSumouMode() const; + int checkNoResetFlg3(daPy_py_c::daPy_FLG3) const; + void checkShieldGet(); + void onNoResetFlg0(daPy_py_c::daPy_FLG0); + int checkEndResetFlg1(daPy_py_c::daPy_ERFLG1) const; + void offNoResetFlg1(daPy_py_c::daPy_FLG1); + void offNoResetFlg2(daPy_py_c::daPy_FLG2); + int checkWolf() const; + void checkSwordGet(); + int checkResetFlg0(daPy_py_c::daPy_RFLG0) const; + int checkNoResetFlg2(daPy_py_c::daPy_FLG2) const; + int checkMagneBootsOn() const; virtual void unk(); virtual bool getMidnaAtnPos(void) const; virtual void setMidnaMsgNum(fopAc_ac_c*, u16); - virtual u32 getModelMtx(void); - virtual u32 getInvMtx(void); + virtual Mtx* getModelMtx(void); + virtual Mtx* getInvMtx(void); virtual cXyz* getShadowTalkAtnPos(void); virtual float getGroundY(); - virtual u32 getLeftItemMatrix(void); - virtual u32 getRightItemMatrix(void); - virtual u32 getLeftHandMatrix(void); - virtual u32 getRightHandMatrix(void); - virtual u32 getLinkBackBone1Matrix(void); - virtual u32 getWolfMouthMatrix(void); - virtual u32 getWolfBackbone2Matrix(void); + virtual Mtx* getLeftItemMatrix(void); + virtual Mtx* getRightItemMatrix(void); + virtual Mtx* getLeftHandMatrix(void); + virtual Mtx* getRightHandMatrix(void); + virtual Mtx* getLinkBackBone1Matrix(void); + virtual Mtx* getWolfMouthMatrix(void); + virtual Mtx* getWolfBackbone2Matrix(void); virtual bool getBottleMtx(void); virtual bool checkPlayerGuard(void) const; virtual bool checkPlayerFly() const; @@ -216,45 +275,45 @@ public: virtual bool checkHorseElecDamage(void) const; virtual float getBaseAnimeFrameRate(void) const; virtual float getBaseAnimeFrame(void) const; - virtual float setAnimeFrame(float); + virtual void setAnimeFrame(float); virtual bool checkWolfLock(fopAc_ac_c*) const; - virtual bool cancelWolfLock(fopAc_ac_c*) const; + virtual bool cancelWolfLock(fopAc_ac_c*); virtual bool getAtnActorID(void) const; - virtual bool getItemID(void) const; + virtual s32 getItemID(void) const; virtual bool getGrabActorID(void) const; virtual bool exchangeGrabActor(fopAc_ac_c*); - virtual bool setForceGrab(fopAc_ac_c*, bool, bool); + virtual bool setForceGrab(fopAc_ac_c*, int, int); virtual void setForcePutPos(cXyz const&); virtual bool checkPlayerNoDraw(void); virtual bool checkRopeTag(void); virtual void voiceStart(u32); virtual void seStartOnlyReverb(u32); virtual void seStartOnlyReverbLevel(u32); - virtual float setOutPower(float, short, bool); - virtual void setGrabCollisionOffset(float, float, void*); + virtual void setOutPower(float, short, int); + virtual void setGrabCollisionOffset(float, float, cBgS_PolyInfo*); virtual void onMagneGrab(float, float); - virtual void onFrollCrashFlg(u8, bool); - virtual bool getModelJoboolMtx(u16); + virtual void onFrollCrashFlg(u8, int); + virtual bool getModelJointMtx(u16); virtual bool getHeadMtx(void); - virtual bool setHookshotCarryOffset(u32, cXyz const*); + virtual bool setHookshotCarryOffset(unsigned int, cXyz const*); virtual bool checkIronBallReturn(void) const; virtual bool checkIronBallGroundStop(void) const; virtual bool checkSingleBoarBattleSecondBowReady(void) const; - virtual bool checkPoboolSubWindowMode(void) const; - virtual void setClothesChange(bool); + virtual bool checkPointSubWindowMode(void) const; + virtual void setClothesChange(int); virtual void setPlayerPosAndAngle(float (*)[4]); virtual void setPlayerPosAndAngle(cXyz const*, csXyz const*); - virtual void setPlayerPosAndAngle(cXyz const*, short, bool); - virtual bool setThrowDamage(short, float, float, bool, bool, bool); - virtual bool checkSetNpcTks(cXyz*, bool, bool); + virtual void setPlayerPosAndAngle(cXyz const*, short, int); + virtual bool setThrowDamage(short, float, float, int, int, int); + virtual bool checkSetNpcTks(cXyz*, int, int); virtual bool setRollJump(float, float, short); virtual void playerStartCollisionSE(u32, u32); - virtual void changeTextureAnime(u16, u16, bool); + virtual void changeTextureAnime(u16, u16, int); virtual void cancelChangeTextureAnime(void); virtual void cancelDungeonWarpReadyNeck(void); virtual void onSceneChangeArea(u8, u8, fopAc_ac_c*); virtual void onSceneChangeAreaJump(u8, u8, fopAc_ac_c*); - virtual void onSceneChangeDead(u8, bool); + virtual void onSceneChangeDead(u8, int); virtual bool checkHorseRide() const; virtual bool checkBoarRide() const; virtual bool checkCanoeRide() const; @@ -263,23 +322,23 @@ public: virtual bool getSpinnerActor(void); virtual bool checkHorseRideNotReady(void) const; virtual bool checkArrowChargeEnd(void) const; - virtual float getSearchBallScale(void) const; + virtual void getSearchBallScale(void) const; virtual bool checkFastShotTime(void); virtual bool checkNoEquipItem(void) const; virtual bool checkFireMaterial(void) const; - virtual bool checkKandelaarSwing(bool) const; + virtual bool checkKandelaarSwing(int) const; virtual bool getBoardCutTurnOffsetAngleY(void) const; - virtual bool getMagneHitPos(void); - virtual bool getMagneBootsTopVec(void); + virtual cXyz* getMagneHitPos(void); + virtual cXyz* getMagneBootsTopVec(void); virtual bool getKandelaarFlamePos(); - virtual bool checkUseKandelaar(bool); + virtual bool checkUseKandelaar(int); virtual void setDkCaught(fopAc_ac_c*); virtual void onPressedDamage(cXyz const&, short); virtual bool checkPriActorOwn(fopAc_ac_c const*) const; virtual bool onWolfEnemyBiteAll(fopAc_ac_c*, daPy_FLG2); virtual bool checkWolfEnemyBiteAllOwn(fopAc_ac_c const*) const; virtual void setWolfEnemyHangBiteAngle(short); - virtual void setKandelaarMtx(float (*)[4], bool, bool); + virtual void setKandelaarMtx(float (*)[4], int, int); virtual bool getStickAngleFromPlayerShape(short*) const; virtual bool checkSpinnerPathMove(void); virtual bool checkSpinnerTriggerAttack(void); @@ -290,13 +349,13 @@ public: virtual bool checkCanoeFishingGetRight(void) const; virtual bool checkBeeChildDrink(void) const; virtual void skipPortalObjWarp(void); - virtual bool checkTreasureRupeeReturn(bool) const; + virtual bool checkTreasureRupeeReturn(int) const; virtual void setSumouReady(fopAc_ac_c*); - virtual bool checkAcceptDungeonWarpAlink(bool); + virtual bool checkAcceptDungeonWarpAlink(int); virtual bool getSumouCounter(void) const; virtual bool checkSumouWithstand(void) const; virtual void cancelGoronThrowEvent(void); - virtual void setSumouGraspCancelCount(bool); + virtual void setSumouGraspCancelCount(int); virtual void setSumouPushBackDirection(short); virtual void setSumouLoseHeadUp(void); virtual s16 getGiantPuzzleAimAngle(void) const; @@ -318,7 +377,7 @@ public: virtual bool checkMetamorphose(void) const; virtual bool checkWolfDownAttackPullOut(void) const; virtual bool checkBootsOrArmorHeavy(void) const; - virtual bool getBottleOpenAppearItem(void) const; + virtual s32 getBottleOpenAppearItem(void) const; virtual bool checkItemSwordEquip(void) const; virtual float getSinkShapeOffset(void) const; virtual bool checkSinkDead(void) const; @@ -329,10 +388,22 @@ public: virtual bool checkCopyRodEquip(void) const; virtual bool checkCutJumpMode(void) const; - inline void onNoResetFlg0(int pFlg) { mNoResetFlg0 |= pFlg; } - inline void onNoResetFlg3(int pFlg) { mNoResetFlg3 |= pFlg; } - inline void offNoResetFlg3(int pFlg) { mNoResetFlg3 &= ~pFlg; } - // inline fopAc_ac_c& getActor() { return mActor; } + inline bool getSumouCameraMode() const { + bool sumouCameraMode = false; + if (field_0x56a != 0 && field_0x56a < 0x26) { + sumouCameraMode = true; + } + return sumouCameraMode; + } + + // some functions use these function as an inline + // is there a better way to handle this? + int i_checkNoResetFlg0(daPy_FLG0 pFlag) const { return mNoResetFlg0 & pFlag; } + int i_checkNoResetFlg1(daPy_FLG1 pFlag) const { return mNoResetFlg1 & pFlag; } + int i_checkNoResetFlg2(daPy_FLG2 pFlag) const { return mNoResetFlg2 & pFlag; } + void i_onNoResetFlg0(int pFlg) { mNoResetFlg0 |= pFlg; } + void i_onEndResetFlg1(daPy_ERFLG1 pFlg) { mEndResetFlg1 |= pFlg; } + int i_checkWolf() { return i_checkNoResetFlg1(Wolf); } static u8 m_midnaActor[4]; }; diff --git a/include/d/bg/d_bg_s_acch.h b/include/d/bg/d_bg_s_acch.h index b47e509e1f..b0e2facd96 100644 --- a/include/d/bg/d_bg_s_acch.h +++ b/include/d/bg/d_bg_s_acch.h @@ -8,6 +8,7 @@ #include "SSystem/SComponent/c_m3d_g_pla.h" #include "d/a/d_a_player.h" #include "d/bg/d_bg_s_gnd_chk.h" +#include "d/bg/d_bg_s_lin_chk.h" #include "d/bg/d_bg_s_roof_chk.h" #include "d/bg/d_bg_s_wtr_chk.h" #include "dolphin/types.h" @@ -69,6 +70,11 @@ public: /* 800773EC */ void OnWallSort(); /* 800773FC */ void ChkWallSort(); /* 80077408 */ void ChkLineDown(); + /* 800D00D0 */ void ChkRoofHit() const; + /* 800D00DC */ void ClrGroundHit(); + /* 80141404 */ void ChkGroundHit() const; + + float GetGroundH() const { return mGroundH; } private: /* 0x000 */ cBgS_Chk field_0x000; @@ -108,6 +114,8 @@ private: /* 0x1D4 */ u8 mWtrChkMode; }; -class dBgS_LinkAcch : public dBgS_Acch {}; +class dBgS_LinkAcch : public dBgS_Acch { + /* 80140F30 */ ~dBgS_LinkAcch(); +}; #endif /* D_BG_D_BG_S_ACCH_H */ diff --git a/include/d/bg/d_bg_s_gnd_chk.h b/include/d/bg/d_bg_s_gnd_chk.h index a979022a31..bdd5831102 100644 --- a/include/d/bg/d_bg_s_gnd_chk.h +++ b/include/d/bg/d_bg_s_gnd_chk.h @@ -15,7 +15,10 @@ private: /* 0x3C */ dBgS_Chk mChk; }; // Size = 0x54 -class dBgS_LinkGndChk : dBgS_GndChk {}; +class dBgS_LinkGndChk : dBgS_GndChk { + virtual void temp(); // temp to build OK + /* 80140EB8 */ virtual ~dBgS_LinkGndChk(); +}; class dBgS_ObjGndChk : dBgS_GndChk {}; diff --git a/include/d/bg/d_bg_s_grp_pass_chk.h b/include/d/bg/d_bg_s_grp_pass_chk.h index 09a3435989..eb5e06d579 100644 --- a/include/d/bg/d_bg_s_grp_pass_chk.h +++ b/include/d/bg/d_bg_s_grp_pass_chk.h @@ -6,6 +6,8 @@ class cBgS_GrpPassChk { public: ~cBgS_GrpPassChk(); + + void* vtable; }; class dBgS_GrpPassChk : public cBgS_GrpPassChk { diff --git a/include/d/bg/d_bg_s_lin_chk.h b/include/d/bg/d_bg_s_lin_chk.h index 9322266cda..6edea1d3e6 100644 --- a/include/d/bg/d_bg_s_lin_chk.h +++ b/include/d/bg/d_bg_s_lin_chk.h @@ -1,6 +1,46 @@ #ifndef D_BG_D_BG_S_LIN_CHK_H #define D_BG_D_BG_S_LIN_CHK_H +#include "SSystem/SComponent/c_bg_s_lin_chk.h" +#include "d/bg/d_bg_s_chk.h" #include "dolphin/types.h" +#include "f_op/f_op_actor.h" + +class dBgS_LinChk { +public: + /* 80077C68 */ dBgS_LinChk(); + /* 80077CDC */ ~dBgS_LinChk(); + /* 80077D64 */ void Set(cXyz const*, cXyz const*, fopAc_ac_c const*); + +private: + /* 0x00 */ cBgS_LinChk mLinChk; + /* 0x58 */ dBgS_Chk mChk; +}; + +class dBgS_LinkLinChk : dBgS_LinChk { +public: + /* 80078030 */ dBgS_LinkLinChk(); + /* 8007808C */ ~dBgS_LinkLinChk(); +}; + +class dBgS_RopeLinChk : dBgS_LinChk { + /* 8007838C */ dBgS_RopeLinChk(); + /* 800783E8 */ ~dBgS_RopeLinChk(); +}; + +class dBgS_BoomerangLinChk : dBgS_LinChk { + /* 800782B8 */ dBgS_BoomerangLinChk(); + /* 80078314 */ ~dBgS_BoomerangLinChk(); +}; + +class dBgS_ArrowLinChk : dBgS_LinChk { + /* 800781D8 */ dBgS_ArrowLinChk(); + /* 80078240 */ ~dBgS_ArrowLinChk(); +}; + +class dBgS_ObjLinChk : dBgS_LinChk { + /* 80077F5C */ dBgS_ObjLinChk(); + /* 80077FB8 */ ~dBgS_ObjLinChk(); +}; #endif /* D_BG_D_BG_S_LIN_CHK_H */ diff --git a/include/d/bg/d_bg_s_poly_pass_chk.h b/include/d/bg/d_bg_s_poly_pass_chk.h index dc20a4bed4..60e911cb3e 100644 --- a/include/d/bg/d_bg_s_poly_pass_chk.h +++ b/include/d/bg/d_bg_s_poly_pass_chk.h @@ -6,6 +6,8 @@ class cBgS_PolyPassChk { public: ~cBgS_PolyPassChk(); + + void* vtable; }; class dBgS_PolyPassChk : public cBgS_PolyPassChk { diff --git a/include/d/bg/d_bg_s_roof_chk.h b/include/d/bg/d_bg_s_roof_chk.h index 86f823faa8..2fbdc6da07 100644 --- a/include/d/bg/d_bg_s_roof_chk.h +++ b/include/d/bg/d_bg_s_roof_chk.h @@ -12,6 +12,7 @@ public: /* 80078FF4 */ dBgS_RoofChk(); /* 80079090 */ ~dBgS_RoofChk(); /* 80079124 */ void Init(); + /* 800B146C */ void SetPos(cXyz const&); private: /* 0x00 */ cBgS_PolyInfo field_0x00; @@ -22,6 +23,9 @@ private: /* 0x4C */ float mNowY; }; // Size = 0x50 -class dBgS_LinkRoofChk : dBgS_RoofChk {}; +class dBgS_LinkRoofChk : dBgS_RoofChk { +public: + /* 80140E40 */ ~dBgS_LinkRoofChk(); +}; #endif /* D_BG_D_BG_S_ROOF_CHK_H */ diff --git a/include/d/cc/d_cc_d.h b/include/d/cc/d_cc_d.h index f861f758d8..37a574ed2c 100644 --- a/include/d/cc/d_cc_d.h +++ b/include/d/cc/d_cc_d.h @@ -152,6 +152,7 @@ public: /* 80084954 */ void MoveCAt(cXyz&); /* 800849C4 */ void MoveCTg(cXyz&); /* 80084D60 */ ~dCcD_Cyl(); + dCcD_Cyl(); private: /* 0x104 */ cCcD_CylAttr mCylAttr; @@ -176,6 +177,7 @@ public: /* 80084824 */ void CalcAtVec(); /* 80084854 */ void CalcTgVec(); /* 8008506C */ ~dCcD_Cps(); + dCcD_Cps(); private: /* 0x104 */ cCcD_CpsAttr mCpsAttr; diff --git a/include/d/com/d_com_inf_game.h b/include/d/com/d_com_inf_game.h index ad3186d54c..d002419509 100644 --- a/include/d/com/d_com_inf_game.h +++ b/include/d/com/d_com_inf_game.h @@ -1,6 +1,7 @@ #ifndef D_COM_D_COM_INF_GAME_H #define D_COM_D_COM_INF_GAME_H +#include "d/a/d_a_alink.h" #include "d/bg/d_bg_s.h" #include "d/cc/d_cc_s.h" #include "d/d_attention.h" @@ -13,16 +14,6 @@ #include "d/save/d_save.h" #include "dolphin/types.h" -struct JKRExpHeap { - /* 802CEE2C */ void create(u32, JKRHeap*, bool); -}; - -struct daAlink_c { - /* 800BDE48 */ void setLastSceneMode(u32*); -}; - -struct daHorse_c {}; - struct dTimer_c { /* 8025D524 */ void deleteCheck(); /* 8025D618 */ void start(int, s16); @@ -392,23 +383,17 @@ public: u8 setWorldDark() { return mWorldDark; } dSv_player_c& getPlayer() { return info.getPlayer(); } - dSv_save_c& getSaveFile() { return info.getSaveFile(); } + dSv_save_c& getSaveFile() { return info.getSavedata(); } u32 getNowVibration() { return play.getNowVibration(); } dDlst_peekZ_c& getdlstPeekZ() { return draw_list_list.dlstPeekZ; } dComIfG_play_c& getPlay() { return play; } dSv_memory_c& getMemory() { return info.getMemory(); } - dSv_event_c& getEvent() { return info.getEvent(); } + dSv_event_c& getEvent() { return info.getTmp(); } dSv_info_c& getInfo() { return info; } inline dDlst_list_c& getDrawlist() { return draw_list_list; } private: /* 0x00000 */ dSv_info_c info; - /* 0x00EEC */ u8 field_0xeec[0x38]; - /* 0x00F24 */ u32 saveTotalTime; - /* 0x00F28 */ u32 saveStartTime; - /* 0x00F2C */ u32 field_0xf2c; - /* 0x00F30 */ u32 field_0xf30; - /* 0x00F34 */ u32 field_0xf34; /* 0x00F38 */ dComIfG_play_c play; /* 0x05F64 */ dDlst_list_c draw_list_list; /* 0x1C110 */ u8 field_0x1C114[0x1E8]; diff --git a/include/d/d_drawlist.h b/include/d/d_drawlist.h index 60e9ab7ecc..86faafac33 100644 --- a/include/d/d_drawlist.h +++ b/include/d/d_drawlist.h @@ -1,21 +1,13 @@ #ifndef D_D_DRAWLIST_H #define D_D_DRAWLIST_H +#include "JSystem/J3DGraphBase/J3DPacket.h" #include "SSystem/SComponent/c_xyz.h" +#include "dolphin/gx/GXTexture.h" +#include "dolphin/mtx/mtx44.h" +#include "dolphin/mtx/mtxvec.h" #include "dolphin/types.h" -struct J3DPacket {}; -struct _GXColor; - -struct J3DDrawBuffer { - /* 80324F08 */ void initialize(); - /* 80324F70 */ void allocBuffer(u32); - /* 80325008 */ ~J3DDrawBuffer(); - /* 80325068 */ void frameInit(); - /* 8032548C */ void entryImm(J3DPacket*, u16); - /* 803254AC */ void draw() const; -}; - class dDlst_FileInfo_c { public: void draw(void); @@ -59,6 +51,7 @@ private: class dDlst_base_c { public: + virtual void temp(); // temp to build OK, remove later virtual void draw(); }; diff --git a/include/d/d_eye_hl.h b/include/d/d_eye_hl.h index 8694bfd883..68d577475a 100644 --- a/include/d/d_eye_hl.h +++ b/include/d/d_eye_hl.h @@ -1,6 +1,35 @@ #ifndef D_D_EYE_HL_H #define D_D_EYE_HL_H +#include "JSystem/J3DGraphAnimator/J3DModelData.h" +#include "JSystem/J3DGraphBase/J3DDrawBuffer.h" +#include "JSystem/JUtility/JUTTexture.h" #include "dolphin/types.h" +class dEyeHL_c; + +class dEyeHL_mng_c { +public: + /* 8009CA48 */ void update(); + /* 8009CB14 */ void entry(dEyeHL_c*); + /* 8009CB34 */ void remove(dEyeHL_c*); + + static u8 m_obj[4 + 4 /* padding */]; + +private: + /* 0x00 */ void* vtable; + /* 0x04 */ ResTIMG* field_0x04; + /* 0x08 */ u16 field_0x08; + /* 0x0A */ u8 field_0x0a[2]; + /* 0x0C */ dEyeHL_mng_c* field_0x0c; + /* 0x10 */ dEyeHL_mng_c* field_0x10; +}; + +class dEyeHL_c : public dEyeHL_mng_c { +public: + /* 8009C964 */ void entry(J3DModelData*, char const*); + /* 8009CA28 */ void remove(); + /* 80140C80 */ ~dEyeHL_c(); +}; + #endif /* D_D_EYE_HL_H */ diff --git a/include/d/d_jnt_col.h b/include/d/d_jnt_col.h index 6f05702f3b..a340444041 100644 --- a/include/d/d_jnt_col.h +++ b/include/d/d_jnt_col.h @@ -1,6 +1,27 @@ #ifndef D_D_JNT_COL_H #define D_D_JNT_COL_H +#include "JSystem/J3DGraphAnimator/J3DModel.h" +#include "SSystem/SComponent/c_m3d_g_lin.h" #include "dolphin/types.h" +#include "f_op/f_op_actor.h" + +class dJntColData_c {}; + +class dJntCol_c { +public: + /* 80035C8C */ dJntCol_c(); + /* 80035CA0 */ void init(fopAc_ac_c*, dJntColData_c const*, J3DModel*, int); + /* 80035CC8 */ void setNowLine(cM3dGLin*, cXyz const*, csXyz const*, cXyz*); + /* 80035DC8 */ void searchNearPos(cM3dGLin const*, cXyz const*, cXyz*, int) const; + /* 80036AEC */ void getArrowOffsetPosAndAngle(cXyz const*, csXyz const*, cXyz*, cXyz*) const; + /* 80036C44 */ void getHitmarkPosAndAngle(cXyz const*, csXyz const*, cXyz*, csXyz*, int) const; + /* 80036FA8 */ void setArrowPosAndAngle(cXyz const*, cXyz const*, int, cXyz*, csXyz*); + + /* 0x00 */ dJntColData_c* mData; + /* 0x04 */ J3DModel* mModel; + /* 0x08 */ int field_0x8; + /* 0x0C */ int field_0xc; +}; #endif /* D_D_JNT_COL_H */ diff --git a/include/d/d_resorce.h b/include/d/d_resorce.h index 4001d2d81c..de0b4315aa 100644 --- a/include/d/d_resorce.h +++ b/include/d/d_resorce.h @@ -2,18 +2,10 @@ #define D_D_RESORCE_H #include "SSystem/SComponent/c_xyz.h" +#include "dolphin/mtx/mtx.h" #include "dolphin/types.h" #include "m_Do/m_Do_ext.h" -struct JKRHeap { - /* 802CE6B0 */ void getSize(void*, JKRHeap*); - /* 802CE784 */ void getTotalFreeSize(); - /* 802CE5CC */ void freeAll(); - /* 802CE83C */ void findFromRoot(void*); - - static u8 sCurrentHeap[4]; -}; - struct JKRArchive { /* 802D5CE4 */ void getIdxResource(u32); /* 802D625C */ void getFileAttribute(u32) const; diff --git a/include/d/kankyo/d_kankyo.h b/include/d/kankyo/d_kankyo.h index 1ce12594b0..bb382bc415 100644 --- a/include/d/kankyo/d_kankyo.h +++ b/include/d/kankyo/d_kankyo.h @@ -1,6 +1,19 @@ #ifndef D_KANKYO_D_KANKYO_H #define D_KANKYO_D_KANKYO_H +#include "SSystem/SComponent/c_xyz.h" +#include "dolphin/gx/GXTexture.h" #include "dolphin/types.h" +struct LIGHT_INFLUENCE { + /* 800CFC7C */ ~LIGHT_INFLUENCE(); + /* 8019F4F8 */ LIGHT_INFLUENCE(); + + /* 0x00 */ cXyz field_0x00; + /* 0x0C */ _GXColorS10 mColor; + /* 0x14 */ float field_0x14; + /* 0x18 */ float field_0x18; + /* 0x1C */ int field_0x1c; +}; + #endif /* D_KANKYO_D_KANKYO_H */ diff --git a/include/d/meter/d_meter2_info.h b/include/d/meter/d_meter2_info.h index 4fcf725326..a0f124a1b2 100644 --- a/include/d/meter/d_meter2_info.h +++ b/include/d/meter/d_meter2_info.h @@ -1,7 +1,9 @@ #ifndef D_METER_D_METER2_INFO_H #define D_METER_D_METER2_INFO_H +#include "JSystem/JUtility/JUTTexture.h" #include "d/d_resorce.h" +#include "d/msg/d_msg_flow.h" #include "dolphin/types.h" #include "f_op/f_op_actor.h" //#include "JSystem/JUtility/JUTFont.h" @@ -14,14 +16,6 @@ struct dMsgObject_c { /* 802384C4 */ void setLetterNameID(u16); }; -struct dMsgFlow_c { - /* 80249F00 */ dMsgFlow_c(); - /* 80249F48 */ ~dMsgFlow_c(); - /* 80249F90 */ void init(fopAc_ac_c*, int, int, fopAc_ac_c**); - /* 8024A2D8 */ void doFlow(fopAc_ac_c*, fopAc_ac_c**, int); - /* 8024A538 */ void getMsgNo(); -}; - class dMeterMap_c { public: /* 8020D900 */ bool isMapOpenCheck(); @@ -51,8 +45,6 @@ class dMeter2_c {}; class dMw_c {}; -struct ResTIMG {}; - class dMeter2Info_c { public: class WarpInfo_c { @@ -105,8 +97,10 @@ public: void resetMiniGameItem(bool); void setMiniGameCount(s8); void setSaveStageName(const char*); + u8& getDirectUseItem() { return mDirectUseItem; } dMeterMap_c* getMeterMapClass() { return mMeterMap; } + void offUseButton(int pButton) { mUseButton &= ~(u16)pButton; } private: /* 0x04 */ u8 unk4[4]; diff --git a/include/d/msg/d_msg_flow.h b/include/d/msg/d_msg_flow.h index 631ad167f7..30e1ae2625 100644 --- a/include/d/msg/d_msg_flow.h +++ b/include/d/msg/d_msg_flow.h @@ -2,5 +2,174 @@ #define D_MSG_D_MSG_FLOW_H #include "dolphin/types.h" +#include "f_op/f_op_actor.h" + +struct mesg_flow_node_branch {}; + +struct mesg_flow_node_event {}; + +struct mesg_flow_node {}; + +class dMsgFlow_c { +public: + /* 80249F00 */ dMsgFlow_c(); + /* 80249F48 */ ~dMsgFlow_c(); + /* 80249F90 */ void init(fopAc_ac_c*, int, int, fopAc_ac_c**); + /* 8024A13C */ void checkOpenDoor(fopAc_ac_c*, int*); + /* 8024A2D8 */ void doFlow(fopAc_ac_c*, fopAc_ac_c**, int); + /* 8024A424 */ void checkEventRender(int*, int*, int*, int*); + /* 8024A4C4 */ void remove(); + /* 8024A528 */ void getEventId(int*); + /* 8024A538 */ void getMsgNo(); + /* 8024A540 */ void getNowMsgNo(); + /* 8024A548 */ void getMsg(); + /* 8024A580 */ void setInitValue(int); + /* 8024A618 */ void setInitValueGroupChange(int, fopAc_ac_c**); + /* 8024A6EC */ void getMsgDataBlock(char const*); + /* 8024A784 */ void getInitNodeIndex(u16); + /* 8024A7CC */ void setNodeIndex(u16, fopAc_ac_c**); + /* 8024A95C */ void setSelectMsg(mesg_flow_node*, mesg_flow_node*, fopAc_ac_c*); + /* 8024AA50 */ void setNormalMsg(mesg_flow_node*, fopAc_ac_c*); + /* 8024AB30 */ void messageNodeProc(fopAc_ac_c*, fopAc_ac_c**); + /* 8024AD54 */ void branchNodeProc(fopAc_ac_c*, fopAc_ac_c**); + /* 8024ADEC */ void eventNodeProc(fopAc_ac_c*, fopAc_ac_c**); + /* 8024AFF8 */ void nodeProc(fopAc_ac_c*, fopAc_ac_c**); + /* 8024B0F0 */ void getParam(u16*, u16*, u8*); + /* 8024B108 */ void getParam(u8*, u8*); + /* 8024B130 */ void getParam(u8*); + /* 8024B138 */ void query001(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B180 */ void query002(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B208 */ void query003(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B250 */ void query004(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B2C0 */ void query005(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B2F8 */ void query006(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B32C */ void query007(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B45C */ void query008(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B4A4 */ void query009(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B4D0 */ void query010(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B504 */ void query011(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B54C */ void query012(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B584 */ void query013(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B5BC */ void query014(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B5F4 */ void query015(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B62C */ void query016(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B664 */ void query017(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B6A8 */ void query018(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B6EC */ void query019(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B730 */ void query020(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B774 */ void query021(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B8E4 */ void query022(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B918 */ void query023(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B954 */ void query024(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B974 */ void query025(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B9BC */ void query026(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024B9E8 */ void query027(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BA4C */ void query028(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BAA0 */ void query029(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BAE0 */ void query030(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BB18 */ void query031(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BB74 */ void query032(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BB9C */ void query033(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BBE4 */ void query034(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BC14 */ void query035(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BC3C */ void query036(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BC80 */ void query037(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BCC4 */ void query038(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BDB0 */ void query039(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BE4C */ void query040(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BF50 */ void query041(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024BFEC */ void query042(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024C0A8 */ void query043(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024C144 */ void query044(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024C18C */ void query045(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024C218 */ void query046(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024C248 */ bool query047(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024C250 */ void query048(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024C2A0 */ void query049(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024C2FC */ void query050(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024C340 */ void query051(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024C3A0 */ void query052(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024C3D4 */ void query053(mesg_flow_node_branch*, fopAc_ac_c*, int); + /* 8024C3FC */ void event000(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C488 */ void event001(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C514 */ void event002(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C550 */ void event003(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C590 */ void event004(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C5F0 */ void event005(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C654 */ void event006(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C694 */ void event007(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C6D8 */ void event008(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C744 */ void event009(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C76C */ void event010(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C7F8 */ void event011(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C884 */ bool event012(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C88C */ void event013(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C8CC */ void event014(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C994 */ void event015(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024CA5C */ void event016(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024CA94 */ void event017(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024CBB0 */ void event018(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024CCA4 */ bool event019(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024CCAC */ void event020(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024CD84 */ void event021(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024CDAC */ void event022(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024CE40 */ void event023(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024CF2C */ void event024(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024CF54 */ void event025(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024CF9C */ void event026(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024D004 */ void event027(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024D3C4 */ void event028(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024D500 */ void event029(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024D544 */ void event030(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024D5BC */ void event031(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024D5EC */ void event032(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024D6BC */ void event033(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024D788 */ void event034(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024D7C8 */ void event035(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024D870 */ void event036(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024D8C4 */ void event037(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024D918 */ void event038(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024D93C */ void event039(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024D970 */ void event040(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024DA78 */ void event041(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024DAA8 */ bool event042(mesg_flow_node_event*, fopAc_ac_c*); + + static u8 mQueryList[636]; + static u8 mEventList[516]; + +private: + /* 0x00 */ void* vtable; + /* 0x04 */ void* field_0x04; + /* 0x08 */ void* field_0x08; + /* 0x0C */ void* field_0x0c; + /* 0x10 */ u16 field_0x10; + /* 0x12 */ u16 field_0x12; + /* 0x14 */ fopAc_ac_c* field_0x14; + /* 0x18 */ int field_0x18; + /* 0x1C */ u16 field_0x1c; + /* 0x1E */ u8 field_0x1e[2]; + /* 0x20 */ int mMsg; + /* 0x24 */ u8 mSelectMessage; + /* 0x25 */ u8 field_0x25; + /* 0x26 */ u8 field_0x26; + /* 0x27 */ u8 field_0x27; + /* 0x28 */ int mMsgNo; + /* 0x2C */ int mNowMsgNo; + /* 0x30 */ u16 field_0x30; + /* 0x32 */ u16 mEventId; + /* 0x34 */ int field_0x34; + /* 0x38 */ u16 field_0x38; + /* 0x3A */ s16 mChoiceNo; + /* 0x3C */ int field_0x3c; + /* 0x40 */ u8 field_0x40; + /* 0x41 */ u8 field_0x41; + /* 0x42 */ s8 field_0x42; + /* 0x43 */ s8 field_0x43; + /* 0x44 */ s8 field_0x44; + /* 0x45 */ s8 field_0x45; + /* 0x46 */ u8 field_0x46; + /* 0x47 */ u8 field_0x47; + /* 0x48 */ u8 mNonStopJunpFlowFlag; +}; #endif /* D_MSG_D_MSG_FLOW_H */ diff --git a/include/d/particle/d_particle.h b/include/d/particle/d_particle.h index 8760226c9c..5bb102e092 100644 --- a/include/d/particle/d_particle.h +++ b/include/d/particle/d_particle.h @@ -1,6 +1,39 @@ #ifndef D_PARTICLE_D_PARTICLE_H #define D_PARTICLE_D_PARTICLE_H +#include "JSystem/JParticle/JPAParticle.h" #include "dolphin/types.h" +#include "f_op/f_op_actor.h" + +class JPAEmitterCallBack { +public: + /* 80050368 */ void execute(JPABaseEmitter*); + /* 8005036C */ void draw(JPABaseEmitter*); + /* 80050370 */ void drawAfter(JPABaseEmitter*); + /* 80050374 */ void executeAfter(JPABaseEmitter*); + /* 8027E6A4 */ ~JPAEmitterCallBack(); +}; + +class dPa_levelEcallBack : public JPAEmitterCallBack { +public: + /* 8004FB18 */ ~dPa_levelEcallBack(); + /* 8004FB8C */ void cleanup(); +}; + +class dPa_hermiteEcallBack_c : public dPa_levelEcallBack { +public: + /* 8004F6B8 */ void setOldPosP(cXyz const*, cXyz const*); + /* 8004F6C4 */ void executeAfter(JPABaseEmitter*); + /* 8004FABC */ void setup(JPABaseEmitter*, cXyz const*, csXyz const*, s8); + /* 8004FCC8 */ ~dPa_hermiteEcallBack_c(); + +private: + /* 0x00 */ void* vtable; + /* 0x04 */ float mRate; + /* 0x08 */ int mMaxCnt; + /* 0x0C */ cXyz* field_0xc; + /* 0x10 */ cXyz* field_0x10; + /* 0x14 */ cXyz* field_0x14; +}; #endif /* D_PARTICLE_D_PARTICLE_H */ diff --git a/include/d/particle/d_particle_copoly.h b/include/d/particle/d_particle_copoly.h index 19e3fc2080..f4da7608d9 100644 --- a/include/d/particle/d_particle_copoly.h +++ b/include/d/particle/d_particle_copoly.h @@ -1,6 +1,31 @@ #ifndef D_PARTICLE_D_PARTICLE_COPOLY_H #define D_PARTICLE_D_PARTICLE_COPOLY_H +#include "d/bg/d_bg_s_acch.h" #include "dolphin/types.h" +struct dKy_tevstr_c {}; + +class dPaPo_c { +public: + /* 80050C9C */ void init(dBgS_Acch*, f32, f32); + /* 80050CC4 */ void checkWaterIn(cXyz*, cXyz const*, dKy_tevstr_c const*, u32, s8, f32, f32); + /* 80050E7C */ void setEffect(u32*, int, dKy_tevstr_c const*, cXyz const*, u32, u32, + cXyz const*, csXyz const*, s8, u8*, u8*); + /* 80051008 */ void setEffectCenter(dKy_tevstr_c const*, cXyz const*, u32, u32, cXyz const*, + csXyz const*, cXyz const*, s8, f32, f32); + /* 8005113C */ void clearID(u32*, u8*); + /* 80051488 */ void getCenterEffType(int) const; + /* 80051524 */ void getCenterEmitter(int, int); + + /* 0x00 */ u8 field_0x00[0x28]; + /* 0x28 */ dBgS_Acch* field_0x28; + /* 0x2C */ float field_0x2c; + /* 0x30 */ float field_0x30; + /* 0x34 */ u8 field_0x34; + /* 0x35 */ u8 field_0x35; + /* 0x36 */ u8 field_0x36; + /* 0x37 */ u8 field_0x37; +}; + #endif /* D_PARTICLE_D_PARTICLE_COPOLY_H */ diff --git a/include/d/save/d_save.h b/include/d/save/d_save.h index 808ccba9da..70177ca30b 100644 --- a/include/d/save/d_save.h +++ b/include/d/save/d_save.h @@ -13,6 +13,8 @@ #define LETTER_INFO_BIT 64 #define BOMB_BAG_MAX 3 #define BOTTLE_MAX 4 +#define TBOX_MAX 64 +#define DSV_MEMBIT_ENUM_MAX 8 enum Wallets { WALLET, BIG_WALLET, GIANT_WALLET }; @@ -302,7 +304,7 @@ enum ItemTable { NO_ITEM }; -enum EquipmentBits { CLOTHING_BITFIELD, SWORD_BITFIELD, SHIELD_BITFIELD }; +enum CollectItem { COLLECT_CLOTHING, COLLECT_SWORD, COLLECT_SHIELD, COLLECT_SMELL, B_BUTTON_ITEM }; enum Swords { ORDON_SWORD_FLAG, MASTER_SWORD_FLAG, WOODEN_SWORD_FLAG, LIGHT_SWORD_FLAG }; @@ -310,9 +312,9 @@ enum Shields { ORDON_SHIELD_FLAG, HYLIAN_SHIELD_FLAG, WOODEN_SHIELD_FLAG }; enum Armors { KOKIRI_CLOTHES_FLAG }; -enum DungeonItem { MAP_FLAG, COMPASS_FLAG, BOSS_KEY_FLAG, OOCCOO_NOTE_FLAG = 6 }; +enum LightDropStages { FARON_VESSEL, ELDIN_VESSEL, LANAYRU_VESSEL }; -enum AreaVessel { FARON_VESSEL, ELDIN_VESSEL, LANAYRU_VESSEL }; +enum ItemMax { ARROW_MAX, NORMAL_BOMB_MAX, WATER_BOMB_MAX, POKE_BOMB_MAX = 6 }; class dSv_player_status_a_c { public: @@ -324,42 +326,42 @@ public: u16 getRupeeMax(void) const; int isMagicFlag(u8) const; - u16& getMaxLife() { return mMaxHealth; } - u16& getLife() { return mCurrentHealth; } - u16& getRupee() { return mCurrentRupees; } - u16& getOil() { return mCurrentLanternOil; } - u8 getSelectEquip(int item) const { return mEquipment[item]; } - void setWalletLV(u8 lv) { mCurrentWallet = lv; } - void setOil(u16 oil) { mCurrentLanternOil = oil; } - void setMaxOil(u16 max) { mMaxLanternOil = max; } - void setWalletSize(u8 size) { mCurrentWallet = size; } - void setMagic(u8 magic) { mCurrentMagic = magic; } + u16& getMaxLife() { return mMaxLife; } + u16& getLife() { return mLife; } + u16& getRupee() { return mRupee; } + u16& getOil() { return mOil; } + u8 getSelectEquip(int item) const { return mSelectEquip[item]; } + void setWalletLV(u8 lv) { mWalletSize = lv; } + void setOil(u16 oil) { mOil = oil; } + void setMaxOil(u16 max) { mMaxOil = max; } + void setWalletSize(u8 size) { mWalletSize = size; } + void setMagic(u8 magic) { mMagic = magic; } void setMaxMagic(u8 max) { mMaxMagic = max; } - void setRupee(u16 rupees) { mCurrentRupees = rupees; } - void setLife(u16 life) { mCurrentHealth = life; } - void setMaxLife(u8 max) { mMaxHealth = max; } - void setSelectEquip(int item_index, u8 item) { mEquipment[item_index] = item; } - -private: - u16 mMaxHealth; - u16 mCurrentHealth; - u16 mCurrentRupees; - u16 mMaxLanternOil; - u16 mCurrentLanternOil; - u8 unk10; - u8 mSelectItem[3]; - u8 mMixItem[3]; - u8 unk17; - u8 unk18; - u8 mEquipment[6]; - u8 mCurrentWallet; - u8 mMaxMagic; - u8 mCurrentMagic; - u8 mMagicFlag; - u8 unk29; - u8 unk30; - u8 unk31[3]; - u8 padding[6]; + void setRupee(u16 rupees) { mRupee = rupees; } + void setLife(u16 life) { mLife = life; } + void setMaxLife(u8 max) { mMaxLife = max; } + void setSelectEquip(int item_index, u8 item) { mSelectEquip[item_index] = item; } + +private: + /* 0x00 */ u16 mMaxLife; + /* 0x02 */ u16 mLife; + /* 0x04 */ u16 mRupee; + /* 0x06 */ u16 mMaxOil; + /* 0x08 */ u16 mOil; + /* 0x0A */ u8 unk10; + /* 0x0B */ u8 mSelectItem[3]; + /* 0x0E */ u8 mMixItem[3]; + /* 0x11 */ u8 unk17; + /* 0x12 */ u8 unk18; + /* 0x13 */ u8 mSelectEquip[6]; + /* 0x19 */ u8 mWalletSize; + /* 0x1A */ u8 mMaxMagic; + /* 0x1B */ u8 mMagic; + /* 0x1C */ u8 mMagicFlag; + /* 0x1D */ u8 unk29; + /* 0x1E */ u8 mTransformStatus; + /* 0x1F */ u8 unk31[3]; + /* 0x22 */ u8 padding[6]; }; class dSv_player_status_b_c { @@ -371,14 +373,13 @@ public: BOOL isTransformLV(int) const; private: - u32 unk0; - u32 unk4; + u64 mDateIpl; u8 mTransformLevelFlag; u8 mDarkClearLevelFlag; u8 unk10; u8 unk11; - float mTimeOfDay; - u16 unk16; + float mTime; + u16 mDate; u8 unk18[3]; u8 padding[3]; }; @@ -417,13 +418,13 @@ public: void set(const char*, const cXyz&, s16, s8, u8); private: - cXyz mLastPosition; - s16 mLastAngle; - char mLastStage[8]; + cXyz mPos; + s16 mAngleY; + char mName[8]; u8 mLastSpawnId; - u8 mLastRoomId; - u8 unk24; - u8 mLastRegion; + u8 mRegionNo; + bool mFieldDataExistFlag; + u8 mRegion; u8 unk26[2]; }; @@ -501,13 +502,13 @@ public: u8 addBottleNum(u8, s16); u8 getBottleNum(u8) const; - void setArrowNum(u8 amount) { mBow = amount; } + void setArrowNum(u8 amount) { mArrowNum = amount; } private: - u8 mBow; - u8 mBombBags[3]; - u8 mBottles[4]; - u8 mSlingshot; + u8 mArrowNum; + u8 mBombNum[3]; + u8 mBottleNum[4]; + u8 mPachinkoNum; u8 unk5[3]; }; @@ -517,11 +518,11 @@ public: void setBombNum(u8, u8); u8 getBombNum(u8) const; - void setArrowNum(u8 max) { mItemCapacities[0] = max; } - u8 getArrowNum() { return mItemCapacities[0]; } + void setArrowNum(u8 max) { mItemMax[ARROW_MAX] = max; } + u8 getArrowNum() { return mItemMax[ARROW_MAX]; } private: - u8 mItemCapacities[8]; + u8 mItemMax[8]; }; class dSv_player_collect_c { @@ -534,15 +535,15 @@ public: void onCollectMirror(u8); BOOL isCollectMirror(u8) const; - u8 getPohNum() { return mPoeCount; } + u8 getPohNum() { return mPohNum; } private: - u8 unk0[8]; + u8 mItem[8]; u8 unk8; u8 mCrystal; u8 mMirror; u8 unk11; - u8 mPoeCount; + u8 mPohNum; u8 padding[3]; }; @@ -564,7 +565,7 @@ public: BOOL isLightDropGetFlag(u8) const; private: - u8 mLightDropCounts[4]; + u8 mLightDropNum[4]; u8 mLightDropGetFlag; u8 unk5[3]; }; @@ -586,31 +587,30 @@ private: class dSv_fishing_info_c { public: void init(void); - void addFishCount(u8); // merged with init in the assembly + void addFishCount(u8); private: u16 mFishCount[16]; - u8 unk32[16]; + u8 mMaxSize[16]; u8 padding[4]; }; class dSv_player_info_c { public: void init(void); - char* getLinkName() { return (char*)link_name; } + char* getLinkName() { return (char*)mPlayerName; } private: u32 unk0; u32 unk4; - u32 unk8; - u32 unk12; + u64 mTotalTime; u16 unk16; - u16 unk18; - u8 link_name[16]; + u16 mDeathCount; + u8 mPlayerName[16]; u8 unk36; - u8 epona_name[16]; + u8 mHorseName[16]; u8 unk53; - u8 unk54; + u8 mClearCount; u8 unk55[5]; u8 padding[4]; }; @@ -627,15 +627,15 @@ public: private: u8 unk0; u8 mSoundMode; - u8 unk2; - u8 mVibrationStatus; + u8 mAttentionType; + u8 mVibration; u8 unk4; u8 unk5; - u16 unk6; - u8 unk8; - u8 unk9; - u8 unk10; - u8 unk11; + u16 mCalibrateDist; + u8 mCalValue; + u8 mShortCut; + u8 mCameraControl; + u8 mPointer; u8 padding[4]; }; @@ -652,8 +652,6 @@ public: dSv_light_drop_c& getLightDrop() { return light_drop; } dSv_player_get_item_c& getPlayerGetItem() { return player_get_item; } - void setPlayerStatusAWalletLV(u8 lv) { player_status_a.setWalletLV(lv); } - private: dSv_player_status_a_c player_status_a; dSv_player_status_b_c player_status_b; @@ -677,6 +675,17 @@ private: #pragma pack(push, 1) class dSv_memBit_c { public: + enum { + MAP_FLAG, + COMPASS_FLAG, + BOSS_KEY_FLAG, + STAGE_BOSS_ENEMY, + STAGE_LIFE, + STAGE_BOSS_DEMO, + OOCCOO_NOTE_FLAG, + STAGE_BOSS_ENEMY_2 + }; + void init(void); void onTbox(int); void offTbox(int); @@ -690,7 +699,7 @@ public: void onDungeonItem(int); bool isDungeonItem(int) const; - u8 getKeyNum() { return small_key_flags; } + u8 getKeyNum() { return mKeyNum; } void onDungeonItemMap() { onDungeonItem(MAP_FLAG); } bool isDungeonItemMap() const { return isDungeonItem(MAP_FLAG); } void onDungeonItemCompass() { onDungeonItem(COMPASS_FLAG); } @@ -699,11 +708,11 @@ public: bool isDungeonItemBossKey() const { return isDungeonItem(BOSS_KEY_FLAG); } private: - u32 area_flags_bitfields1[2]; - u32 area_flags_bitfields2[4]; - u32 rupee_flags_bitfields; - u8 small_key_flags; - u8 dungeons_flags; + /* 0x00 */ u32 mTbox[2]; + /* 0x08 */ u32 mSwitch[4]; + /* 0x18 */ u32 mItem[1]; // not sure if this is right + /* 0x1C */ u8 mKeyNum; + /* 0x1D */ u8 mDungeonItem; }; #pragma pack(pop) @@ -717,7 +726,7 @@ public: u8 getEventReg(u16) const; private: - u8 events[256]; + u8 mEvent[256]; }; class dSv_MiniGame_c { @@ -728,34 +737,34 @@ private: u8 unk0; u8 unk1[3]; u32 unk4; - u32 unk8; - u32 unk12; + u32 mBalloonScore; + u32 mRaceGameTime; u32 unk16; u32 unk20; }; class dSv_memory_c { public: - dSv_memory_c(void); // the assembly for this is in d_com_inf_game.s + dSv_memory_c(void); void init(void); - dSv_memBit_c& getTempFlags() { return temp_flags; } - const dSv_memBit_c& getTempFlagsConst() const { return temp_flags; } + dSv_memBit_c& getMemBit() { return mMemBit; } + const dSv_memBit_c& getMemBitConst() const { return mMemBit; } private: - dSv_memBit_c temp_flags; + dSv_memBit_c mMemBit; u8 padding30[2]; }; class dSv_memory2_c { public: - dSv_memory2_c(void); // the assembly for this is in d_com_inf_game.s + dSv_memory2_c(void); void init(void); void onVisitedRoom(int); void offVisitedRoom(int); BOOL isVisitedRoom(int); private: - u32 unk0[2]; + u32 mVisitedRoom[2]; }; class dSv_danBit_c { @@ -769,11 +778,11 @@ public: BOOL isItem(int) const; private: - s8 mStageNum; + s8 mStageNo; u8 unk1; u8 unk2[2]; - u32 switch_bitfield[2]; - u32 item_bitfield[4]; + u32 mSwitch[2]; + u32 mItem[4]; s16 unk28[16]; }; @@ -796,10 +805,10 @@ public: BOOL isOneItem(int) const; private: - u16 switch_bitfield[2]; - u16 room_switch; - u16 item_bitfield[2]; - u16 room_item; + u16 mSwitch[2]; + u16 mRoomSwitch; + u16 mItem[2]; + u16 mRoomItem; u16 unk12; }; @@ -820,18 +829,18 @@ class dSv_zone_c { public: dSv_zone_c(void); // the assembly for this is in d_com_inf_game.s void init(int); - dSv_zoneBit_c& getZoneBit() { return zone_bit; } - const dSv_zoneBit_c& getZoneBitConst() const { return zone_bit; } - dSv_zoneActor_c& getZoneActor() { return zone_actor; } - const dSv_zoneActor_c& getZoneActorConst() const { return zone_actor; } + dSv_zoneBit_c& getZoneBit() { return mBit; } + const dSv_zoneBit_c& getZoneBitConst() const { return mBit; } + dSv_zoneActor_c& getZoneActor() { return mActor; } + const dSv_zoneActor_c& getZoneActorConst() const { return mActor; } - s8& getUnk0() { return unk0; } + s8& getRoomNo() { return mRoomNo; } private: - s8 unk0; + s8 mRoomNo; u8 unk1; - dSv_zoneBit_c zone_bit; - dSv_zoneActor_c zone_actor; + dSv_zoneBit_c mBit; + dSv_zoneActor_c mActor; }; class dSv_restart_c { @@ -839,22 +848,34 @@ public: void setRoom(const cXyz&, s16, s8); private: - u8 unk0; - u8 unk1[5]; - s16 mXRotation; - cXyz mPosition; - u8 padding20[16]; + /* 0x00 */ s8 mRoomNo; + /* 0x01 */ u8 field_0x01[3]; + /* 0x04 */ s16 mStartPoint; + /* 0x06 */ s16 mRoomAngleY; + /* 0x08 */ cXyz mRoomPos; + /* 0x14 */ u32 mRoomParam; + /* 0x18 */ f32 mLastSpeedF; + /* 0x1C */ u32 mLastMode; + /* 0x20 */ s16 mLastAngleY; }; class dSv_turnRestart_c { public: + class dSv_turnRestart_camera_c { + cXyz mCameraCtr; + cXyz mCameraEye; + cXyz mCameraUp; + }; + void set(const cXyz&, s16, s8, u32); private: - cXyz mPosition; - u32 unk12; - s16 mXRotation; - s8 unk18; + /* 0x00 */ cXyz mPosition; + /* 0x0C */ u32 mParam; + /* 0x10 */ s16 mAngleY; + /* 0x12 */ s8 unk18; + /* 0x14 */ dSv_turnRestart_camera_c mCamera; + /* 0x38 */ f32 mCameraFvy; }; class dSv_reserve_c { @@ -867,28 +888,27 @@ class dSv_save_c { public: void init(void); dSv_memory2_c* getSave2(int); - dSv_player_c& getPlayer() { return player; } - dSv_player_status_a_c& getPlayerStatusA() { return player.getPlayerStatusA(); } - dSv_player_get_item_c& getPlayerGetItem() { return player.getPlayerGetItem(); } - dSv_player_item_record_c& getPlayerItemRecord() { return player.getPlayerItemRecord(); } - dSv_player_item_max_c& getPlayerItemMax() { return player.getPlayerItemMax(); } - dSv_player_last_mark_info_c& getPlayerLastMarkInfo() { return player.getPlayerLastMarkInfo(); } - dSv_player_item_c& getPlayerItem() { return player.getPlayerItem(); } - dSv_player_collect_c& getPlayerCollect() { return player.getPlayerCollect(); } - dSv_light_drop_c& getLightDrop() { return player.getLightDrop(); } - dSv_event_c& getEventFlags() { return event_flags; } - - void setPlayerStatusAWallet(u8 lv) { player.setPlayerStatusAWalletLV(lv); } - - static const int STAGE_MAX = 4; - -private: - dSv_player_c player; - dSv_memory_c area_flags[32]; - dSv_memory2_c unk_flags[64]; - dSv_event_c event_flags; + dSv_player_c& getPlayer() { return mPlayer; } + dSv_player_status_a_c& getPlayerStatusA() { return mPlayer.getPlayerStatusA(); } + dSv_player_get_item_c& getPlayerGetItem() { return mPlayer.getPlayerGetItem(); } + dSv_player_item_record_c& getPlayerItemRecord() { return mPlayer.getPlayerItemRecord(); } + dSv_player_item_max_c& getPlayerItemMax() { return mPlayer.getPlayerItemMax(); } + dSv_player_last_mark_info_c& getPlayerLastMarkInfo() { return mPlayer.getPlayerLastMarkInfo(); } + dSv_player_item_c& getPlayerItem() { return mPlayer.getPlayerItem(); } + dSv_player_collect_c& getPlayerCollect() { return mPlayer.getPlayerCollect(); } + dSv_light_drop_c& getLightDrop() { return mPlayer.getLightDrop(); } + dSv_event_c& getEvent() { return mEvent; } + + static const int STAGE_MAX = 32; + static const int STAGE2_MAX = 64; + +private: + dSv_player_c mPlayer; + dSv_memory_c mSave[STAGE_MAX]; + dSv_memory2_c mSave2[STAGE2_MAX]; + dSv_event_c mEvent; dSv_reserve_c reserve; - dSv_MiniGame_c minigame_flags; + dSv_MiniGame_c mMiniGame; }; #pragma pack(push, 1) class dSv_info_c { @@ -911,20 +931,27 @@ public: void card_to_memory(char*, int); void initdata_to_card(char*, int); - dSv_save_c& getSaveFile() { return save_file; } - dSv_memory_c& getMemory() { return memory; } - dSv_zone_c* getZones() { return zones; } - dSv_player_c& getPlayer() { return save_file.getPlayer(); } - dSv_event_c& getEvent() { return events; } - -private: - /* 0x000 */ dSv_save_c save_file; - /* 0x958 */ dSv_memory_c memory; - /* 0x978 */ dSv_danBit_c dungeon_bit; - /* 0x9B4 */ dSv_zone_c zones[32]; - /* 0xDB4 */ dSv_restart_c restart; - /* 0xDD8 */ dSv_event_c events; - /* 0xED8 */ dSv_turnRestart_c turn_restart; + dSv_save_c& getSavedata() { return mSavedata; } + dSv_memory_c& getMemory() { return mMemory; } + dSv_zone_c* getZones() { return mZone; } + dSv_player_c& getPlayer() { return mSavedata.getPlayer(); } + dSv_event_c& getTmp() { return mTmp; } + +private: + /* 0x000 */ dSv_save_c mSavedata; + /* 0x958 */ dSv_memory_c mMemory; + /* 0x978 */ dSv_danBit_c mDan; + /* 0x9B4 */ dSv_zone_c mZone[32]; + /* 0xDB4 */ dSv_restart_c mRestart; + /* 0xDD8 */ dSv_event_c mTmp; + /* 0xED8 */ dSv_turnRestart_c mTurnRestart; + /* 0xF14 */ u8 field_0xf14[4]; + /* 0xF18 */ u8 mDataNum; + /* 0xF19 */ u8 mNewFile; + /* 0xF1A */ u8 mNoFile; + /* 0xF1B */ u8 field_0xf1b[13]; + /* 0xF28 */ u64 mStartTime; + /* 0xF30 */ u64 mSaveTotalTime; }; #pragma pack(pop) diff --git a/include/dolphin/gx/GXTexture.h b/include/dolphin/gx/GXTexture.h index 75bd5ac4aa..3a111fdad1 100644 --- a/include/dolphin/gx/GXTexture.h +++ b/include/dolphin/gx/GXTexture.h @@ -17,7 +17,7 @@ struct _GXColor { u8 a; }; -struct GXColorS10 { +struct _GXColorS10 { s16 r; s16 g; s16 b; diff --git a/include/f_op/f_op_actor.h b/include/f_op/f_op_actor.h index cac2f918dd..024f86809d 100644 --- a/include/f_op/f_op_actor.h +++ b/include/f_op/f_op_actor.h @@ -3,27 +3,37 @@ #include "SSystem/SComponent/c_sxyz.h" #include "SSystem/SComponent/c_xyz.h" -#include "f_pc/f_pc_base.h" +#include "dolphin/mtx/mtx.h" +#include "f_pc/f_pc_leaf.h" struct JKRSolidHeap; -class fopAc_ac_c : public base_process_class { +struct actor_place { + cXyz mPosition; + csXyz mAngle; + u8 mRoomNo; + u8 field_0x13; +}; + +class fopAc_ac_c : public leafdraw_class { public: - /* 0x0B8 */ u8 unk_0x0B8[0xF0 - 0xB8]; + /* 0x0C0 */ int mAcType; + /* 0x0C4 */ create_tag_class mAcTg; + /* 0x0D8 */ create_tag_class mDwTg; + /* 0x0EC */ profile_method_class* mSubMtd; /* 0x0F0 */ JKRSolidHeap* unk_0x0F0; /* 0x0F4 */ u8 unk_0x0F4[0x496 - 0xF4]; /* 0x496 */ u8 unk_0x496; /* 0x497 */ u8 unk_0x497[0x499 - 0x497]; /* 0x499 */ s8 unk_0x499; - /* 0x497 */ u8 unk_0x49A[0x4D0 - 0x49A]; - /* 0x4D0 */ cXyz mPosition; - /* 0x4DC */ csXyz mAngle; - /* 0x4E2 */ s8 mRoomNo; - /* 0x4E3 */ u8 unk_0x4E3[0x4E6 - 0x4E3]; - /* 0x4E6 */ s16 unk_0x4E6; - /* 0x4E8 */ u8 unk_0x4E8[0x4F8 - 0x4E8]; + /* 0x49A */ u8 unk_0x49A[0x4A8 - 0x49A]; + /* 0x4A8 */ actor_place mOrig; + /* 0x4BC */ actor_place mNext; + /* 0x4D0 */ actor_place mCurrent; + /* 0x4E4 */ csXyz mCollisionRot; + /* 0x4EC */ cXyz mScale; /* 0x4F8 */ cXyz mSpeed; - /* 0x504 */ u8 unk_0x504[4]; + /* 0x504 */ Mtx* mCullMtx; /* 0x508 */ cXyz mCullMin; /* 0x514 */ cXyz mCullMax; /* 0x520 */ u8 unk_0x520[0xC]; @@ -36,8 +46,8 @@ public: static u8 stopStatus[4]; - const cXyz& getPosition() const { return mPosition; } - const csXyz& getAngle() const { return mAngle; } + const cXyz& getPosition() const { return mCurrent.mPosition; } + const csXyz& getAngle() const { return mCurrent.mAngle; } }; // Size: unknown #endif
\ No newline at end of file diff --git a/include/f_op/f_op_actor_mng.h b/include/f_op/f_op_actor_mng.h index 794eb7e59d..a9ec1550f4 100644 --- a/include/f_op/f_op_actor_mng.h +++ b/include/f_op/f_op_actor_mng.h @@ -32,6 +32,8 @@ struct fopAcM_prm_class { class fopAcM_lc_c { public: static bool lineCheck(const cXyz*, const cXyz*, const fopAc_ac_c*); + + static u8 mLineCheck[112]; }; class fopAcM_rc_c { @@ -42,11 +44,17 @@ public: class fopAcM_gc_c { public: static bool gndCheck(const cXyz*); + + static u8 mGndCheck[84]; + static f32 mGroundY; }; class fopAcM_wt_c { public: static bool waterCheck(const cXyz*); + + static u8 mWaterCheck[84 + 4 /* padding */]; + static f32 mWaterY[1 + 1 /* padding */]; }; struct dKy_tevstr_c; @@ -59,7 +67,15 @@ struct DOUBLE_POS { }; inline s32 fopAcM_GetRoomNo(const fopAc_ac_c* pActor) { - return pActor->mRoomNo; + return pActor->mCurrent.mRoomNo; +} + +inline u32 fopAcM_GetID(const void* pActor) { + return fpcM_GetID(pActor); +} + +inline s16 fopAcM_GetName(fopAc_ac_c* pActor) { + return fpcM_GetName(pActor); } void* fopAcM_FastCreate(s16 pProcTypeID, FastCreateReqFunc param_2, void* param_3, void* pData); @@ -94,7 +110,7 @@ void fopAcM_setCullSizeSphere(fopAc_ac_c*, f32, f32, f32, f32); void fopAcM_setCullSizeBox2(fopAc_ac_c*, J3DModelData*); bool fopAcM_addAngleY(fopAc_ac_c*, s16, s16); inline csXyz& fopAcM_GetAngle_p(fopAc_ac_c* pActor) { - return pActor->mAngle; + return pActor->mCurrent.mAngle; } void fopAcM_calcSpeed(fopAc_ac_c*); void fopAcM_posMove(fopAc_ac_c*, const cXyz*); diff --git a/include/f_pc/f_pc_manager.h b/include/f_pc/f_pc_manager.h index 92dfe830e7..7c62fe75ec 100644 --- a/include/f_pc/f_pc_manager.h +++ b/include/f_pc/f_pc_manager.h @@ -15,6 +15,10 @@ typedef int (*fpcM_DrawIteraterFunc)(void*, void*); inline u32 fpcM_GetID(const void* pProc) { return pProc != NULL ? ((base_process_class*)pProc)->mBsPcId : 0xFFFFFFFF; } +inline s16 fpcM_GetName(const void* pActor) { + return ((base_process_class*)pActor)->mProcName; +} + void fpcM_Draw(void* pProc); s32 fpcM_DrawIterater(fpcM_DrawIteraterFunc pFunc); void fpcM_Execute(void* pProc); diff --git a/include/m_Do/m_Do_ext.h b/include/m_Do/m_Do_ext.h index 511cc4d355..aa669108c9 100644 --- a/include/m_Do/m_Do_ext.h +++ b/include/m_Do/m_Do_ext.h @@ -2,23 +2,11 @@ #define M_DO_M_DO_EXT_H #include "JSystem/J3DGraphAnimator/J3DAnimation.h" +#include "JSystem/J3DGraphAnimator/J3DModel.h" +#include "JSystem/JKernel/JKRExpHeap.h" +#include "JSystem/JKernel/JKRSolidHeap.h" #include "dolphin/types.h" -struct J3DModelData { - /* 80325E14 */ void newSharedDisplayList(u32); - /* 80325F94 */ void makeSharedDL(); - /* 8032600C */ void simpleCalcMaterial(u16, f32 (*)[4]); -}; - -struct J3DModel { - /* 80327100 */ void initialize(); - /* 80327184 */ void entryModelData(J3DModelData*, u32, u32); - /* 803275FC */ void newDifferedDisplayList(u32); - /* 8032767C */ void lock(); - /* 803276B4 */ void unlock(); - /* 803279A0 */ void diff(); -}; - struct J3DMaterialTable; struct J3DAnmTextureSRTKey { /* 80329E5C */ J3DAnmTextureSRTKey(); @@ -130,4 +118,14 @@ private: }; #pragma pack(pop) +class mDoExt_AnmRatioPack { +public: + /* 80140DF0 */ ~mDoExt_AnmRatioPack(); + /* 80140E2C */ mDoExt_AnmRatioPack(); + +private: + /* 0x0 */ float mRatio; + /* 0x4 */ J3DAnmTransform* mAnmTransform; +}; // Size = 0x8 + #endif /* M_DO_M_DO_EXT_H */ |