From 20e9957356111843dd6a09a7f9421d3e9359d096 Mon Sep 17 00:00:00 2001 From: Howard Luck Date: Sun, 30 Nov 2025 13:26:50 -0700 Subject: [PATCH] d_a_alink_HIO work (#2852) * daAlink_c::jointControll OK * daalink debug work * checkpoint * fix casting * checkpoint * checkpoint * checkpoint * checkpoint * checkpoint * checkpoint * checkpoint * remaining functions + fixes round 1 * fixes round 2 * fixes round 3 * fixes round 4 * revert getNeckAimAngle for now --- include/d/actor/d_a_alink.h | 5544 +++++++++++++++---------- include/f_op/f_op_actor.h | 2 +- src/JSystem/JHostIO/JORServer.cpp | 6 +- src/d/actor/d_a_alink.cpp | 223 +- src/d/actor/d_a_alink_HIO.inc | 5998 +++++++++++++++++++++++++++- src/d/actor/d_a_alink_HIO_data.inc | 24 +- src/d/actor/d_a_alink_boom.inc | 4 +- src/d/actor/d_a_alink_bottle.inc | 2 +- src/d/actor/d_a_alink_bow.inc | 2 +- src/d/actor/d_a_alink_copyrod.inc | 2 +- src/d/actor/d_a_alink_cut.inc | 9 + src/d/actor/d_a_alink_damage.inc | 118 +- src/d/actor/d_a_alink_demo.inc | 66 +- src/d/actor/d_a_alink_effect.inc | 4 +- src/d/actor/d_a_alink_grab.inc | 110 +- src/d/actor/d_a_alink_hang.inc | 106 +- src/d/actor/d_a_alink_hook.inc | 2 +- src/d/actor/d_a_alink_horse.inc | 40 +- src/d/actor/d_a_alink_ironball.inc | 4 +- src/d/actor/d_a_alink_link.inc | 4 +- src/d/actor/d_a_alink_sumou.inc | 2 +- src/d/actor/d_a_alink_swim.inc | 148 +- src/d/actor/d_a_alink_whistle.inc | 2 +- src/d/actor/d_a_alink_wolf.inc | 1024 ++--- src/d/actor/d_a_npc_bans.cpp | 2 +- src/d/actor/d_a_npc_kn.cpp | 2 +- src/d/actor/d_a_npc_toby.cpp | 2 +- src/d/actor/d_a_npc_wrestler.cpp | 2 +- src/d/actor/d_a_npc_yamid.cpp | 2 +- src/d/actor/d_a_npc_zelda.cpp | 2 +- src/d/actor/d_a_obj_itamato.cpp | 2 +- src/d/actor/d_a_obj_pumpkin.cpp | 2 +- 32 files changed, 10306 insertions(+), 3156 deletions(-) diff --git a/include/d/actor/d_a_alink.h b/include/d/actor/d_a_alink.h index 61d5357ae13..27b98dfbe57 100644 --- a/include/d/actor/d_a_alink.h +++ b/include/d/actor/d_a_alink.h @@ -208,37 +208,3374 @@ struct daAlink_WlAnmData { /* 0x7 */ u8 field_0x7; }; // Size: 0x8 -class daAlinkHIO_wolf_c { +class daAlinkHIO_data_c : public JORReflexible { public: - /* 80140B98 */ ~daAlinkHIO_wolf_c(); + daAlinkHIO_data_c(); + ~daAlinkHIO_data_c(); - /* 0x0 */ u8 unk_0x0; + void setStructData(char*); + void checkDataSize(); + void baseCopy(); + void update(); + + virtual void listenPropertyEvent(const JORPropertyEvent* event); + +public: + /* 0x04 */ int m_anm_num; + /* 0x08 */ int m_u8_num; + /* 0x0C */ int m_s16_num; + /* 0x10 */ int m_f32_num; + /* 0x14 */ int f14; + /* 0x18 */ int f18; + /* 0x1C */ int f1c; + /* 0x20 */ u32 m_len; + /* 0x24 */ void* mp_src_data; + /* 0x28 */ void* mp_data; + /* 0x2C */ const char* m_name_string; + /* 0x30 */ daAlinkHIO_data_c* mpNext; }; -class daAlinkHIO_cut_c { -public: - /* 80140BD4 */ ~daAlinkHIO_cut_c(); +struct daAlinkHIO_basic_c1 { + /* 0x00 */ bool mOneHitKill; + /* 0x02 */ s16 mHeadMaxTurnHorizontal; + /* 0x04 */ s16 mHeadMaxTurnUp; + /* 0x06 */ s16 mHeadMaxTurnDown; + /* 0x08 */ s16 field_0x08; + /* 0x0A */ s16 mHotspringRecoverTime; + /* 0x0C */ s16 mWiiCamSpeedV; + /* 0x0E */ s16 mWiiCamSpeedH; + /* 0x10 */ s16 mTransformBlockFarAngle; + /* 0x14 */ f32 field_0x14; + /* 0x18 */ f32 mBasicInterpolation; + /* 0x1C */ f32 mRotationASpeed; + /* 0x20 */ f32 mStandingGuardInterpolation; + /* 0x24 */ f32 mWaterSurfaceEffectHeight; + /* 0x28 */ f32 mWolfWaterSurfaceEffectHeight; + /* 0x2C */ f32 mMaxWindInfluenceDist; + /* 0x30 */ f32 mNoWindInfluenceDist; + /* 0x34 */ f32 mMaxWindSpeed; + /* 0x38 */ f32 mLavaDeathDepth; + /* 0x3C */ f32 mLinkToWolfCancelFrame; + /* 0x40 */ f32 mWolfToLinkCancelFrame; + /* 0x44 */ f32 mIndoorSpeedFactor; + /* 0x48 */ f32 mSandSinkSpeed; + /* 0x4C */ f32 mSandSurfaceSpeed; + /* 0x50 */ f32 mTransformBlockNearDis; + /* 0x54 */ f32 mTransformBlockFarDis; +}; - /* 0x0 */ u8 unk_0x0; +class daAlinkHIO_basic_c0 { +public: + static daAlinkHIO_basic_c1 const m; +}; + +class daAlinkHIO_basic_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_basic_c(); + ~daAlinkHIO_basic_c() {}; + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_basic_c1 m; +}; + +struct daAlinkHIO_anm_c { + /* 0x00 */ s16 mEndFrame; + /* 0x04 */ f32 mSpeed; + /* 0x08 */ f32 mStartFrame; + /* 0x0C */ f32 mInterpolation; + /* 0x10 */ f32 mCancelFrame; +}; // size: 0x14 + +class daAlinkHIO_move_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mSlideAnm; + /* 0x14 */ s16 mMaxTurnAngle; + /* 0x16 */ s16 mMinTurnAngle; + /* 0x18 */ s16 mTurnAngleRate; + /* 0x1C */ f32 mWaitAnmSpeed; + /* 0x20 */ f32 mWalkAnmSpeed; + /* 0x24 */ f32 mRunAnmSpeed; + /* 0x28 */ f32 mWalkChangeRate; + /* 0x2C */ f32 mRunChangeRate; + /* 0x30 */ f32 mMaxSpeed; + /* 0x34 */ f32 mAcceleration; + /* 0x38 */ f32 mDeceleration; + /* 0x3C */ f32 mSlideThresholdSpeed; // speed needed to trigger a slide + /* 0x40 */ f32 mSlideSpeed; + /* 0x44 */ f32 mSlideDeceleration; + /* 0x48 */ f32 mFootPositionRatio; + /* 0x4C */ f32 mWaitBInterpolation; + /* 0x50 */ f32 mMinWalkRate; + /* 0x54 */ f32 mMinTiredWalkRate; +}; // Size: 0x58 + +class daAlinkHIO_move_c0 { +public: + static daAlinkHIO_move_c1 const m; +}; + +class daAlinkHIO_move_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_move_c(); + ~daAlinkHIO_move_c() {}; + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_move_c1 m; +}; + +class daAlinkHIO_noActAtnMove_c1 { +public: + /* 0x00 */ s16 mMaxTurnAngle; + /* 0x02 */ s16 mMinTurnAngle; + /* 0x04 */ s16 mTurnAngleRate; + /* 0x08 */ f32 mWaitAnmSpeed; + /* 0x0C */ f32 mWalkAnmSpeed; + /* 0x10 */ f32 mRunAnmSpeed; + /* 0x14 */ f32 mWalkChangeRate; + /* 0x18 */ f32 mRunChangeRate; + /* 0x1C */ f32 mMaxSpeed; + /* 0x20 */ f32 mAcceleration; + /* 0x24 */ f32 mDeceleration; + /* 0x28 */ f32 mBackWalkAnmSpeed; + /* 0x2C */ f32 mBackRunAnmSpeed; + /* 0x30 */ f32 mBackWalkChangeRate; + /* 0x34 */ f32 mBackRunChangeRate; + /* 0x38 */ f32 mMaxBackwardsSpeed; + /* 0x3C */ f32 mBackAcceleration; + /* 0x40 */ f32 mBackDeceleration; + /* 0x44 */ f32 mMinWalkFrame; + /* 0x48 */ f32 mMinBackWalkFrame; + /* 0x4C */ f32 mWalkForwardAnmSpeed; + /* 0x50 */ f32 mRunForwardAnmSpeed; +}; // Size: 0x54 + +class daAlinkHIO_noActAtnMove_c0 { +public: + static daAlinkHIO_noActAtnMove_c1 const m; +}; + +class daAlinkHIO_noActAtnMove_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_noActAtnMove_c(); + ~daAlinkHIO_noActAtnMove_c() {}; + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_noActAtnMove_c1 m; +}; + +class daAlinkHIO_frontRoll_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mRollAnm; + /* 0x14 */ daAlinkHIO_anm_c mCrashAnm; + /* 0x28 */ daAlinkHIO_anm_c mCrashHitAnm; // ? + /* 0x3C */ s16 mCrashAngleThreshold; + /* 0x3E */ s16 mTurnRate; + /* 0x40 */ s16 mMaxTurnAngle; + /* 0x42 */ s16 mTurnMinAngle; + /* 0x44 */ f32 mInitSpeed; + /* 0x48 */ f32 mSpeedRate; + /* 0x4C */ f32 mMinSpeed; + /* 0x50 */ f32 mCrashSpeedThreshold; + /* 0x54 */ f32 mCrashInitF; + /* 0x58 */ f32 mCrashEndF; + /* 0x5C */ f32 mCrashSpeedH; + /* 0x60 */ f32 mCrashSpeedV; + /* 0x64 */ f32 mBootsAttackInitF; + /* 0x68 */ f32 mBootsAttackEndF; + /* 0x6C */ f32 mBootsAttackRadius; +}; // Size: 0x70 + +class daAlinkHIO_frontRoll_c0 { +public: + static daAlinkHIO_frontRoll_c1 const m; +}; + +class daAlinkHIO_frontRoll_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_frontRoll_c(); + ~daAlinkHIO_frontRoll_c() {}; + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_frontRoll_c1 m; +}; + +class daAlinkHIO_backJump_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mBackflipAnm; + /* 0x14 */ daAlinkHIO_anm_c mLandAnm; + /* 0x28 */ f32 mBackflipSpeedH; + /* 0x2C */ f32 mBackflipSpeedV; + /* 0x30 */ f32 mFallHeight; + /* 0x34 */ f32 mFallInterpolation; +}; // Size: 0x38 + +class daAlinkHIO_backJump_c0 { +public: + static daAlinkHIO_backJump_c1 const m; +}; + +class daAlinkHIO_backJump_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_backJump_c(); + ~daAlinkHIO_backJump_c() {}; + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_backJump_c1 m; +}; + +class daAlinkHIO_sideStep_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mSideJumpAnm; + /* 0x14 */ daAlinkHIO_anm_c mSideLandAnm; + /* 0x28 */ daAlinkHIO_anm_c mBackJumpAnm; + /* 0x3C */ daAlinkHIO_anm_c mBackLandAnm; + /* 0x50 */ f32 mSideJumpSpeedH; + /* 0x54 */ f32 mSideJumpSpeedV; + /* 0x58 */ f32 mBackJumpSpeedH; + /* 0x5C */ f32 mBackJumpSpeedV; + /* 0x60 */ f32 mFallHeight; + /* 0x64 */ f32 mFallInterpolation; +}; // Size: 0x68 + +class daAlinkHIO_sideStep_c0 { +public: + static daAlinkHIO_sideStep_c1 const m; +}; + +class daAlinkHIO_sideStep_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_sideStep_c(); + ~daAlinkHIO_sideStep_c() {}; + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_sideStep_c1 m; +}; + +class daAlinkHIO_slide_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mForwardSlideAnm; + /* 0x14 */ daAlinkHIO_anm_c mBackwardSlideAnm; + /* 0x28 */ daAlinkHIO_anm_c mForwardLandAnm; + /* 0x3C */ daAlinkHIO_anm_c mBackwardLandAnm; + /* 0x50 */ f32 mMaxSpeed; + /* 0x54 */ f32 mAcceleration; + /* 0x58 */ f32 mSlideAngle; + /* 0x5C */ f32 mClimbAngle; + /* 0x60 */ f32 mClimbAnmMinSpeed; + /* 0x64 */ f32 mMaxClimbSpeed; + /* 0x68 */ f32 mLV2MinibossFloorSlideAngle; + /* 0x6C */ f32 mLV2MinibossFloorWeakSlideAngle; + /* 0x70 */ f32 mLV2MinibossFloorWeakSlideSpeed; + /* 0x74 */ f32 mMaxClimbAnmSpeed; +}; // Size: 0x78 + +class daAlinkHIO_slide_c0 { +public: + static daAlinkHIO_slide_c1 const m; +}; + +class daAlinkHIO_slide_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_slide_c(); + ~daAlinkHIO_slide_c() {}; + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_slide_c1 m; +}; + +class daAlinkHIO_atnMove_c1 { +public: + /* 0x00 */ s16 mMaxTurnAngle; + /* 0x02 */ s16 mMinTurnAngle; + /* 0x04 */ s16 mTurnAngleRate; + /* 0x08 */ f32 mWaitAnmSpeed; + /* 0x0C */ f32 mWalkAnmSpeed; + /* 0x10 */ f32 mRunAnmSpeed; + /* 0x14 */ f32 mWalkChangeRate; + /* 0x18 */ f32 mRunChangeRate; + /* 0x1C */ f32 mMaxSpeed; + /* 0x20 */ f32 mAcceleration; + /* 0x24 */ f32 mDeceleration; + /* 0x28 */ f32 mBackWalkAnmSpeed; + /* 0x2C */ f32 mBackRunAnmSpeed; + /* 0x30 */ f32 mBackWalkChangeRate; + /* 0x34 */ f32 mBackRunChangeRate; + /* 0x38 */ f32 mMaxBackwardsSpeed; + /* 0x3C */ f32 mBackAcceleration; + /* 0x40 */ f32 mBackDeceleration; + /* 0x44 */ f32 mMinWalkFrame; + /* 0x48 */ f32 mMinBackWalkFrame; + /* 0x4C */ f32 mWalkForwardAnmSpeed; + /* 0x50 */ f32 mRunForwardAnmSpeed; +}; // Size: 0x54 + +class daAlinkHIO_atnMove_c0 { +public: + static daAlinkHIO_atnMove_c1 const m; +}; + +class daAlinkHIO_atnMove_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_atnMove_c(); + ~daAlinkHIO_atnMove_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_atnMove_c1 m; +}; + +class daAlinkHIO_cutNormal_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mCutAnm; + /* 0x14 */ f32 mSpeed; + /* 0x18 */ f32 mAttackStartFrame; + /* 0x1C */ f32 mAttackEndFrame; +}; // Size: 0x20 + +class daAlinkHIO_cutNmV_c0 { +public: + static daAlinkHIO_cutNormal_c1 const m; +}; + +class daAlinkHIO_cutNmL_c0 { +public: + static daAlinkHIO_cutNormal_c1 const m; +}; + +class daAlinkHIO_cutNmR_c0 { +public: + static daAlinkHIO_cutNormal_c1 const m; +}; + +class daAlinkHIO_cutNmSL_c0 { +public: + static daAlinkHIO_cutNormal_c1 const m; +}; + +class daAlinkHIO_cutNmSR_c0 { +public: + static daAlinkHIO_cutNormal_c1 const m; +}; + +class daAlinkHIO_cutNormal_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_cutNormal_c(int, float); + ~daAlinkHIO_cutNormal_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ f32 field_0x34; + /* 0x38 */ daAlinkHIO_cutNormal_c1 m; +}; // Size: 0x58 + +class daAlinkHIO_cutFinish_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mCutAnm; + /* 0x14 */ s16 mStopTime; + /* 0x16 */ s16 mComboStopTime; + /* 0x18 */ f32 mSpeed; + /* 0x1C */ f32 mAttackStartFrame; + /* 0x20 */ f32 mAttackEndFrame; + /* 0x24 */ f32 mComboCheckFrame; + /* 0x28 */ f32 mComboStartFrame; +}; // Size: 0x2C + +class daAlinkHIO_cutFnL_c0 { +public: + static daAlinkHIO_cutFinish_c1 const m; +}; + +class daAlinkHIO_cutFnV_c0 { +public: + static daAlinkHIO_cutFinish_c1 const m; +}; + +class daAlinkHIO_cutFnS_c0 { +public: + static daAlinkHIO_cutFinish_c1 const m; +}; + +class daAlinkHIO_cutFnSl_c0 { +public: + static daAlinkHIO_cutFinish_c1 const m; +}; + +class daAlinkHIO_cutFnSm_c0 { +public: + static daAlinkHIO_cutFinish_c1 const m; +}; + +class daAlinkHIO_cutFnR_c0 { +public: + static daAlinkHIO_cutFinish_c1 const m; +}; + +class daAlinkHIO_cutFinish_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_cutFinish_c(int, float); + ~daAlinkHIO_cutFinish_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ f32 field_0x34; + /* 0x38 */ daAlinkHIO_cutFinish_c1 m; +}; + +class daAlinkHIO_cutFnJU_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mCutAnm; + /* 0x14 */ daAlinkHIO_anm_c mLandAnm; + /* 0x28 */ s16 mStopTime; + /* 0x2A */ s16 mComboStopTime; + /* 0x2C */ f32 mSpeedH; + /* 0x30 */ f32 mSpeedV; + /* 0x34 */ f32 mAttackStartFrame; + /* 0x38 */ f32 mAttackEndFrame; + /* 0x3C */ f32 mComboCheckFrame; + /* 0x40 */ f32 mComboStartFrame; + /* 0x44 */ f32 mFallHeight; + /* 0x48 */ f32 mFallInterpolation; + /* 0x4C */ f32 mAttackRadius; + /* 0x50 */ f32 mAttackOffset; +}; // Size: 0x54 + +class daAlinkHIO_cutFnJU_c0 { +public: + static daAlinkHIO_cutFnJU_c1 const m; +}; + +class daAlinkHIO_cutFnJU_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_cutFnJU_c(); + ~daAlinkHIO_cutFnJU_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_cutFnJU_c1 m; +}; // Size: 0x88 + +class daAlinkHIO_cutDash_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mCutAnm; + /* 0x14 */ f32 mAttackStartFrame; + /* 0x18 */ f32 mAttackEndFrame; +}; // Size: 0x1C + +class daAlinkHIO_cutDaL_c0 { +public: + static daAlinkHIO_cutDash_c1 const m; +}; + +class daAlinkHIO_cutDaR_c0 { +public: + static daAlinkHIO_cutDash_c1 const m; +}; + +class daAlinkHIO_cutDaCharge_c0 { +public: + static daAlinkHIO_cutDash_c1 const m; +}; + +class daAlinkHIO_cutDash_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_cutDash_c(int, float); + ~daAlinkHIO_cutDash_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ f32 field_0x34; + /* 0x38 */ daAlinkHIO_cutDash_c1 m; +}; + +class daAlinkHIO_cutJump_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mCutAnm; + /* 0x14 */ daAlinkHIO_anm_c mLandAnm; + /* 0x28 */ f32 mBaseJumpSpeedH; + /* 0x2C */ f32 mBaseJumpSpeedV; + /* 0x30 */ f32 mAirJumpSpeedH; + /* 0x34 */ f32 mAirJumpSpeedV; + /* 0x38 */ f32 mStartAttackFrame; + /* 0x3C */ f32 mEndAttackFrame; + /* 0x40 */ f32 mJumpSpinDelay; +}; // Size: 0x44 + +class daAlinkHIO_cutJump_c0 { +public: + static daAlinkHIO_cutJump_c1 const m; +}; + +class daAlinkHIO_cutJump_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_cutJump_c(); + ~daAlinkHIO_cutJump_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_cutJump_c1 m; +}; // Size: 0x78 + +class daAlinkHIO_cutTurn_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mRightTurnAnm; + /* 0x14 */ daAlinkHIO_anm_c mChargeAnm; + /* 0x28 */ daAlinkHIO_anm_c mLeftTurnAnm; + /* 0x3C */ s16 mStopTime; + /* 0x3E */ s16 field_0x3E; + /* 0x40 */ f32 mRightTurnInputStartFrame; + /* 0x44 */ f32 mRightAttackStartFrame; + /* 0x48 */ f32 mRightAttackEndFrame; + /* 0x4C */ f32 mMoveFBAnmSpeed; + /* 0x50 */ f32 mMoveFBInterpolation; + /* 0x54 */ f32 mMoveLRAnmSpeed; + /* 0x58 */ f32 mMoveLRInterpolation; + /* 0x5C */ f32 mMaxSpeed; + /* 0x60 */ f32 mChargeMoveAccel; + /* 0x64 */ f32 mChargeMoveDecel; + /* 0x68 */ f32 mSpeed; + /* 0x6C */ f32 mRightComboStartFrame; + /* 0x70 */ f32 mAttackRadius; + /* 0x74 */ f32 mLeftTurnInputStartFrame; + /* 0x78 */ f32 mLeftAttackStartFrame; + /* 0x7C */ f32 mLeftAttackEndFrame; + /* 0x80 */ f32 mLeftComboStartFrame; + /* 0x84 */ f32 mAttackRadiusAccel; + /* 0x88 */ f32 mLightAttackRadius; + /* 0x8C */ f32 mLightAttackRadiusAccel; + /* 0x90 */ f32 mLargeAttackRadius; + /* 0x94 */ f32 mLargeAttackAccel; +}; // Size: 0x98 + +class daAlinkHIO_cutTurn_c0 { +public: + static daAlinkHIO_cutTurn_c1 const m; +}; + +class daAlinkHIO_cutTurn_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_cutTurn_c(); + ~daAlinkHIO_cutTurn_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_cutTurn_c1 m; +}; // Size: 0xCC + +class daAlinkHIO_hoCut_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mCutAnm; + /* 0x14 */ f32 mAttackStartFrame; + /* 0x18 */ f32 mAttackEndFrame; + /* 0x1C */ f32 mAfterCutMorf; +}; // Size: 0x20 + +class daAlinkHIO_hoCutLA_c0 { +public: + static daAlinkHIO_hoCut_c1 const m; +}; + +class daAlinkHIO_hoCutLB_c0 { +public: + static daAlinkHIO_hoCut_c1 const m; +}; + +class daAlinkHIO_hoCutRA_c0 { +public: + static daAlinkHIO_hoCut_c1 const m; +}; + +class daAlinkHIO_hoCutRB_c0 { +public: + static daAlinkHIO_hoCut_c1 const m; +}; + +class daAlinkHIO_hoCut_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_hoCut_c(int, float); + ~daAlinkHIO_hoCut_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ f32 field_0x34; + /* 0x38 */ daAlinkHIO_hoCut_c1 m; +}; // Size: 0x58 + +class daAlinkHIO_hoCutCharge_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mChargeAnm; + /* 0x14 */ daAlinkHIO_anm_c mCutAnm; + /* 0x28 */ daAlinkHIO_anm_c mSpinAnm; + /* 0x3C */ s16 mCutStopTime; + /* 0x3E */ s16 mSpinStopTime; + /* 0x40 */ f32 mCutAttackStartFrame; + /* 0x44 */ f32 mCutAttackEndFrame; + /* 0x48 */ f32 mSpinAttackStartFrame; + /* 0x4C */ f32 mSpinAttackEndFrame; + /* 0x50 */ f32 mSpinAttackRadius; +}; // Size: 0x54 + +class daAlinkHIO_hoCutCharge_c0 { +public: + static daAlinkHIO_hoCutCharge_c1 const m; +}; + +class daAlinkHIO_hoCutCharge_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_hoCutCharge_c(); + ~daAlinkHIO_hoCutCharge_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_hoCutCharge_c1 m; +}; // Size: 0x88 + +class daAlinkHIO_cutDown_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mJumpAnm; + /* 0x14 */ daAlinkHIO_anm_c mFallAnm; + /* 0x28 */ daAlinkHIO_anm_c mLandAnm; + /* 0x3C */ daAlinkHIO_anm_c mMissAnm; + /* 0x50 */ daAlinkHIO_anm_c mRecoverAnm; + /* 0x64 */ s16 mSuccessStopTime; + /* 0x66 */ s16 mFailStopTime; + /* 0x68 */ f32 mRecoverSpeedH; + /* 0x6C */ f32 mRecoverSpeedV; + /* 0x70 */ f32 mSpeedV; +}; // Size: 0x74 + +class daAlinkHIO_cutDown_c0 { +public: + static daAlinkHIO_cutDown_c1 const m; +}; + +class daAlinkHIO_cutDown_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_cutDown_c(); + ~daAlinkHIO_cutDown_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_cutDown_c1 m; +}; // Size: 0xA8 + +class daAlinkHIO_cutHead_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mJumpAnm; + /* 0x14 */ daAlinkHIO_anm_c mCutAnm; + /* 0x28 */ daAlinkHIO_anm_c mLandAnm; + /* 0x3C */ f32 mGravity; + /* 0x40 */ f32 mMaxHeight; + /* 0x44 */ f32 mMaxDistance; + /* 0x48 */ f32 mAddSpeedV; + /* 0x4C */ f32 mAddSpeedH; + /* 0x50 */ f32 mAttackStartFrame; + /* 0x54 */ f32 mAttackEndFrame; + /* 0x58 */ f32 mSwordRadius; + /* 0x5C */ f32 mSwordLength; +}; // Size: 0x60 + +class daAlinkHIO_cutHead_c0 { +public: + static daAlinkHIO_cutHead_c1 const m; +}; + +class daAlinkHIO_cutHead_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_cutHead_c(); + ~daAlinkHIO_cutHead_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_cutHead_c1 m; +}; // Size: 0x94 + +class daAlinkHIO_cutLargeJump_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mChargeAnm; + /* 0x14 */ daAlinkHIO_anm_c mChargeMoveAnm; + /* 0x28 */ daAlinkHIO_anm_c mCutAnm; + /* 0x3C */ daAlinkHIO_anm_c mLandAnm; + /* 0x50 */ f32 mCutSpeedH; + /* 0x54 */ f32 mCutSpeedV; + /* 0x58 */ f32 mJumpAttackStartFrame; + /* 0x5C */ f32 mJumpAttackEndFrame; + /* 0x60 */ f32 mCutInitFrame; + /* 0x64 */ f32 mLandAttackInitFrame; + /* 0x68 */ f32 mLandAttackEndFrame; + /* 0x6C */ f32 mLandAttackRadius; + /* 0x70 */ f32 mSpinSlashCheckFrame; +}; // Size: 0x74 + +class daAlinkHIO_cutLargeJump_c0 { +public: + static daAlinkHIO_cutLargeJump_c1 const m; +}; + +class daAlinkHIO_cutLargeJump_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_cutLargeJump_c(); + ~daAlinkHIO_cutLargeJump_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_cutLargeJump_c1 m; +}; // Size: 0xA8 + +class daAlinkHIO_cut_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mEquipAnm; + /* 0x14 */ daAlinkHIO_anm_c mUnequipAnm; + /* 0x28 */ daAlinkHIO_anm_c mRecoilAnm; + /* 0x3C */ daAlinkHIO_anm_c mStabAnm; + /* 0x50 */ bool mForceHitCombo; + /* 0x52 */ s16 mComboDuration; + /* 0x54 */ s16 mBlurAlpha; + /* 0x56 */ s16 mNormalSwingDuration; + /* 0x58 */ s16 mDashBlurAlpha; + /* 0x5A */ s16 mUnkTime; // might be related to flourish + /* 0x5C */ s16 mFlourishTime; + /* 0x5E */ s16 mUnkBodyDownwards; // ? + /* 0x60 */ s16 mUnkBodyUpwards; // ? + /* 0x62 */ s16 mSpinSlashWait; // ? maybe related to wii? + /* 0x64 */ f32 mRecoilSpeed; + /* 0x68 */ f32 mRecoilDeceleration; + /* 0x6C */ f32 mFlourishAnmSpeed; + /* 0x70 */ f32 mFlourishEndAnmSpeed; + /* 0x74 */ f32 mSwordLength; + /* 0x78 */ f32 mSwordRadius; + /* 0x7C */ f32 mSwordLengthHorseback; + /* 0x80 */ f32 mSwordRadiusHorseback; + /* 0x84 */ f32 mRunCutLength; + /* 0x88 */ f32 mRunCutRadius; + /* 0x8C */ f32 mFastUnequipAnmSpeed; + /* 0x90 */ f32 mSwordLengthHorsebackFight; + /* 0x94 */ f32 mSwordRadiusHorsebackFight; + /* 0x98 */ f32 mFlourishControlStartFrame; +}; // Size: 0x9C + +class daAlinkHIO_cut_c0 { +public: + static daAlinkHIO_cut_c1 const m; +}; + +class daAlinkHIO_cut_c +#ifdef DEBUG + : public daAlinkHIO_data_c +#endif +{ +public: +#ifdef DEBUG + daAlinkHIO_cut_c(); +#endif + ~daAlinkHIO_cut_c(); + +#ifdef DEBUG + virtual void genMessage(JORMContext*); + +private: + /* 0x034 */ daAlinkHIO_cutNormal_c mCutVertical; + /* 0x08C */ daAlinkHIO_cutNormal_c mCutLeft; + /* 0x0E4 */ daAlinkHIO_cutNormal_c mCutRight; + /* 0x13C */ daAlinkHIO_cutNormal_c mCutLeftStab; + /* 0x194 */ daAlinkHIO_cutNormal_c mCutRightStab; + /* 0x1EC */ daAlinkHIO_cutFinish_c mCutFinishLeft; + /* 0x250 */ daAlinkHIO_cutFinish_c mCutFinishVertical; + /* 0x2B4 */ daAlinkHIO_cutFinish_c mCutFinishStab; + /* 0x318 */ daAlinkHIO_cutFinish_c mCutFinishSweep; + /* 0x37C */ daAlinkHIO_cutFinish_c mCutFinishSlash; + /* 0x3E0 */ daAlinkHIO_cutFinish_c mCutFinishRight; + /* 0x444 */ daAlinkHIO_cutFnJU_c mCutFinishJumpUppercut; + /* 0x4CC */ daAlinkHIO_cutJump_c mCutJump; + /* 0x544 */ daAlinkHIO_cutTurn_c mCutTurn; + /* 0x610 */ daAlinkHIO_hoCut_c mHorseCutLeftA; + /* 0x668 */ daAlinkHIO_hoCut_c mHorseCutLeftB; + /* 0x6C0 */ daAlinkHIO_hoCut_c mHorseCutRightA; + /* 0x718 */ daAlinkHIO_hoCut_c mHorseCutRightB; + /* 0x770 */ daAlinkHIO_hoCutCharge_c mHorseCutCharge; + /* 0x7F8 */ daAlinkHIO_cutDash_c mCutDashLeft; + /* 0x84C */ daAlinkHIO_cutDash_c mCutDashRight; + /* 0x8A0 */ daAlinkHIO_cutDash_c mCutDashCharge; + /* 0x8F4 */ daAlinkHIO_cutDown_c mCutDown; + /* 0x99C */ daAlinkHIO_cutHead_c mCutHead; + /* 0xA30 */ daAlinkHIO_cutLargeJump_c mCutLargeJump; + /* 0xAD8 */ daAlinkHIO_cut_c1 m; +#endif +}; // Size: 0xB74 + +class daAlinkHIO_guardAttack_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mAttackAnm; + /* 0x14 */ f32 mSpeed; + /* 0x18 */ f32 mAttackStartFrame; + /* 0x1C */ f32 mAttackEndFrame; + /* 0x20 */ f32 mSlashCheckFrame; +}; // Size: 0x24 + +class daAlinkHIO_gAtPush_c0 { +public: + static daAlinkHIO_guardAttack_c1 const m; +}; + +class daAlinkHIO_gAtKick_c0 { +public: + static daAlinkHIO_guardAttack_c1 const m; +}; + +class daAlinkHIO_guardAttack_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_guardAttack_c(int, float); + ~daAlinkHIO_guardAttack_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ f32 field_0x34; + /* 0x38 */ daAlinkHIO_guardAttack_c1 m; +}; + +class daAlinkHIO_turnMove_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mTurnAnm; + /* 0x14 */ s16 mTurnSpeedRate; + /* 0x16 */ s16 mMaxTurnSpeed; + /* 0x18 */ s16 mMinTurnSpeed; + /* 0x1A */ s16 mMaxHalfTurnSpeed; + /* 0x1C */ f32 mHalfTurnAnmSpeed; + /* 0x20 */ f32 mTwirlCutDelayF; + /* 0x24 */ f32 mSideRollAnmSpeed; + /* 0x28 */ f32 mSideRollSpeed; +}; // Size: 0x2C + +class daAlinkHIO_turnMove_c0 { +public: + static daAlinkHIO_turnMove_c1 const m; +}; + +class daAlinkHIO_turnMove_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_turnMove_c(); + ~daAlinkHIO_turnMove_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_turnMove_c1 m; +}; + +class daAlinkHIO_guard_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mGuardHitAnm; + /* 0x14 */ daAlinkHIO_anm_c mCrouchGuardHitAnm; // Unused + /* 0x28 */ daAlinkHIO_anm_c mRecoilAnm; + /* 0x3C */ daAlinkHIO_anm_c mGuardBreakAnm; + /* 0x50 */ s16 mGuardLRAngleMax; + /* 0x52 */ s16 mGuardFBAngleMax; + /* 0x54 */ s16 mGuardBodyInterpolation; + /* 0x56 */ s16 mSmallGuardLRAngleMax; + /* 0x58 */ s16 mSmallGuardFBAngleMax; + /* 0x5C */ f32 mCrouchGuardAnmSpeed; // Unused + /* 0x60 */ f32 mCrouchGuardInterpolation; // Unused + /* 0x64 */ f32 mGuardSpeedNormal; + /* 0x68 */ f32 mGuardSpeedLarge; + /* 0x6C */ f32 mGuardSpeedHuge; + /* 0x70 */ f32 mAttackPosOffset; + /* 0x74 */ f32 mAttackRadius; + /* 0x78 */ f32 mMagneGuardSpeed; + /* 0x7C */ f32 mMagneHvyGuardSpeed; +}; // Size: 0x80 + +class daAlinkHIO_guard_c0 { +public: + static daAlinkHIO_guard_c1 const m; +}; + +class daAlinkHIO_guard_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_guard_c(); + ~daAlinkHIO_guard_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x034 */ daAlinkHIO_guardAttack_c mGuardAttack1; + /* 0x090 */ daAlinkHIO_guardAttack_c mGuardAttack2; + /* 0x0EC */ daAlinkHIO_turnMove_c mTurnMove; + /* 0x14C */ daAlinkHIO_guard_c1 m; +}; + +class daAlinkHIO_crouch_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mCrawlStartAnm; + /* 0x14 */ daAlinkHIO_anm_c mCrawlEndAnm; + /* 0x28 */ s16 mCrawlTurnRate; + /* 0x2A */ s16 mCrawlTurnMax; + /* 0x2C */ s16 mCrawlTurnMin; + /* 0x30 */ f32 mCrouchAnmSpeed; + /* 0x34 */ f32 mCrouchInterpolation; + /* 0x38 */ f32 mStandInterpolation; + /* 0x3C */ f32 mCrawlMoveRate; + /* 0x40 */ f32 mCrawlAnmSpeedMax; + /* 0x44 */ f32 mCrawlAnmSpeedMin; + /* 0x48 */ f32 mCrawlInterpolation; +}; // Size: 0x4C + +class daAlinkHIO_crouch_c0 { +public: + static daAlinkHIO_crouch_c1 const m; +}; + +class daAlinkHIO_crouch_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_crouch_c(); + ~daAlinkHIO_crouch_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_crouch_c1 m; +}; + +class daAlinkHIO_autoJump_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mJumpAnm; + /* 0x14 */ daAlinkHIO_anm_c mLandAnm; + /* 0x28 */ daAlinkHIO_anm_c mDiveAnm; + /* 0x3C */ daAlinkHIO_anm_c mDiveConnectAnm; + /* 0x50 */ bool mAlwaysMaxSpeedJump; + /* 0x52 */ s16 mJumpAngle; + /* 0x54 */ s16 mSpinJumpRotateSpeed; + /* 0x56 */ s16 mSpinJumpLandStopTime; + /* 0x58 */ s16 mCuccoJumpAngle; + /* 0x5C */ f32 mJumpSpeedLimit; + /* 0x60 */ f32 mMinJumpSpeed; + /* 0x64 */ f32 mJumpSpeedRate; + /* 0x68 */ f32 mAirborneInterpolation; + /* 0x6C */ f32 mJumpFallInterpolation; + /* 0x70 */ f32 mFallInterpolation; + /* 0x74 */ f32 mGravity; + /* 0x78 */ f32 mMaxFallSpeed; + /* 0x7C */ f32 mMaxJumpSpeed; + /* 0x80 */ f32 mSpinJumpInterpolation; + /* 0x84 */ f32 mSpinJumpFallInterpolation; + /* 0x88 */ f32 mSpinJumpAddSpeed; + /* 0x8C */ f32 mSpinJumpAccel; + /* 0x90 */ f32 mHangHeightLimit; + /* 0x94 */ f32 mGrabHeightLimit; + /* 0x98 */ f32 mOoccooJumpMaxSpeed; + /* 0x9C */ f32 mDiveSpeedV; + /* 0xA0 */ f32 mDiveSpeedH; + /* 0xA4 */ f32 mDiveGravity; + /* 0xA8 */ f32 mCuccoJumpMaxSpeed; + /* 0xAC */ f32 mCuccoFallMaxSpeed; + /* 0xB0 */ f32 mCuccoStartSpeed; +}; // size = 0xB4 + +class daAlinkHIO_autoJump_c0 { +public: + static daAlinkHIO_autoJump_c1 const m; +}; + +class daAlinkHIO_autoJump_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_autoJump_c(); + ~daAlinkHIO_autoJump_c(); + + virtual void genMessage(JORMContext*); + +private: + daAlinkHIO_autoJump_c1 m; +}; + +class daAlinkHIO_smallJump_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mSmallJumpAnm; + /* 0x14 */ daAlinkHIO_anm_c mStepClimbAnm; + /* 0x28 */ daAlinkHIO_anm_c mStepLandAnm; + /* 0x3C */ f32 mSpeedH; + /* 0x40 */ f32 mTargetHeightOffset; + /* 0x44 */ f32 mFallInterpolation; +}; // Size: 0x48 + +class daAlinkHIO_smallJump_c0 { +public: + static daAlinkHIO_smallJump_c1 const m; +}; + +class daAlinkHIO_smallJump_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_smallJump_c(); + ~daAlinkHIO_smallJump_c(); + + virtual void genMessage(JORMContext*); + +private: + daAlinkHIO_smallJump_c1 m; +}; + +class daAlinkHIO_wallCatch_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mGrabAAnm; + /* 0x14 */ daAlinkHIO_anm_c mGrabBAnm; + /* 0x28 */ daAlinkHIO_anm_c mClimbAnm; + /* 0x3C */ daAlinkHIO_anm_c mJumpAnm; + /* 0x50 */ f32 mClimbStartFrame; +}; // Size: 0x54 + +class daAlinkHIO_wallCatch_c0 { +public: + static daAlinkHIO_wallCatch_c1 const m; +}; + +class daAlinkHIO_wallCatch_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wallCatch_c(); + ~daAlinkHIO_wallCatch_c(); + + virtual void genMessage(JORMContext*); + +private: + daAlinkHIO_wallCatch_c1 m; +}; + +class daAlinkHIO_wallFall_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mOneHandGrabAnm; + /* 0x14 */ daAlinkHIO_anm_c mTwoHandGrabAnm; +}; // Size: 0x28 + +class daAlinkHIO_wallFall_c0 { +public: + static daAlinkHIO_wallFall_c1 const m; +}; + +class daAlinkHIO_wallFall_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wallFall_c(); + ~daAlinkHIO_wallFall_c(); + + virtual void genMessage(JORMContext*); + +private: + daAlinkHIO_wallFall_c1 m; +}; + +class daAlinkHIO_wallMove_c1 { +public: + /* 0x00 */ f32 mMinAnmSpeed; + /* 0x04 */ f32 mMaxAnmSpeed; + /* 0x08 */ f32 mInterpolation; + /* 0x0C */ f32 mMinSpeed; + /* 0x10 */ f32 mMaxSpeed; +}; // Size: 0x14 + +class daAlinkHIO_wallMove_c0 { +public: + static daAlinkHIO_wallMove_c1 const m; +}; + +class daAlinkHIO_wallMove_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wallMove_c(); + ~daAlinkHIO_wallMove_c(); + + virtual void genMessage(JORMContext*); + +private: + daAlinkHIO_wallMove_c1 m; +}; + +class daAlinkHIO_wallHang_c1 { +public: + /* 0x00 */ s16 small_jump_input_time; + /* 0x02 */ s16 grab_input_time; + /* 0x04 */ f32 auto_walk_height; + /* 0x08 */ f32 small_jump_height; + /* 0x0C */ f32 climb_height; + /* 0x10 */ f32 jump_climb_height; + /* 0x14 */ f32 jump_hang_height; + /* 0x18 */ f32 hang_foot_pos_height; +}; // Size: 0x1C + +class daAlinkHIO_wallHang_c0 { +public: + static daAlinkHIO_wallHang_c1 const m; +}; + +class daAlinkHIO_wallHang_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wallHang_c(); + ~daAlinkHIO_wallHang_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_smallJump_c mSmallJump; + /* 0x00 */ daAlinkHIO_wallCatch_c mWallCatch; + /* 0x00 */ daAlinkHIO_wallFall_c mWallFall; + /* 0x00 */ daAlinkHIO_wallMove_c mWallMove; + /* 0x00 */ daAlinkHIO_wallHang_c1 m; +}; + +class daAlinkHIO_pushpull_c1 { +public: + /* 0x00 */ u8 mEnableSumoWaitRotation; + /* 0x02 */ s16 mSumoMaxGauge; + /* 0x04 */ s16 mSumoIncreaseGauge; + /* 0x06 */ s16 mSumoPenaltyTime; + /* 0x08 */ s16 mSumoPower3To2Switch; + /* 0x0A */ s16 mSumoPower2To1Switch; + /* 0x0C */ s16 mSumoRotationAllowPower; + /* 0x0E */ s16 mSumoRotationAngle; + /* 0x10 */ f32 mStandbyASpeed; + /* 0x14 */ f32 mStandbyInterpolation; + /* 0x18 */ f32 mPushASpeed; + /* 0x1C */ f32 mPushInterpolation; + /* 0x20 */ f32 field_0x20; + /* 0x24 */ f32 mPullInterpolation; + /* 0x28 */ f32 mSumoPushASpeed; + /* 0x2C */ f32 mSumoPushAddASpeed; + /* 0x30 */ f32 mSumoPushedASpeed; + /* 0x34 */ f32 mSumoPushedAddASpeed; + /* 0x38 */ f32 mPushASpeedHeavy; +}; // Size: 0x3C + +class daAlinkHIO_pushpull_c0 { +public: + static daAlinkHIO_pushpull_c1 const m; +}; + +class daAlinkHIO_pushpull_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_pushpull_c(); + ~daAlinkHIO_pushpull_c(); + + virtual void genMessage(JORMContext*); + +private: + daAlinkHIO_pushpull_c1 m; +}; + +class daAlinkHIO_damNormal_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mFrontAnm; + /* 0x14 */ daAlinkHIO_anm_c mRearAnm; + /* 0x28 */ daAlinkHIO_anm_c mLeftAnm; + /* 0x3C */ daAlinkHIO_anm_c mRightAnm; + /* 0x50 */ s16 mFrontBackBodyMaxAngle; + /* 0x52 */ s16 mLeftRightBodyMaxAngle; + /* 0x54 */ f32 mInitialSpeed; + /* 0x58 */ f32 mAttackSpeedRate; + /* 0x5C */ f32 mDeceleration; + /* 0x60 */ f32 mIceDamageASpeed; +}; // Size: 0x64 + +class daAlinkHIO_damNormal_c0 { +public: + static daAlinkHIO_damNormal_c1 const m; +}; + +class daAlinkHIO_damNormal_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_damNormal_c(); + ~daAlinkHIO_damNormal_c(); + + virtual void genMessage(JORMContext*); + +private: + daAlinkHIO_damNormal_c1 m; +}; + +class daAlinkHIO_damLaHu_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mFrontGetUpAnm; + /* 0x14 */ daAlinkHIO_anm_c mBackGetUpAnm; + /* 0x28 */ daAlinkHIO_anm_c mLeftGetUpAnm; + /* 0x3C */ daAlinkHIO_anm_c mRightGetUpAnm; + /* 0x50 */ daAlinkHIO_anm_c mFrontWallHitAnm; + /* 0x64 */ daAlinkHIO_anm_c mBackWallHitAnm; + /* 0x78 */ daAlinkHIO_anm_c mLeftWallHitAnm; + /* 0x8C */ daAlinkHIO_anm_c mRightWallHitAnm; + /* 0xA0 */ s16 mBodyRotateRate; + /* 0xA4 */ f32 mGravity; + /* 0xA8 */ f32 mDamageBlend; + /* 0xAC */ f32 mHorizontalSpeed; + /* 0xB0 */ f32 mVerticalSpeed; + /* 0xB4 */ f32 mBounceSpeed; + /* 0xB8 */ f32 mDeceleration; +}; // Size: 0xBC + +class daAlinkHIO_damLarge_c0 { +public: + static daAlinkHIO_damLaHu_c1 const m; +}; + +class daAlinkHIO_damHuge_c0 { +public: + static daAlinkHIO_damLaHu_c1 const m; +}; + +class daAlinkHIO_damLaHu_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_damLaHu_c(int); + ~daAlinkHIO_damLaHu_c(); + + virtual void genMessage(JORMContext*); + +private: + daAlinkHIO_damLaHu_c1 m; +}; + +class daAlinkHIO_damHorse_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mNoDirectionAnm; + /* 0x14 */ daAlinkHIO_anm_c mWithDirectionAnm; + /* 0x28 */ s16 mFrontBackBodyMaxAngle; + /* 0x2A */ s16 mLeftRightBodyMaxAngle; +}; // Size: 0x2C + +class daAlinkHIO_damHorse_c0 { +public: + static daAlinkHIO_damHorse_c1 const m; +}; + +class daAlinkHIO_damHorse_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_damHorse_c(); + ~daAlinkHIO_damHorse_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_damHorse_c1 m; +}; + +class daAlinkHIO_damFall_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mLandAnm; + /* 0x14 */ daAlinkHIO_anm_c mStandAnm; + /* 0x28 */ s16 mSmallStopTime; + /* 0x2A */ s16 mBigStopTime; + /* 0x2C */ f32 mMinRollHeight; + /* 0x30 */ f32 mMaxRollHeight; + /* 0x34 */ f32 mSmallDmgHeight; + /* 0x38 */ f32 mBigDmgHeight; + /* 0x3C */ f32 mSmallDmgLandStartFrame; + /* 0x40 */ f32 mFallAnmTransitionHeight; + /* 0x44 */ f32 mFallAnmMorf; +}; // Size: 0x48 + +class daAlinkHIO_damFall_c0 { +public: + static daAlinkHIO_damFall_c1 const m; +}; + +class daAlinkHIO_damFall_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_damFall_c(); + ~daAlinkHIO_damFall_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_damFall_c1 m; +}; + +class daAlinkHIO_damCaught_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mEscapeAnm; + /* 0x14 */ s16 mGrabDuration; + /* 0x16 */ s16 mInputFadeTime; + /* 0x18 */ f32 mStandbySpeed; + /* 0x1C */ f32 mStandbyInterp; + /* 0x20 */ f32 mStandbyAddASpeed; +}; // Size: 0x24 + +class daAlinkHIO_damCaught_c0 { +public: + static daAlinkHIO_damCaught_c1 const m; +}; + +class daAlinkHIO_damCaught_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_damCaught_c(); + ~daAlinkHIO_damCaught_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_damCaught_c1 m; +}; + +class daAlinkHIO_damSwim_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mFrontAnm; + /* 0x14 */ daAlinkHIO_anm_c mRearAnm; + /* 0x28 */ daAlinkHIO_anm_c mLeftAnm; + /* 0x3C */ daAlinkHIO_anm_c mRightAnm; + /* 0x50 */ daAlinkHIO_anm_c mSinkAnm; + /* 0x64 */ daAlinkHIO_anm_c mSurfaceAnm; + /* 0x78 */ s16 mFrontBackBodyMaxAngle; + /* 0x7A */ s16 mLeftRightBodyMaxAngle; + /* 0x7C */ f32 mInitialSpeed; + /* 0x80 */ f32 mAttackSpeedRate; + /* 0x84 */ f32 mDeceleration; + /* 0x88 */ f32 mMaxSpeed; +}; // Size: 0x8C + +class daAlinkHIO_damSwim_c0 { +public: + static daAlinkHIO_damSwim_c1 const m; +}; + +class daAlinkHIO_damSwim_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_damSwim_c(); + ~daAlinkHIO_damSwim_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_damSwim_c1 m; +}; + +class daAlinkHIO_damage_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mFloorDmgAnm; + /* 0x14 */ daAlinkHIO_anm_c mDashDmgAnm; + /* 0x28 */ u8 mInvincible; + /* 0x2A */ s16 mInvincibleTime; + /* 0x2C */ s16 mWolfFloorInvincibleTime; + /* 0x2E */ s16 mFreezeTime; + /* 0x30 */ s16 mFreezeInitR; + /* 0x32 */ s16 mFreezeInitG; + /* 0x34 */ s16 mFreezeInitB; + /* 0x36 */ s16 mDamageR0; + /* 0x38 */ s16 mDamageG0; + /* 0x3A */ s16 mDamageB0; + /* 0x3C */ s16 mDamageR1; + /* 0x3E */ s16 mDamageG1; + /* 0x40 */ s16 mDamageB1; + /* 0x42 */ s16 mDamageR2; + /* 0x44 */ s16 mDamageG2; + /* 0x46 */ s16 mDamageB2; + /* 0x48 */ s16 mFreezeR; + /* 0x4A */ s16 mFreezeG; + /* 0x4C */ s16 mFreezeB; + /* 0x50 */ f32 mRecoverStandAnmSpeed; + /* 0x54 */ f32 mInvertedFallInterpolation; +}; // Size: 0x58 + +class daAlinkHIO_damage_c0 { +public: + static daAlinkHIO_damage_c1 const m; +}; + +class daAlinkHIO_damage_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_damage_c(); + ~daAlinkHIO_damage_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_damage_c1 m; + /* 0x34 */ daAlinkHIO_damNormal_c mDamNormal; + /* 0x00 */ daAlinkHIO_damLaHu_c mDamLaHu0; + /* 0x00 */ daAlinkHIO_damLaHu_c mDamLaHu1; + /* 0x00 */ daAlinkHIO_damHorse_c mDamHorse; + /* 0x00 */ daAlinkHIO_damFall_c mDamFall; + /* 0x00 */ daAlinkHIO_damCaught_c mDamCaught; + /* 0x00 */ daAlinkHIO_damSwim_c mDamSwim; +}; + +class daAlinkHIO_horse_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mWalkOutAnm; + /* 0x14 */ daAlinkHIO_anm_c mRunOutAnm; + /* 0x28 */ daAlinkHIO_anm_c mWhipAnm; + /* 0x3C */ daAlinkHIO_anm_c mWhipRunOutAnm; + /* 0x50 */ s16 mSwordUpTime; + /* 0x52 */ s16 mSearchRangeAngle; + /* 0x54 */ s16 mWalkOutProhibitionTime; + /* 0x56 */ s16 mWhipWaitTime; + /* 0x58 */ s16 mSubjectiveDownwardMaxAngle; + /* 0x5A */ s16 mSubjectiveUpwardMaxAngle; + /* 0x5C */ f32 mSwordUpAnmSpeed; + /* 0x60 */ f32 mSwordUpInterpolation; + /* 0x64 */ f32 mHorseWalkStartFrame; + /* 0x68 */ f32 mTiredWaitInterpolation; +}; // Size: 0x6C + +class daAlinkHIO_horse_c0 { +public: + static daAlinkHIO_horse_c1 const m; +}; + +class daAlinkHIO_horse_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_horse_c(); + ~daAlinkHIO_horse_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_horse_c1 m; +}; + +class daAlinkHIO_canoe_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mLeftRightChangeAnm; + /* 0x14 */ s16 mMaxTurnAngle; + /* 0x16 */ s16 mMaxTurnAngle_RiverRide; + /* 0x18 */ f32 mStickRowAnmSpeed; + /* 0x1C */ f32 mBtnRowAnmSpeed; + /* 0x20 */ f32 mSpeedRate; + /* 0x24 */ f32 mMaxSpeed; + /* 0x28 */ f32 mDeceleration; + /* 0x2C */ f32 mStickRowStartAnmSpeed; + /* 0x30 */ f32 mBtnRowStartAnmSpeed; + /* 0x34 */ f32 mBackSpeedRate; + /* 0x38 */ f32 mBackMaxSpeed; + /* 0x3C */ f32 mMaxSpeed_RiverRide; + /* 0x40 */ f32 mSpeedRate_RiverRide; + /* 0x44 */ f32 mDeceleration_RiverRide; +}; // Size: 0x48 + +class daAlinkHIO_canoe_c0 { +public: + static daAlinkHIO_canoe_c1 const m; +}; + +class daAlinkHIO_canoe_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_canoe_c(); + ~daAlinkHIO_canoe_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_canoe_c1 m; +}; + +class daAlinkHIO_bow_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mShootAnm; + /* 0x14 */ daAlinkHIO_anm_c mLoadAnm; + /* 0x28 */ s16 mChargeArrowTime; + /* 0x2A */ s16 mBombArrowHoldTime; + /* 0x2C */ s16 mBombArrowFlyExplodeTime; + /* 0x30 */ f32 mStartInterpolation; + /* 0x34 */ f32 mArrowSpeed; + /* 0x38 */ f32 mArrowDistance; + /* 0x3C */ f32 mChargeArrowSpeed; + /* 0x40 */ f32 mChargeArrowDistance; + /* 0x44 */ f32 mArrowAttackRadius; + /* 0x48 */ f32 mBombArrowSpeed; + /* 0x4C */ f32 mBombArrowDistance; + /* 0x50 */ f32 mChargeBombArrowSpeed; + /* 0x54 */ f32 mChargeBombArrowDistance; + /* 0x58 */ f32 mScopeArrowSpeed; + /* 0x5C */ f32 mScopeArrowDistance; + /* 0x60 */ f32 mArrowIncAttackMaxStart; + /* 0x64 */ f32 mArrowIncAttackMax; + /* 0x68 */ f32 mSlingshotSpeed; + /* 0x6C */ f32 mSlingshotDistance; +}; // Size: 0x70 + +class daAlinkHIO_bow_c0 { +public: + static daAlinkHIO_bow_c1 const m; +}; + +class daAlinkHIO_bow_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_bow_c(); + ~daAlinkHIO_bow_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_bow_c1 m; +}; + +class daAlinkHIO_boom_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mThrowAnm; + /* 0x14 */ daAlinkHIO_anm_c mCatchAnm; + /* 0x28 */ s16 mChargeTime; + /* 0x2A */ s16 mBgThroughTime; + /* 0x2C */ f32 mIdleAnmSpeed; + /* 0x30 */ f32 mStartInterpolation; + /* 0x34 */ f32 mFlySpeed; + /* 0x38 */ f32 mChargeFlySpeed; + /* 0x3C */ f32 mFlyDistMax; + /* 0x40 */ f32 mHorsebackFlyDistMax; + /* 0x44 */ f32 mLockDistMax; + /* 0x48 */ f32 mCatchSpeed; +}; // Size: 0x4C + +class daAlinkHIO_boom_c0 { +public: + static daAlinkHIO_boom_c1 const m; +}; + +class daAlinkHIO_boom_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_boom_c(); + ~daAlinkHIO_boom_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_boom_c1 m; +}; + +class daAlinkHIO_bomb_c1 { +public: + /* 0x00 */ s16 mExplodeTime; + /* 0x02 */ s16 mEnemyBombColorR; + /* 0x04 */ s16 mBombInsectLimitAngle; + /* 0x08 */ f32 mGravity; + /* 0x0C */ f32 mMaxFallSpeed; + /* 0x10 */ f32 mBoundRate; + /* 0x14 */ f32 mStopSpeedY; + /* 0x18 */ f32 mMaxSpeedY; + /* 0x1C */ f32 mEffScale; + /* 0x20 */ f32 mAttackRadius; + /* 0x24 */ f32 mPokeBombTrackRate; + /* 0x28 */ f32 mWaterGravity; + /* 0x2C */ f32 mWaterMaxFallSpeed; + /* 0x30 */ f32 mThrowSpeedH; + /* 0x34 */ f32 mThrowSpeedV; + /* 0x38 */ f32 mWaterThrowSpeedH; + /* 0x3C */ f32 mWaterThrowSpeedV; + /* 0x40 */ f32 mWolfThrowSpeedH; + /* 0x44 */ f32 mWolfThrowSpeedV; + /* 0x48 */ f32 mExplodeWaterEffectLimit; +}; // Size: 0x4C + +class daAlinkHIO_bomb_c0 { +public: + static daAlinkHIO_bomb_c1 const m; +}; + +class daAlinkHIO_bomb_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_bomb_c(); + ~daAlinkHIO_bomb_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_bomb_c1 m; +}; + +class daAlinkHIO_huLight_c1 { +public: + /* 0x00 */ u8 mAngleAttenuationType; + /* 0x01 */ u8 mDistanceAttenuationType; + /* 0x02 */ s16 mAlpha; + /* 0x04 */ s16 mColorR; + /* 0x06 */ s16 mColorG; + /* 0x08 */ s16 mColorB; + /* 0x0A */ s16 mXAngle; + /* 0x0C */ f32 mPower; + /* 0x10 */ f32 mWidth; + /* 0x14 */ f32 mYOffset; + /* 0x18 */ f32 mZOffset; +}; // Size: 0x1C + +class daAlinkHIO_huLight_c0 { +public: + static daAlinkHIO_huLight_c1 const m; +}; + +class daAlinkHIO_wlLight_c1 { +public: + /* 0x00 */ s16 field_0x0; + /* 0x02 */ s16 field_0x2; + /* 0x04 */ s16 field_0x4; + /* 0x06 */ s16 field_0x6; + /* 0x08 */ s16 field_0x8; + /* 0x0A */ s16 field_0xA; + /* 0x0C */ f32 field_0xC; + /* 0x10 */ f32 field_0x10; + /* 0x14 */ f32 field_0x14; + /* 0x18 */ f32 field_0x18; +}; // Size: 0x1C + +class daAlinkHIO_wlLight_c0 { +public: + static daAlinkHIO_wlLight_c1 const m; +}; + +class daAlinkHIO_zwLight_c1 { // may be wrong +public: + /* 0x00 */ s16 field_0x0; + /* 0x02 */ s16 field_0x2; + /* 0x04 */ s16 field_0x4; + /* 0x06 */ s16 field_0x6; + /* 0x08 */ s16 field_0x8; + /* 0x0A */ s16 field_0xA; + /* 0x0C */ f32 field_0xC; + /* 0x10 */ f32 field_0x10; + /* 0x14 */ f32 field_0x14; + /* 0x18 */ f32 field_0x18; +}; // Size: 0x1C + +class daAlinkHIO_zwLight_c0 { +public: + static daAlinkHIO_zwLight_c1 const m; +}; + +class daAlinkHIO_light_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_light_c(int); + ~daAlinkHIO_light_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_huLight_c1 m; +}; + +class daAlinkHIO_kandelaar_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mShakeAnm; + /* 0x14 */ daAlinkHIO_anm_c mBeginUnkAnm; + /* 0x28 */ daAlinkHIO_anm_c mEndUnkAnm; + /* 0x3C */ s16 mColorReg1R; + /* 0x3E */ s16 mColorReg1G; + /* 0x40 */ s16 mColorReg1B; + /* 0x42 */ s16 mColorReg2R; + /* 0x44 */ s16 mColorReg2G; + /* 0x46 */ s16 mColorReg2B; + /* 0x48 */ s16 mNormalOilLoss; + /* 0x4A */ s16 mShakeOilLoss; + /* 0x4C */ f32 mFlameTrackRate; +}; // Size: 0x50 + +class daAlinkHIO_kandelaar_c0 { +public: + static daAlinkHIO_kandelaar_c1 const m; +}; + +class daAlinkHIO_kandelaar_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_kandelaar_c(); + ~daAlinkHIO_kandelaar_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_kandelaar_c1 m; +}; + +class daAlinkHIO_magneBoots_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mEquipAnm; + /* 0x14 */ f32 mInputFactor; + /* 0x18 */ f32 mFeetPositionRatio; + /* 0x1C */ f32 mWalkAnmSpeedMax; + /* 0x20 */ f32 mWalkAnmSpeedMin; + /* 0x24 */ f32 mWaterInputFactor; + /* 0x28 */ f32 mWaterWalkAnmRate; + /* 0x2C */ f32 mWaterStartWalkAnmRate; + /* 0x30 */ f32 mMaxMagneFlySpeed; + /* 0x34 */ f32 mMagneFlyAccelRate; + /* 0x38 */ f32 mWaterVelocityY; + /* 0x3C */ f32 mWaterVelocityX; + /* 0x40 */ f32 mWaterVelRateSword; + /* 0x44 */ f32 mZoraWaterInputFactor; + /* 0x48 */ f32 mZoraWaterAnmSpeed; +}; // Size: 0x4C + +class daAlinkHIO_magneBoots_c0 { +public: + static daAlinkHIO_magneBoots_c1 const m; +}; + +class daAlinkHIO_magneBoots_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_magneBoots_c(); + ~daAlinkHIO_magneBoots_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_magneBoots_c1 m; +}; + +class daAlinkHIO_fmChain_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mGripAnm; + /* 0x14 */ daAlinkHIO_anm_c mUnfinishedAnm; +}; // Size: 0x28 + +class daAlinkHIO_fmChain_c0 { +public: + static daAlinkHIO_fmChain_c1 const m; +}; + +class daAlinkHIO_fmChain_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_fmChain_c(); + ~daAlinkHIO_fmChain_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_fmChain_c1 m; +}; + +class daAlinkHIO_hookshot_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mShootAnm; + /* 0x14 */ daAlinkHIO_anm_c mRoofHangAnm; + /* 0x28 */ daAlinkHIO_anm_c mWallHangAnm; + /* 0x3C */ u8 mForceStick; + /* 0x40 */ f32 mWaitAnmSpeed; + /* 0x44 */ f32 mStartInterpolation; + /* 0x48 */ f32 mMaxLength; + /* 0x4C */ f32 mShootSpeed; + /* 0x50 */ f32 mReturnSpeed; + /* 0x54 */ f32 mStickReturnSpeed; + /* 0x58 */ f32 mRoofHangRiseSpeed; + /* 0x5C */ f32 mRoofHangDecendSpeed; + /* 0x60 */ f32 mBossMaxLength; + /* 0x64 */ f32 mBossShootSpeed; + /* 0x68 */ f32 mBossReturnSpeed; + /* 0x6C */ f32 mBossStickReturnSpeed; +}; // Size: 0x70 + +class daAlinkHIO_hookshot_c0 { +public: + static daAlinkHIO_hookshot_c1 const m; +}; + +class daAlinkHIO_hookshot_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_hookshot_c(); + ~daAlinkHIO_hookshot_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_hookshot_c1 m; +}; + +class daAlinkHIO_spinner_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mKickAnm; + /* 0x14 */ s16 mRideMoveTime; + /* 0x16 */ s16 mBoardWaitTime; + /* 0x18 */ s16 mRideRotAngleMax; + /* 0x1A */ s16 mRideRotAngleMin; + /* 0x1C */ s16 mBossRideMoveTime; + /* 0x20 */ f32 mGravity; + /* 0x24 */ f32 mMaxFallSpeed; + /* 0x28 */ f32 mJumpRate; + /* 0x2C */ f32 mRideSpeed; + /* 0x30 */ f32 mDecelSpeedMax; + /* 0x34 */ f32 mDecelSpeedMin; + /* 0x38 */ f32 mDecelRate; + /* 0x3C */ f32 mBossRideSpeed; +}; // Size: 0x40 + +class daAlinkHIO_spinner_c0 { +public: + static daAlinkHIO_spinner_c1 const m; +}; + +class daAlinkHIO_spinner_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_spinner_c(); + ~daAlinkHIO_spinner_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_spinner_c1 m; +}; + +class daAlinkHIO_ironBall_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mCatchAnm; + /* 0x14 */ s16 mThrowChainNum; + /* 0x16 */ s16 mReturnChainRemoveNum; + /* 0x18 */ f32 mWaitAnmSpeed; + /* 0x1C */ f32 mPrepareAnmSpeed; + /* 0x20 */ f32 mPrepareInterpolation; + /* 0x24 */ f32 mTurnAnmSpeed; + /* 0x28 */ f32 mTurnInterpolation; + /* 0x2C */ f32 mPreThrowAnmSpeed; + /* 0x30 */ f32 mPreThrowAnmInterpolation; + /* 0x34 */ f32 mThrowAnmSpeed; + /* 0x38 */ f32 mThrowInterpolation; + /* 0x3C */ f32 mPullAnmSpeed; + /* 0x40 */ f32 mPullInterpolation; + /* 0x44 */ f32 mChainSpeedRate; + /* 0x48 */ f32 mChainGravity; + /* 0x4C */ f32 mReturnChainAccelY; + /* 0x50 */ f32 mReturnChainRate; + /* 0x54 */ f32 mThrowChainAccelZ; + /* 0x58 */ f32 mThrowChainAccelY; + /* 0x5C */ f32 mThrowChainGravity; + /* 0x60 */ f32 mBallGravity; + /* 0x64 */ f32 mThrowBallGravity; + /* 0x68 */ f32 mBallMaxFallSpeed; + /* 0x6C */ f32 field_0x6C; + /* 0x70 */ f32 mThrowSpeedZ; + /* 0x74 */ f32 mThrowSpeedY; + /* 0x78 */ f32 mReturnBallGravity; + /* 0x7C */ f32 mAttackRadius; + /* 0x80 */ f32 mFeetPosRatio; + /* 0x84 */ f32 mWalkAnmSpeedMax; + /* 0x88 */ f32 mWalkAnmSpeedMin; +}; // Size: 0x8C + +class daAlinkHIO_ironBall_c0 { +public: + static daAlinkHIO_ironBall_c1 const m; +}; + +class daAlinkHIO_ironBall_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_ironBall_c(); + ~daAlinkHIO_ironBall_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_ironBall_c1 m; +}; + +class daAlinkHIO_copyRod_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mSwingAnm; + /* 0x14 */ daAlinkHIO_anm_c mBigSwingAnm; + /* 0x28 */ f32 mBallSpeed; + /* 0x2c */ f32 mBallMaxDistance; + /* 0x30 */ f32 mBallReturnSpeed; + /* 0x34 */ f32 mBossBallMaxDistance; +}; // Size: 0x38 + +class daAlinkHIO_copyRod_c0 { +public: + static daAlinkHIO_copyRod_c1 const m; +}; + +class daAlinkHIO_copyRod_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_copyRod_c(); + ~daAlinkHIO_copyRod_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_copyRod_c1 m; +}; + +class daAlinkHIO_pickUp_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mGrabAnm; + /* 0x14 */ daAlinkHIO_anm_c mPlaceAnm; + /* 0x28 */ f32 field_0x28; + /* 0x2C */ f32 field_0x2C; +}; // Size: 0x30 + +class daAlinkHIO_pickUp_c0 { +public: + static daAlinkHIO_pickUp_c1 const m; +}; + +class daAlinkHIO_pickUp_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_pickUp_c(); + ~daAlinkHIO_pickUp_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_pickUp_c1 m; +}; + +class daAlinkHIO_board_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mJumpAnm; // might be wrong + /* 0x14 */ daAlinkHIO_anm_c mAirborneAnm; + /* 0x28 */ daAlinkHIO_anm_c mLandAnm; + /* 0x3C */ daAlinkHIO_anm_c mSpinAnm; + /* 0x50 */ f32 mMaxSpeed; + /* 0x54 */ f32 mPushAccel; + /* 0x58 */ f32 mMinJumpSpeedY; + /* 0x5C */ f32 mMaxJumpSpeedY; + /* 0x60 */ f32 mStandAnmSpeed; + /* 0x64 */ f32 mStandInterpolation; + /* 0x68 */ f32 mSitAnmSpeed; + /* 0x6C */ f32 mSitInterpolation; + /* 0x70 */ f32 mStartMinSpeed; + /* 0x74 */ f32 mStartAddSpeed; + /* 0x78 */ f32 mPushAnmMaxSpeed; + /* 0x7C */ f32 mFastPushSwitchSpeed; + /* 0x80 */ f32 mFastPushInterpolation; + /* 0x84 */ f32 mPushInterpolation; + /* 0x88 */ f32 mPushAnmMinSpeed; + /* 0x8C */ f32 mMaxPushSpeed; + /* 0x90 */ f32 mSpinMinJumpSpeedY; + /* 0x94 */ f32 mSpinMaxJumpSpeedY; + /* 0x98 */ f32 mEffectMaxSpeed; +}; // Size: 0x9C + +class daAlinkHIO_board_c0 { +public: + static daAlinkHIO_board_c1 const m; +}; + +class daAlinkHIO_board_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_board_c(); + ~daAlinkHIO_board_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_board_c1 m; +}; + +class daAlinkHIO_bottle_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mStartDrinkAnm; + /* 0x14 */ daAlinkHIO_anm_c mEndDrinkAnm; + /* 0x28 */ daAlinkHIO_anm_c mOpenBottleAnm; + /* 0x3C */ daAlinkHIO_anm_c mPourAnm; + /* 0x50 */ daAlinkHIO_anm_c mSwingDownAnm; + /* 0x64 */ daAlinkHIO_anm_c mSwingSideAnm; + /* 0x78 */ daAlinkHIO_anm_c mGetAnm; + /* 0x8C */ daAlinkHIO_anm_c mDrinkNastyAnm; + /* 0xA0 */ daAlinkHIO_anm_c mScoopAnm; +}; // Size: 0xB4 + +class daAlinkHIO_bottle_c0 { +public: + static daAlinkHIO_bottle_c1 const m; +}; + +class daAlinkHIO_bottle_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_bottle_c(); + ~daAlinkHIO_bottle_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_bottle_c1 m; +}; + +class daAlinkHIO_item_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mOneHandEquipAnm; + /* 0x14 */ daAlinkHIO_anm_c mTwoHandEquipAnm; + /* 0x28 */ s16 mItemFPTransitionTimer; + /* 0x2A */ s16 mItemFPMaxUnk; + /* 0x2C */ s16 mItemFPUpMaxUnk; + /* 0x2E */ s16 mWiiItemFPDownMaxUnk; + /* 0x30 */ s16 mWiiItemFPUpMaxUnk; + /* 0x34 */ f32 mOneHandReleaseAnmSpeed; + /* 0x38 */ f32 mTwoHandReleaseAnmSpeed; +}; // Size: 0x3C + +class daAlinkHIO_item_c0 { +public: + static daAlinkHIO_item_c1 const m; +}; + +class daAlinkHIO_item_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_item_c(); + ~daAlinkHIO_item_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_bow_c mBow; + /* 0x00 */ daAlinkHIO_boom_c mBoomerang; + /* 0x00 */ daAlinkHIO_bomb_c mBomb; + /* 0x00 */ daAlinkHIO_light_c mLanternPL; + /* 0x00 */ daAlinkHIO_kandelaar_c mLantern; + /* 0x00 */ daAlinkHIO_fmChain_c mFmChain; + /* 0x00 */ daAlinkHIO_magneBoots_c mIronBoots; + /* 0x00 */ daAlinkHIO_pickUp_c mPickUp; + /* 0x00 */ daAlinkHIO_board_c mBoard; + /* 0x00 */ daAlinkHIO_bottle_c mBottle; + /* 0x00 */ daAlinkHIO_hookshot_c mHookshot; + /* 0x00 */ daAlinkHIO_spinner_c mSpinner; + /* 0x00 */ daAlinkHIO_ironBall_c mIronBall; + /* 0x00 */ daAlinkHIO_copyRod_c mCopyRod; + /* 0x00 */ daAlinkHIO_light_c mZoraArmorPL; + /* 0x00 */ daAlinkHIO_item_c1 m; +}; + +class daAlinkHIO_ladder_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mWallAttachAnm; + /* 0x14 */ daAlinkHIO_anm_c mWallAttachMissAnm; + /* 0x28 */ f32 mClimbUpStartASpeed; + /* 0x2C */ f32 mClimbUpStartInterp; + /* 0x30 */ f32 mClimbUpEndASpeed; + /* 0x34 */ f32 mClimbUpEndInterp; + /* 0x38 */ f32 mClimbDownStartASpeed; + /* 0x3C */ f32 mClimbDownStartInterp; + /* 0x40 */ f32 mClimbDownEndASpeed; + /* 0x44 */ f32 mClimbDownEndInterp; + /* 0x48 */ f32 mMoveMinASpeed; + /* 0x4C */ f32 mMoveMaxSpeed; + /* 0x50 */ f32 mMoveInterp; + /* 0x54 */ f32 mClimbDownEndCF; + /* 0x58 */ f32 mClimbUpEndCF; + /* 0x5C */ f32 mWallHorizontalMinAnmSpeed; + /* 0x60 */ f32 mWallHorizontalMaxAnmSpeed; + /* 0x64 */ f32 mWallVerticalMinAnmSpeed; + /* 0x68 */ f32 mWallVerticalMaxAnmSpeed; + /* 0x6C */ f32 mWallApproachOffset; +}; // Size: 0x70 + +class daAlinkHIO_ladder_c0 { +public: + static daAlinkHIO_ladder_c1 const m; +}; + +class daAlinkHIO_ladder_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_ladder_c(); + ~daAlinkHIO_ladder_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_ladder_c1 m; +}; + +class daAlinkHIO_roofHang_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mRoofHangAnm; + /* 0x14 */ s16 mTurnAngleRate; + /* 0x16 */ s16 mMaxTurnAngle; + /* 0x18 */ s16 mMinTurnAngle; + /* 0x1C */ f32 mStandbyASpeed; + /* 0x20 */ f32 mStandbyInterp; + /* 0x24 */ f32 mVertMoveMinASpeed; + /* 0x28 */ f32 mVertMoveMaxASpeed; + /* 0x2C */ f32 mVertMoveInterp; + /* 0x30 */ f32 mVertMoveMinSpeed; + /* 0x34 */ f32 mVertMoveMaxSpeed; + /* 0x38 */ f32 mHorizMoveMinASpeed; + /* 0x3C */ f32 mHorizMoveMaxASpeed; + /* 0x40 */ f32 mHorizMoveInterp; + /* 0x44 */ f32 mInvertASpeed; + /* 0x48 */ f32 mInvertInterp; +}; // Size: 0x4C + +class daAlinkHIO_roofHang_c0 { +public: + static daAlinkHIO_roofHang_c1 const m; +}; + +class daAlinkHIO_roofHang_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_roofHang_c(); + ~daAlinkHIO_roofHang_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_roofHang_c1 m; +}; + +class daAlinkHIO_grab_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mPrepareAnm; + /* 0x14 */ daAlinkHIO_anm_c mLiftBackAnm; + /* 0x28 */ daAlinkHIO_anm_c mStandReverseAnm; + /* 0x3C */ daAlinkHIO_anm_c mLiftAnm; + /* 0x50 */ daAlinkHIO_anm_c mThrowAnm; + /* 0x64 */ daAlinkHIO_anm_c mCarryAnm; + /* 0x78 */ daAlinkHIO_anm_c mRecoilAnm; + /* 0x8C */ daAlinkHIO_anm_c mFailAnm; + /* 0xA0 */ daAlinkHIO_anm_c mCarryLiftAnm; + /* 0xB4 */ daAlinkHIO_anm_c mCarryPlaceReverseAnm; + /* 0xC8 */ daAlinkHIO_anm_c mIronBallThrowAnm; + /* 0xDC */ s16 mForceWeightSpec; + /* 0xDE */ s16 mFailStopTime; + /* 0xE0 */ f32 field_0xE0; +}; // Size: 0xE4 + +class daAlinkHIO_grab_c0 { +public: + static daAlinkHIO_grab_c1 const m; +}; + +class daAlinkHIO_grab_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_grab_c(); + ~daAlinkHIO_grab_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_grab_c1 m; +}; + +class daAlinkHIO_swim_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mFloatUpAnm; + /* 0x14 */ daAlinkHIO_anm_c mDiveAnm; + /* 0x28 */ daAlinkHIO_anm_c mUnderwaterDiveAnm; + /* 0x3C */ daAlinkHIO_anm_c mDashAnm; + /* 0x50 */ s16 mTurnRate; + /* 0x52 */ s16 mMinTurn; + /* 0x54 */ s16 mMaxTurn; + /* 0x56 */ s16 mUnderwaterTurnRate; + /* 0x58 */ s16 mUnderwaterMinTurn; + /* 0x5A */ s16 mUnderwaterMaxTurn; + /* 0x5C */ s16 field_0x5c; // related to dash + /* 0x5E */ s16 field_0x5e; // related to dash + /* 0x60 */ f32 mStartHeight; + /* 0x64 */ f32 mFloatUpHeight; + /* 0x68 */ f32 mForwardMaxSpeed; + /* 0x6C */ f32 mStrafeMaxSpeed; + /* 0x70 */ f32 mBackwardMaxSpeed; + /* 0x74 */ f32 mUnderwaterMaxSpeed; + /* 0x78 */ f32 mUnderwaterFallMaxSpeed; + /* 0x7C */ f32 mAcceleration; + /* 0x80 */ f32 mDeceleration; + /* 0x84 */ f32 mMaxFallSpeed; + /* 0x88 */ f32 mMaxFloatUpSpeed; + /* 0x8C */ f32 mBuoyancy; + /* 0x90 */ f32 mWaitAnmSpeed; + /* 0x94 */ f32 mWaitInterpolation; + /* 0x98 */ f32 mWaitUpDownShakeAmount; + /* 0x9C */ f32 mForwardMinAnmSpeed; + /* 0xA0 */ f32 mForwardMaxAnmSpeed; + /* 0xA4 */ f32 mStrafeMinAnmSpeed; + /* 0xA8 */ f32 mStrafeMaxAnmSpeed; + /* 0xAC */ f32 mBackwardMinAnmSpeed; + /* 0xB0 */ f32 mBackwardMaxAnmSpeed; + /* 0xB4 */ f32 mUnderwaterMinAnmSpeed; + /* 0xB8 */ f32 mUnderwaterMaxAnmSpeed; + /* 0xBC */ f32 mMoveInterpolation; + /* 0xC0 */ f32 mClimbHeight; + /* 0xC4 */ f32 mClimbWaterSurfaceUnder; + /* 0xC8 */ f32 mForwardMinSpeed; + /* 0xCC */ f32 mStandingMaxFallSpeed; + /* 0xD0 */ f32 mBootsMaxFallSpeed; + /* 0xD4 */ f32 mNormalBuoyancyWaterDepth; + /* 0xD8 */ f32 mZoraClothesBuoyancy; + /* 0xDC */ f32 mUnderwaterButtonAdditionalSpeed; + /* 0xE0 */ f32 mUnderwaterAdditionalAnmSpeed; + /* 0xE4 */ f32 mBootsGravity; + /* 0xE8 */ f32 mFloatUpSwimSpeedRate; + /* 0xEC */ f32 mDashMaxSpeed; + /* 0xF0 */ f32 mDashDeceleration; + /* 0xF4 */ f32 mDashMinAnmSpeed; + /* 0xF8 */ f32 mDashMaxAnmSpeed; +}; // Size: 0xFC + +class daAlinkHIO_swim_c0 { +public: + static daAlinkHIO_swim_c1 const m; +}; + +class daAlinkHIO_swim_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_swim_c(); + ~daAlinkHIO_swim_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_swim_c1 m; +}; + +class daAlinkHIO_wlMove_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mSlipAnm; + /* 0x14 */ daAlinkHIO_anm_c mReverseAnm; + /* 0x28 */ daAlinkHIO_anm_c mADashAnm; + /* 0x3C */ daAlinkHIO_anm_c mDashReboundAnm; + /* 0x50 */ s16 mTurnMax; + /* 0x52 */ s16 mTurnMin; + /* 0x54 */ s16 mTurnAngleRate; + /* 0x56 */ s16 mADashDuration; + /* 0x58 */ s16 mADashCooldownTime; + /* 0x5A */ s16 mADashDurationSlow; + /* 0x5C */ s16 mADashCooldownTimeSlow; + /* 0x5E */ s16 mADashDurationSlow2; + /* 0x60 */ s16 mADashCooldownTimeSlow2; + /* 0x64 */ f32 mMaxSpeed; + /* 0x68 */ f32 mAcceleration; + /* 0x6C */ f32 mDeceleration; + /* 0x70 */ f32 mIdleAnmSpeed; + /* 0x74 */ f32 mWalkAnmSpeed; + /* 0x78 */ f32 mBriskWalkAnmSpeed; + /* 0x7C */ f32 mRunAnmSpeed; + /* 0x80 */ f32 mQuickRunAnmSpeed; + /* 0x84 */ f32 mIdleToWalkRate; + /* 0x88 */ f32 mWalkToBriskWalkRate; + /* 0x8C */ f32 mStandbyRunToRunRate; + /* 0x90 */ f32 mRunToQuickRunRate; + /* 0x94 */ f32 mNormalInterpolation; + /* 0x98 */ f32 mWalkRunInterpolation; + /* 0x9C */ f32 mRunAnmMinBlendRate; + /* 0xA0 */ f32 mSlipStartRate; + /* 0xA4 */ f32 mSlipInitSpeedRate; + /* 0xA8 */ f32 mSlipDeceleration; + /* 0xAC */ f32 mReverseSpeed; + /* 0xB0 */ f32 mIdleReverseStartFrame; + /* 0xB4 */ f32 mGazeMaxSpeed; + /* 0xB8 */ f32 mGazeIdleAnmSpeed; + /* 0xBC */ f32 mIdleInterpolation; + /* 0xC0 */ f32 mReverseFallHeight; + /* 0xC4 */ f32 mReverseFallInterpolation; + /* 0xC8 */ f32 mADashMaxSpeed; + /* 0xCC */ f32 mADashQuickRunAnmSpeed; + /* 0xD0 */ f32 mADashAcceleration; + /* 0xD4 */ f32 mADashInitSpeed; + /* 0xD8 */ f32 mDashReboundHorizontalSpeed; + /* 0xDC */ f32 mDashReboundVerticalSpeed; + /* 0xE0 */ f32 mADashMaxSpeedSlow; + /* 0xE4 */ f32 mADashInitSpeedSlow; + /* 0xE8 */ f32 mADashQuickRunASpeedSlow; + /* 0xEC */ f32 mADashAccelerationSlow; + /* 0xF0 */ f32 mADashMaxSpeedSlow2; + /* 0xF4 */ f32 mADashInitSpeedSlow2; + /* 0xF8 */ f32 mADashQuickRunASpeedSlow2; + /* 0xFC */ f32 mADashAccelerationSlow2; +}; // Size: 0x100 + +class daAlinkHIO_wlMove_c0 { +public: + static daAlinkHIO_wlMove_c1 const m; +}; + +class daAlinkHIO_wlMove_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlMove_c(); + ~daAlinkHIO_wlMove_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_wlMove_c1 m; +}; + +class daAlinkHIO_wlMoveNoP_c1 { +public: + /* 0x00 */ s16 mTurnMax; + /* 0x02 */ s16 mTurnMin; + /* 0x04 */ s16 mTurnAngleRate; + /* 0x08 */ f32 mMaxSpeed; + /* 0x0C */ f32 mAcceleration; + /* 0x10 */ f32 mDeceleration; + /* 0x14 */ f32 mIdleAnmSpeed; + /* 0x18 */ f32 mWalkAnmSpeed; + /* 0x1C */ f32 mJogAnmSpeed; + /* 0x20 */ f32 mRunAnmSpeed; + /* 0x24 */ f32 mIdleToWalkRate; + /* 0x28 */ f32 mWalkToJogRate; + /* 0x2C */ f32 mJogToRunRate; + /* 0x30 */ f32 mWalkRunInterpolation; + /* 0x34 */ f32 mRunAnmMinBlendRate; + /* 0x38 */ f32 mSlideStartRate; + /* 0x3C */ f32 mSlideInitSpeed; + /* 0x40 */ f32 mSlideDeceleration; + /* 0x44 */ f32 mReverseSpeed; +}; // Size: 0x48 + +class daAlinkHIO_wlMoveNoP_c0 { +public: + static daAlinkHIO_wlMoveNoP_c1 const m; +}; + +class daAlinkHIO_wlMoveNoP_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlMoveNoP_c(); + ~daAlinkHIO_wlMoveNoP_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlMoveNoP_c1 m; +}; + +class daAlinkHIO_wlAtnMove_c1 { +public: + /* 0x00 */ s16 mTurnAngleMax; + /* 0x02 */ s16 mTurnAngleMin; + /* 0x04 */ s16 mTurnAngleRate; + /* 0x08 */ f32 mWalkAnmSpeed; + /* 0x0C */ f32 mRunAnmSpeed; + /* 0x10 */ f32 mWalkChangeRate; + /* 0x14 */ f32 mRunChangeRate; + /* 0x18 */ f32 mMaxSpeed; + /* 0x1C */ f32 mAcceleration; + /* 0x20 */ f32 mDeceleration; + /* 0x24 */ f32 mRearWalkAnmSpeed; + /* 0x28 */ f32 mRearWalkChangeRate; + /* 0x2C */ f32 mRearMaxSpeed; + /* 0x30 */ f32 mRearAcceleration; + /* 0x34 */ f32 mRearDeceleration; +}; // Size: 0x38 + +class daAlinkHIO_wlAtnMove_c0 { +public: + static daAlinkHIO_wlAtnMove_c1 const m; +}; + +class daAlinkHIO_wlAtnMove_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlAtnMove_c(); + ~daAlinkHIO_wlAtnMove_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlAtnMove_c1 m; +}; + +class daAlinkHIO_wlHowl_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mHowlAnm; + /* 0x14 */ daAlinkHIO_anm_c mSittingHowlAnm; + /* 0x28 */ daAlinkHIO_anm_c mThreatAnm; + /* 0x3C */ daAlinkHIO_anm_c mThreatStanceAnm; + /* 0x50 */ f32 mThreatMoveInterp; + /* 0x54 */ f32 mThreatMoveRate; + /* 0x58 */ f32 mThreatMoveMaxAnmSpeed; + /* 0x5C */ f32 mThreatMoveMinAnmSpeed; +}; // Size: 0x60 + +class daAlinkHIO_wlHowl_c0 { +public: + static daAlinkHIO_wlHowl_c1 const m; +}; + +class daAlinkHIO_wlHowl_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlHowl_c(); + ~daAlinkHIO_wlHowl_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlHowl_c1 m; +}; + +class daAlinkHIO_wlSideStep_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mSideJumpAnm; + /* 0x14 */ daAlinkHIO_anm_c mSideLandAnm; + /* 0x28 */ daAlinkHIO_anm_c mBackJumpAnm; + /* 0x3C */ daAlinkHIO_anm_c mBackLandAnm; + /* 0x50 */ f32 mSideJumpHorizSpeed; + /* 0x54 */ f32 mSideJumpVertSpeed; + /* 0x58 */ f32 mBackJumpHorizSpeed; + /* 0x5C */ f32 mBackJumpVertSpeed; + /* 0x60 */ f32 mFallHeight; + /* 0x64 */ f32 mFallInterp; +}; // Size: 0x68 + +class daAlinkHIO_wlSideStep_c0 { +public: + static daAlinkHIO_wlSideStep_c1 const m; +}; + +class daAlinkHIO_wlSideStep_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlSideStep_c(); + ~daAlinkHIO_wlSideStep_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlSideStep_c1 m; +}; + +class daAlinkHIO_wlBackJump_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mBackJumpAnm; + /* 0x14 */ daAlinkHIO_anm_c mBackLandAnm; + /* 0x28 */ f32 mBackJumpHorizSpeed; + /* 0x2C */ f32 mBackJumpVertSpeed; + /* 0x30 */ f32 mFallHeight; + /* 0x34 */ f32 mFallInterp; +}; // Size: 0x38 + +class daAlinkHIO_wlBackJump_c0 { +public: + static daAlinkHIO_wlBackJump_c1 const m; +}; + +class daAlinkHIO_wlBackJump_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlBackJump_c(); + ~daAlinkHIO_wlBackJump_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlBackJump_c1 m; +}; + +class daAlinkHIO_wlAutoJump_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mJumpAnm; + /* 0x14 */ daAlinkHIO_anm_c mLandingAnm; + /* 0x28 */ daAlinkHIO_anm_c mClimbAnm; + /* 0x3C */ u8 mAlwaysMaxSpeedJump; + /* 0x3E */ s16 field_0x3e; + /* 0x40 */ s16 mJumpAngle; + /* 0x42 */ s16 mWeakJumpAngle; + /* 0x44 */ f32 mJumpLimitSpeed; + /* 0x48 */ f32 mJumpMinSpeed; + /* 0x4C */ f32 mJumpSpeedRate; + /* 0x50 */ f32 mJumpFallInterp; + /* 0x54 */ f32 mNormalFallInterp; + /* 0x58 */ f32 mGravity; + /* 0x5C */ f32 mMaxFallSpeed; + /* 0x60 */ f32 mWeakJumpAnmSpeed; + /* 0x64 */ f32 mWeakJumpLimitSpeed; + /* 0x68 */ f32 mWeakJumpMinSpeed; + /* 0x6C */ f32 mWeakJumpSpeedRate; + /* 0x70 */ f32 mJumpMaxSpeed; + /* 0x74 */ f32 mWeakJumpMaxSpeed; + /* 0x78 */ f32 mHangLimitHeight; +}; // size = 0x7C + +class daAlinkHIO_wlAutoJump_c0 { +public: + static daAlinkHIO_wlAutoJump_c1 const m; +}; + +class daAlinkHIO_wlAutoJump_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlAutoJump_c(); + ~daAlinkHIO_wlAutoJump_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlAutoJump_c1 m; +}; + +class daAlinkHIO_wlPush_c1 { +public: + /* 0x00 */ f32 mIdleAnmSpeed; + /* 0x04 */ f32 mIdleInterp; + /* 0x08 */ f32 mPushAnmSpeed; + /* 0x0C */ f32 mPushInterp; + /* 0x10 */ f32 mHeavyPushAnmSpeed; +}; // Size: 0x14 + +class daAlinkHIO_wlPush_c0 { +public: + static daAlinkHIO_wlPush_c1 const m; +}; + +class daAlinkHIO_wlPush_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlPush_c(); + ~daAlinkHIO_wlPush_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlPush_c1 m; +}; + +class daAlinkHIO_wlLie_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mSittingAnm; + /* 0x14 */ daAlinkHIO_anm_c mProneStartAnm; + /* 0x28 */ s16 mProneTurnRate; + /* 0x2A */ s16 mProneTurnMax; + /* 0x2C */ s16 mProneTurnMin; + /* 0x30 */ f32 mStandUpInterp; + /* 0x34 */ f32 mProneMoveRate; + /* 0x38 */ f32 mProneMaxAnmSpeed; + /* 0x3C */ f32 mProneMinAnmSpeed; + /* 0x40 */ f32 mProneMoveInterp; + /* 0x44 */ f32 mSittingIdleAnmSpeed; + /* 0x48 */ f32 mSittingIdleInterp; +}; // Size: 0x4C + +class daAlinkHIO_wlLie_c0 { +public: + static daAlinkHIO_wlLie_c1 const m; +}; + +class daAlinkHIO_wlLie_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlLie_c(); + ~daAlinkHIO_wlLie_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlLie_c1 m; +}; + +class daAlinkHIO_wlWallHang_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mPreGrabJumpAnm; + /* 0x14 */ daAlinkHIO_anm_c mClimbAnm; + /* 0x28 */ daAlinkHIO_anm_c mFallGrabAnm; + /* 0x3C */ daAlinkHIO_anm_c mWallGrabAnm; + /* 0x50 */ daAlinkHIO_anm_c mLedgeClimbAnm; + /* 0x64 */ daAlinkHIO_anm_c mLedgeLandAnm; + /* 0x78 */ f32 mAutoWalkHeight; + /* 0x7C */ f32 mSmallJumpHeight; + /* 0x80 */ f32 mWallGrabHeight; + /* 0x84 */ f32 mClimbHeight; + /* 0x88 */ f32 mHangingFootHeight; + /* 0x8C */ f32 mJumpHorizontalSpeed; + /* 0x90 */ f32 mJumpTargetHeightOffset; + /* 0x94 */ f32 mJumpToFallInterp; + /* 0x98 */ f32 mHangingFallInterp; +}; // Size: 0x9C + +class daAlinkHIO_wlWallHang_c0 { +public: + static daAlinkHIO_wlWallHang_c1 const m; +}; + +class daAlinkHIO_wlWallHang_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlWallHang_c(); + ~daAlinkHIO_wlWallHang_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlWallHang_c1 m; +}; + +class daAlinkHIO_wlDamNormal_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mForwardAnm; + /* 0x14 */ daAlinkHIO_anm_c mBackwardAnm; + /* 0x28 */ daAlinkHIO_anm_c mLeftAnm; + /* 0x3C */ daAlinkHIO_anm_c mRightAnm; + /* 0x50 */ f32 mInitSpeed; + /* 0x54 */ f32 mAttackSpeedRate; + /* 0x58 */ f32 mDeceleration; + /* 0x5C */ f32 mIceDamageAnmSpeed; +}; // Size: 0x60 + +class daAlinkHIO_wlDamNormal_c0 { +public: + static daAlinkHIO_wlDamNormal_c1 const m; +}; + +class daAlinkHIO_wlDamNormal_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlDamNormal_c(); + ~daAlinkHIO_wlDamNormal_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlDamNormal_c1 m; +}; + +class daAlinkHIO_wlDamLaHu_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mFrontRiseAnm; + /* 0x14 */ daAlinkHIO_anm_c mBackRiseAnm; + /* 0x28 */ daAlinkHIO_anm_c mLeftRiseAnm; + /* 0x3C */ daAlinkHIO_anm_c mRightRiseAnm; + /* 0x50 */ s16 mBodyRotationSpeed; + /* 0x54 */ f32 mGravity; + /* 0x58 */ f32 mDamageInterp; + /* 0x5C */ f32 mHorizontalSpeed; + /* 0x60 */ f32 mVerticalSpeed; + /* 0x64 */ f32 mBounceSpeed; + /* 0x68 */ f32 mDeceleration; +}; // Size: 0x6C + +class daAlinkHIO_wlDamLarge_c0 { +public: + static daAlinkHIO_wlDamLaHu_c1 const m; +}; + +class daAlinkHIO_wlDamHuge_c0 { +public: + static daAlinkHIO_wlDamLaHu_c1 const m; +}; + +class daAlinkHIO_wlDamLaHu_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlDamLaHu_c(int); + ~daAlinkHIO_wlDamLaHu_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlDamLaHu_c1 m; +}; + +class daAlinkHIO_wlDamCaught_c1 { +public: + /* 0x00 */ s16 mCaughtTime; + /* 0x02 */ s16 mInputDecayTime; + /* 0x04 */ f32 mCaughtSpeed; + /* 0x08 */ f32 mWaitInterp; + /* 0x0C */ f32 mWaitAddAnmSpeed; +}; // Size: 0x10 + +class daAlinkHIO_wlDamCaught_c0 { +public: + static daAlinkHIO_wlDamCaught_c1 const m; +}; + +class daAlinkHIO_wlDamCaught_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlDamCaught_c(); + ~daAlinkHIO_wlDamCaught_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlDamCaught_c1 m; +}; + +class daAlinkHIO_wlDamFall_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mLandingAnm; + /* 0x14 */ daAlinkHIO_anm_c mRightRiseAnm; + /* 0x28 */ s16 mSmallStopTime; + /* 0x2A */ s16 mLargeStopTime; + /* 0x2C */ f32 mSmallDamageHeight; + /* 0x30 */ f32 mLargeDamageHeight; + /* 0x34 */ f32 mSmallDamageLandingStartFrame; + /* 0x38 */ f32 mAirAnmTransitionHeight; + /* 0x3C */ f32 mAirAnmInterp; +}; // Size: 0x40 + +class daAlinkHIO_wlDamFall_c0 { +public: + static daAlinkHIO_wlDamFall_c1 const m; +}; + +class daAlinkHIO_wlDamFall_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlDamFall_c(); + ~daAlinkHIO_wlDamFall_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlDamFall_c1 m; +}; + +class daAlinkHIO_wlDamage_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mRunningAnm; + /* 0x14 */ daAlinkHIO_anm_c mPolygonAnm; + /* 0x28 */ f32 mReturnWakeupAnmSpeed; +}; // Size: 0x2C + +class daAlinkHIO_wlDamage_c0 { +public: + static daAlinkHIO_wlDamage_c1 const m; +}; + +class daAlinkHIO_wlDamage_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlDamage_c(); + ~daAlinkHIO_wlDamage_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_wlDamage_c1 m; + /* 0x00 */ daAlinkHIO_wlDamNormal_c mNormal; + /* 0x00 */ daAlinkHIO_wlDamLaHu_c mLarge; + /* 0x00 */ daAlinkHIO_wlDamLaHu_c mStrongLarge; + /* 0x00 */ daAlinkHIO_wlDamFall_c mFall; + /* 0x00 */ daAlinkHIO_wlDamCaught_c mCapture; +}; + +class daAlinkHIO_wlSlide_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mFrontSlideAnm; + /* 0x14 */ daAlinkHIO_anm_c mBackSlideAnm; + /* 0x28 */ daAlinkHIO_anm_c mLandingAnm; + /* 0x3c */ daAlinkHIO_anm_c mSlipDownRecoveryAnm; + /* 0x50 */ s16 mSlipDownRotationMax; + /* 0x52 */ s16 mSlipDownRotationMin; + /* 0x54 */ f32 mMaxSpeed; + /* 0x58 */ f32 mAcceleration; + /* 0x5c */ f32 mSlidingAngle; + /* 0x60 */ f32 mClimbingAngle; + /* 0x64 */ f32 mClimbingAnmSpeed; + /* 0x68 */ f32 mClimbingMaxSpeed; + /* 0x6c */ f32 mClimbingAnmSpeedWeak; + /* 0x70 */ f32 mClimbingMaxSpeedWeak; + /* 0x74 */ f32 mSlipDownAcceleration; + /* 0x78 */ f32 mSlipDownMaxSpeed; +}; // Size: 0x7C + +class daAlinkHIO_wlSlide_c0 { +public: + static daAlinkHIO_wlSlide_c1 const m; +}; + +class daAlinkHIO_wlSlide_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlSlide_c(); + ~daAlinkHIO_wlSlide_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlSlide_c1 m; +}; + +class daAlinkHIO_wlRope_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mFlipAnm; + /* 0x14 */ s16 mSwingAngle; + /* 0x16 */ s16 mMovementSwayTransitionTime; + /* 0x18 */ f32 mMovementMinAnmSpeed; + /* 0x1c */ f32 mMovementMaxAnmSpeed; + /* 0x20 */ f32 mMovementInterpolation; + /* 0x24 */ f32 mMovementRate; + /* 0x28 */ f32 mTwistClimbAnmSpeed; + /* 0x2c */ f32 mFallInterpolation; + /* 0x30 */ f32 mTwistClimbInterpolation; + /* 0x34 */ f32 mBackMovementMaxAnmSpeed; +}; // Size: 0x38 + +class daAlinkHIO_wlRope_c0 { +public: + static daAlinkHIO_wlRope_c1 const m; +}; + +class daAlinkHIO_wlRope_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlRope_c(); + ~daAlinkHIO_wlRope_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlRope_c1 m; +}; + +class daAlinkHIO_wlAtWait_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mAttackAnm; + /* 0x14 */ s16 mStopTime; + /* 0x16 */ s16 mComboMidStopTime; + /* 0x18 */ f32 mSpeed; + /* 0x1C */ f32 mSpeedAddForward; + /* 0x20 */ f32 mAttackJudgmentStartForward; + /* 0x24 */ f32 mAttackJudgmentEndForward; + /* 0x28 */ f32 mComboMidCF; + /* 0x2C */ f32 mComboMidStartF; + /* 0x30 */ f32 mAttackRadiusOffset; + /* 0x34 */ f32 mAttackRadius; + /* 0x38 */ f32 mAttackHeight; +}; // Size: 0x3C + +class daAlinkHIO_wlAtWaTl_c0 { +public: + static daAlinkHIO_wlAtWait_c1 const m; +}; + +class daAlinkHIO_wlAtWaSc_c0 { +public: + static daAlinkHIO_wlAtWait_c1 const m; +}; + +class daAlinkHIO_wlAtWaLr_c0 { +public: + static daAlinkHIO_wlAtWait_c1 const m; +}; + +class daAlinkHIO_wlAtWait_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlAtWait_c(int, float); + ~daAlinkHIO_wlAtWait_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ f32 field_0x34; + /* 0x38 */ daAlinkHIO_wlAtWait_c1 m; +}; // Size: 0x74 + +class daAlinkHIO_wlAtRoll_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mAttackAnm; + /* 0x14 */ f32 mAttackRadius; + /* 0x18 */ f32 mAttackSpeed; + /* 0x1c */ f32 mSpiderThreadEscapeStartF; +}; // Size: 0x20 + +class daAlinkHIO_wlAtRoll_c0 { +public: + static daAlinkHIO_wlAtRoll_c1 const m; +}; + +class daAlinkHIO_wlAtRoll_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlAtRoll_c(); + ~daAlinkHIO_wlAtRoll_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_wlAtRoll_c1 m; +}; // Size: 0x54 + +class daAlinkHIO_wlAtNjump_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mAerialAttackAnm; + /* 0x14 */ f32 mAttackInitSpeed; + /* 0x18 */ f32 mMaxHorizontalSpeed; + /* 0x1c */ f32 mMaxVerticalSpeed; + /* 0x20 */ f32 mMinVerticalSpeed; + /* 0x24 */ f32 mAerialAnmSpeed; + /* 0x28 */ f32 mAerialInterpolation; + /* 0x2c */ f32 mAttackRadiusOffset; + /* 0x30 */ f32 mAttackRadius; + /* 0x34 */ f32 mAttackHeight; + /* 0x38 */ f32 mMinHorizontalSpeed; +}; // Size: 0x3C + +class daAlinkHIO_wlAtNjump_c0 { +public: + static daAlinkHIO_wlAtNjump_c1 const m; +}; + +class daAlinkHIO_wlAtNjump_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlAtNjump_c(); + ~daAlinkHIO_wlAtNjump_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_wlAtNjump_c1 m; +}; // Size: 0x70 + +class daAlinkHIO_wlAtCjump_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mAerialAttackAnm; + /* 0x14 */ daAlinkHIO_anm_c mFlipKickAnm; + /* 0x28 */ f32 mAttackInitSpeed; + /* 0x2c */ f32 mMaxHorizontalSpeed; + /* 0x30 */ f32 mMaxVerticalSpeed; + /* 0x34 */ f32 mMinVerticalSpeed; + /* 0x38 */ f32 mAerialAnmSpeed; + /* 0x3c */ f32 mAerialInterpolation; + /* 0x40 */ f32 mFlipKickPostStartF; + /* 0x44 */ f32 mFlipKickPostAnmSpeed; + /* 0x48 */ f32 mAttackRadiusOffset; + /* 0x4c */ f32 mAttackRadius; + /* 0x50 */ f32 mAttackHeight; + /* 0x54 */ f32 mMinHorizontalSpeed; + /* 0x58 */ f32 mHitDecelRate; + /* 0x5c */ f32 mHitMinSpeed; + /* 0x60 */ f32 mHitDecel; +}; // Size: 0x64 + +class daAlinkHIO_wlAtCjump_c0 { +public: + static daAlinkHIO_wlAtCjump_c1 const m; +}; + +class daAlinkHIO_wlAtCjump_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlAtCjump_c(); + ~daAlinkHIO_wlAtCjump_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_wlAtCjump_c1 m; +}; // Size: 0x98 + +class daAlinkHIO_wlAtLand_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mNormalLandingAnm; + /* 0x14 */ daAlinkHIO_anm_c mFrontSlideAnm; + /* 0x28 */ daAlinkHIO_anm_c mBackSlideAnm; + /* 0x3C */ f32 mSlideDeceleration; +}; // Size: 0x40 + +class daAlinkHIO_wlAtLand_c0 { +public: + static daAlinkHIO_wlAtLand_c1 const m; +}; + +class daAlinkHIO_wlAtLand_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlAtLand_c(); + ~daAlinkHIO_wlAtLand_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_wlAtLand_c1 m; +}; // Size: 0x74 + +class daAlinkHIO_wlAtDown_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mLowStanceAnm; + /* 0x14 */ daAlinkHIO_anm_c mPushDownAnm; + /* 0x28 */ daAlinkHIO_anm_c mFrontRollAnm; + /* 0x3C */ daAlinkHIO_anm_c mCrouchAnm; + /* 0x50 */ daAlinkHIO_anm_c mBackRollAnm; + /* 0x64 */ daAlinkHIO_anm_c mRollOverAnm; + /* 0x78 */ daAlinkHIO_anm_c mProneGetUpAnm; + /* 0x8C */ s16 field_0x8C; + /* 0x8E */ s16 mFallDuration; + /* 0x90 */ f32 mSideRollMovementWidth; + /* 0x94 */ f32 mLandingSideRollMovementWidth; + /* 0x98 */ f32 mLandingFrontBackMovementWidth; +}; // Size: 0x9C + +class daAlinkHIO_wlAtDown_c0 { +public: + static daAlinkHIO_wlAtDown_c1 const m; +}; + +class daAlinkHIO_wlAtDown_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlAtDown_c(); + ~daAlinkHIO_wlAtDown_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_wlAtDown_c1 m; +}; // Size: 0xD0 + +class daAlinkHIO_wlAtLock_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mFrontLandingAnm; + /* 0x14 */ daAlinkHIO_anm_c mRearLandingAnm; + /* 0x28 */ s16 mAutoActivationTime; + /* 0x2C */ f32 mStartRadius; + /* 0x30 */ f32 mMaxRadius; + /* 0x34 */ f32 mRadiusAcceleration; + /* 0x38 */ f32 mAttackSpeed; + /* 0x3C */ f32 mAttackRadiusOffset; + /* 0x40 */ f32 mAttackRadius; + /* 0x44 */ f32 mAttackHeight; + /* 0x48 */ f32 mGravity; + /* 0x4C */ f32 mMaxJumpHeight; + /* 0x50 */ f32 mMaxJumpDistance; +}; // Size: 0x54 + +class daAlinkHIO_wlAtLock_c0 { +public: + static daAlinkHIO_wlAtLock_c1 const m; +}; + +class daAlinkHIO_wlAtLock_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlAtLock_c(); + ~daAlinkHIO_wlAtLock_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_wlAtLock_c1 m; +}; // Size: 0x88 + +class daAlinkHIO_wlAtBite_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mBitePreparationAnm; + /* 0x14 */ daAlinkHIO_anm_c mHangingBitePreparationAnm; + /* 0x28 */ s16 mBiteAttachTime; + /* 0x2A */ s16 field_0x2A; + /* 0x2C */ f32 mEnemyBiteThrowAnmSpeed; + /* 0x30 */ f32 mEnemyBiteThrowInterpolation; + /* 0x34 */ f32 mEnemyBiteThrowCF; + /* 0x38 */ f32 mBitePreparationMidStartF; + /* 0x3C */ f32 mBiteMidAnmSpeedMin; + /* 0x40 */ f32 mHangingBiteMidAnmSpeedMin; + /* 0x44 */ f32 mBiteMidAnmSpeedMax; + /* 0x48 */ f32 mHangingBiteMidAnmSpeedMax; + /* 0x4C */ f32 mBiteMidAnmSpeedAcceleration; + /* 0x50 */ f32 mHangingBiteMidAnmSpeedAcceleration; + /* 0x54 */ f32 mBiteMidAnmSpeedDeceleration; + /* 0x58 */ f32 mHangingBiteMidAnmSpeedDeceleration; +}; // Size: 0x5C + +class daAlinkHIO_wlAtBite_c0 { +public: + static daAlinkHIO_wlAtBite_c1 const m; +}; + +class daAlinkHIO_wlAtBite_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlAtBite_c(); + ~daAlinkHIO_wlAtBite_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_wlAtBite_c1 m; +}; // Size: 0x90 + +class daAlinkHIO_wlAttack_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mJumpBackLandAnm; + /* 0x14 */ s16 mChargeTime; + /* 0x16 */ s16 mComboDuration; + /* 0x18 */ f32 mFallHeight; + /* 0x1C */ f32 mFallInterpolation; + /* 0x20 */ f32 mReadyInterpolation; + /* 0x24 */ f32 mAttackRange; + /* 0x28 */ f32 mJumpBackSpeedH; + /* 0x2C */ f32 mJumpBackSpeedV; + /* 0x30 */ f32 mJumpAttackSpeedV; + /* 0x34 */ f32 mJumpAttackSpeedH; +}; // Size: 0x38 + +class daAlinkHIO_wlAttack_c0 { +public: + static daAlinkHIO_wlAttack_c1 const m; +}; + +class daAlinkHIO_wlAttack_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlAttack_c(); + ~daAlinkHIO_wlAttack_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x034 */ daAlinkHIO_wlAtWait_c mHorizontalAttack; + /* 0x0A8 */ daAlinkHIO_wlAtWait_c mScratchAttack; + /* 0x11C */ daAlinkHIO_wlAtWait_c mTailAttack; + /* 0x190 */ daAlinkHIO_wlAtRoll_c mAtRoll; + /* 0x1E4 */ daAlinkHIO_wlAtNjump_c mWlAtNjump; + /* 0x254 */ daAlinkHIO_wlAtCjump_c mWlAtCjump; + /* 0x2EC */ daAlinkHIO_wlAtLand_c mWlAtLand; + /* 0x360 */ daAlinkHIO_wlAtDown_c mWlAtDown; + /* 0x430 */ daAlinkHIO_wlAtLock_c mWlAtLock; + /* 0x4B8 */ daAlinkHIO_wlAtBite_c mWlAtBite; + /* 0x548 */ daAlinkHIO_wlAttack_c1 m; +}; + +class daAlinkHIO_wlPoint_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mForwardJumpAnm; + /* 0x14 */ daAlinkHIO_anm_c mBackwardJumpAnm; + /* 0x28 */ daAlinkHIO_anm_c mLandingAnm; + /* 0x3C */ daAlinkHIO_anm_c mTagLandingAnm; + /* 0x50 */ s16 mLockJumpStopTime; + /* 0x54 */ f32 mIdleAnmSpeed; + /* 0x58 */ f32 mIdleInterpolation; + /* 0x5C */ f32 mAerialInterpolation; + /* 0x60 */ f32 mJumpSpeed; + /* 0x64 */ f32 mFailureJumpSpeed; + /* 0x68 */ f32 mTagJumpSpeed; + /* 0x6C */ f32 mLockLandingIceInitSpeed; + /* 0x70 */ f32 mLockLandingIceDecelRate; + /* 0x74 */ f32 mLockLandingIceMaxDecel; + /* 0x78 */ f32 mLockLandingIceMinDecel; +}; // Size: 0x7C + +class daAlinkHIO_wlPoint_c0 { +public: + static daAlinkHIO_wlPoint_c1 const m; +}; + +class daAlinkHIO_wlPoint_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlPoint_c(); + ~daAlinkHIO_wlPoint_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlPoint_c1 m; +}; + +class daAlinkHIO_wlChain_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mLoweringStartAnm; + /* 0x14 */ daAlinkHIO_anm_c mDigAnm; + /* 0x28 */ daAlinkHIO_anm_c mDigFallAnm; + /* 0x3C */ s16 mTensionWaitTime; + /* 0x3E */ s16 mReleaseWaitTime; + /* 0x40 */ f32 mWaitAnmSpeed; + /* 0x44 */ f32 mWaitInterp; + /* 0x48 */ f32 mSwingAnmSpeed; + /* 0x4C */ f32 mSwingInterp; + /* 0x50 */ f32 mFallSpeed; + /* 0x54 */ f32 mSniffAnmSpeed; + /* 0x58 */ f32 mSniffInterp; +}; // Size: 0x5C + +class daAlinkHIO_wlChain_c0 { +public: + static daAlinkHIO_wlChain_c1 const m; +}; + +class daAlinkHIO_wlChain_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlChain_c(); + ~daAlinkHIO_wlChain_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlChain_c1 m; +}; + +class daAlinkHIO_wlSwim_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mSurfacingAnm; + /* 0x14 */ daAlinkHIO_anm_c mWaterSplashIdleAnm; + /* 0x28 */ daAlinkHIO_anm_c mDashAnm; + /* 0x3C */ s16 mTurnRate; + /* 0x3E */ s16 mTurnMin; + /* 0x40 */ s16 mTurnMax; + /* 0x42 */ s16 mIdleTurnRate; + /* 0x44 */ s16 mIdleTurnMin; + /* 0x46 */ s16 mIdleTurnMax; + /* 0x48 */ f32 mStartHeight; + /* 0x4C */ f32 mSurfacingHeight; + /* 0x50 */ f32 mMaxSpeed; + /* 0x54 */ f32 mDeceleration; + /* 0x58 */ f32 mMaxFallSpeed; + /* 0x5C */ f32 mMaxSurfacingSpeed; + /* 0x60 */ f32 mBuoyancy; + /* 0x64 */ f32 mIdleAnmSpeed; + /* 0x68 */ f32 mIdleInterp; + /* 0x6C */ f32 mIdleUpDownSwayAmount; + /* 0x70 */ f32 mMoveMinAnmSpeed; + /* 0x74 */ f32 mMoveMaxAnmSpeed; + /* 0x78 */ f32 mMoveInterp; + /* 0x7C */ f32 mClimbHeight; + /* 0x80 */ f32 mMaxSpeedWeak; + /* 0x84 */ f32 mDecelerationWeak; + /* 0x88 */ f32 mIdleAnmSpeedWeak; + /* 0x8C */ f32 mMoveMinAnmSpeedWeak; + /* 0x90 */ f32 mMoveMaxAnmSpeedWeak; + /* 0x94 */ f32 mClimbBelowWaterSurface; + /* 0x98 */ f32 mHeavyIdleUpDownSwayAmount; + /* 0x9C */ f32 mHeavyBuoyancy; + /* 0xA0 */ f32 mHeavyMaxFallSpeed; + /* 0xA4 */ f32 mHeavyMaxSurfacingSpeed; +}; // Size: 0xA8 + +class daAlinkHIO_wlSwim_c0 { +public: + static daAlinkHIO_wlSwim_c1 const m; +}; + +class daAlinkHIO_wlSwim_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlSwim_c(); + ~daAlinkHIO_wlSwim_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlSwim_c1 m; +}; + +class daAlinkHIO_wlGrab_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mPotGrabAnm; + /* 0x14 */ daAlinkHIO_anm_c mPotReleaseAnm; + /* 0x28 */ daAlinkHIO_anm_c mBoneGrabAnm; + /* 0x3C */ daAlinkHIO_anm_c mBoneReleaseAnm; + /* 0x50 */ daAlinkHIO_anm_c mThrowAnm; +}; // Size: 0x64 + +class daAlinkHIO_wlGrab_c0 { +public: + static daAlinkHIO_wlGrab_c1 const m; +}; + +class daAlinkHIO_wlGrab_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlGrab_c(); + ~daAlinkHIO_wlGrab_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlGrab_c1 m; +}; + +class daAlinkHIO_wlBall_c1 { +public: + /* 0x00 */ daAlinkHIO_anm_c mFullBodyAnm; + /* 0x14 */ daAlinkHIO_anm_c mNeckAnm; + /* 0x28 */ s16 mMpConsumptionTime; + /* 0x2C */ f32 mLifeOrbGravity; + /* 0x30 */ f32 mLifeOrbHorizSpeed; + /* 0x34 */ f32 mLifeOrbVertSpeed; +}; // Size: 0x38 + +class daAlinkHIO_wlBall_c0 { +public: + static daAlinkHIO_wlBall_c1 const m; +}; + +class daAlinkHIO_wlBall_c : public daAlinkHIO_data_c { +public: + daAlinkHIO_wlBall_c(); + ~daAlinkHIO_wlBall_c(); + + virtual void genMessage(JORMContext*); + +private: + /* 0x00 */ daAlinkHIO_wlBall_c1 m; +}; + +class daAlinkHIO_wolf_c1 { +public: + /* 0x00 */ s16 mMaxNeckTurnH; + /* 0x02 */ s16 mMaxNeckTurnUp; + /* 0x04 */ s16 mMaxNeckTurnDown; + /* 0x06 */ s16 mMaxTiredNeckTurnH; + /* 0x08 */ s16 mMaxTiredNeckTurnUp; + /* 0x0A */ s16 mMaxTiredNeckTurnDown; + /* 0x0C */ s16 mSensesLingerTime; // ? + /* 0x0E */ s16 mLightDropR; + /* 0x10 */ s16 mLightDropG; + /* 0x12 */ s16 mLightDropB; + /* 0x14 */ f32 mUnderwaterInputRate; +}; // Size: 0x18 + +class daAlinkHIO_wolf_c0 { +public: + static daAlinkHIO_wolf_c1 const m; +}; + +class daAlinkHIO_wolf_c +#ifdef DEBUG + : public daAlinkHIO_data_c +#endif +{ +public: +#ifdef DEBUG + daAlinkHIO_wolf_c(); +#endif + ~daAlinkHIO_wolf_c(); + +#ifdef DEBUG + virtual void genMessage(JORMContext*); + +private: + /* 0x34 */ daAlinkHIO_wlMove_c mWlMove; + /* 0x00 */ daAlinkHIO_wlMoveNoP_c mWlMoveNoP; + /* 0x00 */ daAlinkHIO_wlAtnMove_c mWlAtnMove; + /* 0x00 */ daAlinkHIO_wlSideStep_c mWlSideStep; + /* 0x00 */ daAlinkHIO_wlBackJump_c mWlBackJump; + /* 0x00 */ daAlinkHIO_wlHowl_c mWlHowl; + /* 0x00 */ daAlinkHIO_wlAutoJump_c mWlAutoJump; + /* 0x00 */ daAlinkHIO_wlPush_c mWlPush; + /* 0x00 */ daAlinkHIO_wlLie_c mWlLie; + /* 0x00 */ daAlinkHIO_light_c mLight; + /* 0x00 */ daAlinkHIO_wlWallHang_c mWlWallHang; + /* 0x00 */ daAlinkHIO_wlDamage_c mWlDamage; + /* 0x00 */ daAlinkHIO_wlSlide_c mWlSlide; + /* 0x00 */ daAlinkHIO_wlRope_c mWlRope; + /* 0x00 */ daAlinkHIO_wlAttack_c mWlAttack; + /* 0x00 */ daAlinkHIO_wlPoint_c mWlPoint; + /* 0x00 */ daAlinkHIO_wlChain_c mWlChain; + /* 0x00 */ daAlinkHIO_wlSwim_c mWlSwim; + /* 0x00 */ daAlinkHIO_wlGrab_c mWlGrab; + /* 0x00 */ daAlinkHIO_wlBall_c mWlBall; + /* 0x00 */ daAlinkHIO_wolf_c1 m; +#endif }; class daAlinkHIO_c #ifdef DEBUG -: public mDoHIO_entry_c + : public mDoHIO_entry_c #endif { public: /* 80140B88 */ daAlinkHIO_c(); /* 80140C10 */ virtual ~daAlinkHIO_c(); - void genMessage(JORMContext*); void jumpStateUpdate(const cXyz*, const cXyz*, f32); + void genMessage(JORMContext*); +#ifdef DEBUG + void readFileData(char*); + size_t makeFileOutData(char*, char*); + void listenPropertyEvent(const JORPropertyEvent*); + daAlinkHIO_basic_c mBasic; + daAlinkHIO_move_c mMove; + daAlinkHIO_atnMove_c mAtnMove; + daAlinkHIO_noActAtnMove_c mNoActAtnMove; + daAlinkHIO_frontRoll_c mFrontRoll; + daAlinkHIO_backJump_c mBackJump; + daAlinkHIO_sideStep_c mSideStep; + daAlinkHIO_slide_c mSlide; + daAlinkHIO_cut_c mCut; + daAlinkHIO_guard_c mGuard; + daAlinkHIO_crouch_c mCrouch; + daAlinkHIO_autoJump_c mAutoJump; + daAlinkHIO_wallHang_c mWallHang; + daAlinkHIO_pushpull_c mPushpull; + daAlinkHIO_damage_c mDamage; + daAlinkHIO_horse_c mHorse; + daAlinkHIO_canoe_c mCanoe; + daAlinkHIO_item_c mItem; + daAlinkHIO_ladder_c mLadder; + daAlinkHIO_roofHang_c mRoofHang; + daAlinkHIO_grab_c mGrab; + daAlinkHIO_swim_c mSwim; + daAlinkHIO_wolf_c mWolf; +#else /* 0x04 */ u8 field_0x4[0xC - 0x4]; /* 0x0C */ daAlinkHIO_cut_c mCut; /* 0x0D */ u8 field_0xD[0x4B - 0xD]; /* 0x4B */ daAlinkHIO_wolf_c mWolf; /* 0x4C */ u8 field_0x4C[0x6C - 0x4C]; +#endif }; class daAlink_c; @@ -3466,7 +6803,9 @@ public: } s32 checkPlayerDemoMode() const { return mDemo.getDemoType(); } - BOOL checkSpecialDemoMode() const { return mDemo.getDemoType() == daPy_demo_c::DEMO_TYPE_SPECIAL_e; } + BOOL checkSpecialDemoMode() const { + return mDemo.getDemoType() == daPy_demo_c::DEMO_TYPE_SPECIAL_e; + } static bool checkMidnaChargeAttack() { return dComIfGs_isEventBit(0x501); } u16 getMidnaMsgNum() const { return mMidnaMsgNum; } u32 getStartEvent() { return fopAcM_GetParam(this) >> 0x18; } @@ -3635,7 +6974,7 @@ public: BOOL checkCanoeRideOwn(const fopAc_ac_c* param_0) const { return checkCanoeRide() && mRideAcKeep.getActorConst() == param_0; } - BOOL checkBoarRideOwn(const fopAc_ac_c* i_actorP) const { + BOOL checkBoarRideOwn(const fopAc_ac_c* i_actorP) const { return checkBoarRide() && mRideAcKeep.getActorConst() == i_actorP; } bool checkWolfDashMode() const { return checkNoResetFlg1(FLG1_DASH_MODE); } @@ -3686,7 +7025,7 @@ public: J3DAnmTransform* getNowAnmPackUnder(daAlink_UNDER i_idx) { return mNowAnmPackUnder[i_idx].getAnmTransform(); } - bool doButton() const { return mItemButton & BTN_A; } + BOOL doButton() const { return mItemButton & BTN_A; } void setGrassCancelStatus(u8 param_0) { setBStatus(param_0); } void seStartSystem(u32 i_seID) { mDoAud_seStart(i_seID, NULL, 0, 0); } @@ -3959,9 +7298,9 @@ public: /* 0x02018 */ daPy_frameCtrl_c mUpperFrameCtrl[3]; /* 0x02060 */ mDoExt_MtxCalcOldFrame* field_0x2060; /* 0x02064 */ daAlink_sight_c mSight; - #if PLATFORM_WII - u8 unk_0x20f0[4]; - #endif +#if PLATFORM_WII + u8 unk_0x20f0[4]; +#endif /* 0x020F0 */ daPy_anmHeap_c mAnmHeap3; /* 0x02104 */ daPy_anmHeap_c mAnmHeap4; /* 0x02118 */ daPy_anmHeap_c mFaceBtpHeap; @@ -4489,2181 +7828,6 @@ struct daAlink_cutHorseParamTbl { /* 0xA */ u8 m_cutType; }; // Size: 0xC -struct daAlinkHIO_anm_c { - /* 0x00 */ s16 mEndFrame; - /* 0x04 */ f32 mSpeed; - /* 0x08 */ f32 mStartFrame; - /* 0x0C */ f32 mInterpolation; - /* 0x10 */ f32 mCancelFrame; -}; // size: 0x14 - -struct daAlinkHIO_basic_c1 { - /* 0x00 */ bool mOneHitKill; - /* 0x02 */ s16 mNeckMaxHorizontal; - /* 0x04 */ s16 mNeckMaxUp; - /* 0x06 */ s16 mNeckMaxDown; - /* 0x08 */ s16 field_0x08; - /* 0x0A */ s16 mHotspringRecoverTime; - /* 0x0C */ s16 mWiiCamSpeedV; - /* 0x0E */ s16 mWiiCamSpeedH; - /* 0x10 */ s16 mTransformBlockFarAngle; - /* 0x14 */ f32 field_0x14; - /* 0x18 */ f32 mAnmBlendFactor; - /* 0x1C */ f32 mWaitTurnSpeed; - /* 0x20 */ f32 mStandDefenseBlend; - /* 0x24 */ f32 mWaterSurfaceEffectHeight; - /* 0x28 */ f32 mWolfWaterSurfaceEffectHeight; - /* 0x2C */ f32 mMaxWindInfluenceDist; - /* 0x30 */ f32 mNoWindInfluenceDist; - /* 0x34 */ f32 mMaxWindSpeed; - /* 0x38 */ f32 mLavaDeathDepth; - /* 0x3C */ f32 mLinkWolfTransformSpeed; - /* 0x40 */ f32 mWolfLinkTransformSpeed; - /* 0x44 */ f32 mIndoorSpeedFactor; - /* 0x48 */ f32 mSandSinkSpeed; - /* 0x4C */ f32 mSandSurfaceSpeed; - /* 0x50 */ f32 mTransformBlockNearDis; - /* 0x54 */ f32 mTransformBlockFarDis; -}; - -class daAlinkHIO_basic_c0 { -public: - static daAlinkHIO_basic_c1 const m; -}; - -class daAlinkHIO_backJump_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mBackflipAnm; - /* 0x14 */ daAlinkHIO_anm_c mLandAnm; - /* 0x28 */ f32 mBackflipSpeedH; - /* 0x2C */ f32 mBackflipSpeedV; - /* 0x30 */ f32 mFallHeight; - /* 0x34 */ f32 mFallInterpolation; -}; // Size: 0x38 - -class daAlinkHIO_backJump_c0 { -public: - static daAlinkHIO_backJump_c1 const m; -}; - -class daAlinkHIO_autoJump_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mJumpAnm; - /* 0x14 */ daAlinkHIO_anm_c mLandAnm; - /* 0x28 */ daAlinkHIO_anm_c mDiveAnm; - /* 0x3C */ daAlinkHIO_anm_c mDiveConnectAnm; - /* 0x50 */ bool mAlwaysMaxSpeedJump; - /* 0x52 */ s16 mJumpAngle; - /* 0x54 */ s16 mSpinJumpRotateSpeed; - /* 0x56 */ s16 mSpinJumpLandStopTime; - /* 0x58 */ s16 mCuccoJumpAngle; - /* 0x5C */ f32 mJumpSpeedLimit; - /* 0x60 */ f32 mMinJumpSpeed; - /* 0x64 */ f32 mJumpSpeedRate; - /* 0x68 */ f32 mAirborneInterpolation; - /* 0x6C */ f32 mJumpFallInterpolation; - /* 0x70 */ f32 mFallInterpolation; - /* 0x74 */ f32 mGravity; - /* 0x78 */ f32 mMaxFallSpeed; - /* 0x7C */ f32 mMaxJumpSpeed; - /* 0x80 */ f32 mSpinJumpInterpolation; - /* 0x84 */ f32 mSpinJumpFallInterpolation; - /* 0x88 */ f32 mSpinJumpAddSpeed; - /* 0x8C */ f32 mSpinJumpAccel; - /* 0x90 */ f32 mHangHeightLimit; - /* 0x94 */ f32 mGrabHeightLimit; - /* 0x98 */ f32 mOoccooJumpMaxSpeed; - /* 0x9C */ f32 mDiveSpeedV; - /* 0xA0 */ f32 mDiveSpeedH; - /* 0xA4 */ f32 mDiveGravity; - /* 0xA8 */ f32 mCuccoJumpMaxSpeed; - /* 0xAC */ f32 mCuccoFallMaxSpeed; - /* 0xB0 */ f32 mCuccoStartSpeed; -}; // size = 0xB4 - -class daAlinkHIO_autoJump_c0 { -public: - static daAlinkHIO_autoJump_c1 const m; -}; - -class daAlinkHIO_smallJump_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mSmallJumpAnm; - /* 0x14 */ daAlinkHIO_anm_c mStepClimbAnm; - /* 0x28 */ daAlinkHIO_anm_c mStepLandAnm; - /* 0x3C */ f32 mSpeedH; - /* 0x40 */ f32 mTargetHeightOffset; - /* 0x44 */ f32 mFallInterpolation; -}; // Size: 0x48 - -class daAlinkHIO_smallJump_c0 { -public: - static daAlinkHIO_smallJump_c1 const m; -}; - -class daAlinkHIO_cut_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mEquipAnm; - /* 0x14 */ daAlinkHIO_anm_c mUnequipAnm; - /* 0x28 */ daAlinkHIO_anm_c mRecoilAnm; - /* 0x3C */ daAlinkHIO_anm_c mStabAnm; - /* 0x50 */ bool mForceHitCombo; - /* 0x52 */ s16 mComboDuration; - /* 0x54 */ s16 mBlurAlpha; - /* 0x56 */ s16 mNormalSwingDuration; - /* 0x58 */ s16 mDashBlurAlpha; - /* 0x5A */ s16 mUnkTime; // might be related to flourish - /* 0x5C */ s16 mFlourishTime; - /* 0x5E */ s16 mUnkBodyDownwards; // ? - /* 0x60 */ s16 mUnkBodyUpwards; // ? - /* 0x62 */ s16 mSpinSlashWait; // ? maybe related to wii? - /* 0x64 */ f32 mRecoilSpeed; - /* 0x68 */ f32 mRecoilDeceleration; - /* 0x6C */ f32 mFlourishAnmSpeed; - /* 0x70 */ f32 mFlourishEndAnmSpeed; - /* 0x74 */ f32 mSwordLength; - /* 0x78 */ f32 mSwordRadius; - /* 0x7C */ f32 mSwordLengthHorseback; - /* 0x80 */ f32 mSwordRadiusHorseback; - /* 0x84 */ f32 mRunCutLength; - /* 0x88 */ f32 mRunCutRadius; - /* 0x8C */ f32 mFastUnequipAnmSpeed; - /* 0x90 */ f32 mSwordLengthHorsebackFight; - /* 0x94 */ f32 mSwordRadiusHorsebackFight; - /* 0x98 */ f32 mFlourishControlStartFrame; -}; // Size: 0x9C - -class daAlinkHIO_cut_c0 { -public: - static daAlinkHIO_cut_c1 const m; -}; - -class daAlinkHIO_cutJump_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mCutAnm; - /* 0x14 */ daAlinkHIO_anm_c mLandAnm; - /* 0x28 */ f32 mBaseJumpSpeedH; - /* 0x2C */ f32 mBaseJumpSpeedV; - /* 0x30 */ f32 mAirJumpSpeedH; - /* 0x34 */ f32 mAirJumpSpeedV; - /* 0x38 */ f32 mStartAttackFrame; - /* 0x3C */ f32 mEndAttackFrame; - /* 0x40 */ f32 mJumpSpinDelay; -}; // Size: 0x44 - -class daAlinkHIO_cutJump_c0 { -public: - static daAlinkHIO_cutJump_c1 const m; -}; - -class daAlinkHIO_cutLargeJump_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mChargeAnm; - /* 0x14 */ daAlinkHIO_anm_c mChargeMoveAnm; - /* 0x28 */ daAlinkHIO_anm_c mCutAnm; - /* 0x3C */ daAlinkHIO_anm_c mLandAnm; - /* 0x50 */ f32 mCutSpeedH; - /* 0x54 */ f32 mCutSpeedV; - /* 0x58 */ f32 mJumpAttackStartFrame; - /* 0x5C */ f32 mJumpAttackEndFrame; - /* 0x60 */ f32 mCutInitFrame; - /* 0x64 */ f32 mLandAttackInitFrame; - /* 0x68 */ f32 mLandAttackEndFrame; - /* 0x6C */ f32 mLandAttackRadius; - /* 0x70 */ f32 mSpinSlashCheckFrame; -}; // Size: 0x74 - -class daAlinkHIO_cutLargeJump_c0 { -public: - static daAlinkHIO_cutLargeJump_c1 const m; -}; - -class daAlinkHIO_cutNormal_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mCutAnm; - /* 0x14 */ f32 mSpeed; - /* 0x18 */ f32 mAttackStartFrame; - /* 0x1C */ f32 mAttackEndFrame; -}; // Size: 0x20 - -class daAlinkHIO_cutNmV_c0 { -public: - static daAlinkHIO_cutNormal_c1 const m; -}; - -class daAlinkHIO_cutNmL_c0 { -public: - static daAlinkHIO_cutNormal_c1 const m; -}; - -class daAlinkHIO_cutNmR_c0 { -public: - static daAlinkHIO_cutNormal_c1 const m; -}; - -class daAlinkHIO_cutNmSL_c0 { -public: - static daAlinkHIO_cutNormal_c1 const m; -}; - -class daAlinkHIO_cutNmSR_c0 { -public: - static daAlinkHIO_cutNormal_c1 const m; -}; - -class daAlinkHIO_cutFinish_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mCutAnm; - /* 0x14 */ s16 mStopTime; - /* 0x16 */ s16 mComboStopTime; - /* 0x18 */ f32 mSpeed; - /* 0x1C */ f32 mAttackStartFrame; - /* 0x20 */ f32 mAttackEndFrame; - /* 0x24 */ f32 mComboCheckFrame; - /* 0x28 */ f32 mComboStartFrame; -}; // Size: 0x2C - -class daAlinkHIO_cutFnL_c0 { -public: - static daAlinkHIO_cutFinish_c1 const m; -}; - -class daAlinkHIO_cutFnV_c0 { -public: - static daAlinkHIO_cutFinish_c1 const m; -}; - -class daAlinkHIO_cutFnS_c0 { -public: - static daAlinkHIO_cutFinish_c1 const m; -}; - -class daAlinkHIO_cutFnSl_c0 { -public: - static daAlinkHIO_cutFinish_c1 const m; -}; - -class daAlinkHIO_cutFnSm_c0 { -public: - static daAlinkHIO_cutFinish_c1 const m; -}; - -class daAlinkHIO_cutFnR_c0 { -public: - static daAlinkHIO_cutFinish_c1 const m; -}; - -class daAlinkHIO_cutFnJU_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mCutAnm; - /* 0x14 */ daAlinkHIO_anm_c mLandAnm; - /* 0x28 */ s16 mStopTime; - /* 0x2A */ s16 mComboStopTime; - /* 0x2C */ f32 mSpeedH; - /* 0x30 */ f32 mSpeedV; - /* 0x34 */ f32 mAttackStartFrame; - /* 0x38 */ f32 mAttackEndFrame; - /* 0x3C */ f32 mComboCheckFrame; - /* 0x40 */ f32 mComboStartFrame; - /* 0x44 */ f32 mFallHeight; - /* 0x48 */ f32 mFallInterpolation; - /* 0x4C */ f32 mAttackRadius; - /* 0x50 */ f32 mAttackOffset; -}; // Size: 0x54 - -class daAlinkHIO_cutFnJU_c0 { -public: - static daAlinkHIO_cutFnJU_c1 const m; -}; - -class daAlinkHIO_cutTurn_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mRightTurnAnm; - /* 0x14 */ daAlinkHIO_anm_c mChargeAnm; - /* 0x28 */ daAlinkHIO_anm_c mLeftTurnAnm; - /* 0x3C */ s16 mStopTime; - /* 0x3E */ s16 field_0x3E; - /* 0x40 */ f32 mRightTurnInputStartFrame; - /* 0x44 */ f32 mRightAttackStartFrame; - /* 0x48 */ f32 mRightAttackEndFrame; - /* 0x4C */ f32 mMoveFBAnmSpeed; - /* 0x50 */ f32 mMoveFBInterpolation; - /* 0x54 */ f32 mMoveLRAnmSpeed; - /* 0x58 */ f32 mMoveLRInterpolation; - /* 0x5C */ f32 mMaxSpeed; - /* 0x60 */ f32 mChargeMoveAccel; - /* 0x64 */ f32 mChargeMoveDecel; - /* 0x68 */ f32 mSpeed; - /* 0x6C */ f32 mRightComboStartFrame; - /* 0x70 */ f32 mAttackRadius; - /* 0x74 */ f32 mLeftTurnInputStartFrame; - /* 0x78 */ f32 mLeftAttackStartFrame; - /* 0x7C */ f32 mLeftAttackEndFrame; - /* 0x80 */ f32 mLeftComboStartFrame; - /* 0x84 */ f32 mAttackRadiusAccel; - /* 0x88 */ f32 mLightAttackRadius; - /* 0x8C */ f32 mLightAttackRadiusAccel; - /* 0x90 */ f32 mLargeAttackRadius; - /* 0x94 */ f32 mLargeAttackAccel; -}; // Size: 0x98 - -class daAlinkHIO_cutTurn_c0 { -public: - static daAlinkHIO_cutTurn_c1 const m; -}; - -class daAlinkHIO_hoCut_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mCutAnm; - /* 0x14 */ f32 mAttackStartFrame; - /* 0x18 */ f32 mAttackEndFrame; - /* 0x1C */ f32 mAfterCutMorf; -}; - -class daAlinkHIO_hoCutLA_c0 { -public: - static daAlinkHIO_hoCut_c1 const m; -}; - -class daAlinkHIO_hoCutLB_c0 { -public: - static daAlinkHIO_hoCut_c1 const m; -}; - -class daAlinkHIO_hoCutRA_c0 { -public: - static daAlinkHIO_hoCut_c1 const m; -}; - -class daAlinkHIO_hoCutRB_c0 { -public: - static daAlinkHIO_hoCut_c1 const m; -}; - -class daAlinkHIO_hoCutCharge_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ s16 field_0x3C; - /* 0x3E */ s16 field_0x3E; - /* 0x40 */ f32 field_0x40; - /* 0x44 */ f32 field_0x44; - /* 0x48 */ f32 field_0x48; - /* 0x4C */ f32 field_0x4C; - /* 0x50 */ f32 field_0x50; -}; // Size: 0x54 - -class daAlinkHIO_hoCutCharge_c0 { -public: - static daAlinkHIO_hoCutCharge_c1 const m; -}; - -class daAlinkHIO_cutDash_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mCutAnm; - /* 0x14 */ f32 mAttackStartFrame; - /* 0x18 */ f32 mAttackEndFrame; -}; // Size: 0x1C - -class daAlinkHIO_cutDaL_c0 { -public: - static daAlinkHIO_cutDash_c1 const m; -}; - -class daAlinkHIO_cutDaR_c0 { -public: - static daAlinkHIO_cutDash_c1 const m; -}; - -class daAlinkHIO_cutDaCharge_c0 { -public: - static daAlinkHIO_cutDash_c1 const m; -}; - -class daAlinkHIO_cutDown_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mJumpAnm; - /* 0x14 */ daAlinkHIO_anm_c mFallAnm; - /* 0x28 */ daAlinkHIO_anm_c mLandAnm; - /* 0x3C */ daAlinkHIO_anm_c mMissAnm; - /* 0x50 */ daAlinkHIO_anm_c mRecoverAnm; - /* 0x64 */ s16 mSuccessStopTime; - /* 0x66 */ s16 mFailStopTime; - /* 0x68 */ f32 mRecoverSpeedH; - /* 0x6C */ f32 mRecoverSpeedV; - /* 0x70 */ f32 mSpeedV; -}; // Size: 0x74 - -class daAlinkHIO_cutDown_c0 { -public: - static daAlinkHIO_cutDown_c1 const m; -}; - -class daAlinkHIO_cutHead_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mJumpAnm; - /* 0x14 */ daAlinkHIO_anm_c mCutAnm; - /* 0x28 */ daAlinkHIO_anm_c mLandAnm; - /* 0x3C */ f32 mGravity; - /* 0x40 */ f32 mMaxHeight; - /* 0x44 */ f32 mMaxDistance; - /* 0x48 */ f32 mAddSpeedV; - /* 0x4C */ f32 mAddSpeedH; - /* 0x50 */ f32 mAttackStartFrame; - /* 0x54 */ f32 mAttackEndFrame; - /* 0x58 */ f32 mSwordRadius; - /* 0x5C */ f32 mSwordLength; -}; // Size: 0x60 - -class daAlinkHIO_cutHead_c0 { -public: - static daAlinkHIO_cutHead_c1 const m; -}; - -class daAlinkHIO_guardAttack_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mAttackAnm; - /* 0x14 */ f32 mSpeed; - /* 0x18 */ f32 mAttackStartFrame; - /* 0x1C */ f32 mAttackEndFrame; - /* 0x20 */ f32 mSlashCheckFrame; -}; // Size: 0x24 - -class daAlinkHIO_gAtPush_c0 { -public: - static daAlinkHIO_guardAttack_c1 const m; -}; - -class daAlinkHIO_gAtKick_c0 { -public: - static daAlinkHIO_guardAttack_c1 const m; -}; - -class daAlinkHIO_guard_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mGuardHitAnm; - /* 0x14 */ daAlinkHIO_anm_c mCrouchGuardHitAnm; // Unused - /* 0x28 */ daAlinkHIO_anm_c mRecoilAnm; - /* 0x3C */ daAlinkHIO_anm_c mGuardBreakAnm; - /* 0x50 */ s16 mGuardLRAngleMax; - /* 0x52 */ s16 mGuardFBAngleMax; - /* 0x54 */ s16 mGuardBodyInterpolation; - /* 0x56 */ s16 mSmallGuardLRAngleMax; - /* 0x58 */ s16 mSmallGuardFBAngleMax; - /* 0x5C */ f32 mCrouchGuardAnmSpeed; // Unused - /* 0x60 */ f32 mCrouchGuardInterpolation; // Unused - /* 0x64 */ f32 mGuardSpeedNormal; - /* 0x68 */ f32 mGuardSpeedLarge; - /* 0x6C */ f32 mGuardSpeedHuge; - /* 0x70 */ f32 mAttackPosOffset; - /* 0x74 */ f32 mAttackRadius; - /* 0x78 */ f32 mMagneGuardSpeed; - /* 0x7C */ f32 mMagneHvyGuardSpeed; -}; // Size: 0x80 - -class daAlinkHIO_guard_c0 { -public: - static daAlinkHIO_guard_c1 const m; -}; - -class daAlinkHIO_crouch_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mCrawlStartAnm; - /* 0x14 */ daAlinkHIO_anm_c mCrawlEndAnm; - /* 0x28 */ s16 mCrawlTurnRate; - /* 0x2A */ s16 mCrawlTurnMax; - /* 0x2C */ s16 mCrawlTurnMin; - /* 0x30 */ f32 mCrouchAnmSpeed; - /* 0x34 */ f32 mCrouchInterpolation; - /* 0x38 */ f32 mStandInterpolation; - /* 0x3C */ f32 mCrawlMoveRate; - /* 0x40 */ f32 mCrawlAnmSpeedMax; - /* 0x44 */ f32 mCrawlAnmSpeedMin; - /* 0x48 */ f32 mCrawlInterpolation; -}; // Size: 0x4C - -class daAlinkHIO_crouch_c0 { -public: - static daAlinkHIO_crouch_c1 const m; -}; - -class daAlinkHIO_move_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mSlideAnm; - /* 0x14 */ s16 mMaxTurnAngle; - /* 0x16 */ s16 mMinTurnAngle; - /* 0x18 */ s16 mTurnAngleRate; - /* 0x1C */ f32 mWaitAnmSpeed; - /* 0x20 */ f32 mWalkAnmSpeed; - /* 0x24 */ f32 mRunAnmSpeed; - /* 0x28 */ f32 mWalkChangeRate; - /* 0x2C */ f32 mRunChangeRate; - /* 0x30 */ f32 mMaxSpeed; - /* 0x34 */ f32 mAcceleration; - /* 0x38 */ f32 mDeceleration; - /* 0x3C */ f32 mSlideThresholdSpeed; // speed needed to trigger a slide - /* 0x40 */ f32 mSlideSpeed; - /* 0x44 */ f32 mSlideDeceleration; - /* 0x48 */ f32 mFootPositionRatio; - /* 0x4C */ f32 mWaitBInterpolation; - /* 0x50 */ f32 mMinWalkRate; - /* 0x54 */ f32 mMinTiredWalkRate; -}; // Size: 0x58 - -class daAlinkHIO_move_c0 { -public: - static daAlinkHIO_move_c1 const m; -}; - -class daAlinkHIO_sideStep_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mSideJumpAnm; - /* 0x14 */ daAlinkHIO_anm_c mSideLandAnm; - /* 0x28 */ daAlinkHIO_anm_c mBackJumpAnm; - /* 0x3C */ daAlinkHIO_anm_c mBackLandAnm; - /* 0x50 */ f32 mSideJumpSpeedH; - /* 0x54 */ f32 mSideJumpSpeedV; - /* 0x58 */ f32 mBackJumpSpeedH; - /* 0x5C */ f32 mBackJumpSpeedV; - /* 0x60 */ f32 mFallHeight; - /* 0x64 */ f32 mFallInterpolation; -}; // Size: 0x68 - -class daAlinkHIO_sideStep_c0 { -public: - static daAlinkHIO_sideStep_c1 const m; -}; - -class daAlinkHIO_atnMove_c1 { -public: - /* 0x00 */ s16 mMaxTurnAngle; - /* 0x02 */ s16 mMinTurnAngle; - /* 0x04 */ s16 mTurnAngleRate; - /* 0x08 */ f32 mWaitAnmSpeed; - /* 0x0C */ f32 mWalkAnmSpeed; - /* 0x10 */ f32 mRunAnmSpeed; - /* 0x14 */ f32 mWalkChangeRate; - /* 0x18 */ f32 mRunChangeRate; - /* 0x1C */ f32 mMaxSpeed; - /* 0x20 */ f32 mAcceleration; - /* 0x24 */ f32 mDeceleration; - /* 0x28 */ f32 mBackWalkAnmSpeed; - /* 0x2C */ f32 mBackRunAnmSpeed; - /* 0x30 */ f32 mBackWalkChangeRate; - /* 0x34 */ f32 mBackRunChangeRate; - /* 0x38 */ f32 mMaxBackwardsSpeed; - /* 0x3C */ f32 mBackAcceleration; - /* 0x40 */ f32 mBackDeceleration; - /* 0x44 */ f32 mMinWalkFrame; - /* 0x48 */ f32 mMinBackWalkFrame; - /* 0x4C */ f32 mWalkForwardAnmSpeed; - /* 0x50 */ f32 mRunForwardAnmSpeed; -}; // Size: 0x54 - -class daAlinkHIO_atnMove_c0 { -public: - static daAlinkHIO_atnMove_c1 const m; -}; - -class daAlinkHIO_noActAtnMove_c1 { -public: - /* 0x00 */ s16 mMaxTurnAngle; - /* 0x02 */ s16 mMinTurnAngle; - /* 0x04 */ s16 mTurnAngleRate; - /* 0x08 */ f32 mWaitAnmSpeed; - /* 0x0C */ f32 mWalkAnmSpeed; - /* 0x10 */ f32 mRunAnmSpeed; - /* 0x14 */ f32 mWalkChangeRate; - /* 0x18 */ f32 mRunChangeRate; - /* 0x1C */ f32 mMaxSpeed; - /* 0x20 */ f32 mAcceleration; - /* 0x24 */ f32 mDeceleration; - /* 0x28 */ f32 mBackWalkAnmSpeed; - /* 0x2C */ f32 mBackRunAnmSpeed; - /* 0x30 */ f32 mBackWalkChangeRate; - /* 0x34 */ f32 mBackRunChangeRate; - /* 0x38 */ f32 mMaxBackwardsSpeed; - /* 0x3C */ f32 mBackAcceleration; - /* 0x40 */ f32 mBackDeceleration; - /* 0x44 */ f32 mMinWalkFrame; - /* 0x48 */ f32 mMinBackWalkFrame; - /* 0x4C */ f32 mWalkForwardAnmSpeed; - /* 0x50 */ f32 mRunForwardAnmSpeed; -}; // Size: 0x54 - -class daAlinkHIO_noActAtnMove_c0 { -public: - static daAlinkHIO_noActAtnMove_c1 const m; -}; - -class daAlinkHIO_wallMove_c1 { -public: - /* 0x00 */ f32 mMinAnmSpeed; - /* 0x04 */ f32 mMaxAnmSpeed; - /* 0x08 */ f32 mInterpolation; - /* 0x0C */ f32 mMinSpeed; - /* 0x10 */ f32 mMaxSpeed; -}; - -class daAlinkHIO_wallMove_c0 { -public: - static daAlinkHIO_wallMove_c1 const m; -}; - -class daAlinkHIO_wallFall_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mOneHandGrabAnm; - /* 0x14 */ daAlinkHIO_anm_c mTwoHandGrabAnm; -}; // Size: 0x28 - -class daAlinkHIO_wallFall_c0 { -public: - static daAlinkHIO_wallFall_c1 const m; -}; - -class daAlinkHIO_wallCatch_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mGrabAAnm; - /* 0x14 */ daAlinkHIO_anm_c mGrabBAnm; - /* 0x28 */ daAlinkHIO_anm_c mClimbAnm; - /* 0x3C */ daAlinkHIO_anm_c mJumpAnm; - /* 0x50 */ f32 mClimbStartFrame; -}; // Size: 0x54 - -class daAlinkHIO_wallCatch_c0 { -public: - static daAlinkHIO_wallCatch_c1 const m; -}; - -class daAlinkHIO_wallHang_c1 { -public: - /* 0x00 */ s16 small_jump_input_time; - /* 0x02 */ s16 grab_input_time; - /* 0x04 */ f32 auto_walk_height; - /* 0x08 */ f32 small_jump_height; - /* 0x0C */ f32 climb_height; - /* 0x10 */ f32 jump_climb_height; - /* 0x14 */ f32 jump_hang_height; - /* 0x18 */ f32 hang_foot_pos_height; -}; // Size: 0x1C - -class daAlinkHIO_wallHang_c0 { -public: - static daAlinkHIO_wallHang_c1 const m; -}; - -class daAlinkHIO_roofHang_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ s16 field_0x14; - /* 0x16 */ s16 field_0x16; - /* 0x18 */ s16 field_0x18; - /* 0x1C */ f32 field_0x1C; - /* 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; -}; // Size: 0x4C - -class daAlinkHIO_roofHang_c0 { -public: - static daAlinkHIO_roofHang_c1 const m; -}; - -class daAlinkHIO_turnMove_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mTurnAnm; - /* 0x14 */ s16 mTurnSpeedRate; - /* 0x16 */ s16 mMaxTurnSpeed; - /* 0x18 */ s16 mMinTurnSpeed; - /* 0x1A */ s16 mMaxHalfTurnSpeed; - /* 0x1C */ f32 mHalfTurnAnmSpeed; - /* 0x20 */ f32 mTwirlCutDelayF; - /* 0x24 */ f32 mSideRollAnmSpeed; - /* 0x28 */ f32 mSideRollSpeed; -}; // Size: 0x2C - -class daAlinkHIO_turnMove_c0 { -public: - static daAlinkHIO_turnMove_c1 const m; -}; - -class daAlinkHIO_slide_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mForwardSlideAnm; - /* 0x14 */ daAlinkHIO_anm_c mBackwardSlideAnm; - /* 0x28 */ daAlinkHIO_anm_c mForwardLandAnm; - /* 0x3C */ daAlinkHIO_anm_c mBackwardLandAnm; - /* 0x50 */ f32 mMaxSpeed; - /* 0x54 */ f32 mAcceleration; - /* 0x58 */ f32 mSlideAngle; - /* 0x5C */ f32 mClimbAngle; - /* 0x60 */ f32 mClimbAnmMinSpeed; - /* 0x64 */ f32 mMaxClimbSpeed; - /* 0x68 */ f32 mLV2MinibossFloorSlideAngle; - /* 0x6C */ f32 mLV2MinibossFloorWeakSlideAngle; - /* 0x70 */ f32 mLV2MinibossFloorWeakSlideSpeed; - /* 0x74 */ f32 mMaxClimbAnmSpeed; -}; // Size: 0x78 - -class daAlinkHIO_slide_c0 { -public: - static daAlinkHIO_slide_c1 const m; -}; - -class daAlinkHIO_frontRoll_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mRollAnm; - /* 0x14 */ daAlinkHIO_anm_c mCrashAnm; - /* 0x28 */ daAlinkHIO_anm_c mCrashHitAnm; // ? - /* 0x3C */ s16 mCrashAngleThreshold; - /* 0x3E */ s16 mTurnRate; - /* 0x40 */ s16 mTurnMaxAngle; - /* 0x42 */ s16 mTurnMinAngle; - /* 0x44 */ f32 mInitSpeed; - /* 0x48 */ f32 mSpeedRate; - /* 0x4C */ f32 mMinSpeed; - /* 0x50 */ f32 mCrashSpeedThreshold; - /* 0x54 */ f32 mCrashInitF; - /* 0x58 */ f32 mCrashEndF; - /* 0x5C */ f32 mCrashSpeedH; - /* 0x60 */ f32 mCrashSpeedV; - /* 0x64 */ f32 mBootsAttackInitF; - /* 0x68 */ f32 mBootsAttackEndF; - /* 0x6C */ f32 mBootsAttackRadius; -}; // Size: 0x70 - -class daAlinkHIO_frontRoll_c0 { -public: - static daAlinkHIO_frontRoll_c1 const m; -}; - -class daAlinkHIO_swim_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mResurfaceAnm; - /* 0x14 */ daAlinkHIO_anm_c mDiveAnm; - /* 0x28 */ daAlinkHIO_anm_c mUnderwaterDiveAnm; - /* 0x3C */ daAlinkHIO_anm_c mDashAnm; - /* 0x50 */ s16 mTurnRate; - /* 0x52 */ s16 mTurnMin; - /* 0x54 */ s16 mTurnMax; - /* 0x56 */ s16 mUnderwaterTurnRate; - /* 0x58 */ s16 mUnderwaterTurnMin; - /* 0x5A */ s16 mUnderwaterTurnMax; - /* 0x5C */ s16 field_0x5c; // related to dash - /* 0x5E */ s16 field_0x5e; // related to dash - /* 0x60 */ f32 mInitHeight; - /* 0x64 */ f32 mResurfaceHeight; - /* 0x68 */ f32 mMaxForwardSpeed; - /* 0x6C */ f32 mMaxStrafeSpeed; - /* 0x70 */ f32 mMaxBackwardSpeed; - /* 0x74 */ f32 mMaxUnderwaterSpeed; - /* 0x78 */ f32 mUnderwaterMaxSinkSpeed; - /* 0x7C */ f32 mAcceleration; - /* 0x80 */ f32 mDeceleration; - /* 0x84 */ f32 mMaxSinkSpeed; - /* 0x88 */ f32 mMaxFloatUpSpeed; - /* 0x8C */ f32 mBuoyancy; // ? - /* 0x90 */ f32 mWaitAnmSpeed; - /* 0x94 */ f32 mWaitInterpolation; - /* 0x98 */ f32 mWaitVibrationIntensity; - /* 0x9C */ f32 mForwardMinAnmSpeed; - /* 0xA0 */ f32 mForwardMaxAnmSpeed; - /* 0xA4 */ f32 mStrafeMinAnmSpeed; - /* 0xA8 */ f32 mStrafeMaxAnmSpeed; - /* 0xAC */ f32 mBackwardMinAnmSpeed; - /* 0xB0 */ f32 mBackwardMaxAnmSpeed; - /* 0xB4 */ f32 mUnderwaterMinAnmSpeed; - /* 0xB8 */ f32 mUnderwaterMaxAnmSpeed; - /* 0xBC */ f32 mMoveInterpolation; - /* 0xC0 */ f32 mClimbHeight; - /* 0xC4 */ f32 mUnderwaterClimbHeight; - /* 0xC8 */ f32 mForwardMinSpeed; - /* 0xCC */ f32 mInitMaxSinkSpeed; - /* 0xD0 */ f32 mBootsMaxSinkSpeed; - /* 0xD4 */ f32 mNormalFloatDepth; - /* 0xD8 */ f32 mZoraFloatDepth; - /* 0xDC */ f32 mUnderwaterButtonSpeed; - /* 0xE0 */ f32 mUnderwaterButtonAnmSpeed; // ? - /* 0xE4 */ f32 mBootsGravity; - /* 0xE8 */ f32 mSurfaceSwimSpeedRate; - /* 0xEC */ f32 mDMaxSpeed; // ? - /* 0xF0 */ f32 mDDeceleration; - /* 0xF4 */ f32 mDMinAnmSpeed; - /* 0xF8 */ f32 mDMaxAnmSpeed; -}; // Size: 0xFC - -class daAlinkHIO_swim_c0 { -public: - static daAlinkHIO_swim_c1 const m; -}; - -class daAlinkHIO_ladder_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 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 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; -}; // Size: 0x70 - -class daAlinkHIO_ladder_c0 { -public: - static daAlinkHIO_ladder_c1 const m; -}; - -class daAlinkHIO_pushpull_c1 { -public: - /* 0x00 */ s16 field_0x0; - /* 0x02 */ s16 field_0x2; - /* 0x04 */ s16 field_0x4; - /* 0x06 */ s16 field_0x6; - /* 0x08 */ s16 field_0x8; - /* 0x0A */ s16 field_0xA; - /* 0x0C */ s16 field_0xC; - /* 0x0E */ s16 field_0xE; - /* 0x10 */ f32 field_0x10; - /* 0x14 */ f32 field_0x14; - /* 0x18 */ f32 field_0x18; - /* 0x1C */ f32 field_0x1C; - /* 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; -}; // Size: 0x3C - -class daAlinkHIO_pushpull_c0 { -public: - static daAlinkHIO_pushpull_c1 const m; -}; - -class daAlinkHIO_grab_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ daAlinkHIO_anm_c field_0x3C; - /* 0x50 */ daAlinkHIO_anm_c field_0x50; - /* 0x64 */ daAlinkHIO_anm_c field_0x64; - /* 0x78 */ daAlinkHIO_anm_c field_0x78; - /* 0x8C */ daAlinkHIO_anm_c field_0x8C; - /* 0xA0 */ daAlinkHIO_anm_c field_0xA0; - /* 0xB4 */ daAlinkHIO_anm_c field_0xB4; - /* 0xC8 */ daAlinkHIO_anm_c field_0xC8; - /* 0xDC */ s16 field_0xDC; - /* 0xDE */ s16 field_0xDE; - /* 0xE0 */ f32 field_0xE0; -}; // Size: 0xE4 - -class daAlinkHIO_grab_c0 { -public: - static daAlinkHIO_grab_c1 const m; -}; - -class daAlinkHIO_horse_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mWalkAnm; - /* 0x14 */ daAlinkHIO_anm_c mRunAnm; - /* 0x28 */ daAlinkHIO_anm_c mWhipAnm; - /* 0x3C */ daAlinkHIO_anm_c mWhipRunAnm; - /* 0x50 */ s16 mSwordUpTime; - /* 0x52 */ s16 mSearchRangeAngle; - /* 0x54 */ s16 mNoWalkTime; - /* 0x56 */ s16 mWhipWaitTime; - /* 0x58 */ s16 field_0x58; - /* 0x5A */ s16 field_0x5A; - /* 0x5C */ f32 mSwordUpAnmSpeed; - /* 0x60 */ f32 mSwordUpInterpolation; - /* 0x64 */ f32 mHorseWalkStartFrame; - /* 0x68 */ f32 mTiredWaitInterpolation; -}; // Size: 0x6C - -class daAlinkHIO_horse_c0 { -public: - static daAlinkHIO_horse_c1 const m; -}; - -class daAlinkHIO_canoe_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mLeftRightChangeAnm; - /* 0x14 */ s16 mMaxTurnAngle; - /* 0x16 */ s16 mMaxTurnAngle_RiverRide; - /* 0x18 */ f32 mStickRowAnmSpeed; - /* 0x1C */ f32 mBtnRowAnmSpeed; - /* 0x20 */ f32 mSpeedRate; - /* 0x24 */ f32 mMaxSpeed; - /* 0x28 */ f32 mDeceleration; - /* 0x2C */ f32 mStickRowStartAnmSpeed; - /* 0x30 */ f32 mBtnRowStartAnmSpeed; - /* 0x34 */ f32 mBackSpeedRate; - /* 0x38 */ f32 mBackMaxSpeed; - /* 0x3C */ f32 mMaxSpeed_RiverRide; - /* 0x40 */ f32 mSpeedRate_RiverRide; - /* 0x44 */ f32 mDeceleration_RiverRide; -}; // Size: 0x48 - -class daAlinkHIO_canoe_c0 { -public: - static daAlinkHIO_canoe_c1 const m; -}; - -class daAlinkHIO_damage_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mFloorDmgAnm; - /* 0x14 */ daAlinkHIO_anm_c mDashDmgAnm; - /* 0x28 */ u8 mInvincible; - /* 0x2A */ s16 mInvincibleTime; - /* 0x2C */ s16 mWolfFloorInvincibleTime; - /* 0x2E */ s16 mFreezeTime; - /* 0x30 */ s16 mFreezeInitR; - /* 0x32 */ s16 mFreezeInitG; - /* 0x34 */ s16 mFreezeInitB; - /* 0x36 */ s16 mDamageR0; - /* 0x38 */ s16 mDamageG0; - /* 0x3A */ s16 mDamageB0; - /* 0x3C */ s16 mDamageR1; - /* 0x3E */ s16 mDamageG1; - /* 0x40 */ s16 mDamageB1; - /* 0x42 */ s16 mDamageR2; - /* 0x44 */ s16 mDamageG2; - /* 0x46 */ s16 mDamageB2; - /* 0x48 */ s16 mFreezeR; - /* 0x4A */ s16 mFreezeG; - /* 0x4C */ s16 mFreezeB; - /* 0x50 */ f32 mRecoverStandAnmSpeed; - /* 0x54 */ f32 mInvertedFallInterpolation; -}; // Size: 0x58 - -class daAlinkHIO_damage_c0 { -public: - static daAlinkHIO_damage_c1 const m; -}; - -class daAlinkHIO_damNormal_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ daAlinkHIO_anm_c field_0x3C; - /* 0x50 */ s16 field_0x50; - /* 0x52 */ s16 field_0x52; - /* 0x54 */ f32 field_0x54; - /* 0x58 */ f32 field_0x58; - /* 0x5C */ f32 field_0x5C; - /* 0x60 */ f32 field_0x60; -}; // Size: 0x64 - -class daAlinkHIO_damNormal_c0 { -public: - static daAlinkHIO_damNormal_c1 const m; -}; - -class daAlinkHIO_damLaHu_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ daAlinkHIO_anm_c field_0x3C; - /* 0x50 */ daAlinkHIO_anm_c field_0x50; - /* 0x64 */ daAlinkHIO_anm_c field_0x64; - /* 0x78 */ daAlinkHIO_anm_c field_0x78; - /* 0x8C */ daAlinkHIO_anm_c field_0x8C; - /* 0xA0 */ s16 field_0xA0; - /* 0xA4 */ f32 field_0xA4; - /* 0xA8 */ f32 field_0xA8; - /* 0xAC */ f32 field_0xAC; - /* 0xB0 */ f32 field_0xB0; - /* 0xB4 */ f32 field_0xB4; - /* 0xB8 */ f32 field_0xB8; -}; - -class daAlinkHIO_damLarge_c0 { -public: - static daAlinkHIO_damLaHu_c1 const m; -}; - -class daAlinkHIO_damHuge_c0 { -public: - static daAlinkHIO_damLaHu_c1 const m; -}; - -class daAlinkHIO_damHorse_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ s16 field_0x28; - /* 0x2A */ s16 field_0x2A; -}; // Size: 0x2C - -class daAlinkHIO_damHorse_c0 { -public: - static daAlinkHIO_damHorse_c1 const m; -}; - -class daAlinkHIO_damFall_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mLandAnm; - /* 0x14 */ daAlinkHIO_anm_c mStandAnm; - /* 0x28 */ s16 mSmallStopTime; - /* 0x2A */ s16 mBigStopTime; - /* 0x2C */ f32 mMinRollHeight; - /* 0x30 */ f32 mMaxRollHeight; - /* 0x34 */ f32 mSmallDmgHeight; - /* 0x38 */ f32 mBigDmgHeight; - /* 0x3C */ f32 mSmallDmgLandStartFrame; - /* 0x40 */ f32 mFallAnmTransitionHeight; - /* 0x44 */ f32 mFallAnmMorf; -}; // Size: 0x48 - -class daAlinkHIO_damFall_c0 { -public: - static daAlinkHIO_damFall_c1 const m; -}; - -class daAlinkHIO_damCaught_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ s16 field_0x14; - /* 0x16 */ s16 field_0x16; - /* 0x18 */ f32 field_0x18; - /* 0x1C */ f32 field_0x1C; - /* 0x20 */ f32 field_0x20; -}; // Size: 0x24 - -class daAlinkHIO_damCaught_c0 { -public: - static daAlinkHIO_damCaught_c1 const m; -}; - -class daAlinkHIO_damSwim_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ daAlinkHIO_anm_c field_0x3C; - /* 0x50 */ daAlinkHIO_anm_c field_0x50; - /* 0x64 */ daAlinkHIO_anm_c field_0x64; - /* 0x78 */ s16 field_0x78; - /* 0x7A */ s16 field_0x7A; - /* 0x7C */ f32 field_0x7C; - /* 0x80 */ f32 field_0x80; - /* 0x84 */ f32 field_0x84; - /* 0x88 */ f32 field_0x88; -}; // Size: 0x8C - -class daAlinkHIO_damSwim_c0 { -public: - static daAlinkHIO_damSwim_c1 const m; -}; - -class daAlinkHIO_huLight_c1 { -public: - /* 0x00 */ u8 field_0x0; - /* 0x00 */ u8 field_0x1; - /* 0x02 */ s16 field_0x2; - /* 0x04 */ s16 field_0x4; - /* 0x06 */ s16 field_0x6; - /* 0x08 */ s16 field_0x8; - /* 0x0A */ s16 field_0xA; - /* 0x0C */ f32 field_0xC; - /* 0x10 */ f32 field_0x10; - /* 0x14 */ f32 field_0x14; - /* 0x18 */ f32 field_0x18; -}; // Size: 0x1C - -class daAlinkHIO_huLight_c0 { -public: - static daAlinkHIO_huLight_c1 const m; -}; - -class daAlinkHIO_fmChain_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; -}; // Size: 0x28 - -class daAlinkHIO_fmChain_c0 { -public: - static daAlinkHIO_fmChain_c1 const m; -}; - -class daAlinkHIO_pickUp_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ f32 field_0x28; - /* 0x2C */ f32 field_0x2C; -}; // Size: 0x30 - -class daAlinkHIO_pickUp_c0 { -public: - static daAlinkHIO_pickUp_c1 const m; -}; - -class daAlinkHIO_wolf_c1 { -public: - /* 0x00 */ s16 mMaxNeckTurnH; - /* 0x02 */ s16 mMaxNeckTurnUp; - /* 0x04 */ s16 mMaxNeckTurnDown; - /* 0x06 */ s16 mMaxTiredNeckTurnH; - /* 0x08 */ s16 mMaxTiredNeckTurnUp; - /* 0x0A */ s16 mMaxTiredNeckTurnDown; - /* 0x0C */ s16 mSensesLingerTime; // ? - /* 0x0E */ s16 mLightDropR; - /* 0x10 */ s16 mLightDropG; - /* 0x12 */ s16 mLightDropB; - /* 0x14 */ f32 mUnderwaterInputRate; -}; // Size: 0x18 - -class daAlinkHIO_wolf_c0 { -public: - static daAlinkHIO_wolf_c1 const m; -}; - -class daAlinkHIO_wlMove_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ daAlinkHIO_anm_c field_0x3C; - /* 0x50 */ s16 field_0x50; - /* 0x52 */ s16 field_0x52; - /* 0x54 */ s16 field_0x54; - /* 0x56 */ s16 field_0x56; - /* 0x58 */ s16 field_0x58; - /* 0x5A */ s16 field_0x5A; - /* 0x5C */ s16 field_0x5C; - /* 0x5E */ s16 field_0x5E; - /* 0x60 */ s16 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; - /* 0xB4 */ f32 field_0xB4; - /* 0xB8 */ f32 field_0xB8; - /* 0xBC */ f32 field_0xBC; - /* 0xC0 */ f32 field_0xC0; - /* 0xC4 */ f32 field_0xC4; - /* 0xC8 */ f32 field_0xC8; - /* 0xCC */ f32 field_0xCC; - /* 0xD0 */ f32 field_0xD0; - /* 0xD4 */ f32 field_0xD4; - /* 0xD8 */ f32 field_0xD8; - /* 0xDC */ f32 field_0xDC; - /* 0xE0 */ f32 field_0xE0; - /* 0xE4 */ f32 field_0xE4; - /* 0xE8 */ f32 field_0xE8; - /* 0xEC */ f32 field_0xEC; - /* 0xF0 */ f32 field_0xF0; - /* 0xF4 */ f32 field_0xF4; - /* 0xF8 */ f32 field_0xF8; - /* 0xFC */ f32 field_0xFC; -}; // Size: 0x100 - -class daAlinkHIO_wlMove_c0 { -public: - static daAlinkHIO_wlMove_c1 const m; -}; - -class daAlinkHIO_wlMoveNoP_c1 { -public: - /* 0x00 */ s16 field_0x0; - /* 0x02 */ s16 field_0x2; - /* 0x04 */ s16 field_0x4; - /* 0x08 */ f32 field_0x8; - /* 0x0C */ f32 field_0xC; - /* 0x10 */ f32 field_0x10; - /* 0x14 */ f32 field_0x14; - /* 0x18 */ f32 field_0x18; - /* 0x1C */ f32 field_0x1C; - /* 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; -}; // Size: 0x48 - -class daAlinkHIO_wlMoveNoP_c0 { -public: - static daAlinkHIO_wlMoveNoP_c1 const m; -}; - -class daAlinkHIO_wlAtnMove_c1 { -public: - /* 0x00 */ s16 field_0x0; - /* 0x02 */ s16 field_0x2; - /* 0x04 */ s16 field_0x4; - /* 0x08 */ f32 field_0x8; - /* 0x0C */ f32 field_0xC; - /* 0x10 */ f32 field_0x10; - /* 0x14 */ f32 field_0x14; - /* 0x18 */ f32 field_0x18; - /* 0x1C */ f32 field_0x1C; - /* 0x20 */ f32 field_0x20; - /* 0x24 */ f32 field_0x24; - /* 0x28 */ f32 field_0x28; - /* 0x2C */ f32 field_0x2C; - /* 0x30 */ f32 field_0x30; - /* 0x34 */ f32 field_0x34; -}; // Size: 0x38 - -class daAlinkHIO_wlAtnMove_c0 { -public: - static daAlinkHIO_wlAtnMove_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 daAlinkHIO_wlSlide_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ daAlinkHIO_anm_c field_0x3C; - /* 0x50 */ s16 field_0x50; - /* 0x52 */ s16 field_0x52; - /* 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_wlSlide_c0 { -public: - static daAlinkHIO_wlSlide_c1 const m; -}; - -class daAlinkHIO_wlSideStep_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ daAlinkHIO_anm_c field_0x3C; - /* 0x50 */ f32 field_0x50; - /* 0x54 */ f32 field_0x54; - /* 0x58 */ f32 field_0x58; - /* 0x5C */ f32 field_0x5C; - /* 0x60 */ f32 field_0x60; - /* 0x64 */ f32 field_0x64; -}; // Size: 0x68 - -class daAlinkHIO_wlSideStep_c0 { -public: - static daAlinkHIO_wlSideStep_c1 const m; -}; - -class daAlinkHIO_wlBackJump_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ f32 field_0x28; - /* 0x2C */ f32 field_0x2C; - /* 0x30 */ f32 field_0x30; - /* 0x34 */ f32 field_0x34; -}; // Size: 0x38 - -class daAlinkHIO_wlBackJump_c0 { -public: - static daAlinkHIO_wlBackJump_c1 const m; -}; - -class daAlinkHIO_wlRope_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ s16 field_0x14; - /* 0x16 */ s16 field_0x16; - /* 0x18 */ f32 field_0x18; - /* 0x1C */ f32 field_0x1C; - /* 0x20 */ f32 field_0x20; - /* 0x24 */ f32 field_0x24; - /* 0x28 */ f32 field_0x28; - /* 0x2C */ f32 field_0x2C; - /* 0x30 */ f32 field_0x30; - /* 0x34 */ f32 field_0x34; -}; // Size: 0x38 - -class daAlinkHIO_wlRope_c0 { -public: - static daAlinkHIO_wlRope_c1 const m; -}; - -class daAlinkHIO_wlPush_c1 { -public: - /* 0x00 */ f32 field_0x0; - /* 0x04 */ f32 field_0x4; - /* 0x08 */ f32 field_0x8; - /* 0x0C */ f32 field_0xC; - /* 0x10 */ f32 field_0x10; -}; // Size: 0x14 - -class daAlinkHIO_wlPush_c0 { -public: - static daAlinkHIO_wlPush_c1 const m; -}; - -class daAlinkHIO_wlPoint_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ daAlinkHIO_anm_c field_0x3C; - /* 0x50 */ daAlinkHIO_anm_c field_0x50; - /* 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_wlPoint_c0 { -public: - static daAlinkHIO_wlPoint_c1 const m; -}; - -class daAlinkHIO_wlWallHang_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ daAlinkHIO_anm_c field_0x3C; - /* 0x50 */ daAlinkHIO_anm_c field_0x50; - /* 0x64 */ daAlinkHIO_anm_c field_0x64; - /* 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; -}; // Size: 0x9C - -class daAlinkHIO_wlWallHang_c0 { -public: - static daAlinkHIO_wlWallHang_c1 const m; -}; - -class daAlinkHIO_wlSwim_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ s16 field_0x3C; - /* 0x3E */ s16 field_0x3E; - /* 0x40 */ s16 field_0x40; - /* 0x42 */ s16 field_0x42; - /* 0x44 */ s16 field_0x44; - /* 0x46 */ s16 field_0x46; - /* 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; - /* 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; -}; // Size: 0xA8 - -class daAlinkHIO_wlSwim_c0 { -public: - static daAlinkHIO_wlSwim_c1 const m; -}; - -class daAlinkHIO_wlAttack_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mLandAnm; - /* 0x14 */ s16 mUnkTime; - /* 0x16 */ s16 mComboDuration; - /* 0x18 */ f32 mFallHeight; - /* 0x1C */ f32 mFallInterpolation; - /* 0x20 */ f32 mReadyInterpolation; - /* 0x24 */ f32 mAttackRange; - /* 0x28 */ f32 mJumpBackSpeedH; - /* 0x2C */ f32 mJumpBackSpeedV; - /* 0x30 */ f32 mJumpAttackSpeedV; - /* 0x34 */ f32 mJumpAttackSpeedH; -}; // Size: 0x38 - -class daAlinkHIO_wlAttack_c0 { -public: - static daAlinkHIO_wlAttack_c1 const m; -}; - -class daAlinkHIO_wlAtBite_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ s16 field_0x28; - /* 0x2A */ s16 field_0x2A; - /* 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 field_0x50; - /* 0x54 */ f32 field_0x54; - /* 0x58 */ f32 field_0x58; -}; // Size: 0x5C - -class daAlinkHIO_wlAtBite_c0 { -public: - static daAlinkHIO_wlAtBite_c1 const m; -}; - -class daAlinkHIO_wlAtCjump_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 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 field_0x50; - /* 0x54 */ f32 field_0x54; - /* 0x58 */ f32 field_0x58; - /* 0x5C */ f32 field_0x5C; - /* 0x60 */ f32 field_0x60; -}; // Size: 0x64 - -class daAlinkHIO_wlAtCjump_c0 { -public: - static daAlinkHIO_wlAtCjump_c1 const m; -}; - -class daAlinkHIO_wlHowl_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ daAlinkHIO_anm_c field_0x3C; - /* 0x50 */ f32 field_0x50; - /* 0x54 */ f32 field_0x54; - /* 0x58 */ f32 field_0x58; - /* 0x5C */ f32 field_0x5C; -}; // Size: 0x60 - -class daAlinkHIO_wlHowl_c0 { -public: - static daAlinkHIO_wlHowl_c1 const m; -}; - -class daAlinkHIO_wlGrab_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ daAlinkHIO_anm_c field_0x3C; - /* 0x50 */ daAlinkHIO_anm_c field_0x50; -}; // Size: 0x64 - -class daAlinkHIO_wlGrab_c0 { -public: - static daAlinkHIO_wlGrab_c1 const m; -}; - -class daAlinkHIO_wlChain_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ s16 field_0x3C; - /* 0x3E */ s16 field_0x3E; - /* 0x40 */ f32 field_0x40; - /* 0x44 */ f32 field_0x44; - /* 0x48 */ f32 field_0x48; - /* 0x4C */ f32 field_0x4C; - /* 0x50 */ f32 field_0x50; - /* 0x54 */ f32 field_0x54; - /* 0x58 */ f32 field_0x58; -}; // Size: 0x5C - -class daAlinkHIO_wlChain_c0 { -public: - static daAlinkHIO_wlChain_c1 const m; -}; - -class daAlinkHIO_wlBall_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ s16 field_0x28; - /* 0x2C */ f32 field_0x2C; - /* 0x30 */ f32 field_0x30; - /* 0x34 */ f32 field_0x34; -}; // Size: 0x38 - -class daAlinkHIO_wlBall_c0 { -public: - static daAlinkHIO_wlBall_c1 const m; -}; - -class daAlinkHIO_wlLie_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ s16 field_0x28; - /* 0x2A */ s16 field_0x2A; - /* 0x2C */ s16 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; -}; // Size: 0x4C - -class daAlinkHIO_wlLie_c0 { -public: - static daAlinkHIO_wlLie_c1 const m; -}; - -class daAlinkHIO_wlLight_c1 { -public: - /* 0x00 */ s16 field_0x0; - /* 0x02 */ s16 field_0x2; - /* 0x04 */ s16 field_0x4; - /* 0x06 */ s16 field_0x6; - /* 0x08 */ s16 field_0x8; - /* 0x0A */ s16 field_0xA; - /* 0x0C */ f32 field_0xC; - /* 0x10 */ f32 field_0x10; - /* 0x14 */ f32 field_0x14; - /* 0x18 */ f32 field_0x18; -}; // Size: 0x1C - -class daAlinkHIO_wlLight_c0 { -public: - static daAlinkHIO_wlLight_c1 const m; -}; - -class daAlinkHIO_wlAtDown_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ daAlinkHIO_anm_c field_0x3C; - /* 0x50 */ daAlinkHIO_anm_c field_0x50; - /* 0x64 */ daAlinkHIO_anm_c field_0x64; - /* 0x78 */ daAlinkHIO_anm_c field_0x78; - /* 0x8C */ s16 field_0x8C; - /* 0x8E */ s16 field_0x8E; - /* 0x90 */ f32 field_0x90; - /* 0x94 */ f32 field_0x94; - /* 0x98 */ f32 field_0x98; -}; // Size: 0x9C - -class daAlinkHIO_wlAtDown_c0 { -public: - static daAlinkHIO_wlAtDown_c1 const m; -}; - -class daAlinkHIO_wlAtWait_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ s16 field_0x14; - /* 0x16 */ s16 field_0x16; - /* 0x18 */ f32 field_0x18; - /* 0x1C */ f32 field_0x1C; - /* 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; -}; - -class daAlinkHIO_wlAtWaTl_c0 { -public: - static daAlinkHIO_wlAtWait_c1 const m; -}; - -class daAlinkHIO_wlAtWaSc_c0 { -public: - static daAlinkHIO_wlAtWait_c1 const m; -}; - -class daAlinkHIO_wlAtWaLr_c0 { -public: - static daAlinkHIO_wlAtWait_c1 const m; -}; - -class daAlinkHIO_wlAtRoll_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ f32 field_0x14; - /* 0x18 */ f32 field_0x18; - /* 0x1C */ f32 field_0x1C; -}; // Size: 0x20 - -class daAlinkHIO_wlAtRoll_c0 { -public: - static daAlinkHIO_wlAtRoll_c1 const m; -}; - -class daAlinkHIO_wlAtNjump_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ f32 field_0x14; - /* 0x18 */ f32 field_0x18; - /* 0x1C */ f32 field_0x1C; - /* 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; -}; // Size: 0x3C - -class daAlinkHIO_wlAtNjump_c0 { -public: - static daAlinkHIO_wlAtNjump_c1 const m; -}; - -class daAlinkHIO_wlAtLock_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ f32 field_0x3C; - /* 0x40 */ f32 field_0x40; - /* 0x44 */ f32 field_0x44; - /* 0x48 */ f32 field_0x48; - /* 0x4C */ f32 field_0x4C; - /* 0x50 */ f32 field_0x50; -}; // Size: 0x54 - -class daAlinkHIO_wlAtLock_c0 { -public: - static daAlinkHIO_wlAtLock_c1 const m; -}; - -class daAlinkHIO_wlAtLand_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ f32 field_0x3C; -}; // Size: 0x40 - -class daAlinkHIO_wlAtLand_c0 { -public: - static daAlinkHIO_wlAtLand_c1 const m; -}; - -class daAlinkHIO_wlDamage_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ f32 field_0x28; -}; // Size: 0x2C - -class daAlinkHIO_wlDamage_c0 { -public: - static daAlinkHIO_wlDamage_c1 const m; -}; - -class daAlinkHIO_wlDamNormal_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ daAlinkHIO_anm_c field_0x3C; - /* 0x50 */ f32 field_0x50; - /* 0x54 */ f32 field_0x54; - /* 0x58 */ f32 field_0x58; - /* 0x5C */ f32 field_0x5C; -}; // Size: 0x60 - -class daAlinkHIO_wlDamNormal_c0 { -public: - static daAlinkHIO_wlDamNormal_c1 const m; -}; - -class daAlinkHIO_wlDamLaHu_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ daAlinkHIO_anm_c field_0x28; - /* 0x3C */ daAlinkHIO_anm_c field_0x3C; - /* 0x50 */ s16 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; -}; - -class daAlinkHIO_wlDamLarge_c0 { -public: - static daAlinkHIO_wlDamLaHu_c1 const m; -}; - -class daAlinkHIO_wlDamHuge_c0 { -public: - static daAlinkHIO_wlDamLaHu_c1 const m; -}; - -class daAlinkHIO_wlDamFall_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c field_0x0; - /* 0x14 */ daAlinkHIO_anm_c field_0x14; - /* 0x28 */ s16 field_0x28; - /* 0x2A */ s16 field_0x2A; - /* 0x2C */ f32 field_0x2C; - /* 0x30 */ f32 field_0x30; - /* 0x34 */ f32 field_0x34; - /* 0x38 */ f32 field_0x38; - /* 0x3C */ f32 field_0x3C; -}; // Size: 0x40 - -class daAlinkHIO_wlDamFall_c0 { -public: - static daAlinkHIO_wlDamFall_c1 const m; -}; - -class daAlinkHIO_wlDamCaught_c1 { -public: - /* 0x00 */ s16 field_0x0; - /* 0x02 */ s16 field_0x2; - /* 0x04 */ f32 field_0x4; - /* 0x08 */ f32 field_0x8; - /* 0x0C */ f32 field_0xC; -}; // Size: 0x10 - -class daAlinkHIO_wlDamCaught_c0 { -public: - static daAlinkHIO_wlDamCaught_c1 const m; -}; - -class daAlinkHIO_zwLight_c1 { // may be wrong -public: - /* 0x00 */ s16 field_0x0; - /* 0x02 */ s16 field_0x2; - /* 0x04 */ s16 field_0x4; - /* 0x06 */ s16 field_0x6; - /* 0x08 */ s16 field_0x8; - /* 0x0A */ s16 field_0xA; - /* 0x0C */ f32 field_0xC; - /* 0x10 */ f32 field_0x10; - /* 0x14 */ f32 field_0x14; - /* 0x18 */ f32 field_0x18; -}; // Size: 0x1C - -class daAlinkHIO_zwLight_c0 { -public: - static daAlinkHIO_zwLight_c1 const m; -}; - -class daAlinkHIO_board_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mJumpAnm; // might be wrong - /* 0x14 */ daAlinkHIO_anm_c mAirborneAnm; - /* 0x28 */ daAlinkHIO_anm_c mLandAnm; - /* 0x3C */ daAlinkHIO_anm_c mSpinAnm; - /* 0x50 */ f32 mMaxSpeed; - /* 0x54 */ f32 mPushAccel; - /* 0x58 */ f32 mMinJumpSpeedY; - /* 0x5C */ f32 mMaxJumpSpeedY; - /* 0x60 */ f32 mStandAnmSpeed; - /* 0x64 */ f32 mStandInterpolation; - /* 0x68 */ f32 mSitAnmSpeed; - /* 0x6C */ f32 mSitInterpolation; - /* 0x70 */ f32 mStartMinSpeed; - /* 0x74 */ f32 mStartAddSpeed; - /* 0x78 */ f32 mPushAnmMaxSpeed; - /* 0x7C */ f32 mFastPushSwitchSpeed; - /* 0x80 */ f32 mFastPushInterpolation; - /* 0x84 */ f32 mPushInterpolation; - /* 0x88 */ f32 mPushAnmMinSpeed; - /* 0x8C */ f32 mMaxPushSpeed; - /* 0x90 */ f32 mSpinMinJumpSpeedY; - /* 0x94 */ f32 mSpinMaxJumpSpeedY; - /* 0x98 */ f32 mEffectMaxSpeed; -}; // Size: 0x9C - -class daAlinkHIO_board_c0 { -public: - static daAlinkHIO_board_c1 const m; -}; - -class daAlinkHIO_item_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mOneHandEquipAnm; - /* 0x14 */ daAlinkHIO_anm_c mTwoHandEquipAnm; - /* 0x28 */ s16 mItemFPTransitionTimer; - /* 0x2A */ s16 mItemFPMaxUnk; - /* 0x2C */ s16 mItemFPUpMaxUnk; - /* 0x2E */ s16 mWiiItemFPDownMaxUnk; - /* 0x30 */ s16 mWiiItemFPUpMaxUnk; - /* 0x34 */ f32 mOneHandReleaseAnmSpeed; - /* 0x38 */ f32 mTwoHandReleaseAnmSpeed; -}; // Size: 0x3C - -class daAlinkHIO_item_c0 { -public: - static daAlinkHIO_item_c1 const m; -}; - -class daAlinkHIO_kandelaar_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mShakeAnm; - /* 0x14 */ daAlinkHIO_anm_c mBeginUnkAnm; - /* 0x28 */ daAlinkHIO_anm_c mEndUnkAnm; - /* 0x3C */ s16 mColorReg1R; - /* 0x3E */ s16 mColorReg1G; - /* 0x40 */ s16 mColorReg1B; - /* 0x42 */ s16 mColorReg2R; - /* 0x44 */ s16 mColorReg2G; - /* 0x46 */ s16 mColorReg2B; - /* 0x48 */ s16 mNormalOilLoss; - /* 0x4A */ s16 mShakeOilLoss; - /* 0x4C */ f32 mFlameTrackRate; -}; // Size: 0x50 - -class daAlinkHIO_kandelaar_c0 { -public: - static daAlinkHIO_kandelaar_c1 const m; -}; - -class daAlinkHIO_bottle_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mStartDrinkAnm; - /* 0x14 */ daAlinkHIO_anm_c mEndDrinkAnm; - /* 0x28 */ daAlinkHIO_anm_c mOpenBottleAnm; - /* 0x3C */ daAlinkHIO_anm_c mPourAnm; - /* 0x50 */ daAlinkHIO_anm_c mSwingDownAnm; - /* 0x64 */ daAlinkHIO_anm_c mSwingSideAnm; - /* 0x78 */ daAlinkHIO_anm_c mGetAnm; - /* 0x8C */ daAlinkHIO_anm_c mDrinkNastyAnm; - /* 0xA0 */ daAlinkHIO_anm_c mScoopAnm; -}; // Size: 0xB4 - -class daAlinkHIO_bottle_c0 { -public: - static daAlinkHIO_bottle_c1 const m; -}; - -class daAlinkHIO_boom_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mThrowAnm; - /* 0x14 */ daAlinkHIO_anm_c mCatchAnm; - /* 0x28 */ s16 mChargeTime; - /* 0x2A */ s16 mBgThroughTime; - /* 0x2C */ f32 mIdleAnmSpeed; - /* 0x30 */ f32 mStartInterpolation; - /* 0x34 */ f32 mFlySpeed; - /* 0x38 */ f32 mChargeFlySpeed; - /* 0x3C */ f32 mFlyDistMax; - /* 0x40 */ f32 mHorsebackFlyDistMax; - /* 0x44 */ f32 mLockDistMax; - /* 0x48 */ f32 mCatchSpeed; -}; // Size: 0x4C - -class daAlinkHIO_boom_c0 { -public: - static daAlinkHIO_boom_c1 const m; -}; - -class daAlinkHIO_bow_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mShootAnm; - /* 0x14 */ daAlinkHIO_anm_c mLoadAnm; - /* 0x28 */ s16 mChargeArrowTime; - /* 0x2A */ s16 mBombArrowHoldTime; - /* 0x2C */ s16 mBombArrowFlyExplodeTime; - /* 0x30 */ f32 mStartInterpolation; - /* 0x34 */ f32 mArrowSpeed; - /* 0x38 */ f32 mArrowDistance; - /* 0x3C */ f32 mChargeArrowSpeed; - /* 0x40 */ f32 mChargeArrowDistance; - /* 0x44 */ f32 mArrowAttackRadius; - /* 0x48 */ f32 mBombArrowSpeed; - /* 0x4C */ f32 mBombArrowDistance; - /* 0x50 */ f32 mChargeBombArrowSpeed; - /* 0x54 */ f32 mChargeBombArrowDistance; - /* 0x58 */ f32 mScopeArrowSpeed; - /* 0x5C */ f32 mScopeArrowDistance; - /* 0x60 */ f32 mArrowIncAttackMaxStart; - /* 0x64 */ f32 mArrowIncAttackMax; - /* 0x68 */ f32 mSlingshotSpeed; - /* 0x6C */ f32 mSlingshotDistance; -}; // Size: 0x70 - -class daAlinkHIO_bow_c0 { -public: - static daAlinkHIO_bow_c1 const m; -}; - -class daAlinkHIO_ironBall_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mCatchAnm; - /* 0x14 */ s16 mThrowChainNum; - /* 0x16 */ s16 mReturnChainRemoveNum; - /* 0x18 */ f32 mWaitAnmSpeed; - /* 0x1C */ f32 mPrepareAnmSpeed; - /* 0x20 */ f32 mPrepareInterpolation; - /* 0x24 */ f32 mTurnAnmSpeed; - /* 0x28 */ f32 mTurnInterpolation; - /* 0x2C */ f32 mPreThrowAnmSpeed; - /* 0x30 */ f32 mPreThrowAnmInterpolation; - /* 0x34 */ f32 mThrowAnmSpeed; - /* 0x38 */ f32 mThrowInterpolation; - /* 0x3C */ f32 mPullAnmSpeed; - /* 0x40 */ f32 mPullInterpolation; - /* 0x44 */ f32 mChainSpeedRate; - /* 0x48 */ f32 mChainGravity; - /* 0x4C */ f32 mReturnChainAccelY; - /* 0x50 */ f32 mReturnChainRate; - /* 0x54 */ f32 mThrowChainAccelZ; - /* 0x58 */ f32 mThrowChainAccelY; - /* 0x5C */ f32 mThrowChainGravity; - /* 0x60 */ f32 mBallGravity; - /* 0x64 */ f32 mThrowBallGravity; - /* 0x68 */ f32 mBallMaxFallSpeed; - /* 0x6C */ f32 field_0x6C; - /* 0x70 */ f32 mThrowSpeedZ; - /* 0x74 */ f32 mThrowSpeedY; - /* 0x78 */ f32 mReturnBallGravity; - /* 0x7C */ f32 mAttackRadius; - /* 0x80 */ f32 mFeetPosRatio; - /* 0x84 */ f32 mWalkAnmSpeedMax; - /* 0x88 */ f32 mWalkAnmSpeedMin; -}; // Size: 0x8C - -class daAlinkHIO_ironBall_c0 { -public: - static daAlinkHIO_ironBall_c1 const m; -}; - -class daAlinkHIO_copyRod_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mSwingAnm; - /* 0x14 */ daAlinkHIO_anm_c mBigSwingAnm; - /* 0x28 */ f32 mBallSpeed; - /* 0x2c */ f32 mBallMaxDistance; - /* 0x30 */ f32 mBallReturnSpeed; - /* 0x34 */ f32 mBossBallMaxDistance; -}; // Size: 0x38 - -class daAlinkHIO_copyRod_c0 { -public: - static daAlinkHIO_copyRod_c1 const m; -}; - -class daAlinkHIO_bomb_c1 { -public: - /* 0x00 */ s16 mExplodeTime; - /* 0x02 */ s16 mEnemyBombColorR; - /* 0x04 */ s16 mBombInsectLimitAngle; - /* 0x08 */ f32 mGravity; - /* 0x0C */ f32 mMaxFallSpeed; - /* 0x10 */ f32 mBoundRate; - /* 0x14 */ f32 mStopSpeedY; - /* 0x18 */ f32 mMaxSpeedY; - /* 0x1C */ f32 mEffScale; - /* 0x20 */ f32 mAttackRadius; - /* 0x24 */ f32 mPokeBombTrackRate; - /* 0x28 */ f32 mWaterGravity; - /* 0x2C */ f32 mWaterMaxFallSpeed; - /* 0x30 */ f32 mThrowSpeedH; - /* 0x34 */ f32 mThrowSpeedV; - /* 0x38 */ f32 mWaterThrowSpeedH; - /* 0x3C */ f32 mWaterThrowSpeedV; - /* 0x40 */ f32 mWolfThrowSpeedH; - /* 0x44 */ f32 mWolfThrowSpeedV; - /* 0x48 */ f32 mExplodeWaterEffectLimit; -}; // Size: 0x4C - -class daAlinkHIO_bomb_c0 { -public: - static daAlinkHIO_bomb_c1 const m; -}; - -class daAlinkHIO_magneBoots_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mEquipAnm; - /* 0x14 */ f32 mInputFactor; - /* 0x18 */ f32 mFeetPositionRatio; - /* 0x1C */ f32 mWalkAnmSpeedMax; - /* 0x20 */ f32 mWalkAnmSpeedMin; - /* 0x24 */ f32 mWaterInputFactor; - /* 0x28 */ f32 mWaterStartWalkAnmRate; - /* 0x2C */ f32 mWaterWalkAnmRate; - /* 0x30 */ f32 mMaxMagneFlySpeed; - /* 0x34 */ f32 mMagneFlyAccelRate; - /* 0x38 */ f32 mWaterVelocityY; - /* 0x3C */ f32 mWaterVelocityX; - /* 0x40 */ f32 mWaterVelRateSword; - /* 0x44 */ f32 mZoraWaterInputFactor; - /* 0x48 */ f32 mZoraWaterAnmSpeed; -}; // Size: 0x4C - -class daAlinkHIO_magneBoots_c0 { -public: - static daAlinkHIO_magneBoots_c1 const m; -}; - -class daAlinkHIO_spinner_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mKickAnm; - /* 0x14 */ s16 mRideMoveTime; - /* 0x16 */ s16 mBoardWaitTime; - /* 0x18 */ s16 mRideRotAngleMax; - /* 0x1A */ s16 mRideRotAngleMin; - /* 0x1C */ s16 mBossRideMoveTime; - /* 0x20 */ f32 mGravity; - /* 0x24 */ f32 mMaxFallSpeed; - /* 0x28 */ f32 mJumpRate; - /* 0x2C */ f32 mRideSpeed; - /* 0x30 */ f32 mDecelSpeedMax; - /* 0x34 */ f32 mDecelSpeedMin; - /* 0x38 */ f32 mDecelRate; - /* 0x3C */ f32 mBossRideSpeed; -}; // Size: 0x40 - -class daAlinkHIO_spinner_c0 { -public: - static daAlinkHIO_spinner_c1 const m; -}; - -class daAlinkHIO_hookshot_c1 { -public: - /* 0x00 */ daAlinkHIO_anm_c mShootAnm; - /* 0x14 */ daAlinkHIO_anm_c mRoofHangAnm; - /* 0x28 */ daAlinkHIO_anm_c mWallHangAnm; - /* 0x3C */ u8 mForceStick; - /* 0x40 */ f32 mWaitAnmSpeed; - /* 0x44 */ f32 mStartInterpolation; - /* 0x48 */ f32 mMaxLength; - /* 0x4C */ f32 mShootSpeed; - /* 0x50 */ f32 mReturnSpeed; - /* 0x54 */ f32 mStickReturnSpeed; - /* 0x58 */ f32 mRoofHangRiseSpeed; - /* 0x5C */ f32 mRoofHangDecendSpeed; - /* 0x60 */ f32 mBossMaxLength; - /* 0x64 */ f32 mBossShootSpeed; - /* 0x68 */ f32 mBossReturnSpeed; - /* 0x6C */ f32 mBossStickReturnSpeed; -}; // Size: 0x70 - -class daAlinkHIO_hookshot_c0 { -public: - static daAlinkHIO_hookshot_c1 const m; -}; - inline BOOL dComIfGs_isTransformLV(int i_no); inline BOOL dComIfGs_isEventBit(const u16); diff --git a/include/f_op/f_op_actor.h b/include/f_op/f_op_actor.h index f48ea19acf9..6a9e2a9bab3 100644 --- a/include/f_op/f_op_actor.h +++ b/include/f_op/f_op_actor.h @@ -310,7 +310,7 @@ public: /* 800196A0 */ void drawBallModel(dKy_tevstr_c*); bool checkWolfNoLock() const { return mFlags & fopEn_flag_WolfNoLock; } - bool checkHeadLockFlg() const { return mFlags & fopEn_flag_HeadLock; } + BOOL checkHeadLockFlg() const { return mFlags & fopEn_flag_HeadLock; } BOOL checkWolfBiteDamage() const { return mFlags & fopEn_flag_WolfBiteDamage; } bool checkWolfDownPullFlg() const { return mFlags & fopEn_flag_WolfDownPull; } bool checkDownFlg() { return mFlags & fopEn_flag_Down; } diff --git a/src/JSystem/JHostIO/JORServer.cpp b/src/JSystem/JHostIO/JORServer.cpp index 495d6b976ec..c724ba72e08 100644 --- a/src/JSystem/JHostIO/JORServer.cpp +++ b/src/JSystem/JHostIO/JORServer.cpp @@ -92,19 +92,19 @@ void JORReflexible::listenPropertyEvent(const JORPropertyEvent* pEvent) { case 'CMBX': if (pEvent->field_0x14 >= 4) { JORPropertyEvent* event = (JORPropertyEvent*)pEvent; - JORServer::defSetVal(event->id, event->kind, event->field_0x18.U32); + JORServer::defSetVal((void*)event->id, event->kind, event->field_0x18.U32); } break; case 'CHBX': if (pEvent->field_0x14 >= 4) { JORPropertyEvent* event = (JORPropertyEvent*)pEvent; - JORServer::defSetBitVal(event->id, event->kind, (u16)event->field_0x18.U16[0], (u16)event->field_0x18.U16[1]); + JORServer::defSetBitVal((void*)event->id, event->kind, (u16)event->field_0x18.U16[0], (u16)event->field_0x18.U16[1]); } break; case 'EDBX': JORPropertyEvent* event = (JORPropertyEvent*)pEvent; JSUMemoryInputStream stream(&event->field_0x18, event->field_0x14); - stream >> event->id; + stream >> (char*)event->id; break; } return; diff --git a/src/d/actor/d_a_alink.cpp b/src/d/actor/d_a_alink.cpp index 7b87f4e8431..bae31469122 100644 --- a/src/d/actor/d_a_alink.cpp +++ b/src/d/actor/d_a_alink.cpp @@ -54,6 +54,8 @@ BOOL daAlink_c::getE3Zhint() { return false; } +#include "d/actor/d_a_alink_HIO.inc" + /* 80452C50-80452C58 001250 0005+03 2/2 0/0 0/0 .sdata2 l_wArcName */ static const char l_wArcName[] = "Wmdl"; @@ -81,23 +83,6 @@ static const char l_sWShdArcName[] = "SWShd"; /* 80452C90-80452C98 001290 0006+02 7/7 0/0 0/0 .sdata2 l_arcName */ static const char l_arcName[] = "Alink"; -#if DEBUG -void daAlinkHIO_c::jumpStateUpdate(const cXyz* param_0, const cXyz* param_1, f32 param_2) { - char buf[68]; - - f32 xDiff = param_0->x - param_1->x; - f32 zDiff = param_0->z - param_1->z; - JORMContext* ctx = attachJORMContext(8); - ctx->startUpdateNode(this); - sprintf(buf, "水平距離 %-8.3f", JMAFastSqrt(xDiff * xDiff + zDiff * zDiff)); - ctx->updateLabel(2, 0x4000006, buf); - sprintf(buf, "最頂点 %-8.3f", param_2); - ctx->updateLabel(2, 0x4000007, buf); - ctx->endUpdateNode(); - releaseJORMContext(ctx); -} -#endif - /* 8009D884-8009D88C 0981C4 0008+00 0/0 0/0 13/13 .text getAlinkArcName__9daAlink_cFv */ const char* daAlink_c::getAlinkArcName() { return l_arcName; @@ -1797,7 +1782,17 @@ static dJntColData_c l_wolfJntColData[] = { #include "d/actor/d_a_alink_swindow.inc" -#include "d/actor/d_a_alink_HIO.inc" +/* 80140B88-80140B98 13B4C8 0010+00 1/1 0/0 0/0 .text __ct__12daAlinkHIO_cFv */ +daAlinkHIO_c::daAlinkHIO_c() {} + +/* 80140B98-80140BD4 13B4D8 003C+00 1/1 0/0 0/0 .text __dt__17daAlinkHIO_wolf_cFv */ +daAlinkHIO_wolf_c::~daAlinkHIO_wolf_c() {} + +/* 80140BD4-80140C10 13B514 003C+00 1/1 0/0 0/0 .text __dt__16daAlinkHIO_cut_cFv */ +daAlinkHIO_cut_c::~daAlinkHIO_cut_c() {} + +/* 80140C10-80140C80 13B550 0070+00 1/0 0/0 0/0 .text __dt__12daAlinkHIO_cFv */ +daAlinkHIO_c::~daAlinkHIO_c() {} /* 80450FC8-80450FCC -00001 0004+00 5/5 0/0 0/0 .sbss None */ /* 80450FC8 0001+00 data_80450FC8 None */ @@ -1927,8 +1922,8 @@ int daAlink_c::jointControll(int param_0) { csXyz sp18(0, 0, 0); int var_r27 = 0; - J3DTransformInfo sp80; - J3DTransformInfo sp60 = *field_0x2060->getOldFrameTransInfo(param_0); + J3DTransformInfo jointTrans; + J3DTransformInfo rootTrans = *field_0x2060->getOldFrameTransInfo(param_0); Quaternion sp50; Quaternion sp40; @@ -1962,7 +1957,7 @@ int daAlink_c::jointControll(int param_0) { sp18.set(field_0x3080, 0, field_0x3082); sp10.set(2, 1, 0); - sp80 = *field_0x2060->getOldFrameTransInfo(0); + jointTrans = *field_0x2060->getOldFrameTransInfo(0); var_r27 |= 2; } else if (param_0 == 3) { sp18.set((field_0x30d6 + field_0x30b2), 0, field_0x30b0); @@ -2022,12 +2017,12 @@ int daAlink_c::jointControll(int param_0) { sp18.set(field_0x3080, 0, field_0x3082); sp10.set(2, 0, 1); - sp80 = *field_0x2060->getOldFrameTransInfo(0); + jointTrans = *field_0x2060->getOldFrameTransInfo(0); var_r27 |= 2; if (field_0x2f99 == 0x60) { - sp80.mTranslate.x -= field_0x384c->x; - sp80.mTranslate.y -= field_0x384c->y; - sp80.mTranslate.z -= field_0x384c->z; + jointTrans.mTranslate.x -= field_0x384c->x; + jointTrans.mTranslate.y -= field_0x384c->y; + jointTrans.mTranslate.z -= field_0x384c->z; } } else if (param_0 == 0x1B) { setMatrixWorldAxisRot(mpLinkModel->getAnmMtx(param_0), mFootData1[0].field_0x6, 0, 0, 1, NULL); @@ -2100,7 +2095,7 @@ int daAlink_c::jointControll(int param_0) { J3DTransformInfo* var_r25; if ((var_r27 & 2)) { - var_r25 = &sp80; + var_r25 = &jointTrans; } else { var_r25 = field_0x2060->getOldFrameTransInfo(param_0); } @@ -2112,7 +2107,7 @@ int daAlink_c::jointControll(int param_0) { spC = field_0x2060->getOldFrameQuaternion(param_0); } - mDoMtx_stack_c::transS(sp60.mTranslate.x, sp60.mTranslate.y, sp60.mTranslate.z); + mDoMtx_stack_c::transS(rootTrans.mTranslate.x, rootTrans.mTranslate.y, rootTrans.mTranslate.z); mDoMtx_stack_c::quatM(&sp20); mDoMtx_stack_c::inverse(); cMtx_concat(temp_r26, mDoMtx_stack_c::get(), J3DSys::mCurrentMtx); @@ -2960,7 +2955,11 @@ s16 daAlink_c::getNeckAimAngle(cXyz* param_0, s16* param_1, s16* param_2, s16* p s16 sp18; s16 sp16 = field_0x2fe6 + mBodyAngle.y; if ((mProcID == PROC_GOAT_CATCH && mProcVar1.field_0x300a == 0) || (mProcID == PROC_HAND_PAT && mProcVar2.field_0x300c == 0)) { +#if VERSION == VERSION_SHIELD_DEBUG + sp16 += (s16)0x8000; +#else sp16 -= (s16)0x8000; +#endif } cXyz sp28 = eyePos - field_0x34e0; @@ -2996,25 +2995,25 @@ s16 daAlink_c::getNeckAimAngle(cXyz* param_0, s16* param_1, s16* param_2, s16* p var_r28 = cLib_minMaxLimit((s16)var_r28, -daAlinkHIO_wolf_c0::m.mMaxNeckTurnH, daAlinkHIO_wolf_c0::m.mMaxNeckTurnH); } } else { - temp_r24 = cLib_minMaxLimit((s16)temp_r24, daAlinkHIO_basic_c0::m.mNeckMaxUp, daAlinkHIO_basic_c0::m.mNeckMaxDown); + temp_r24 = cLib_minMaxLimit((s16)temp_r24, daAlinkHIO_basic_c0::m.mHeadMaxTurnUp, daAlinkHIO_basic_c0::m.mHeadMaxTurnDown); s16 spC; s16 spA; if (dComIfGp_checkPlayerStatus1(0, 0x02000000)) { if (field_0x3020 == 1) { spC = -0x1000; - spA = daAlinkHIO_basic_c0::m.mNeckMaxHorizontal; + spA = daAlinkHIO_basic_c0::m.mHeadMaxTurnHorizontal; } else { - spC = -daAlinkHIO_basic_c0::m.mNeckMaxHorizontal; + spC = -daAlinkHIO_basic_c0::m.mHeadMaxTurnHorizontal; spA = 0x1000; } } else { if (checkGrabAnimeCarry()) { spC = 0; } else { - spC = -daAlinkHIO_basic_c0::m.mNeckMaxHorizontal; + spC = -daAlinkHIO_basic_c0::m.mHeadMaxTurnHorizontal; } - spA = daAlinkHIO_basic_c0::m.mNeckMaxHorizontal; + spA = daAlinkHIO_basic_c0::m.mHeadMaxTurnHorizontal; } var_r28 = cLib_minMaxLimit((s16)var_r28, spC, spA); @@ -3285,7 +3284,7 @@ void daAlink_c::setMoveSlantAngle() { s16 var_r29; s16 var_r28; - if ((mProcID == PROC_MOVE && temp_f31 > daAlinkHIO_move_c0::m.mRunChangeRate) || (mProcID == PROC_WOLF_MOVE && temp_f31 > daAlinkHIO_wlMove_c0::m.field_0x84)) { + if ((mProcID == PROC_MOVE && temp_f31 > daAlinkHIO_move_c0::m.mRunChangeRate) || (mProcID == PROC_WOLF_MOVE && temp_f31 > daAlinkHIO_wlMove_c0::m.mIdleToWalkRate)) { var_r28 = cLib_minMaxLimit((s16)(field_0x2fe6 - shape_angle.y) * 2, -0xC00, 0xC00); if (abs(var_r28) > 0x800) { int var_r27; @@ -3300,7 +3299,7 @@ void daAlink_c::setMoveSlantAngle() { var_r29 = 0; } - if ((mProcID == PROC_WOLF_MOVE && checkAttentionState()) || temp_f31 < daAlinkHIO_wlMove_c0::m.field_0x8C) { + if ((mProcID == PROC_WOLF_MOVE && checkAttentionState()) || temp_f31 < daAlinkHIO_wlMove_c0::m.mStandbyRunToRunRate) { var_r28 = 0; } } else if ((mProcID == PROC_WOLF_WAIT || mProcID == PROC_WOLF_SWIM_MOVE) && shape_angle.y != field_0x2fe6) { @@ -4579,9 +4578,9 @@ int daAlink_c::setStartProcInit() { } else if (checkSwimAction(1)) { if (start_mode == 1) { if (checkWolf()) { - mNormalSpeed = 0.5f * daAlinkHIO_wlSwim_c0::m.field_0x50; + mNormalSpeed = 0.5f * daAlinkHIO_wlSwim_c0::m.mMaxSpeed; } else { - mNormalSpeed = 0.5f * daAlinkHIO_swim_c0::m.mMaxForwardSpeed; + mNormalSpeed = 0.5f * daAlinkHIO_swim_c0::m.mForwardMaxSpeed; } } @@ -4598,7 +4597,7 @@ int daAlink_c::setStartProcInit() { field_0x2f99 = 0; } else if (start_mode == 1) { if (checkWolf()) { - mNormalSpeed = daAlinkHIO_wlMove_c0::m.field_0x84 * daAlinkHIO_wlMove_c0::m.field_0x64; + mNormalSpeed = daAlinkHIO_wlMove_c0::m.mIdleToWalkRate * daAlinkHIO_wlMove_c0::m.mMaxSpeed; speedF = mNormalSpeed; procWolfMoveInit(); } else { @@ -4624,8 +4623,8 @@ int daAlink_c::setStartProcInit() { procCrawlMoveInit(0, 0); } } else if (checkWolf()) { - if (mNormalSpeed > daAlinkHIO_wlMove_c0::m.field_0x64) { - mNormalSpeed = daAlinkHIO_wlMove_c0::m.field_0x64; + if (mNormalSpeed > daAlinkHIO_wlMove_c0::m.mMaxSpeed) { + mNormalSpeed = daAlinkHIO_wlMove_c0::m.mMaxSpeed; } speedF = mNormalSpeed; procWolfMoveInit(); @@ -5131,12 +5130,12 @@ void daAlink_c::setPolygonSpeed() { f32 var_f29; if (temp_f27 < sp3C - 29.9f) { if (checkWolf()) { - var_f29 = daAlinkHIO_wlMoveNoP_c0::m.field_0x8; + var_f29 = daAlinkHIO_wlMoveNoP_c0::m.mMaxSpeed; } else { var_f29 = daAlinkHIO_move_c0::m.mMaxSpeed; } } else if (checkWolf()) { - var_f29 = daAlinkHIO_wlSlide_c0::m.field_0x70; + var_f29 = daAlinkHIO_wlSlide_c0::m.mClimbingMaxSpeedWeak; } else { var_f29 = daAlinkHIO_slide_c0::m.mMaxClimbSpeed; } @@ -6600,7 +6599,7 @@ void daAlink_c::setFrameCtrl(daPy_frameCtrl_c* i_ctrl, u8 i_attr, s16 i_start, s if (checkZoraWearAbility()) { i_rate *= daAlinkHIO_magneBoots_c0::m.mZoraWaterAnmSpeed; } else { - i_rate *= daAlinkHIO_magneBoots_c0::m.mWaterWalkAnmRate; + i_rate *= daAlinkHIO_magneBoots_c0::m.mWaterStartWalkAnmRate; } } @@ -6795,14 +6794,14 @@ int daAlink_c::setDoubleAnime(f32 i_blendRate, f32 i_anmSpeedA, f32 i_anmSpeedB, if (i_anmA == ANM_WAIT_B && checkModeFlg(1)) { i_morf = daAlinkHIO_move_c0::m.mWaitBInterpolation; } else { - i_morf = daAlinkHIO_basic_c0::m.mAnmBlendFactor; + i_morf = daAlinkHIO_basic_c0::m.mBasicInterpolation; } if (checkNoResetFlg0(FLG0_UNDERWATER)) { if (checkZoraWearAbility()) { i_morf *= (1.0f / daAlinkHIO_magneBoots_c0::m.mZoraWaterAnmSpeed); } else { - i_morf *= (1.0f / daAlinkHIO_magneBoots_c0::m.mWaterStartWalkAnmRate); + i_morf *= (1.0f / daAlinkHIO_magneBoots_c0::m.mWaterWalkAnmRate); } } } else if (i_anmA == ANM_WAIT_B && checkModeFlg(1) && i_morf > 0.0f) { @@ -6812,7 +6811,7 @@ int daAlink_c::setDoubleAnime(f32 i_blendRate, f32 i_anmSpeedA, f32 i_anmSpeedB, if (checkZoraWearAbility()) { i_morf *= (1.0f / daAlinkHIO_magneBoots_c0::m.mZoraWaterAnmSpeed); } else { - i_morf *= (1.0f / daAlinkHIO_magneBoots_c0::m.mWaterStartWalkAnmRate); + i_morf *= (1.0f / daAlinkHIO_magneBoots_c0::m.mWaterWalkAnmRate); } } } @@ -6881,7 +6880,7 @@ void daAlink_c::commonSingleAnime(J3DAnmTransform* param_0, J3DAnmTransform* par if (checkZoraWearAbility() && mProcID != PROC_FRONT_ROLL && mEquipItem == 0x103) { param_2 *= daAlinkHIO_magneBoots_c0::m.mWaterVelRateSword * (1.0f / daAlinkHIO_magneBoots_c0::m.mZoraWaterAnmSpeed); } else if (!checkZoraWearAbility()) { - param_2 *= daAlinkHIO_magneBoots_c0::m.mWaterStartWalkAnmRate * (1.0f / daAlinkHIO_magneBoots_c0::m.mWaterWalkAnmRate); + param_2 *= daAlinkHIO_magneBoots_c0::m.mWaterWalkAnmRate * (1.0f / daAlinkHIO_magneBoots_c0::m.mWaterStartWalkAnmRate); } } @@ -7101,7 +7100,7 @@ int daAlink_c::setUpperAnime(u16 i_anmResID, daAlink_c::daAlink_UPPER param_1, f } if (!checkZoraWearAbility() && (checkEquipAnime() || checkCutDashAnime()) && (checkNoResetFlg0(FLG0_UNDERWATER) || !checkNoResetFlg0(FLG0_SWIM_UP))) { - i_speed *= daAlinkHIO_magneBoots_c0::m.mWaterStartWalkAnmRate * (1.0f / daAlinkHIO_magneBoots_c0::m.mWaterWalkAnmRate); + i_speed *= daAlinkHIO_magneBoots_c0::m.mWaterWalkAnmRate * (1.0f / daAlinkHIO_magneBoots_c0::m.mWaterStartWalkAnmRate); } setFrameCtrl(&mUpperFrameCtrl[param_1], var_r30->getAttribute(), i_startFrame, i_endFrame, i_speed, var_f31); @@ -7462,7 +7461,7 @@ void daAlink_c::setBlendMoveAnime(f32 param_0) { var_f27 = 19.0f; } - var_f29 = daAlinkHIO_basic_c0::m.mWaitTurnSpeed; + var_f29 = daAlinkHIO_basic_c0::m.mRotationASpeed; var_f28 = 0.85f + (0.001f * abs(sp8)); if (var_f28 > 1.0f) { var_f28 = 1.0f; @@ -8542,12 +8541,12 @@ void daAlink_c::setFrontWallType() { if (checkWolf()) { if (checkModeFlg(2)) { - hang_height = daAlinkHIO_wlAutoJump_c0::m.field_0x78; + hang_height = daAlinkHIO_wlAutoJump_c0::m.mHangLimitHeight; } else { - hang_height = daAlinkHIO_wlWallHang_c0::m.field_0x84; + hang_height = daAlinkHIO_wlWallHang_c0::m.mClimbHeight; } - small_jump_height = daAlinkHIO_wlWallHang_c0::m.field_0x7C; - climb_height = daAlinkHIO_wlWallHang_c0::m.field_0x80; + small_jump_height = daAlinkHIO_wlWallHang_c0::m.mSmallJumpHeight; + climb_height = daAlinkHIO_wlWallHang_c0::m.mWallGrabHeight; } else { if (checkModeFlg(2)) { hang_height = daAlinkHIO_autoJump_c0::m.mHangHeightLimit; @@ -8630,11 +8629,11 @@ void daAlink_c::setFrontWallType() { f32 sp14; f32 sp10; if (checkWolf()) { - sp14 = 0.01f + daAlinkHIO_wlSwim_c0::m.field_0x7C; - sp10 = daAlinkHIO_wlSwim_c0::m.field_0x94; + sp14 = 0.01f + daAlinkHIO_wlSwim_c0::m.mClimbHeight; + sp10 = daAlinkHIO_wlSwim_c0::m.mClimbBelowWaterSurface; } else { sp14 = 0.01f + daAlinkHIO_swim_c0::m.mClimbHeight; - sp10 = daAlinkHIO_swim_c0::m.mUnderwaterClimbHeight; + sp10 = daAlinkHIO_swim_c0::m.mClimbWaterSurfaceUnder; } if (checkNoResetFlg0(FLG0_SWIM_UP)) { @@ -9616,9 +9615,9 @@ void daAlink_c::setNormalSpeedF(f32 i_incSpeed, f32 param_1) { if (checkNoResetFlg3(FLG3_UNK_1000)) { f32 sp18; if (checkWolf()) { - sp18 = daAlinkHIO_wlSwim_c0::m.field_0x48; + sp18 = daAlinkHIO_wlSwim_c0::m.mStartHeight; } else { - sp18 = daAlinkHIO_swim_c0::m.mInitHeight; + sp18 = daAlinkHIO_swim_c0::m.mStartHeight; } f32 sp14 = cLib_minMaxLimit((mWaterY - (30.0f + current.pos.y)) / (sp18 - 30.0f), 0.0f, 1.0f); @@ -10623,9 +10622,9 @@ BOOL daAlink_c::checkAutoJumpAction() { f32 sp10; if (checkWolf()) { if (checkWolfDashMode()) { - sp10 = daAlinkHIO_wlAutoJump_c0::m.field_0x44; + sp10 = daAlinkHIO_wlAutoJump_c0::m.mJumpLimitSpeed; } else { - sp10 = daAlinkHIO_wlAutoJump_c0::m.field_0x64; + sp10 = daAlinkHIO_wlAutoJump_c0::m.mWeakJumpLimitSpeed; } sp18 = 0.0f; } else { @@ -10701,7 +10700,7 @@ BOOL daAlink_c::checkAutoJumpAction() { } if (checkWolf()) { - return procWolfFallInit(1, daAlinkHIO_wlAutoJump_c0::m.field_0x54); + return procWolfFallInit(1, daAlinkHIO_wlAutoJump_c0::m.mNormalFallInterp); } else { return procFallInit(1, sp24); } @@ -11106,11 +11105,11 @@ BOOL daAlink_c::checkUpperItemAction() { field_0x30f6--; if (swordTrigger() || doTrigger()) { - field_0x30f6 -= daAlinkHIO_damCaught_c0::m.field_0x16; + field_0x30f6 -= daAlinkHIO_damCaught_c0::m.mInputFadeTime; } if (checkInputOnR() && abs((s16)(mStickAngle - mPrevStickAngle)) > 0x1000) { - field_0x30f6 -= daAlinkHIO_damCaught_c0::m.field_0x16; + field_0x30f6 -= daAlinkHIO_damCaught_c0::m.mInputFadeTime; } if (field_0x30f6 < 0 || !checkNoResetFlg0(FLG0_DK_CAUGHT)) { @@ -12507,15 +12506,15 @@ void daAlink_c::initGravity() { if (checkWolf()) { if (checkModeFlg(MODE_SWIMMING)) { if (checkHeavyStateOn(1, 1)) { - gravity = -daAlinkHIO_wlSwim_c0::m.field_0x9C; - max_fall_speed = daAlinkHIO_wlSwim_c0::m.field_0xA0; + gravity = -daAlinkHIO_wlSwim_c0::m.mHeavyBuoyancy; + max_fall_speed = daAlinkHIO_wlSwim_c0::m.mHeavyMaxFallSpeed; } else { - gravity = -daAlinkHIO_wlSwim_c0::m.field_0x60; - max_fall_speed = daAlinkHIO_wlSwim_c0::m.field_0x58; + gravity = -daAlinkHIO_wlSwim_c0::m.mBuoyancy; + max_fall_speed = daAlinkHIO_wlSwim_c0::m.mMaxFallSpeed; } } else { - gravity = daAlinkHIO_wlAutoJump_c0::m.field_0x58; - max_fall_speed = daAlinkHIO_wlAutoJump_c0::m.field_0x5c; + gravity = daAlinkHIO_wlAutoJump_c0::m.mGravity; + max_fall_speed = daAlinkHIO_wlAutoJump_c0::m.mMaxFallSpeed; } } else if (checkModeFlg(MODE_SWIMMING) || checkNoResetFlg0(FLG0_UNDERWATER)) { max_fall_speed = getSwimMaxFallSpeed(); @@ -12756,7 +12755,7 @@ void daAlink_c::posMove() { } if (getZoraSwim() && !checkZoraWearAbility()) { - speedF *= daAlinkHIO_swim_c0::m.mSurfaceSwimSpeedRate; + speedF *= daAlinkHIO_swim_c0::m.mFloatUpSwimSpeedRate; } f32 var_f31 = speedF; @@ -12807,7 +12806,7 @@ void daAlink_c::posMove() { } if (checkModeFlg(MODE_SWIMMING)) { - cLib_chasePos(&field_0x3750, cXyz::Zero, daAlinkHIO_damSwim_c0::m.field_0x84); + cLib_chasePos(&field_0x3750, cXyz::Zero, daAlinkHIO_damSwim_c0::m.mDeceleration); current.pos += field_0x3750; if (checkNoResetFlg0(FLG0_SWIM_UP) && mProcID != PROC_SWIM_DIVE) { @@ -12818,16 +12817,16 @@ void daAlink_c::posMove() { speed.y = 0.0f; } else if (checkWolf()) { if (checkHeavyStateOn(1, 1)) { - speed.y += daAlinkHIO_wlSwim_c0::m.field_0x9C; + speed.y += daAlinkHIO_wlSwim_c0::m.mHeavyBuoyancy; - if (speed.y > daAlinkHIO_wlSwim_c0::m.field_0xA4) { - speed.y = daAlinkHIO_wlSwim_c0::m.field_0xA4; + if (speed.y > daAlinkHIO_wlSwim_c0::m.mHeavyMaxSurfacingSpeed) { + speed.y = daAlinkHIO_wlSwim_c0::m.mHeavyMaxSurfacingSpeed; } } else { - speed.y += daAlinkHIO_wlSwim_c0::m.field_0x60; + speed.y += daAlinkHIO_wlSwim_c0::m.mBuoyancy; - if (speed.y > daAlinkHIO_wlSwim_c0::m.field_0x5C) { - speed.y = daAlinkHIO_wlSwim_c0::m.field_0x5C; + if (speed.y > daAlinkHIO_wlSwim_c0::m.mMaxSurfacingSpeed) { + speed.y = daAlinkHIO_wlSwim_c0::m.mMaxSurfacingSpeed; } } } else if (!checkEquipHeavyBoots() && getZoraSwim()) { @@ -12845,9 +12844,9 @@ void daAlink_c::posMove() { speed.y += 1.0f; } else { if (checkZoraWearAbility() && - mWaterY > current.pos.y + daAlinkHIO_swim_c0::m.mNormalFloatDepth) + mWaterY > current.pos.y + daAlinkHIO_swim_c0::m.mNormalBuoyancyWaterDepth) { - speed.y += daAlinkHIO_swim_c0::m.mZoraFloatDepth; + speed.y += daAlinkHIO_swim_c0::m.mZoraClothesBuoyancy; if (speed.y < 0.0f) { speed.y = 0.0f; @@ -13379,7 +13378,7 @@ BOOL daAlink_c::checkRestartRoom() { } } else if (mLinkAcch.ChkGroundHit() && field_0x2fbd == 2) { return procCoLavaReturnInit(1); - } else if ((checkModeFlg(0x40000) || (checkNoResetFlg0(FLG0_UNK_80) && mWaterY - current.pos.y > daAlinkHIO_swim_c0::m.mInitHeight)) && fopAcM_GetRoomNo(this) == 0 && checkStageName("F_SP114")) { + } else if ((checkModeFlg(0x40000) || (checkNoResetFlg0(FLG0_UNK_80) && mWaterY - current.pos.y > daAlinkHIO_swim_c0::m.mStartHeight)) && fopAcM_GetRoomNo(this) == 0 && checkStageName("F_SP114")) { return procCoSwimFreezeReturnInit(); } else if (!checkCargoCarry() && (field_0x3174 == 4 || field_0x3174 == 10 || (-G_CM3D_F_INF == mLinkAcch.GetGroundH() && !checkModeFlg(0x40000)))) { BOOL temp_r28 = mWaterY > mLinkAcch.GetGroundH(); @@ -13557,7 +13556,7 @@ int daAlink_c::checkSceneChange(int exitID) { exit_speed = 10.0f; demo_stick = 0.6f; } else { - exit_speed = daAlinkHIO_wlMoveNoP_c0::m.field_0x8; + exit_speed = daAlinkHIO_wlMoveNoP_c0::m.mMaxSpeed; demo_stick = 1.0f; } } else if (mNormalSpeed < 10.0f || var_r3) { @@ -13987,7 +13986,7 @@ BOOL daAlink_c::setItemActor() { setGrabItemActor(actor); dComIfGp_addSelectItemNum(mSelectItemId, -1); field_0x33e4 = 38.0f; - setGrabUpperAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setGrabUpperAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); } } mEquipItem = fpcNm_ITEM_NONE; @@ -14636,7 +14635,7 @@ void daAlink_c::setLight() { } } else { if (checkNoResetFlg1(FLG1_UNK_80)) { - var_f31 = light_m->field_0xC; + var_f31 = light_m->mPower; } else { var_f31 = 0.0f; } @@ -14654,19 +14653,19 @@ void daAlink_c::setLight() { var_f29 = 0.2f; } - cLib_chaseF(&field_0x33fc, var_f31, light_m->field_0xC * var_f29); + cLib_chaseF(&field_0x33fc, var_f31, light_m->mPower * var_f29); cXyz spB8; f32 var_f27; if (field_0x33fc > 0.0f) { GXColor spF0 = {0x00, 0x00, 0x00, 0xFF}; - spF0.r = light_m->field_0x4; - spF0.g = light_m->field_0x6; - spF0.b = light_m->field_0x8; + spF0.r = light_m->mColorR; + spF0.g = light_m->mColorG; + spF0.b = light_m->mColorB; Vec spC4 = {0.0f, 0.0f, 0.0f}; - spC4.y = light_m->field_0x14; - spC4.z = light_m->field_0x18; + spC4.y = light_m->mYOffset; + spC4.z = light_m->mZOffset; f32 var_f26; if ((uintptr_t)light_m == (uintptr_t)&daAlinkHIO_wlLight_c0::m) { @@ -14695,7 +14694,7 @@ void daAlink_c::setLight() { var_f26 = cM_sht2d(-shape_angle.y); } - dKy_WolfEyeLight_set(&spB8, var_f27 + light_m->field_0xA, var_f26, (light_m->field_0x10 * field_0x33fc) / light_m->field_0xC, &spF0, field_0x33fc, light_m->field_0x0, light_m->field_0x1); + dKy_WolfEyeLight_set(&spB8, var_f27 + light_m->mXAngle, var_f26, (light_m->mWidth * field_0x33fc) / light_m->mPower, &spF0, field_0x33fc, light_m->mAngleAttenuationType, light_m->mDistanceAttenuationType); } } @@ -15034,7 +15033,7 @@ void daAlink_c::commonProcInit(daAlink_c::daAlink_PROC i_procID) { if (((!checkEquipAnime() || !checkModeFlg(4)) && (!checkModeFlg(0x40000) || !checkWolfEnemyThrowAnime()) && !checkModeFlg(0x1000)) || (checkSwordTwirlAnime() && mProcID != PROC_ATN_ACTOR_WAIT && mProcID != PROC_ATN_ACTOR_MOVE) || (checkWolf() && checkFmChainGrabAnime() && checkModeFlg(0x40)) || checkNoResetFlg1(FLG1_UNK_10000000)) { if ((!checkDkCaught2Anime() || mProcID != PROC_DAMAGE) && !checkNoSetUpperAnime()) { - resetUpperAnime(UPPER_2, daAlinkHIO_basic_c0::m.mAnmBlendFactor); + resetUpperAnime(UPPER_2, daAlinkHIO_basic_c0::m.mBasicInterpolation); } if (checkBombItem(mEquipItem)) { @@ -15158,7 +15157,7 @@ BOOL daAlink_c::commonProcInitNotSameProc(daAlink_PROC procID) { int daAlink_c::procPreActionUnequipInit(int i_procAfter, fopAc_ac_c* param_1) { commonProcInit(PROC_PREACTION_UNEQUIP); mNormalSpeed = 0.0f; - setBlendMoveAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setBlendMoveAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); allUnequip(0); mProcVar4.field_0x3010 = 0; @@ -15335,7 +15334,7 @@ int daAlink_c::procWaitInit() { commonProcInit(PROC_WAIT); mNormalSpeed = 0.0f; - setBlendMoveAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setBlendMoveAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); current.angle.y = shape_angle.y; if (var_r30) { @@ -15399,7 +15398,7 @@ int daAlink_c::procMoveInit() { return 0; } - setBlendMoveAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setBlendMoveAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); setFootEffectProcType(3); return 1; } @@ -15417,8 +15416,8 @@ int daAlink_c::procMove() { setBlendMoveAnime(-1.0f); if (field_0x3174 != 8) { field_0x30a0 = - cLib_minMaxLimit((s16)(field_0x2ff0 >> 1), daAlinkHIO_basic_c0::m.mNeckMaxUp, - daAlinkHIO_basic_c0::m.mNeckMaxDown); + cLib_minMaxLimit((s16)(field_0x2ff0 >> 1), daAlinkHIO_basic_c0::m.mHeadMaxTurnUp, + daAlinkHIO_basic_c0::m.mHeadMaxTurnDown); } } @@ -15431,7 +15430,7 @@ int daAlink_c::procAtnMoveInit() { return 0; } - setBlendAtnMoveAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setBlendAtnMoveAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); return 1; } @@ -15463,9 +15462,9 @@ int daAlink_c::procAtnActorWaitInit() { } if (checkAtnWaitAnime()) { - setBlendAtnMoveAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setBlendAtnMoveAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); } else { - setBlendMoveAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setBlendMoveAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); } return 1; @@ -15492,7 +15491,7 @@ int daAlink_c::procAtnActorMoveInit() { return 0; } - setBlendAtnMoveAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setBlendAtnMoveAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); return 1; } @@ -15512,8 +15511,8 @@ int daAlink_c::procWaitTurnInit() { return 0; } - setSingleAnimeBaseSpeed(ANM_STEP_TURN, daAlinkHIO_basic_c0::m.mWaitTurnSpeed, - daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setSingleAnimeBaseSpeed(ANM_STEP_TURN, daAlinkHIO_basic_c0::m.mRotationASpeed, + daAlinkHIO_basic_c0::m.mBasicInterpolation); if (checkEventRun()) { mNormalSpeed = 0.0f; } @@ -15559,7 +15558,7 @@ int daAlink_c::procMoveTurnInit(int param_0) { return 0; } - setBlendMoveAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setBlendMoveAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); dComIfGp_setPlayerStatus0(0, 0x800); if (param_0 != 0) { @@ -15966,7 +15965,7 @@ int daAlink_c::procFrontRoll() { if (checkInputOnR()) { cLib_addCalcAngleS(¤t.angle.y, field_0x2fe2, daAlinkHIO_frontRoll_c0::m.mTurnRate, - daAlinkHIO_frontRoll_c0::m.mTurnMaxAngle, + daAlinkHIO_frontRoll_c0::m.mMaxTurnAngle, daAlinkHIO_frontRoll_c0::m.mTurnMinAngle); shape_angle.y = current.angle.y; } @@ -17199,7 +17198,7 @@ int daAlink_c::procCoMetamorphoseInit() { setSingleAnimeWolfBase(WANM_TRANSFORM_TO_HUMAN); field_0x3588 = l_wolfBaseAnime; field_0x347c = 0.5f; - field_0x3480 = daAlinkHIO_basic_c0::m.mWolfLinkTransformSpeed; + field_0x3480 = daAlinkHIO_basic_c0::m.mWolfToLinkCancelFrame; mProcVar2.field_0x300c = shape_angle.x; daMidna_c* midna = (daMidna_c*)getMidnaActor(); @@ -17217,7 +17216,7 @@ int daAlink_c::procCoMetamorphoseInit() { setSingleAnimeBase(ANM_TRANSFORM_TO_WOLF); setMetamorphoseModel(1); field_0x3588 = l_waitBaseAnime; - field_0x3480 = daAlinkHIO_basic_c0::m.mLinkWolfTransformSpeed; + field_0x3480 = daAlinkHIO_basic_c0::m.mLinkToWolfCancelFrame; cXyz pos(current.pos.x + (cM_ssin(shape_angle.y) * 100.0f), current.pos.y + 300.0f, current.pos.z + (cM_scos(shape_angle.y) * 100.0f)); @@ -17299,7 +17298,7 @@ int daAlink_c::procCoMetamorphose() { dComIfGp_evmng_cutEnd(mAlinkStaffId); if (checkWolf()) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMoveNoP_c0::m.field_0x14, -1.0f); + setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMoveNoP_c0::m.mIdleAnmSpeed, -1.0f); } else { setSingleAnimeBaseSpeed(ANM_WAIT, daAlinkHIO_move_c0::m.mWaitAnmSpeed, -1.0f); } @@ -17345,7 +17344,7 @@ int daAlink_c::procCoMetamorphose() { dComIfGp_evmng_cutEnd(mAlinkStaffId); if (checkWolf()) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMoveNoP_c0::m.field_0x14, -1.0f); + setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMoveNoP_c0::m.mIdleAnmSpeed, -1.0f); } else { setSingleAnimeBaseSpeed(ANM_WAIT, daAlinkHIO_move_c0::m.mWaitAnmSpeed, -1.0f); } @@ -17462,7 +17461,7 @@ int daAlink_c::procCoMetamorphoseOnly() { mProcVar3.field_0x300e = 1; if (checkWolf()) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMoveNoP_c0::m.field_0x14, + setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMoveNoP_c0::m.mIdleAnmSpeed, -1.0f); } else { setSingleAnimeBaseSpeed(ANM_WAIT, daAlinkHIO_move_c0::m.mWaitAnmSpeed, -1.0f); @@ -17513,7 +17512,7 @@ int daAlink_c::procGoronRideWaitInit(fopAc_ac_c* param_0) { current.pos.z = param_0->current.pos.z; field_0x2f99 = 0x50; current.angle.y = shape_angle.y; - setBlendMoveAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setBlendMoveAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); return 1; } @@ -17544,7 +17543,7 @@ int daAlink_c::procGoronRideWait() { var_f31 = 1.0f - var_f31; - setDoubleAnime(var_f31, daAlinkHIO_basic_c0::m.mWaitTurnSpeed, daAlinkHIO_move_c0::m.mWaitAnmSpeed, var_r28, ANM_WAIT, 2, -1.0f); + setDoubleAnime(var_f31, daAlinkHIO_basic_c0::m.mRotationASpeed, daAlinkHIO_move_c0::m.mWaitAnmSpeed, var_r28, ANM_WAIT, 2, -1.0f); current.angle.y = shape_angle.y; } @@ -17985,13 +17984,13 @@ int daAlink_c::execute() { if (mProcID == PROC_HOOKSHOT_FLY) { var_f31 = current.pos.y - (field_0x598 * 0.5f); } else if (dComIfGp_checkPlayerStatus1(0, 0x2000000)) { - var_f31 = (current.pos.y + -65.0f) - (daAlinkHIO_swim_c0::m.mInitHeight - 5.0f); + var_f31 = (current.pos.y + -65.0f) - (daAlinkHIO_swim_c0::m.mStartHeight - 5.0f); } else { var_f31 = current.pos.y; } if (!checkNoResetFlg0(FLG0_UNK_80) || - mWaterY - var_f31 <= daAlinkHIO_swim_c0::m.mInitHeight - 5.0f) + mWaterY - var_f31 <= daAlinkHIO_swim_c0::m.mStartHeight - 5.0f) { swimOutAfter(0); } diff --git a/src/d/actor/d_a_alink_HIO.inc b/src/d/actor/d_a_alink_HIO.inc index e3ba2796028..ab342891382 100644 --- a/src/d/actor/d_a_alink_HIO.inc +++ b/src/d/actor/d_a_alink_HIO.inc @@ -3,16 +3,5998 @@ * Player HostIO interface handling */ +#include "JSystem/JHostIO/JORFile.h" #include "d/actor/d_a_alink.h" +#include "d/d_com_inf_game.h" -/* 80140B88-80140B98 13B4C8 0010+00 1/1 0/0 0/0 .text __ct__12daAlinkHIO_cFv */ -daAlinkHIO_c::daAlinkHIO_c() {} +#ifdef DEBUG -/* 80140B98-80140BD4 13B4D8 003C+00 1/1 0/0 0/0 .text __dt__17daAlinkHIO_wolf_cFv */ -daAlinkHIO_wolf_c::~daAlinkHIO_wolf_c() {} +static void daAlinkHIO_setAnmGenMessage(daAlinkHIO_anm_c* i_anmP, JORMContext* ctx, char* param_3, + f32 param_4, int param_5) { + size_t sVar1; + char acStack_94[100]; -/* 80140BD4-80140C10 13B514 003C+00 1/1 0/0 0/0 .text __dt__16daAlinkHIO_cut_cFv */ -daAlinkHIO_cut_c::~daAlinkHIO_cut_c() {} + sVar1 = strlen(param_3); + sprintf(acStack_94, param_3); -/* 80140C10-80140C80 13B550 0070+00 1/0 0/0 0/0 .text __dt__12daAlinkHIO_cFv */ -daAlinkHIO_c::~daAlinkHIO_c() {} \ No newline at end of file + // A Speed + sprintf(acStack_94 + sVar1, "Ａ速度"); + ctx->genSlider(acStack_94, &i_anmP->mSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + + // Starting F + sprintf(acStack_94 + sVar1, "開始Ｆ"); + ctx->genSlider(acStack_94, &i_anmP->mStartFrame, 0.0f, param_4, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + + // Ending F + sprintf(acStack_94 + sVar1, "終了Ｆ"); + ctx->genSlider(acStack_94, &i_anmP->mEndFrame, 0, param_4, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + + if (param_5 != 0) { + sprintf(acStack_94 + sVar1, "ＣＦ"); + ctx->genSlider(acStack_94, &i_anmP->mCancelFrame, -1.0f, param_4 + 1.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + } + + // Interpolation + sprintf(acStack_94 + sVar1, "補間"); + ctx->genSlider(acStack_94, &i_anmP->mInterpolation, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +static void daAlinkHIO_setReverseAnmGenMessage(daAlinkHIO_anm_c* i_anmP, JORMContext* ctx, + char* param_3, f32 param_4, int param_5) { + size_t sVar1; + char acStack_94[100]; + + sVar1 = strlen(param_3); + sprintf(acStack_94, param_3); + + // A Speed + sprintf(acStack_94 + sVar1, "Ａ速度"); + ctx->genSlider(acStack_94, &i_anmP->mSpeed, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + + // Starting F + sprintf(acStack_94 + sVar1, "開始Ｆ"); + ctx->genSlider(acStack_94, &i_anmP->mEndFrame, 0, param_4, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + + // Ending F + sprintf(acStack_94 + sVar1, "終了Ｆ"); + ctx->genSlider(acStack_94, &i_anmP->mStartFrame, 0.0f, param_4, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + + if (param_5 != 0) { + sprintf(acStack_94 + sVar1, "ＣＦ"); + ctx->genSlider(acStack_94, &i_anmP->mCancelFrame, -1.0f, param_4 + 1.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + } + + // Interpolation + sprintf(acStack_94 + sVar1, "補間"); + ctx->genSlider(acStack_94, &i_anmP->mInterpolation, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +// NONMATCHING - regalloc + extra mr instruction +void daAlinkHIO_data_c::setStructData(char* param_1) { + u8* pfVar2; + u8* pfVar4; + + sprintf(param_1 + strlen(param_1), m_name_string); + pfVar2 = (u8*)mp_data; + + for (int i = 0; i < m_anm_num; i++) { + sprintf(param_1 + strlen(param_1), "\t{\n"); + pfVar4 = pfVar2; + + for (int i = 0; i < 2; i++) { + sprintf(param_1 + strlen(param_1), "\t\t%d,\n", *(s16*)pfVar4); + pfVar4 += 2; + } + + pfVar4 = pfVar2; + + for (int i = 0; i < 4; i++) { + sprintf(param_1 + strlen(param_1), "\t\t%ff,\n", *(f32*)pfVar4); + pfVar4 += 4; + } + + pfVar2 += 0x14; + sprintf(param_1 + strlen(param_1), "\t},\n"); + } + + pfVar4 = pfVar2; + + for (int i = 0; i < m_u8_num; i++) { + sprintf(param_1 + strlen(param_1), "\t%d,\n", *(u8*)pfVar2); + pfVar2++; + } + + for (int i = 0; i < m_s16_num; i++) { + sprintf(param_1 + strlen(param_1), "\t%d,\n", *(s16*)pfVar2); + pfVar2 += 2; + } + + for (int i = 0; i < m_f32_num; i++) { + sprintf(param_1 + strlen(param_1), "\t%ff,\n", *(f32*)pfVar2); + pfVar2 += 4; + } + + sprintf(param_1 + strlen(param_1), "};\n\n"); +} + +daAlinkHIO_data_c* l_HIO_before; +daAlinkHIO_data_c* l_HIO_top; + +void daAlinkHIO_data_c::checkDataSize() { + u32 dataSize = (m_u8_num + m_anm_num * 0x14) + (m_s16_num * 2) + (m_f32_num * 4); + JUT_ASSERT(188, dataSize == m_len); + + if (l_HIO_before != NULL) { + l_HIO_before->mpNext = this; + } else { + l_HIO_top = this; + } + + mpNext = NULL; + l_HIO_before = this; +} + +void daAlinkHIO_data_c::baseCopy() { + cLib_memCpy(mp_data, mp_src_data, m_len); +} + +// NONMATCHING +void daAlinkHIO_data_c::update() { + baseCopy(); + JORMContext* ctx = attachJORMContext(8); + ctx->startUpdateNode(this); + u8* local_20 = (u8*)mp_data; + + for (int i = 0; i < m_anm_num; i++) { + ctx->updateSlider(2, (s16*)local_20, 0, 0, 0); + + for (int j = 0; j < 4; local_20 += 4, j++) { + ctx->updateSlider(2, (f32*)local_20, 0.0f, 0.0f, 0); + } + } + + for (int i = 0; i < f14; i++) { + ctx->updateCheckBox(2, local_20, 1, 0); + } + + for (int i = 0; i < f18; i++) { + ctx->updateComboBox(2, local_20, 0); + // local_20++; + } + + for (int i = 0; i < (m_u8_num - f14 + f18); i++) { + // local_20++; + } + + int iVar1 = f1c; + int iVar3 = m_s16_num; + + for (int i = 0; i < iVar3 - iVar1; i++) { + ctx->updateSlider(2, (s16*)local_20, 0, 0, 0); + // local_20 += 2; + } + + for (int i = 0; i < f1c; i++) { + // local_20 += 2; + } + + for (int i = 0; i < m_f32_num; i++) { + ctx->updateSlider(2, (f32*)local_20, 0.0f, 0.0f, 0); + // local_20 += 4; + } + + ctx->endUpdateNode(); + releaseJORMContext(ctx); +} + +void daAlinkHIO_data_c::listenPropertyEvent(const JORPropertyEvent* event) { + JORReflexible::listenPropertyEvent(event); + + switch ((u32)event->id) + case 0x4000003: + update(); +} + +void daAlinkHIO_basic_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Basic Interpolation + ctx->genSlider("基本補間", &m.mBasicInterpolation, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Rotation A Speed + ctx->genSlider("旋回Ａ速度", &m.mRotationASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Max horizontal head turn + ctx->genSlider("首横向き最大", &m.mHeadMaxTurnHorizontal, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Max vertical head turn up + ctx->genSlider("首上向き最大", &m.mHeadMaxTurnUp, -0x7fff, 0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Max vertical head turn down + ctx->genSlider("首下向き最大", &m.mHeadMaxTurnDown, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Standing guard interpolation + ctx->genSlider("立ち防御補間", &m.mStandingGuardInterpolation, 0.0f, 50.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // One hit death + ctx->genCheckBox("一撃死", (u8*)(&m.mOneHitKill), 1, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Adult water effect height + ctx->genSlider("大人水面エフェクト高さ", &m.mWaterSurfaceEffectHeight, 0.0f, 100.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Wolf water effect height + ctx->genSlider("狼水面エフェクト高さ", &m.mWolfWaterSurfaceEffectHeight, 0.0f, 100.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Max wind influence distance + ctx->genSlider("風影響最大距離", &m.mMaxWindInfluenceDist, 0.0f, 1000.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // No wind influence distance + ctx->genSlider("風影響無し距離", &m.mNoWindInfluenceDist, 0.0f, 1000.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Max wind speed + ctx->genSlider("風最大速度", &m.mMaxWindSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Lava instant death depth + ctx->genSlider("溶岩即死深さ", &m.mLavaDeathDepth, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Link -> Wolf Cancel Frame + ctx->genSlider("リンク→狼ＣＦ", &m.mLinkToWolfCancelFrame, 0.0f, 35.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Wolf -> Link Cancel Frame + ctx->genSlider("狼→リンクＣＦ", &m.mWolfToLinkCancelFrame, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Room speed rate + ctx->genSlider("部屋速度率", &m.mIndoorSpeedFactor, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Hot spring heal time + ctx->genSlider("温泉回復時間", &m.mHotspringRecoverTime, 0, 0xff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Sand sinking speed + ctx->genSlider("砂沈み速度", &m.mSandSinkSpeed, 0.0f, 5.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Sand floating speed + ctx->genSlider("砂浮上速度", &m.mSandSurfaceSpeed, 0.0f, 5.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Wii perspective camera speed (horizontal) + ctx->genSlider("Wii主観カメラ速度横", &m.mWiiCamSpeedH, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Wii perspective camera speed (vertical) + ctx->genSlider("Wii主観カメラ速度縦", &m.mWiiCamSpeedV, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Transformation prohibit distance (near) + ctx->genSlider("変身禁止距離（近）", &m.mTransformBlockNearDis, 0.0f, 10000.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Transformation prohibit distance (far) + ctx->genSlider("変身禁止距離（遠）", &m.mTransformBlockFarDis, 0.0, 10000.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Transformation prohibit angle (far) + ctx->genSlider("変身禁止角度（遠）", &m.mTransformBlockFarAngle, 0, 0x7fff, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); +} + +daAlinkHIO_basic_c::daAlinkHIO_basic_c() { + const static char plabel[] = "const daAlinkHIO_basic_c1 daAlinkHIO_basic_c0::m = {\n"; + m_len = 88; + mp_src_data = (void*)&daAlinkHIO_basic_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 0; + m_u8_num = 2; + m_s16_num = 9; + m_f32_num = 17; + f14 = 1; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +daAlinkHIO_data_c::~daAlinkHIO_data_c() {} +daAlinkHIO_data_c::daAlinkHIO_data_c() {} + +void daAlinkHIO_move_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max speed + ctx->genSlider("最高速度", &m.mMaxSpeed, 0.0, 50.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Acceleration + ctx->genSlider("加速度", &m.mAcceleration, 0.0, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Wait A speed + ctx->genSlider("待機Ａ速度", &m.mWaitAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Walking A speed + ctx->genSlider("歩きＡ速度", &m.mWalkAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Running A speed + ctx->genSlider("走りＡ速度", &m.mRunAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Walking change rate + ctx->genSlider("歩き変更率", &m.mWalkChangeRate, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Running change rate + ctx->genSlider("走り変更率", &m.mRunChangeRate, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Walking minimum synthesis rate + ctx->genSlider("歩き最低合成率", &m.mMinWalkRate, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Tired walking minimum synthesis rate + ctx->genSlider("疲れ歩き最低合成率", &m.mMinTiredWalkRate, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Rotation angle max + ctx->genSlider("旋回角度最大", &m.mMaxTurnAngle, 0, 0x4000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Rotation angle min + ctx->genSlider("旋回角度最小", &m.mMinTurnAngle, 0, 0x4000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Rotation angle rate + ctx->genSlider("旋回角度率", &m.mTurnAngleRate, 0, 0x14, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Deceleration + ctx->genSlider("減速", &m.mDeceleration, 0.0, 20.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Slide + daAlinkHIO_setAnmGenMessage(&m.mSlideAnm, ctx, "滑り", 11.0f, 0); + // Slide start + ctx->genSlider("滑り開始", &m.mSlideThresholdSpeed, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Slide initial speed rate + ctx->genSlider("滑り初速率", &m.mSlideSpeed, 0.0, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Slide deceleration + ctx->genSlider("滑り減速", &m.mSlideDeceleration, 0.0, 20.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Foot propotional placement when walking + ctx->genSlider("歩き時足位置比率", &m.mFootPositionRatio, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Light stance interpolation + ctx->genSlider("軽く構え補間", &m.mWaitBInterpolation, 0.0, 10.0, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_move_c::daAlinkHIO_move_c() { + static const char plabel[] = "const daAlinkHIO_move_c1 daAlinkHIO_move_c0::m = {\n"; + m_len = 88; + mp_src_data = (void*)&daAlinkHIO_move_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 4; + m_f32_num = 15; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_atnMove_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max speed + ctx->genSlider("最高速度", &m.mMaxSpeed, 0.0, 50.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Acceleration + ctx->genSlider("加速度", &m.mAcceleration, 0.0, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Idle A speed + ctx->genSlider("待機Ａ速度", &m.mWaitAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Walking A speed + ctx->genSlider("歩きＡ速度", &m.mWalkAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Running A speed + ctx->genSlider("走りＡ速度", &m.mRunAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Walking update rate + ctx->genSlider("歩き変更率", &m.mWalkChangeRate, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Running update rate + ctx->genSlider("走り変更率", &m.mRunChangeRate, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Walking minimum synthesis rate + ctx->genSlider("歩き最低合成率", &m.mMinWalkFrame, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Forward walk A speed + ctx->genSlider("前歩きＡ速度", &m.mWalkForwardAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Forward run A speed + ctx->genSlider("前走りＡ速度", &m.mRunForwardAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Max rotation angle + ctx->genSlider("旋回角度最大", &m.mMaxTurnAngle, 0, 0x4000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Min rotation angle + ctx->genSlider("旋回角度最小", &m.mMinTurnAngle, 0, 0x4000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Rotation angle rate + ctx->genSlider("旋回角度率", &m.mTurnAngleRate, 0, 0x14, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Deceleration + ctx->genSlider("減速", &m.mDeceleration, 0.0, 20.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max speed backwards + ctx->genSlider("後方最高速度", &m.mMaxBackwardsSpeed, 0.0, 50.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Acceleration backwards + ctx->genSlider("後方加速度", &m.mBackAcceleration, 0.0, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Back walk A speed + ctx->genSlider("後歩Ａ速度", &m.mBackWalkAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Back run A speed + ctx->genSlider("後走Ａ速度", &m.mBackRunAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Back walk rate of change + ctx->genSlider("後歩変更率", &m.mBackWalkChangeRate, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Back run rate of change + ctx->genSlider("後走変更率", &m.mBackRunChangeRate, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Back walk minimum synthesis rate + ctx->genSlider("後歩最低合成率", &m.mMinBackWalkFrame, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Back walk deceleration + ctx->genSlider("後方減速", &m.mBackDeceleration, 0.0, 20.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_atnMove_c::daAlinkHIO_atnMove_c() { + static const char plabel[] = "const daAlinkHIO_atnMove_c1 daAlinkHIO_atnMove_c0::m = {\n"; + m_len = 84; + mp_src_data = (void*)&daAlinkHIO_atnMove_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 0; + m_u8_num = 0; + m_s16_num = 4; + m_f32_num = 19; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_noActAtnMove_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max speed + ctx->genSlider("最高速度", &m.mMaxSpeed, 0.0, 50.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Acceleration + ctx->genSlider("加速度", &m.mAcceleration, 0.0, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Wait A speed + ctx->genSlider("待機Ａ速度", &m.mWaitAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Walk A speed + ctx->genSlider("歩きＡ速度", &m.mWalkAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Run A speed + ctx->genSlider("走りＡ速度", &m.mRunAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Walk rate of change + ctx->genSlider("歩き変更率", &m.mWalkChangeRate, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Run rate of change + ctx->genSlider("走り変更率", &m.mRunChangeRate, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Walk minimum synthesis rate + ctx->genSlider("歩き最低合成率", &m.mMinWalkFrame, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Max rotation angle + ctx->genSlider("旋回角度最大", &m.mMaxTurnAngle, 0, 0x4000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Min rotation angle + ctx->genSlider("旋回角度最小", &m.mMinTurnAngle, 0, 0x4000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Rotation angle rate + ctx->genSlider("旋回角度率", &m.mTurnAngleRate, 0, 0x14, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Deceleration + ctx->genSlider("減速", &m.mDeceleration, 0.0, 20.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max backwards speed + ctx->genSlider("後方最高速度", &m.mMaxBackwardsSpeed, 0.0, 50.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Backwards acceleration + ctx->genSlider("後方加速度", &m.mBackAcceleration, 0.0, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Back walk A speed + ctx->genSlider("後歩Ａ速度", &m.mBackWalkAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Back run A speed + ctx->genSlider("後走Ａ速度", &m.mBackRunAnmSpeed, 0.01, 10.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Backwards walk rate of change + ctx->genSlider("後歩変更率", &m.mBackWalkChangeRate, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Backwards run rate of change + ctx->genSlider("後走変更率", &m.mBackRunChangeRate, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Minimum back walk synthesis rate + ctx->genSlider("後歩最低合成率", &m.mMinBackWalkFrame, 0.0, 1.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Backwards deceleration + ctx->genSlider("後方減速", &m.mBackDeceleration, 0.0, 20.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Minimum rotation A speed + ctx->genSlider("旋回Ａ速度最小", &m.mWalkForwardAnmSpeed, 0.0, 5.0, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Maximum backwards A speed + ctx->genSlider("後方Ａ速度最大", &m.mRunForwardAnmSpeed, 0.0, 5.0, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_noActAtnMove_c::daAlinkHIO_noActAtnMove_c() { + static const char plabel[] = + "const daAlinkHIO_noActAtnMove_c1 daAlinkHIO_noActAtnMove_c0::m = {\n"; + m_len = 84; + mp_src_data = (void*)&daAlinkHIO_noActAtnMove_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 0; + m_u8_num = 0; + m_s16_num = 4; + m_f32_num = 19; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_frontRoll_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Forward roll + daAlinkHIO_setAnmGenMessage(&m.mRollAnm, ctx, "前転", 29.0, 1); + // Initial speed + ctx->genSlider("初速", &m.mInitSpeed, 0.0, 50.0, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Speed rate of change + ctx->genSlider("速度率", &m.mSpeedRate, 0.0f, 5.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Minimum speed + ctx->genSlider("最低速度", &m.mMinSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Rotation rate + ctx->genSlider("旋回率", &m.mTurnRate, 0, 100, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max rotation angle + ctx->genSlider("旋回最大角度", &m.mMaxTurnAngle, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Min rotation angle + ctx->genSlider("旋回最小角度", &m.mTurnMinAngle, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Boots attack start F + ctx->genSlider("ブーツ攻撃開始Ｆ", &m.mBootsAttackInitF, 0.0f, 33.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Boots attack end F + ctx->genSlider("ブーツ攻撃終了Ｆ", &m.mBootsAttackEndF, 0.0f, 33.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Boots attack radius + ctx->genSlider("ブーツ攻撃半径", &m.mBootsAttackRadius, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Required impact speed + ctx->genSlider("衝突必要速度", &m.mCrashSpeedThreshold, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Required impact angle + ctx->genSlider("衝突必要角度", &m.mCrashAngleThreshold, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Impact allowed start F + ctx->genSlider("衝突許可開始Ｆ", &m.mCrashInitF, 0.0f, 29.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Impact allowed end F + ctx->genSlider("衝突許可終了Ｆ", &m.mCrashEndF, 0.0f, 29.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Impact + daAlinkHIO_setAnmGenMessage(&m.mCrashAnm, ctx, "衝突", 29.0f, 1); + // Impact horizontal speed + ctx->genSlider("衝突水平速度", &m.mCrashSpeedH, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Impact vertical speed + ctx->genSlider("衝突垂直速度", &m.mCrashSpeedV, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Impact success + daAlinkHIO_setAnmGenMessage(&m.mCrashHitAnm, ctx, "衝突成功", 33.0f, 1); +} + +daAlinkHIO_frontRoll_c::daAlinkHIO_frontRoll_c() { + static const char plabel[] = "const daAlinkHIO_frontRoll_c1 daAlinkHIO_frontRoll_c0::m = {\n"; + m_len = 112; + mp_src_data = (void*)&daAlinkHIO_frontRoll_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 3; + m_u8_num = 0; + m_s16_num = 4; + m_f32_num = 11; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_backJump_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Backflip + daAlinkHIO_setAnmGenMessage(&m.mBackflipAnm, ctx, "バク転", 9.0f, 0); + // Backflip horizontal speed + ctx->genSlider("バク転水平速度", &m.mBackflipSpeedH, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Backflip vertical speed + ctx->genSlider("バク転垂直速度", &m.mBackflipSpeedV, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Landing + daAlinkHIO_setAnmGenMessage(&m.mLandAnm, ctx, "着地", 17.0f, 1); + // Fall height + ctx->genSlider("落下高さ", &m.mFallHeight, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Fall interpolation + ctx->genSlider("落下補間", &m.mFallInterpolation, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_backJump_c::daAlinkHIO_backJump_c() { + static const char plabel[] = "const daAlinkHIO_backJump_c1 daAlinkHIO_backJump_c0::m = {\n"; + m_len = 56; + mp_src_data = (void*)&daAlinkHIO_backJump_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 4; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_sideStep_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Side step + daAlinkHIO_setAnmGenMessage(&m.mSideJumpAnm, ctx, "横飛", 5.0f, 0); + // Side step horizontal speed + ctx->genSlider("横飛水平速度", &m.mSideJumpSpeedH, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Side step vertical speed + ctx->genSlider("横飛垂直速度", &m.mSideJumpSpeedV, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Side landing + daAlinkHIO_setAnmGenMessage(&m.mSideLandAnm, ctx, "横着地", 9.0f, 1); + // Back step + daAlinkHIO_setAnmGenMessage(&m.mBackJumpAnm, ctx, "後飛", 6.0f, 0); + // Back step horizontal speed + ctx->genSlider("後飛水平速度", &m.mBackJumpSpeedH, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Back step vertical speed + ctx->genSlider("後飛垂直速度", &m.mBackJumpSpeedV, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Back landing + daAlinkHIO_setAnmGenMessage(&m.mBackLandAnm, ctx, "後着地", 9.0f, 1); + // Fall height + ctx->genSlider("落下高さ", &m.mFallHeight, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Fall interpolation + ctx->genSlider("落下補間", &m.mFallInterpolation, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_sideStep_c::daAlinkHIO_sideStep_c() { + static const char plabel[] = "const daAlinkHIO_sideStep_c1 daAlinkHIO_sideStep_c0::m = {\n"; + m_len = 104; + mp_src_data = (void*)&daAlinkHIO_sideStep_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 6; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_slide_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Slide angle + ctx->genSlider("滑り角度", &m.mSlideAngle, 0.0f, 90.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Slope climb angle + ctx->genSlider("登坂角度", &m.mClimbAngle, 0.0f, 90.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Slope climb A minimum speed + ctx->genSlider("登坂Ａ速度最小", &m.mClimbAnmMinSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Slope climb A max speed + ctx->genSlider("登坂Ａ速度最大", &m.mMaxClimbAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Slope climb max speed + ctx->genSlider("登坂最高速度", &m.mMaxClimbSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Forward slide + daAlinkHIO_setAnmGenMessage(&m.mForwardSlideAnm, ctx, "前滑り", 14.0f, 0); + // Back slide + daAlinkHIO_setAnmGenMessage(&m.mBackwardSlideAnm, ctx, "後滑り", 6.0f, 0); + // Max speed + ctx->genSlider("最大速度", &m.mMaxSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Acceleration + ctx->genSlider("加速度", &m.mAcceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Forward landing + daAlinkHIO_setAnmGenMessage(&m.mForwardLandAnm, ctx, "前着地", 15.0f, 1); + // Backward landing + daAlinkHIO_setAnmGenMessage(&m.mBackwardLandAnm, ctx, "後着地", 20.0f, 1); + // Lava floor slide angle + ctx->genSlider("溶岩床滑り角度", &m.mLV2MinibossFloorSlideAngle, 0.0f, 90.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Lava floor weak slide angle + ctx->genSlider("溶岩床弱滑り角度", &m.mLV2MinibossFloorWeakSlideAngle, 0.0f, 90.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Lava floor weak slide speed + ctx->genSlider("溶岩床弱滑り速度", &m.mLV2MinibossFloorWeakSlideSpeed, 0.0f, 100.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_slide_c::daAlinkHIO_slide_c() { + static const char plabel[] = "const daAlinkHIO_slide_c1 daAlinkHIO_slide_c0::m = {\n"; + m_len = 120; + mp_src_data = (void*)&daAlinkHIO_slide_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 10; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_cutNormal_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Cut + daAlinkHIO_setAnmGenMessage(&m.mCutAnm, ctx, "斬り", field_0x34, 1); + // Speed + ctx->genSlider("速度", &m.mSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Attack start F + ctx->genSlider("攻撃開始Ｆ", &m.mAttackStartFrame, 0.0f, field_0x34, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Attack end F + ctx->genSlider("攻撃終了Ｆ", &m.mAttackEndFrame, 0.0f, field_0x34, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_cutNormal_c::daAlinkHIO_cutNormal_c(int param_0, float param_1) { + field_0x34 = param_1; + + static void* baseP[5] = {(void*)&daAlinkHIO_cutNmV_c0::m, (void*)&daAlinkHIO_cutNmL_c0::m, + (void*)&daAlinkHIO_cutNmR_c0::m, (void*)&daAlinkHIO_cutNmSL_c0::m, + (void*)&daAlinkHIO_cutNmSR_c0::m}; + + static const char* plabel[] = {"const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmSL_c0::m = {\n", + "const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmV_c0::m = {\n", + "const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmL_c0::m = {\n", + "const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmSR_c0::m = {\n", + "const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmR_c0::m = {\n"}; + + m_len = 32; + mp_src_data = baseP[param_0]; + mp_data = (void*)&m; + m_name_string = plabel[param_0]; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 3; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_cutFinish_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Cut + daAlinkHIO_setAnmGenMessage(&m.mCutAnm, ctx, "斬り", field_0x34, 1); + // Speed + ctx->genSlider("速度", &m.mSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Attack start F + ctx->genSlider("攻撃開始Ｆ", &m.mAttackStartFrame, 0.0f, field_0x34, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Attack end F + ctx->genSlider("攻撃終了Ｆ", &m.mAttackEndFrame, 0.0f, field_0x34, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Stop time + ctx->genSlider("停止時間", &m.mStopTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Mid-combo start F + ctx->genSlider("コンボ中開始Ｆ", &m.mComboStartFrame, 0.0f, field_0x34 + 1.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Mid-combo CF + ctx->genSlider("コンボ中ＣＦ", &m.mComboCheckFrame, 0.0f, field_0x34 + 1.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Mid-combo stop time + ctx->genSlider("コンボ中停止時間", &m.mComboStopTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_cutFinish_c::daAlinkHIO_cutFinish_c(int param_0, float param_1) { + field_0x34 = param_1; + + static void* baseP[6] = {(void*)&daAlinkHIO_cutFnL_c0::m, (void*)&daAlinkHIO_cutFnV_c0::m, + (void*)&daAlinkHIO_cutFnS_c0::m, (void*)&daAlinkHIO_cutFnSl_c0::m, + (void*)&daAlinkHIO_cutFnSm_c0::m, (void*)&daAlinkHIO_cutFnR_c0::m}; + + static const char* plabel[] = { + "const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnL_c0::m = {\n", + "const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnV_c0::m = {\n", + "const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnS_c0::m = {\n", + "const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnSl_c0::m = {\n", + "const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnSm_c0::m = {\n", + "const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnR_c0::m = {\n", + }; + + m_len = 44; + mp_src_data = baseP[param_0]; + mp_data = (void*)&m; + m_name_string = plabel[param_0]; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 5; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_cutFnJU_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Cut + daAlinkHIO_setAnmGenMessage(&m.mCutAnm, ctx, "斬り", 19.0f, 0); + // Horizontal speed + ctx->genSlider("水平速度", &m.mSpeedH, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Vertical speed + ctx->genSlider("垂直速度", &m.mSpeedV, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Attack start F + ctx->genSlider("攻撃開始Ｆ", &m.mAttackStartFrame, 0.0f, 19.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack end F + ctx->genSlider("攻撃終了Ｆ", &m.mAttackEndFrame, 0.0f, 19.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Stop time + ctx->genSlider("停止時間", &m.mStopTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Mid-combo start F + ctx->genSlider("コンボ中開始Ｆ", &m.mComboStartFrame, 0.0f, 19.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Landing + daAlinkHIO_setAnmGenMessage(&m.mLandAnm, ctx, "着地", 17.0f, 1); + // Mid-combo CF + ctx->genSlider("コンボ中ＣＦ", &m.mComboCheckFrame, 0.0f, 18.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Mid-combo stop time + ctx->genSlider("コンボ中停止時間", &m.mComboStopTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Fall height + ctx->genSlider("落下高さ", &m.mFallHeight, 0.0f, 1000.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Fall interpolation + ctx->genSlider("落下補間", &m.mFallInterpolation, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack radius + ctx->genSlider("攻撃半径", &m.mAttackRadius, 0.0f, 200.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack offset + ctx->genSlider("攻撃オフセット", &m.mAttackOffset, 0.0f, 1000.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_cutFnJU_c::daAlinkHIO_cutFnJU_c() { + static const char plabel[] = "const daAlinkHIO_cutFnJU_c1 daAlinkHIO_cutFnJU_c0::m = {\n"; + m_len = 84; + mp_src_data = (void*)&daAlinkHIO_cutFnJU_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 10; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_cutDash_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Cut + daAlinkHIO_setAnmGenMessage(&m.mCutAnm, ctx, "斬り", field_0x34, 1); + // Attack start F + ctx->genSlider("攻撃開始Ｆ", &m.mAttackStartFrame, 0.0f, field_0x34, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Attack end F + ctx->genSlider("攻撃終了Ｆ", &m.mAttackEndFrame, 0.0f, field_0x34, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_cutDash_c::daAlinkHIO_cutDash_c(int param_0, float param_1) { + field_0x34 = param_1; + + static void* baseP[3] = { + (void*)&daAlinkHIO_cutDaL_c0::m, + (void*)&daAlinkHIO_cutDaR_c0::m, + (void*)&daAlinkHIO_cutDaCharge_c0::m, + }; + + static const char* plabel[] = { + "const daAlinkHIO_cutDash_c1 daAlinkHIO_cutDaL_c0::m = {\n", + "const daAlinkHIO_cutDash_c1 daAlinkHIO_cutDaR_c0::m = {\n", + "const daAlinkHIO_cutDash_c1 daAlinkHIO_cutDaCharge_c0::m = {\n", + }; + + m_len = 28; + mp_src_data = baseP[param_0]; + mp_data = (void*)&m; + m_name_string = plabel[param_0]; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 2; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_cutJump_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Cut + daAlinkHIO_setAnmGenMessage(&m.mCutAnm, ctx, "斬り", 17.0f, 0); + // Attack start F + ctx->genSlider("攻撃開始Ｆ", &m.mStartAttackFrame, 0.0f, 17.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack end F + ctx->genSlider("攻撃終了Ｆ", &m.mEndAttackFrame, 0.0f, 14.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Horizontal cut speed + ctx->genSlider("斬り水平速度", &m.mBaseJumpSpeedH, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Vertical cut speed + ctx->genSlider("斬り垂直速度", &m.mBaseJumpSpeedV, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Cut short horizontal speed + ctx->genSlider("斬り短い水平速度", &m.mAirJumpSpeedH, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Cut short vertical speed + ctx->genSlider("斬り短い垂直速度", &m.mAirJumpSpeedV, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Landing + daAlinkHIO_setAnmGenMessage(&m.mLandAnm, ctx, "着地", 29.0f, 1); + // Spin attack CF + ctx->genSlider("回転斬りＣＦ", &m.mJumpSpinDelay, 0.0f, 29.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_cutJump_c::daAlinkHIO_cutJump_c() { + static const char plabel[] = "const daAlinkHIO_cutJump_c1 daAlinkHIO_cutJump_c0::m = {\n"; + m_len = 68; + mp_src_data = (void*)&daAlinkHIO_cutJump_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 7; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_cutTurn_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Right spin + daAlinkHIO_setAnmGenMessage(&m.mRightTurnAnm, ctx, "右回り", 47.0f, 1); + // Right mid-combo start F + ctx->genSlider("右コンボ中開始Ｆ", &m.mRightComboStartFrame, 0.0f, 47.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Right spin input time start F + ctx->genSlider("右回転入力時開始Ｆ", &m.mRightTurnInputStartFrame, 0.0f, 47.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Right attack start F + ctx->genSlider("右攻撃開始Ｆ", &m.mRightAttackStartFrame, 0.0f, 47.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Right attack end F + ctx->genSlider("右攻撃終了Ｆ", &m.mRightAttackEndFrame, 0.0f, 47.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Left spin + daAlinkHIO_setAnmGenMessage(&m.mLeftTurnAnm, ctx, "左回り", 42.0f, 1); + // Left mid-combo start F + ctx->genSlider("左コンボ中開始Ｆ", &m.mLeftComboStartFrame, 0.0f, 42.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Left spin input time start F + ctx->genSlider("左回転入力時開始Ｆ", &m.mLeftTurnInputStartFrame, 0.0f, 42.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Left attack start F + ctx->genSlider("左攻撃開始Ｆ", &m.mLeftAttackStartFrame, 0.0f, 42.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Left attack end F + ctx->genSlider("左攻撃終了Ｆ", &m.mLeftAttackEndFrame, 0.0f, 42.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Stop time + ctx->genSlider("停止時間", &m.mStopTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Charge movement + daAlinkHIO_setAnmGenMessage(&m.mChargeAnm, ctx, "ため移行", 9.0f, 0); + // Forward/back movement A speed + ctx->genSlider("前後移動Ａ速度", &m.mMoveFBAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Forward/back movement interpolation + ctx->genSlider("前後移動補間", &m.mMoveFBInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Left/right movement A speed + ctx->genSlider("左右移動Ａ速度", &m.mMoveLRAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Left/right movement interpolation + ctx->genSlider("左右移動補間", &m.mMoveLRInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Max speed + ctx->genSlider("最高速度", &m.mMaxSpeed, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Charge movement acceleration + ctx->genSlider("ため移動加速", &m.mChargeMoveAccel, 0.0f, 5.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Charge movement deceleration + ctx->genSlider("ため移動減速", &m.mChargeMoveDecel, 0.0f, 5.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Speed + ctx->genSlider("速度", &m.mSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Attack radius + ctx->genSlider("攻撃半径", &m.mAttackRadius, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack radius speed increase + ctx->genSlider("攻撃半径増加速度", &m.mAttackRadiusAccel, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Light sword attack radius + ctx->genSlider("光攻撃半径", &m.mLightAttackRadius, 0.0f, 1000.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Light sword attack radius speed increase + ctx->genSlider("光攻撃半径増加速度", &m.mLightAttackRadiusAccel, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Big attack radius + ctx->genSlider("大攻撃半径", &m.mLargeAttackRadius, 0.0f, 1000.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Big attack radius speed increase + ctx->genSlider("大攻撃半径増加速度", &m.mLargeAttackAccel, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); +} + +daAlinkHIO_cutTurn_c::daAlinkHIO_cutTurn_c() { + static const char plabel[] = "const daAlinkHIO_cutTurn_c1 daAlinkHIO_cutTurn_c0::m = {\n"; + m_len = 152; + mp_src_data = (void*)&daAlinkHIO_cutTurn_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 3; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 22; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_hoCut_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Cut + daAlinkHIO_setAnmGenMessage(&m.mCutAnm, ctx, "斬り", field_0x34, 1); + // Post-cut interpolation + ctx->genSlider("斬り後補間", &m.mAfterCutMorf, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack start F + ctx->genSlider("攻撃開始Ｆ", &m.mAttackStartFrame, 0.0f, field_0x34, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Attack end F + ctx->genSlider("攻撃終了Ｆ", &m.mAttackEndFrame, 0.0f, field_0x34, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_hoCut_c::daAlinkHIO_hoCut_c(int param_0, float param_1) { + field_0x34 = param_1; + + static void* baseP[4] = { + (void*)&daAlinkHIO_hoCutLA_c0::m, + (void*)&daAlinkHIO_hoCutLB_c0::m, + (void*)&daAlinkHIO_hoCutRA_c0::m, + (void*)&daAlinkHIO_hoCutRB_c0::m, + }; + + static const char* plabel[] = { + "const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutLA_c0::m = {\n", + "const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutLB_c0::m = {\n", + "const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutRA_c0::m = {\n", + "const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutRB_c0::m = {\n", + }; + + m_len = 32; + mp_src_data = baseP[param_0]; + mp_data = (void*)&m; + m_name_string = plabel[param_0]; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 3; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_hoCutCharge_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Charge + daAlinkHIO_setAnmGenMessage(&m.mChargeAnm, ctx, "ため", 6.0f, 0); + // Cut + daAlinkHIO_setAnmGenMessage(&m.mCutAnm, ctx, "斬り", 21.0f, 0); + // Cut attack start F + ctx->genSlider("斬り攻撃開始Ｆ", &m.mCutAttackStartFrame, 0.0f, 21.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Cut attack end F + ctx->genSlider("斬り攻撃終了Ｆ", &m.mCutAttackEndFrame, 0.0f, 21.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Cut stop time + ctx->genSlider("斬り停止時間", &m.mCutStopTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Spin + daAlinkHIO_setAnmGenMessage(&m.mSpinAnm, ctx, "回転", 49.0f, 1); + // Spin attack start F + ctx->genSlider("回転攻撃開始Ｆ", &m.mSpinAttackStartFrame, 0.0f, 49.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Spin attack end F + ctx->genSlider("回転攻撃終了Ｆ", &m.mSpinAttackEndFrame, 0.0f, 49.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Spin attack radius + ctx->genSlider("回転攻撃半径", &m.mSpinAttackRadius, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Spin stop time + ctx->genSlider("回転停止時間", &m.mSpinStopTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_hoCutCharge_c::daAlinkHIO_hoCutCharge_c() { + static const char plabel[] = + "const daAlinkHIO_hoCutCharge_c1 daAlinkHIO_hoCutCharge_c0::m = {\n"; + m_len = 84; + mp_src_data = (void*)&daAlinkHIO_hoCutCharge_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 3; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 5; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_cutDown_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Vertical speed + ctx->genSlider("垂直速度", &m.mRecoverSpeedH, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Jump + daAlinkHIO_setAnmGenMessage(&m.mJumpAnm, ctx, "飛出", 8.0f, 0); + // Brace + daAlinkHIO_setAnmGenMessage(&m.mFallAnm, ctx, "構え", 15.0f, 0); + // Landing + daAlinkHIO_setAnmGenMessage(&m.mLandAnm, ctx, "着地", 16.0f, 0); + // Success stop time + ctx->genSlider("成功停止時間", &m.mSuccessStopTime, 0, 0x96, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Failure stop time + ctx->genSlider("失敗停止時間", &m.mFailStopTime, 0, 0x96, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Return horizontal speed + ctx->genSlider("戻り水平速度", &m.mRecoverSpeedV, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Return vertical speed + ctx->genSlider("戻り垂直速度", &m.mSpeedV, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Return + daAlinkHIO_setAnmGenMessage(&m.mRecoverAnm, ctx, "戻り", 9.0f, 0); + // Failure + daAlinkHIO_setAnmGenMessage(&m.mMissAnm, ctx, "失敗", 73.0f, 1); +} + +daAlinkHIO_cutDown_c::daAlinkHIO_cutDown_c() { + static const char plabel[] = "const daAlinkHIO_cutDown_c1 daAlinkHIO_cutDown_c0::m = {\n"; + m_len = 116; + mp_src_data = (void*)&daAlinkHIO_cutDown_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 5; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 3; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_cutHead_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Jump + daAlinkHIO_setAnmGenMessage(&m.mJumpAnm, ctx, "飛出", 8.0f, 0); + // Gravity + ctx->genSlider("重力", &m.mGravity, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max height + ctx->genSlider("最大高さ", &m.mMaxHeight, 0.0f, 1000.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max distance + ctx->genSlider("最大距離", &m.mMaxDistance, 0.0f, 1000.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Cut + daAlinkHIO_setAnmGenMessage(&m.mCutAnm, ctx, "斬り", 21.0f, 0); + // Attack start F + ctx->genSlider("攻撃開始Ｆ", &m.mAttackStartFrame, 0.0f, 21.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack end F + ctx->genSlider("攻撃終了Ｆ", &m.mAttackEndFrame, 0.0f, 21.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Sword length ratio + ctx->genSlider("剣長さ比率", &m.mSwordLength, 0.0f, 5.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Sword radius + ctx->genSlider("剣半径", &m.mSwordRadius, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Additional vertical speed + ctx->genSlider("追加垂直速度", &m.mAddSpeedV, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Additional horizontal speed + ctx->genSlider("追加水平速度", &m.mAddSpeedH, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Landing + daAlinkHIO_setAnmGenMessage(&m.mLandAnm, ctx, "着地", 21.0f, 1); +} + +daAlinkHIO_cutHead_c::daAlinkHIO_cutHead_c() { + static const char plabel[] = "const daAlinkHIO_cutHead_c1 daAlinkHIO_cutHead_c0::m = {\n"; + m_len = 96; + mp_src_data = (void*)&daAlinkHIO_cutHead_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 3; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 9; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_cutLargeJump_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Charge + daAlinkHIO_setAnmGenMessage(&m.mChargeAnm, ctx, "ため", 29.0f, 0); + // Jump forward + daAlinkHIO_setAnmGenMessage(&m.mChargeMoveAnm, ctx, "飛前", 6.0f, 0); + // Jump forward attack start F + ctx->genSlider("飛前攻撃開始Ｆ", &m.mJumpAttackStartFrame, 0.0f, 6.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Jump forward attack end F + ctx->genSlider("飛前攻撃終了Ｆ", &m.mJumpAttackEndFrame, 0.0f, 6.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Cut + daAlinkHIO_setAnmGenMessage(&m.mCutAnm, ctx, "斬り", 16.0f, 0); + // Cut attack start F + ctx->genSlider("斬り攻撃開始Ｆ", &m.mCutInitFrame, 0.0f, 16.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Cut horizontal speed + ctx->genSlider("斬り水平速度", &m.mCutSpeedH, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Cut vertical speed + ctx->genSlider("斬り垂直速度", &m.mCutSpeedV, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Landing + daAlinkHIO_setAnmGenMessage(&m.mLandAnm, ctx, "着地", 35.0f, 1); + // Spin attack CF + ctx->genSlider("回転斬りＣＦ", &m.mSpinSlashCheckFrame, 0.0f, 35.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Landing attack start F + ctx->genSlider("着地攻撃開始Ｆ", &m.mLandAttackInitFrame, 0.0f, 35.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Landing attack end F + ctx->genSlider("着地攻撃終了Ｆ", &m.mLandAttackEndFrame, 0.0f, 35.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Landing attack radius + ctx->genSlider("着地攻撃半径", &m.mLandAttackRadius, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_cutLargeJump_c::daAlinkHIO_cutLargeJump_c() { + static const char plabel[] = + "const daAlinkHIO_cutLargeJump_c1 daAlinkHIO_cutLargeJump_c0::m = {\n"; + m_len = 116; + mp_src_data = (void*)&daAlinkHIO_cutLargeJump_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 9; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_cut_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Vertical + ctx->genNode("縦", &mCutVertical, 0, 0); + // Left + ctx->genNode("左", &mCutLeft, 0, 0); + // Right + ctx->genNode("右", &mCutRight, 0, 0); + // Left stab + ctx->genNode("左突", &mCutLeftStab, 0, 0); + // Right stab + ctx->genNode("右突", &mCutRightStab, 0, 0); + // E left + ctx->genNode("Ｅ左", &mCutFinishLeft, 0, 0); + // E vertical + ctx->genNode("Ｅ縦", &mCutFinishVertical, 0, 0); + // E stab + ctx->genNode("Ｅ突", &mCutFinishStab, 0, 0); + // E sweep + ctx->genNode("Ｅ払", &mCutFinishSweep, 0, 0); + // E slash + ctx->genNode("Ｅ袈裟", &mCutFinishSlash, 0, 0); + // E right + ctx->genNode("Ｅ右", &mCutFinishRight, 0, 0); + // E J upper cut + ctx->genNode("ＥＪ斬上", &mCutFinishJumpUppercut, 0, 0); + // Jump + ctx->genNode("ジャンプ", &mCutJump, 0, 0); + // Spin + ctx->genNode("回転", &mCutTurn, 0, 0); + // Horse left A + ctx->genNode("馬上左Ａ", &mHorseCutLeftA, 0, 0); + // Horse left B + ctx->genNode("馬上左Ｂ", &mHorseCutLeftB, 0, 0); + // Horse right A + ctx->genNode("馬上右Ａ", &mHorseCutRightA, 0, 0); + // Horse right B + ctx->genNode("馬上右Ｂ", &mHorseCutRightB, 0, 0); + // Horse charge + ctx->genNode("馬上ため", &mHorseCutCharge, 0, 0); + // Run left + ctx->genNode("走り左", &mCutDashLeft, 0, 0); + // Run right + ctx->genNode("走り右", &mCutDashRight, 0, 0); + // Run charge + ctx->genNode("走りため", &mCutDashCharge, 0, 0); + // Ending Blow + ctx->genNode("ダウン下突き", &mCutDown, 0, 0); + // Helm Splitter + ctx->genNode("兜割", &mCutHead, 0, 0); + // Jump Strike + ctx->genNode("大ジャンプ", &mCutLargeJump, 0, 0); + // Equip + daAlinkHIO_setReverseAnmGenMessage(&m.mEquipAnm, ctx, "装備", 22.0f, 0); + // Cancel + daAlinkHIO_setAnmGenMessage(&m.mUnequipAnm, ctx, "解除", 22.0f, 0); + // Early cancel A speed + ctx->genSlider("早解除Ａ速度", &m.mFastUnequipAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Combo continue time + ctx->genSlider("コンボ持続時間", &m.mComboDuration, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Jump back + daAlinkHIO_setAnmGenMessage(&m.mRecoilAnm, ctx, "跳返", 45.0f, 1); + // Jump back speed + ctx->genSlider("跳返速度", &m.mRecoilSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Jump back deceleration + ctx->genSlider("跳返減速", &m.mRecoilDeceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Blur alpha + ctx->genSlider("ブラーアルファ", &m.mBlurAlpha, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Dash blur alpha + ctx->genSlider("ダッシュブラーアルファ", &m.mDashBlurAlpha, 0, 0xff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Special sword cancel A speed + ctx->genSlider("特殊剣解除Ａ速度", &m.mFlourishAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Special sword cancel finish A speed + ctx->genSlider("特殊剣解除終了Ａ速度", &m.mFlourishEndAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Special sword cancel CF + ctx->genSlider("特殊剣解除ＣＦ", &m.mFlourishControlStartFrame, 0.0f, 59.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Special sword cancel accept time + ctx->genSlider("特殊剣解除受付時間", &m.mFlourishTime, 0, 1000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Sword length ratio + ctx->genSlider("剣長さ比率", &m.mSwordLength, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Sword radius + ctx->genSlider("剣半径", &m.mSwordRadius, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Mounted sword length ratio + ctx->genSlider("馬上剣長さ比率", &m.mSwordLengthHorseback, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Mounted sword radius + ctx->genSlider("馬上剣半径", &m.mSwordRadiusHorseback, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Running sword length ratio + ctx->genSlider("走り剣長さ比率", &m.mRunCutLength, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Running sword radius + ctx->genSlider("走り剣半径", &m.mRunCutRadius, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Normal sword swing decision time + ctx->genSlider("通常剣振り判定時間", &m.mNormalSwingDuration, 0, 0x1e, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Force hit combo + ctx->genCheckBox("強制ヒットコンボ", (u8*)&m.mForceHitCombo, 1, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Mounted duel sword length ratio + ctx->genSlider("一騎打ち馬上剣長さ比率", &m.mSwordLengthHorsebackFight, 0.0f, 10.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Mounted duel sword radius + ctx->genSlider("一騎打ち馬上剣半径", &m.mSwordRadiusHorsebackFight, 0.0f, 100.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Mortal draw time + ctx->genSlider("居合時間", &m.mUnkTime, 0, 1000, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max body face up + ctx->genSlider("体上向き最大", &m.mUnkBodyUpwards, -0x7fff, 0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Max body face down + ctx->genSlider("体下向き最大", &m.mUnkBodyDownwards, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // OI stab + daAlinkHIO_setAnmGenMessage(&m.mStabAnm, ctx, "ＯＩ刺し", 47.0f, 1); + // Spin attack wait + ctx->genSlider("回転斬り待ち", &m.mSpinSlashWait, 0, 1000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_cut_c::daAlinkHIO_cut_c() + : mCutVertical(0, 27.0f), mCutLeft(1, 27.0f), mCutRight(2, 27.0f), mCutLeftStab(3, 31.0f), + mCutRightStab(4, 27.0f), mCutFinishLeft(0, 29.0f), mCutFinishVertical(1, 33.0f), + mCutFinishStab(2, 31.0f), mCutFinishSweep(3, 33.0f), mCutFinishSlash(4, 31.0f), + mCutFinishRight(5, 34.0f), mCutFinishJumpUppercut(), mCutJump(), mCutTurn(), + mHorseCutLeftA(0, 21.0f), mHorseCutLeftB(1, 24.0f), mHorseCutRightA(2, 24.0f), + mHorseCutRightB(3, 11.0f), mHorseCutCharge(), mCutDashLeft(0, 12.0f), mCutDashRight(1, 14.0f), + mCutDashCharge(2, 14.0f), mCutDown(), mCutHead(), mCutLargeJump() { + static const char plabel[] = "const daAlinkHIO_cut_c1 daAlinkHIO_cut_c0::m = {\n"; + m_len = 156; + mp_src_data = (void*)&daAlinkHIO_cut_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 2; + m_s16_num = 9; + m_f32_num = 14; + f14 = 1; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +daAlinkHIO_cutLargeJump_c::~daAlinkHIO_cutLargeJump_c() {} +daAlinkHIO_cutHead_c::~daAlinkHIO_cutHead_c() {} +daAlinkHIO_cutDown_c::~daAlinkHIO_cutDown_c() {} +daAlinkHIO_cutDash_c::~daAlinkHIO_cutDash_c() {} +daAlinkHIO_hoCutCharge_c::~daAlinkHIO_hoCutCharge_c() {} +daAlinkHIO_hoCut_c::~daAlinkHIO_hoCut_c() {} +daAlinkHIO_cutTurn_c::~daAlinkHIO_cutTurn_c() {} +daAlinkHIO_cutJump_c::~daAlinkHIO_cutJump_c() {} +daAlinkHIO_cutFnJU_c::~daAlinkHIO_cutFnJU_c() {} +daAlinkHIO_cutFinish_c::~daAlinkHIO_cutFinish_c() {} +daAlinkHIO_cutNormal_c::~daAlinkHIO_cutNormal_c() {} + +void daAlinkHIO_guardAttack_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Attack + daAlinkHIO_setAnmGenMessage(&m.mAttackAnm, ctx, "攻撃", field_0x34, 1); + // Slash check frame + ctx->genSlider("剣振りＣＦ", &m.mSlashCheckFrame, 0.0f, field_0x34, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Speed + ctx->genSlider("速度", &m.mSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Attack start F + ctx->genSlider("攻撃開始Ｆ", &m.mAttackStartFrame, 0.0f, field_0x34, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Attack end F + ctx->genSlider("攻撃終了Ｆ", &m.mAttackEndFrame, 0.0f, field_0x34, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_guardAttack_c::daAlinkHIO_guardAttack_c(int param_0, float param_1) { + field_0x34 = param_1; + + static void* baseP[2] = { + (void*)&daAlinkHIO_gAtPush_c0::m, + (void*)&daAlinkHIO_gAtKick_c0::m, + }; + + static const char* plabel[] = { + "const daAlinkHIO_guardAttack_c1 daAlinkHIO_gAtPush_c0::m = {\n", + "const daAlinkHIO_guardAttack_c1 daAlinkHIO_gAtKick_c0::m = {\n", + }; + + m_len = 36; + mp_src_data = baseP[param_0]; + mp_data = (void*)&m; + m_name_string = plabel[param_0]; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 4; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_turnMove_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // + daAlinkHIO_setAnmGenMessage((daAlinkHIO_anm_c*)(this + 0x34), ctx, "回込", 27.0, 1); + // + ctx->genSlider("半回転回込Ａ速度", (float*)(this + 0x50), 0.0, 10.0, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // + ctx->genSlider("斬上げＣＦ", (float*)(this + 0x54), 0.0, 28.0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // + ctx->genSlider("回転速度率", (short*)(this + 0x48), 0, 100, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // + ctx->genSlider("回転速度最大", (short*)(this + 0x4a), 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // + ctx->genSlider("回転速度最小", (short*)(this + 0x4c), 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // + ctx->genSlider("半回転速度最大", (short*)(this + 0x4e), 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // + ctx->genSlider("通常側転Ａ速度", (float*)(this + 0x58), 0.0, 10.0, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // + ctx->genSlider("通常側転速度", (float*)(this + 0x5c), 0.0, 100.0, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_turnMove_c::daAlinkHIO_turnMove_c() { + static const char plabel[] = "const daAlinkHIO_turnMove_c1 daAlinkHIO_turnMove_c0::m = {\n"; + m_len = 44; + mp_src_data = (void*)&daAlinkHIO_turnMove_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 4; + m_f32_num = 4; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_guard_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Shield + ctx->genNode("盾", &mGuardAttack1, 0, 0); + // Sidestep + ctx->genNode("回り込み", &mTurnMove, 0, 0); + // Crouch guard anm speed + ctx->genSlider("しゃがみ防御Ａ速度", &m.mCrouchGuardAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Crouch guard interpolation + ctx->genSlider("しゃがみ防御補間", &m.mCrouchGuardInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Guard hit + daAlinkHIO_setAnmGenMessage(&m.mGuardHitAnm, ctx, "防御ヒット", 11.0f, 0); + // Crouch guard hit + daAlinkHIO_setAnmGenMessage(&m.mCrouchGuardHitAnm, ctx, "しゃがみ防御ヒット", 11.0f, 0); + // Guard speed normal + ctx->genSlider("防御通常速度", &m.mGuardSpeedNormal, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Guard speed large + ctx->genSlider("防御大速度", &m.mGuardSpeedLarge, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Guard speed huge + ctx->genSlider("防御強大速度", &m.mGuardSpeedHuge, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Magne guard speed + ctx->genSlider("大マグネ速度", &m.mMagneGuardSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Magne heavy guard speed + ctx->genSlider("大マグネ重い速度", &m.mMagneHvyGuardSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Guard front-back body angle max + ctx->genSlider("防御前後体角度最大", &m.mGuardFBAngleMax, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Guard left-right body angle max + ctx->genSlider("防御左右体角度最大", &m.mGuardLRAngleMax, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Guard body interpolation + ctx->genSlider("防御体角度補間", &m.mGuardBodyInterpolation, 0, 0x1e, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Attack position offset + ctx->genSlider("攻撃位置オフセット", &m.mAttackPosOffset, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Attack radius + ctx->genSlider("攻撃半径", &m.mAttackRadius, 0.0f, 300.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Small guard front-back body angle max + ctx->genSlider("小防御前後体角度最大", &m.mSmallGuardFBAngleMax, 0, 0x7fff, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Small guard left-right body angle max + ctx->genSlider("小防御左右体角度最大", &m.mSmallGuardLRAngleMax, 0, 0x7fff, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Recoil + daAlinkHIO_setAnmGenMessage(&m.mRecoilAnm, ctx, "跳返", 19.0f, 1); + // Guard break + daAlinkHIO_setAnmGenMessage(&m.mGuardBreakAnm, ctx, "崩され", 35.0f, 1); +} + +daAlinkHIO_guard_c::daAlinkHIO_guard_c() + : mGuardAttack1(0, 17.0f), mGuardAttack2(1, 21.0f), mTurnMove() { + static const char plabel[] = "const daAlinkHIO_guard_c1 daAlinkHIO_guard_c0::m = {\n"; + m_len = 128; + mp_src_data = (void*)&daAlinkHIO_guard_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 6; + m_f32_num = 9; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +daAlinkHIO_turnMove_c::~daAlinkHIO_turnMove_c() {} +daAlinkHIO_guardAttack_c::~daAlinkHIO_guardAttack_c() {} + +void daAlinkHIO_crouch_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Crouch animation speed + ctx->genSlider("しゃがみＡ速度", &m.mCrouchAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Crouch interpolation + ctx->genSlider("しゃがみ補間", &m.mCrouchInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Stand interpolation + ctx->genSlider("立ち上がり補間", &m.mStandInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Crawl start + daAlinkHIO_setAnmGenMessage(&m.mCrawlStartAnm, ctx, "ほふく開始", 9.0f, 1); + // Crawl minimum animation speed + ctx->genSlider("ほふく最小Ａ速度", &m.mCrawlAnmSpeedMin, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Crawl maximum animation speed + ctx->genSlider("ほふく最大Ａ速度", &m.mCrawlAnmSpeedMax, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Crawl movement interpolation + ctx->genSlider("ほふく移動補間", &m.mCrawlInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Crawl movement rate + ctx->genSlider("ほふく移動率", &m.mCrawlMoveRate, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Crawl turn rate + ctx->genSlider("ほふく旋回率", &m.mCrawlTurnRate, 0, 100, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Crawl turn maximum + ctx->genSlider("ほふく旋回最大", &m.mCrawlTurnMax, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Crawl turn minimum + ctx->genSlider("ほふく旋回最小", &m.mCrawlTurnMin, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Crawl end + daAlinkHIO_setReverseAnmGenMessage(&m.mCrawlEndAnm, ctx, "ほふく終了", 9.0f, 1); +} + +daAlinkHIO_crouch_c::daAlinkHIO_crouch_c() { + static const char plabel[] = "const daAlinkHIO_crouch_c1 daAlinkHIO_crouch_c0::m = {\n"; + m_len = 76; + mp_src_data = (void*)&daAlinkHIO_crouch_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 4; + m_f32_num = 7; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_autoJump_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Gravity + ctx->genSlider("重力", &m.mGravity, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max fall speed + ctx->genSlider("最大落下速度", &m.mMaxFallSpeed, -300.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Jump + daAlinkHIO_setAnmGenMessage(&m.mJumpAnm, ctx, "ジャンプ", 6.0f, 0); + // Jump speed limit + ctx->genSlider("ジャンプ限度速度", &m.mJumpSpeedLimit, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Min jump speed + ctx->genSlider("ジャンプ最低速度", &m.mMinJumpSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Max jump speed + ctx->genSlider("ジャンプ最高速度", &m.mMaxJumpSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Jump speed rate + ctx->genSlider("ジャンプ速度率", &m.mJumpSpeedRate, 0.0f, 5.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Jump angle + ctx->genSlider("ジャンプ角度", &m.mJumpAngle, 0, 0x4000, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Airborne interpolation + ctx->genSlider("滞空補間", &m.mAirborneInterpolation, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Jump fall interpolation + ctx->genSlider("ジャンプ落下補間", &m.mJumpFallInterpolation, 0.0f, 50.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Always max speed jump + ctx->genCheckBox("必ず最高速度ジャンプ", (u8*)&m.mAlwaysMaxSpeedJump, 1, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Land + daAlinkHIO_setAnmGenMessage(&m.mLandAnm, ctx, "着地", 7.0f, 1); + // Fall interpolation + ctx->genSlider("通常落下補間", &m.mFallInterpolation, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Spin jump interpolation + ctx->genSlider("回転ジャンプ補間", &m.mSpinJumpInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Spin jump rotate speed + ctx->genSlider("回転ジャンプ回転速度", &m.mSpinJumpRotateSpeed, 0, 0x7fff, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Spin jump fall interpolation + ctx->genSlider("回転ジャンプ落下補間", &m.mSpinJumpFallInterpolation, 0.0f, 20.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Spin jump land stop time + ctx->genSlider("回転ジャンプ着地停止時間", &m.mSpinJumpLandStopTime, 0, 100, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Spin jump add speed + ctx->genSlider("回転ジャンプ追加速度", &m.mSpinJumpAddSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Spin jump accel + ctx->genSlider("回転ジャンプ加速度", &m.mSpinJumpAccel, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Hang height limit + ctx->genSlider("ぶら下がり限界高さ", &m.mHangHeightLimit, 0.0f, 1000.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Grab height limit + ctx->genSlider("掴まり限界高さ", &m.mGrabHeightLimit, 0.0f, 1000.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Ooccoo jump max speed + ctx->genSlider("天空人滑空ジャンプ最高速度", &m.mOoccooJumpMaxSpeed, 0.0f, 50.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Dive + daAlinkHIO_setAnmGenMessage(&m.mDiveAnm, ctx, "飛込", 4.0f, 0); + // Dive connect + daAlinkHIO_setAnmGenMessage(&m.mDiveConnectAnm, ctx, "飛込繋", 10.0f, 0); + // Dive horizontal speed + ctx->genSlider("飛込水平速度", &m.mDiveSpeedH, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Dive vertical speed + ctx->genSlider("飛込垂直速度", &m.mDiveSpeedV, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Dive gravity + ctx->genSlider("飛込重力", &m.mDiveGravity, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Cucco jump max speed + ctx->genSlider("コッコジャンプ最高速度", &m.mCuccoJumpMaxSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Cucco jump angle + ctx->genSlider("コッコジャンプ角度", &m.mCuccoJumpAngle, 0, 0x4000, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Cucco max fall speed + ctx->genSlider("コッコ最大落下速度", &m.mCuccoFallMaxSpeed, -300.0f, 0.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Cucco start speed + ctx->genSlider("コッコ初速", &m.mCuccoStartSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_autoJump_c::daAlinkHIO_autoJump_c() { + static const char plabel[] = "const daAlinkHIO_autoJump_c1 daAlinkHIO_autoJump_c0::m = {\n"; + m_len = 180; + mp_src_data = (void*)&daAlinkHIO_autoJump_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 2; + m_s16_num = 5; + m_f32_num = 22; + f14 = 1; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_smallJump_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Small jump + daAlinkHIO_setAnmGenMessage(&m.mSmallJumpAnm, ctx, "小ジャンプ", 8.0f, 0); + // Horizontal speed + ctx->genSlider("水平速度", &m.mSpeedH, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Target height offset + ctx->genSlider("目標高さオフセット", &m.mTargetHeightOffset, 0.0f, 200.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Fall interpolation + ctx->genSlider("落下補間", &m.mFallInterpolation, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Step climb + daAlinkHIO_setAnmGenMessage(&m.mStepClimbAnm, ctx, "段差登", 5.0f, 0); + // Step land + daAlinkHIO_setAnmGenMessage(&m.mStepLandAnm, ctx, "段差着地", 29.0f, 1); +} + +daAlinkHIO_smallJump_c::daAlinkHIO_smallJump_c() { + static const char plabel[] = "const daAlinkHIO_smallJump_c1 daAlinkHIO_smallJump_c0::m = {\n"; + m_len = 72; + mp_src_data = (void*)&daAlinkHIO_smallJump_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 3; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 3; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wallCatch_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Grab A + daAlinkHIO_setAnmGenMessage(&m.mGrabAAnm, ctx, "掴みＡ", 19.0f, 1); + // Grab B + daAlinkHIO_setAnmGenMessage(&m.mGrabBAnm, ctx, "掴みＢ", 7.0f, 0); + // Climb + daAlinkHIO_setAnmGenMessage(&m.mClimbAnm, ctx, "よじ登り", 29.0f, 1); + // Climb midway start F + ctx->genSlider("よじ登り途中開始Ｆ", &m.mClimbStartFrame, 0.0f, 29.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Jump + daAlinkHIO_setAnmGenMessage(&m.mJumpAnm, ctx, "ジャンプ", 13.0f, 0); +} + +daAlinkHIO_wallCatch_c::daAlinkHIO_wallCatch_c() { + static const char plabel[] = "const daAlinkHIO_wallCatch_c1 daAlinkHIO_wallCatch_c0::m = {\n"; + m_len = 84; + mp_src_data = (void*)&daAlinkHIO_wallCatch_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 1; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wallFall_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // One hand grab + daAlinkHIO_setAnmGenMessage(&m.mOneHandGrabAnm, ctx, "片手掴み", 22.0f, 0); + // Two hand grab + daAlinkHIO_setAnmGenMessage(&m.mTwoHandGrabAnm, ctx, "両手掴み", 12.0f, 0); +} +daAlinkHIO_wallFall_c::daAlinkHIO_wallFall_c() { + static const char plabel[] = "const daAlinkHIO_wallFall_c1 daAlinkHIO_wallFall_c0::m = {\n"; + m_len = 40; + mp_src_data = (void*)&daAlinkHIO_wallFall_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 0; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wallMove_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Minimum animation speed + ctx->genSlider("最小Ａ速度", &m.mMinAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Maximum animation speed + ctx->genSlider("最大Ａ速度", &m.mMaxAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Interpolation + ctx->genSlider("補間", &m.mInterpolation, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Minimum speed + ctx->genSlider("最小移動速度", &m.mMinSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Maximum speed + ctx->genSlider("最大移動速度", &m.mMaxSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_wallMove_c::daAlinkHIO_wallMove_c() { + static const char plabel[] = "const daAlinkHIO_wallMove_c1 daAlinkHIO_wallMove_c0::m = {\n"; + m_len = 20; + mp_src_data = (void*)&daAlinkHIO_wallMove_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 0; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 5; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wallHang_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Small Jump + ctx->genNode("小ジャンプ", &mSmallJump, 0, 0); + // Wall Catch + ctx->genNode("壁掴み", &mWallCatch, 0, 0); + // Wall Fall + ctx->genNode("落下掴み", &mWallFall, 0, 0); + // Wall Move + ctx->genNode("掴み移動", &mWallMove, 0, 0); + // Auto walk height + ctx->genSlider("自動歩き高さ", &m.auto_walk_height, 0.0f, 300.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Small jump height + ctx->genSlider("小ジャンプ高さ", &m.small_jump_height, 0.0f, 300.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Climb height + ctx->genSlider("よじ登り高さ", &m.climb_height, 0.0f, 300.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Jump climb height + ctx->genSlider("ジャンプ登り高さ", &m.jump_climb_height, 0.0f, 300.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Jump hang height + ctx->genSlider("ジャンプぶら下がり高さ", &m.jump_hang_height, 0.0f, 300.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Hang foot position height + ctx->genSlider("ぶら下がり足位置高さ", &m.hang_foot_pos_height, 0.0f, 300.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Small jump key input time + ctx->genSlider("小ジャンプキー入力時間", &m.small_jump_input_time, 0, 0x1e, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Grab key input time + ctx->genSlider("掴みキー入力時間", &m.grab_input_time, 0, 0x1e, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_wallHang_c::daAlinkHIO_wallHang_c() + : mSmallJump(), mWallCatch(), mWallFall(), mWallMove() { + static const char plabel[] = " const daAlinkHIO_wallHang_c1 daAlinkHIO_wallHang_c0::m = {\n"; + m_len = 28; + mp_src_data = (void*)&daAlinkHIO_wallHang_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 0; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 6; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +daAlinkHIO_wallMove_c::~daAlinkHIO_wallMove_c() {} +daAlinkHIO_wallFall_c::~daAlinkHIO_wallFall_c() {} +daAlinkHIO_wallCatch_c::~daAlinkHIO_wallCatch_c() {} +daAlinkHIO_smallJump_c::~daAlinkHIO_smallJump_c() {} + +void daAlinkHIO_pushpull_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Standby A speed + ctx->genSlider("待機Ａ速度", &m.mStandbyASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Standby interpolation + ctx->genSlider("待機補間", &m.mStandbyInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Push A speed + ctx->genSlider("押しＡ速度", &m.mPushASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Push A speed (heavy) + ctx->genSlider("押しＡ速度（重）", &m.mPushASpeedHeavy, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Push interpolation + ctx->genSlider("押し補間", &m.mPushInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Pull interpolation + ctx->genSlider("引き補間", &m.mPullInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Sumo push A speed + ctx->genSlider("相撲押しＡ速度", &m.mSumoPushASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Sumo push additional A speed + ctx->genSlider("相撲押し追加Ａ速度", &m.mSumoPushAddASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Sumo pushed A speed + ctx->genSlider("相撲押されＡ速度", &m.mSumoPushedASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Sumo pushed additional A speed + ctx->genSlider("相撲押され追加Ａ速度", &m.mSumoPushedAddASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Sumo max gauge + ctx->genSlider("相撲最大ゲージ", &m.mSumoMaxGauge, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Sumo increase gauge + ctx->genSlider("相撲増加ゲージ", &m.mSumoIncreaseGauge, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Sumo penalty time + ctx->genSlider("相撲ペナルティ時間", &m.mSumoPenaltyTime, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Sumo power 3/2 switch + ctx->genSlider("相撲パワー３・２境界", &m.mSumoPower3To2Switch, 0, 0x7fff, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Sumo power 2/1 switch + ctx->genSlider("相撲パワー２・１境界", &m.mSumoPower2To1Switch, 0, 0x7fff, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Sumo rotation allow power + ctx->genSlider("相撲旋回許可パワー", &m.mSumoRotationAllowPower, 0, 3, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Sumo rotation angle + ctx->genSlider("相撲旋回角度", &m.mSumoRotationAngle, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Sumo wait rotation allow + ctx->genCheckBox("相撲待機旋回許可", &m.mEnableSumoWaitRotation, '\x01', 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); +} + +daAlinkHIO_pushpull_c::daAlinkHIO_pushpull_c() { + static const char plabel[] = "const daAlinkHIO_pushpull_c1 daAlinkHIO_pushpull_c0::m = {\n"; + m_len = 60; + mp_src_data = (void*)&daAlinkHIO_pushpull_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 0; + m_u8_num = 2; + m_s16_num = 7; + m_f32_num = 11; + f14 = 1; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_damNormal_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Front + daAlinkHIO_setAnmGenMessage(&m.mFrontAnm, ctx, "前方", 22.0f, 1); + // Rear + daAlinkHIO_setAnmGenMessage(&m.mRearAnm, ctx, "後方", 19.0f, 1); + // Left + daAlinkHIO_setAnmGenMessage(&m.mLeftAnm, ctx, "左方", 19.0f, 1); + // Right + daAlinkHIO_setAnmGenMessage(&m.mRightAnm, ctx, "右方", 19.0f, 1); + // Front-back body angle maximum + ctx->genSlider("前後体角度最大", &m.mFrontBackBodyMaxAngle, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Left-right body angle maximum + ctx->genSlider("左右体角度最大", &m.mLeftRightBodyMaxAngle, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Initial speed + ctx->genSlider("初速", &m.mInitialSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Attack speed rate + ctx->genSlider("攻撃速度率", &m.mAttackSpeedRate, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Deceleration + ctx->genSlider("減速", &m.mDeceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Ice damage A speed + ctx->genSlider("氷ダメージＡ速度", &m.mIceDamageASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_damNormal_c::daAlinkHIO_damNormal_c() { + static const char plabel[] = "const daAlinkHIO_damNormal_c1 daAlinkHIO_damNormal_c0::m = {\n"; + m_len = 100; + mp_src_data = (void*)&daAlinkHIO_damNormal_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 4; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_damLaHu_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Damage interpolation + ctx->genSlider("ダメージ補間", &m.mDamageBlend, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Gravity + ctx->genSlider("重力", &m.mGravity, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Horizontal speed + ctx->genSlider("水平速度", &m.mHorizontalSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Vertical speed + ctx->genSlider("垂直速度", &m.mVerticalSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Deceleration + ctx->genSlider("減速", &m.mDeceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Bounce speed + ctx->genSlider("跳ね返り速度", &m.mBounceSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Body rotation speed + ctx->genSlider("体回転速度", &m.mBodyRotateRate, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Front get up + daAlinkHIO_setAnmGenMessage(&m.mFrontGetUpAnm, ctx, "前起", 49.0f, 1); + // Back get up + daAlinkHIO_setAnmGenMessage(&m.mBackGetUpAnm, ctx, "後起", 64.0f, 1); + // Left get up + daAlinkHIO_setAnmGenMessage(&m.mLeftGetUpAnm, ctx, "左起", 39.0f, 1); + // Right get up + daAlinkHIO_setAnmGenMessage(&m.mRightGetUpAnm, ctx, "右起", 39.0f, 1); + // Front wall hit + daAlinkHIO_setAnmGenMessage(&m.mFrontWallHitAnm, ctx, "前壁", 49.0f, 0); + // Back wall hit + daAlinkHIO_setAnmGenMessage(&m.mBackWallHitAnm, ctx, "後壁", 39.0f, 0); + // Left wall hit + daAlinkHIO_setAnmGenMessage(&m.mLeftWallHitAnm, ctx, "左壁", 39.0f, 0); + // Right wall hit + daAlinkHIO_setAnmGenMessage(&m.mRightWallHitAnm, ctx, "右壁", 39.0f, 0); +} + +daAlinkHIO_damLaHu_c::daAlinkHIO_damLaHu_c(int param_0) { + static void* baseP[2] = { + (void*)&daAlinkHIO_damLarge_c0::m, + (void*)&daAlinkHIO_damHuge_c0::m, + }; + + static const char* plabel[] = { + "const daAlinkHIO_guardAttack_c1 daAlinkHIO_damLarge_c0::m = {\n", + "const daAlinkHIO_guardAttack_c1 daAlinkHIO_damHuge_c0::m = {\n", + }; + + m_len = 188; + mp_src_data = baseP[param_0]; + mp_data = (void*)&m; + m_name_string = plabel[param_0]; + baseCopy(); + m_anm_num = 8; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 6; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_damHorse_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // No direction + daAlinkHIO_setAnmGenMessage(&m.mNoDirectionAnm, ctx, "方向なし", 9.0f, 0); + // With direction + daAlinkHIO_setAnmGenMessage(&m.mWithDirectionAnm, ctx, "方向あり", 11.0f, 0); + // Front-back body angle maximum + ctx->genSlider("前後体角度最大", &m.mFrontBackBodyMaxAngle, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Left-right body angle maximum + ctx->genSlider("左右体角度最大", &m.mLeftRightBodyMaxAngle, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_damHorse_c::daAlinkHIO_damHorse_c() { + static const char plabel[] = "const daAlinkHIO_damHorse_c1 daAlinkHIO_damHorse_c0::m = {\n"; + m_len = 44; + mp_src_data = (void*)&daAlinkHIO_damHorse_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 0; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_damFall_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Min safe landing height + ctx->genSlider("受身可能最小高さ", &m.mMinRollHeight, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Max safe landing height + ctx->genSlider("受身可能最大高さ", &m.mMaxRollHeight, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Small damage height + ctx->genSlider("小ダメージ高さ", &m.mSmallDmgHeight, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Large damage height + ctx->genSlider("大ダメージ高さ", &m.mBigDmgHeight, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Fall animation transition height + ctx->genSlider("空中アニメ移行高さ", &m.mFallAnmTransitionHeight, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Fall animation interpolation + ctx->genSlider("空中アニメ補間", &m.mFallAnmMorf, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Landing + daAlinkHIO_setAnmGenMessage(&m.mLandAnm, ctx, "着地", 11.0f, 0); + // Small damage landing start F + ctx->genSlider("小ダメージ着地開始Ｆ", &m.mSmallDmgLandStartFrame, 0.0f, 11.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Small stop time + ctx->genSlider("小停止時間", &m.mSmallStopTime, 0, 0x96, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Large stop time + ctx->genSlider("大停止時間", &m.mBigStopTime, 0, 0x96, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Aerial get up + daAlinkHIO_setAnmGenMessage(&m.mStandAnm, ctx, "起上り", 17.0f, 1); +} + +daAlinkHIO_damFall_c::daAlinkHIO_damFall_c() { + static const char plabel[] = "const daAlinkHIO_damFall_c1 daAlinkHIO_damFall_c0::m = {\n"; + m_len = 72; + mp_src_data = (void*)&daAlinkHIO_damFall_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 7; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_damCaught_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Grab duration + ctx->genSlider("捕まり時間", &m.mGrabDuration, 0, 1000, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Input fade time + ctx->genSlider("入力減り時間", &m.mInputFadeTime, 0, 0x1e, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Standby add A speed + ctx->genSlider("待機追加Ａ速度", &m.mStandbyAddASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Standby interpolation + ctx->genSlider("待機補間", &m.mStandbyInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Escape + daAlinkHIO_setAnmGenMessage(&m.mEscapeAnm, ctx, "脱出", 59.0f, 1); +} + +daAlinkHIO_damCaught_c::daAlinkHIO_damCaught_c() { + static const char plabel[] = "const daAlinkHIO_damCaught_c1 daAlinkHIO_damCaught_c0::m = {\n"; + m_len = 36; + mp_src_data = (void*)&daAlinkHIO_damCaught_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 3; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_damSwim_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Front + daAlinkHIO_setAnmGenMessage(&m.mFrontAnm, ctx, "前", 22.0f, 1); + // Rear + daAlinkHIO_setAnmGenMessage(&m.mRearAnm, ctx, "後", 19.0f, 1); + // Left + daAlinkHIO_setAnmGenMessage(&m.mLeftAnm, ctx, "左", 19.0f, 1); + // Right + daAlinkHIO_setAnmGenMessage(&m.mRightAnm, ctx, "右", 19.0f, 1); + // Front-back body angle maximum + ctx->genSlider("前後体角度最大", &m.mFrontBackBodyMaxAngle, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Left-right body angle maximum + ctx->genSlider("左右体角度最大", &m.mLeftRightBodyMaxAngle, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Initial speed + ctx->genSlider("初速", &m.mInitialSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Attack speed rate + ctx->genSlider("攻撃速度率", &m.mAttackSpeedRate, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Max speed + ctx->genSlider("最高速", &m.mMaxSpeed, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Deceleration + ctx->genSlider("減速", &m.mDeceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Sink + daAlinkHIO_setAnmGenMessage(&m.mSinkAnm, ctx, "下沈", 10.0f, 0); + // Water surface + daAlinkHIO_setAnmGenMessage(&m.mSurfaceAnm, ctx, "水面", 11.0f, 1); +} + +daAlinkHIO_damSwim_c::daAlinkHIO_damSwim_c() { + static const char plabel[] = "const daAlinkHIO_damSwim_c1 daAlinkHIO_damSwim_c0::m = {\n"; + m_len = 140; + mp_src_data = (void*)&daAlinkHIO_damSwim_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 6; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 4; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_damage_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Normal + ctx->genNode("通常", &mDamNormal, 0, 0); + // Large + ctx->genNode("大", &mDamLaHu0, 0, 0); + // Heavy large + ctx->genNode("強大", &mDamLaHu1, 0, 0); + // On horse + ctx->genNode("馬上", &mDamHorse, 0, 0); + // Fall + ctx->genNode("落下", &mDamFall, 0, 0); + // Captured + ctx->genNode("捕縛", &mDamCaught, 0, 0); + // Swim + ctx->genNode("泳ぎ", &mDamSwim, 0, 0); + // Invincible state + ctx->genCheckBox("無敵状態", &m.mInvincible, '\x01', 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Invincible time + ctx->genSlider("無敵時間", &m.mInvincibleTime, 0, 0x96, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Wolf floor invincible time + ctx->genSlider("狼ポリゴン時無敵時間", &m.mWolfFloorInvincibleTime, 0, 0x96, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Floor get up + daAlinkHIO_setAnmGenMessage(&m.mFloorDmgAnm, ctx, "床起き", 14.0f, 1); + // Dash + daAlinkHIO_setAnmGenMessage(&m.mDashDmgAnm, ctx, "ダッシュ", 9.0f, 0); + // Recover stand anm speed + ctx->genSlider("復帰起き上がりＡ速度", &m.mRecoverStandAnmSpeed, 1.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Inverted fall interpolation + ctx->genSlider("逆さま落下補間", &m.mInvertedFallInterpolation, 0.0f, 50.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Freeze wait time + ctx->genSlider("凍り待ち時間", &m.mFreezeTime, 1, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Freeze initial R + ctx->genSlider("凍り初期Ｒ", &m.mFreezeInitR, -0x40, 0x40, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Freeze initial G + ctx->genSlider("凍り初期Ｇ", &m.mFreezeInitG, -0x40, 0x40, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Freeze initial B + ctx->genSlider("凍り初期Ｂ", &m.mFreezeInitB, -0x40, 0x40, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Freeze middle R + ctx->genSlider("凍り中Ｒ", &m.mFreezeR, -0xff, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Freeze middle G + ctx->genSlider("凍り中Ｇ", &m.mFreezeG, -0xff, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Freeze middle B + ctx->genSlider("凍り中Ｂ", &m.mFreezeB, -0xff, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Damage R0 + ctx->genSlider("ダメージＲ０", &m.mDamageR0, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Damage G0 + ctx->genSlider("ダメージＧ０", &m.mDamageG0, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Damage B0 + ctx->genSlider("ダメージＢ０", &m.mDamageB0, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Damage R1 + ctx->genSlider("ダメージＲ１", &m.mDamageR1, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Damage G1 + ctx->genSlider("ダメージＧ１", &m.mDamageG1, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Damage B1 + ctx->genSlider("ダメージＢ１", &m.mDamageB1, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Damage R2 + ctx->genSlider("ダメージＲ２", &m.mDamageR2, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Damage G2 + ctx->genSlider("ダメージＧ２", &m.mDamageG2, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Damage B2 + ctx->genSlider("ダメージＢ２", &m.mDamageB2, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_damage_c::daAlinkHIO_damage_c() + : mDamNormal(), mDamLaHu0(0), mDamLaHu1(1), mDamHorse(), mDamFall(), mDamCaught(), mDamSwim() { + static const char plabel[] = "const daAlinkHIO_damage_c1 daAlinkHIO_damage_c0::m = {\n"; + m_len = 88; + mp_src_data = (void*)&daAlinkHIO_damage_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 2; + m_s16_num = 19; + m_f32_num = 2; + f14 = 1; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +daAlinkHIO_damSwim_c::~daAlinkHIO_damSwim_c() {} +daAlinkHIO_damCaught_c::~daAlinkHIO_damCaught_c() {} +daAlinkHIO_damFall_c::~daAlinkHIO_damFall_c() {} +daAlinkHIO_damHorse_c::~daAlinkHIO_damHorse_c() {} +daAlinkHIO_damLaHu_c::~daAlinkHIO_damLaHu_c() {} +daAlinkHIO_damNormal_c::~daAlinkHIO_damNormal_c() {} + +void daAlinkHIO_horse_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Sword up Animation speed + ctx->genSlider("剣上Ａ速度", &m.mSwordUpAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Sword up interpolation + ctx->genSlider("剣上補間", &m.mSwordUpInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Sword up time + ctx->genSlider("剣上時間", &m.mSwordUpTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Search range angle + ctx->genSlider("サーチ範囲角度", &m.mSearchRangeAngle, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Walk out prohibition time + ctx->genSlider("歩出禁止時間", &m.mWalkOutProhibitionTime, 0, 500, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Walk out + daAlinkHIO_setAnmGenMessage(&m.mWalkOutAnm, ctx, "歩出", 18.0f, 0); + // Run out + daAlinkHIO_setAnmGenMessage(&m.mRunOutAnm, ctx, "走出", 22.0f, 0); + // Horse walk start F + ctx->genSlider("馬歩出開始Ｆ", &m.mHorseWalkStartFrame, 0.0f, 18.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Whip(ctx, + daAlinkHIO_setAnmGenMessage(&m.mWhipAnm, ctx, "鞭", 43.0f, 0); + // Whip run out + daAlinkHIO_setAnmGenMessage(&m.mWhipRunOutAnm, ctx, "鞭走出", 22.0f, 0); + // Tired wait interpolation + ctx->genSlider("疲れ待機補間", &m.mTiredWaitInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Whip wait time + ctx->genSlider("鞭打ち待ち時間", &m.mWhipWaitTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Subjective downward max angle + ctx->genSlider("主観下向最大角度", &m.mSubjectiveDownwardMaxAngle, 0, 0x4000, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Subjective upward max angle + ctx->genSlider("主観上向最大角度", &m.mSubjectiveUpwardMaxAngle, -0x4000, 0, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); +} + +daAlinkHIO_horse_c::daAlinkHIO_horse_c() { + static const char plabel[] = "const daAlinkHIO_horse_c1 daAlinkHIO_horse_c0::m = {\n"; + m_len = 108; + mp_src_data = (void*)&daAlinkHIO_horse_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 6; + m_f32_num = 4; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_canoe_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Stick rowing animation speed + ctx->genSlider("スティック漕ぎＡ速度", &m.mStickRowAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Button rowing animation speed + ctx->genSlider("ボタン漕ぎＡ速度", &m.mBtnRowAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Stick rowing start animation speed + ctx->genSlider("スティック漕ぎ始めＡ速度", &m.mStickRowStartAnmSpeed, 0.0f, 10.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Button rowing start animation speed + ctx->genSlider("ボタン漕ぎ始めＡ速度", &m.mBtnRowStartAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Canoe speed rate + ctx->genSlider("カヌー速度率", &m.mSpeedRate, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Canoe maximum speed + ctx->genSlider("カヌー最高速度", &m.mMaxSpeed, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Canoe backward speed rate + ctx->genSlider("カヌー後退速度率", &m.mBackSpeedRate, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Canoe backward maximum speed + ctx->genSlider("カヌー後退最高速度", &m.mBackMaxSpeed, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Canoe deceleration value + ctx->genSlider("カヌー減速値", &m.mDeceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Canoe maximum turning angle + ctx->genSlider("カヌー最高旋回角度", &m.mMaxTurnAngle, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Left-right grip change + daAlinkHIO_setAnmGenMessage(&m.mLeftRightChangeAnm, ctx, "左右持替", 23.0f, 0); + // Downriver canoe maximum turning angle + ctx->genSlider("川下りカヌー最高旋回角度", &m.mMaxTurnAngle_RiverRide, 0, 0x7fff, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Downriver canoe maximum speed + ctx->genSlider("川下りカヌー最高速度", &m.mMaxSpeed_RiverRide, 0.0f, 200.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Downriver canoe speed rate + ctx->genSlider("川下りカヌー速度率", &m.mSpeedRate_RiverRide, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Downriver canoe deceleration value + ctx->genSlider("川下りカヌー減速値", &m.mDeceleration_RiverRide, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); +} + +daAlinkHIO_canoe_c::daAlinkHIO_canoe_c() { + static const char plabel[] = "const daAlinkHIO_canoe_c1 daAlinkHIO_canoe_c0::m = {\n"; + m_len = 72; + mp_src_data = (void*)&daAlinkHIO_canoe_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 12; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_bow_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Shoot + daAlinkHIO_setAnmGenMessage(&m.mShootAnm, ctx, "撃つ", 9.0f, 1); + // Load + daAlinkHIO_setAnmGenMessage(&m.mLoadAnm, ctx, "装填", 6.0f, 0); + // Start interpolation + ctx->genSlider("開始補間", &m.mStartInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Arrow speed + ctx->genSlider("矢速度", &m.mArrowSpeed, 0.0f, 1000.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Arrow distance + ctx->genSlider("矢飛距離", &m.mArrowDistance, 0.0f, 100000.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Charge time + ctx->genSlider("ため時間", &m.mChargeArrowTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Charge arrow speed + ctx->genSlider("ため矢速度", &m.mChargeArrowSpeed, 0.0f, 1000.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Charge arrow distance + ctx->genSlider("ため矢飛距離", &m.mChargeArrowDistance, 0.0f, 100000.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Scope arrow speed + ctx->genSlider("スコープ矢速度", &m.mScopeArrowSpeed, 0.0f, 1000.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Scope arrow distance + ctx->genSlider("スコープ矢飛距離", &m.mScopeArrowDistance, 0.0f, 100000.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Arrow additional attack radius + ctx->genSlider("矢追加攻撃半径", &m.mArrowAttackRadius, 0.0f, 300.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Arrow additional attack radius start + ctx->genSlider("矢追加攻撃半径開始", &m.mArrowIncAttackMaxStart, 0.0f, 100000.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Arrow additional attack radius max + ctx->genSlider("矢追加攻撃半径最大", &m.mArrowIncAttackMax, 0.0f, 100000.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Bomb arrow speed + ctx->genSlider("爆弾矢速度", &m.mBombArrowSpeed, 0.0f, 1000.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Bomb arrow distance + ctx->genSlider("爆弾矢飛距離", &m.mBombArrowDistance, 0.0f, 100000.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Charge bomb arrow speed + ctx->genSlider("ため爆弾矢速度", &m.mChargeBombArrowSpeed, 0.0f, 1000.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Charge bomb arrow distance + ctx->genSlider("ため爆弾矢飛距離", &m.mChargeBombArrowDistance, 0.0f, 100000.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Arrow wait time + ctx->genSlider("矢待ち時間", &m.mBombArrowHoldTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Bomb arrow fly explode time + ctx->genSlider("爆弾矢飛行爆発時間", &m.mBombArrowFlyExplodeTime, 0, 1000, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Slingshot speed + ctx->genSlider("パチンコ速度", &m.mSlingshotSpeed, 0.0f, 1000.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Slingshot distance + ctx->genSlider("パチンコ飛距離", &m.mSlingshotDistance, 0.0f, 100000.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); +} + +daAlinkHIO_bow_c::daAlinkHIO_bow_c() { + static const char plabel[] = "const daAlinkHIO_bow_c1 daAlinkHIO_bow_c0::m = {\n"; + m_len = 112; + mp_src_data = (void*)&daAlinkHIO_bow_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 4; + m_f32_num = 16; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_boom_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Throw + daAlinkHIO_setAnmGenMessage(&m.mThrowAnm, ctx, "投げ", 21.0f, 1); + // Catch + daAlinkHIO_setAnmGenMessage(&m.mCatchAnm, ctx, "キャッチ", 25.0f, 1); + // Idle animation speed + ctx->genSlider("待機Ａ速度", &m.mIdleAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Start interpolation + ctx->genSlider("開始補間", &m.mStartInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Fly speed + ctx->genSlider("飛行速度", &m.mFlySpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Charge fly speed + ctx->genSlider("ため飛行速度", &m.mChargeFlySpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Entangling fly speed + ctx->genSlider("巻込飛行速度", &m.mCatchSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Fly distance max + ctx->genSlider("飛行距離", &m.mFlyDistMax, 0.0f, 10000.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Horseback fly distance max + ctx->genSlider("馬上飛行距離", &m.mHorsebackFlyDistMax, 0.0f, 10000.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Charge time + ctx->genSlider("ため時間", &m.mChargeTime, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Lock distance max + ctx->genSlider("ロック距離", &m.mLockDistMax, 0.0f, 10000.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Wall piercing time + ctx->genSlider("壁突き抜け時間", &m.mBgThroughTime, 0, 1000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_boom_c::daAlinkHIO_boom_c() { + static const char plabel[] = "const daAlinkHIO_boom_c1 daAlinkHIO_boom_c0::m = {\n"; + m_len = 76; + mp_src_data = (void*)&daAlinkHIO_boom_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 8; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_bomb_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Explode time + ctx->genSlider("爆発時間", &m.mExplodeTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Gravity + ctx->genSlider("重力", &m.mGravity, -5.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max fall speed + ctx->genSlider("最大落下速度", &m.mMaxFallSpeed, -500.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Throw horizontal speed + ctx->genSlider("投げ水平速度", &m.mThrowSpeedH, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Throw vertical speed + ctx->genSlider("投げ垂直速度", &m.mThrowSpeedV, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Bound rate + ctx->genSlider("バウンド率", &m.mBoundRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Vertical stop speed + ctx->genSlider("垂直停止速度", &m.mStopSpeedY, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Bounce time max speed + ctx->genSlider("跳返時最大速度", &m.mMaxSpeedY, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Effect scale + ctx->genSlider("爆発エフェクトスケール", &m.mEffScale, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Underwater explode switch + ctx->genSlider("水中爆発切替え", &m.mExplodeWaterEffectLimit, 0.0f, 1000.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Explode attack radius + ctx->genSlider("爆発攻撃半径", &m.mAttackRadius, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Bomb insect red blink + ctx->genSlider("爆弾虫赤点滅", &m.mEnemyBombColorR, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Bomb insect effect track rate + ctx->genSlider("爆弾虫エフェクト追従率", &m.mPokeBombTrackRate, 0.0f, 5.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Water gravity + ctx->genSlider("水中重力", &m.mWaterGravity, -5.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Water max fall speed + ctx->genSlider("水中最大落下速度", &m.mWaterMaxFallSpeed, -500.0f, 0.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Water throw horizontal speed + ctx->genSlider("水中投げ水平速度", &m.mWaterThrowSpeedH, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Water throw vertical speed + ctx->genSlider("水中投げ垂直速度", &m.mWaterThrowSpeedV, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Wolf throw horizontal speed + ctx->genSlider("狼投げ水平速度", &m.mWolfThrowSpeedH, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Wolf throw vertical speed + ctx->genSlider("狼投げ垂直速度", &m.mWolfThrowSpeedV, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Poke insect limit angle + ctx->genSlider("ポケムシ制限角度", &m.mBombInsectLimitAngle, 0, 0x5a, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_bomb_c::daAlinkHIO_bomb_c() { + static const char plabel[] = "const daAlinkHIO_bomb_c1 daAlinkHIO_bomb_c0::m = {\n"; + m_len = 76; + mp_src_data = (void*)&daAlinkHIO_bomb_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 0; + m_u8_num = 0; + m_s16_num = 4; + m_f32_num = 17; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_light_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // X angle + ctx->genSlider("Ｘ角度", &m.mXAngle, -0xb4, 0xb4, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Power + ctx->genSlider("パワー", &m.mPower, 0.0f, 200.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Width + ctx->genSlider("幅", &m.mWidth, 0.0f, 200.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Y offset + ctx->genSlider("Ｙずらし", &m.mYOffset, -10000.0f, 10000.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Z offset + ctx->genSlider("Ｚずらし", &m.mZOffset, -10000.0f, 10000.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Color R + ctx->genSlider("色Ｒ", &m.mColorR, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Color G + ctx->genSlider("色Ｇ", &m.mColorG, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Color B + ctx->genSlider("色Ｂ", &m.mColorB, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Distance attenuation + ctx->startComboBox("距離減衰", &m.mDistanceAttenuationType, 0, NULL, 0xffff, 0xffff, 0x100, + 0x1a); + // No attenuation [GX_DA_OFF] + ctx->genComboBoxItem("減衰なし [GX_DA_OFF]", 0); + // Gentle [GX_DA_GENTLE] + ctx->genComboBoxItem("おだやか [GX_DA_GENTLE]", 1); + // Medium [GX_DA_MEDIUM] + ctx->genComboBoxItem("中間 [GX_DA_MEDIUM]", 2); + // Steep [GX_DA_STEEP] + ctx->genComboBoxItem("険しい [GX_DA_STEEP]", 3); + ctx->endComboBox(); + // Angle attenuation + ctx->startComboBox("角度減衰", &m.mAngleAttenuationType, 0, NULL, 0xffff, 0xffff, 0x100, 0x1a); + // Point [GX_SP_OFF] + ctx->genComboBoxItem("ポイント [GX_SP_OFF]", 0); + // Right angle [GX_SP_FLAT] + ctx->genComboBoxItem("直角 [GX_SP_FLAT]", 1); + // COS curve [GX_SP_COS] + ctx->genComboBoxItem("COS曲線 [GX_SP_COS]", 2); + // COS2 curve [GX_SP_COS2] + ctx->genComboBoxItem("COS2曲線 [GX_SP_COS2]", 3); + // Sharp [GX_SP_SHARP] + ctx->genComboBoxItem("シャープ [GX_SP_SHARP]", 4); + // Ring shape [GX_SP_RING1] + ctx->genComboBoxItem("リング状 [GX_SP_RING1]", 5); + // Ring shape 2 [GX_SP_RING2] + ctx->genComboBoxItem("リング状2[GX_SP_RING2]", 6); + ctx->endComboBox(); +} + +daAlinkHIO_light_c::daAlinkHIO_light_c(int param_0) { + static void* baseP[] = { + (void*)&daAlinkHIO_huLight_c0::m, + (void*)&daAlinkHIO_wlLight_c0::m, + (void*)&daAlinkHIO_zwLight_c0::m, + + }; + + static const char* plabel[] = { + "const daAlinkHIO_light_c1 daAlinkHIO_huLight_c0::m = {\n", + "const daAlinkHIO_light_c1 daAlinkHIO_wlLight_c0::m = {\n", + "const daAlinkHIO_light_c1 daAlinkHIO_zwLight_c0::m = {\n", + }; + + m_len = 28; + mp_src_data = baseP[param_0]; + mp_data = (void*)&m; + m_name_string = plabel[param_0]; + baseCopy(); + m_anm_num = 0; + m_u8_num = 4; + m_s16_num = 4; + m_f32_num = 4; + f14 = 0; + f18 = 2; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_kandelaar_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Shake + daAlinkHIO_setAnmGenMessage(&m.mShakeAnm, ctx, "振る", 30.0f, 1); + // Color Reg 1 R + ctx->genSlider("カラレジ１Ｒ", &m.mColorReg1R, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Color Reg 1 G + ctx->genSlider("カラレジ１Ｇ", &m.mColorReg1G, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Color Reg 1 B + ctx->genSlider("カラレジ１Ｂ", &m.mColorReg1B, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Color Reg 2 R + ctx->genSlider("カラレジ２Ｒ", &m.mColorReg2R, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Color Reg 2 G + ctx->genSlider("カラレジ２Ｇ", &m.mColorReg2G, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Color Reg 2 B + ctx->genSlider("カラレジ２Ｂ", &m.mColorReg2B, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Flame Track Rate + ctx->genSlider("炎追従率", &m.mFlameTrackRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Pour Begin + daAlinkHIO_setAnmGenMessage(&m.mBeginUnkAnm, ctx, "注始", 11.0f, 0); + // Pour End + daAlinkHIO_setAnmGenMessage(&m.mEndUnkAnm, ctx, "注終", 17.0f, 0); + // Normal Oil Loss + ctx->genSlider("通常油減り", &m.mNormalOilLoss, 0, 30000, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Shake Oil Loss + ctx->genSlider("振り油減り", &m.mShakeOilLoss, 0, 30000, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_kandelaar_c::daAlinkHIO_kandelaar_c() { + static const char plabel[] = "const daAlinkHIO_kandelaar_c1 daAlinkHIO_kandelaar_c0::m = {\n"; + m_len = 80; + mp_src_data = (void*)&daAlinkHIO_kandelaar_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 3; + m_u8_num = 0; + m_s16_num = 8; + m_f32_num = 1; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_magneBoots_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Equip + daAlinkHIO_setAnmGenMessage(&m.mEquipAnm, ctx, "装備", 29.0f, 1); + // Key input rate + ctx->genSlider("キー入力率", &m.mInputFactor, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Foot position ratio + ctx->genSlider("足位置比率", &m.mFeetPositionRatio, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Walk A speed max + ctx->genSlider("歩きＡ速度最大", &m.mWalkAnmSpeedMax, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Walk A speed min + ctx->genSlider("歩きＡ速度最小", &m.mWalkAnmSpeedMin, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Underwater key input rate + ctx->genSlider("水中キー入力率", &m.mWaterInputFactor, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Underwater A speed rate + ctx->genSlider("水中Ａ速度率", &m.mWaterStartWalkAnmRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Underwater A speed rate (slow) + ctx->genSlider("水中Ａ速度率（遅）", &m.mWaterWalkAnmRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Underwater A speed rate (sword) + ctx->genSlider("水中Ａ速度率（剣）", &m.mWaterVelRateSword, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Max fly speed + ctx->genSlider("最大飛び速度", &m.mMaxMagneFlySpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Fly acceleration + ctx->genSlider("飛び加速度", &m.mMagneFlyAccelRate, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Underwater vertical speed rate + ctx->genSlider("水中垂直速度率", &m.mWaterVelocityY, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Underwater horizontal speed rate + ctx->genSlider("水中平面速度率", &m.mWaterVelocityX, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Underwater key input rate (Zora) + ctx->genSlider("水中キー入力率（ゾーラ）", &m.mZoraWaterInputFactor, 0.0f, 1.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Underwater A speed rate (Zora) + ctx->genSlider("水中Ａ速度率（ゾーラ）", &m.mZoraWaterAnmSpeed, 0.0f, 1.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); +} + +daAlinkHIO_magneBoots_c::daAlinkHIO_magneBoots_c() { + static const char plabel[] = "const daAlinkHIO_magneBoots_c1 daAlinkHIO_magneBoots_c0::m = {\n"; + m_len = 76; + mp_src_data = (void*)&daAlinkHIO_magneBoots_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 14; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_fmChain_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Grip + daAlinkHIO_setAnmGenMessage(&m.mGripAnm, ctx, "掴み", 20.0f, 1); + // Unfinished + daAlinkHIO_setReverseAnmGenMessage(&m.mUnfinishedAnm, ctx, "放し", 20.0f, 1); +} + +daAlinkHIO_fmChain_c::daAlinkHIO_fmChain_c() { + static const char plabel[] = "const daAlinkHIO_fmChain_c1 daAlinkHIO_fmChain_c0::m = {\n"; + m_len = 40; + mp_src_data = (void*)&daAlinkHIO_fmChain_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 0; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_hookshot_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Idle A speed + ctx->genSlider("待機Ａ速度", &m.mWaitAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Start interpolation + ctx->genSlider("開始補間", &m.mStartInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Maximum length + ctx->genSlider("最大長さ", &m.mMaxLength, 0.0f, 10000.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Launch speed + ctx->genSlider("発射速度", &m.mShootSpeed, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Return speed + ctx->genSlider("戻り速度", &m.mReturnSpeed, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Pierce return speed + ctx->genSlider("刺戻り速度", &m.mStickReturnSpeed, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Shoot + daAlinkHIO_setAnmGenMessage(&m.mShootAnm, ctx, "撃つ", 12.0f, 0); + // Throw wait + daAlinkHIO_setAnmGenMessage(&m.mRoofHangAnm, ctx, "天井停止", 39.0f, 1); + // Ceiling ascent speed + ctx->genSlider("天井上昇速度", &m.mRoofHangRiseSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Ceiling descent speed + ctx->genSlider("天井降下速度", &m.mRoofHangDecendSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Wall wait + daAlinkHIO_setAnmGenMessage(&m.mWallHangAnm, ctx, "壁停止", 28.0f, 1); + // Forced pierce + ctx->genCheckBox("強制刺さり", &m.mForceStick, '\x01', 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Boss battle maximum length + ctx->genSlider("ボス戦最大長さ", &m.mBossMaxLength, 0.0f, 10000.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Boss battle launch speed + ctx->genSlider("ボス戦発射速度", &m.mBossShootSpeed, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Boss battle return speed + ctx->genSlider("ボス戦戻り速度", &m.mBossReturnSpeed, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Boss battle pierce return speed + ctx->genSlider("ボス戦刺戻り速度", &m.mBossStickReturnSpeed, 0.0f, 500.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); +} + +daAlinkHIO_hookshot_c::daAlinkHIO_hookshot_c() { + static const char plabel[] = "const daAlinkHIO_hookshot_c1 daAlinkHIO_hookshot_c0::m = {\n"; + m_len = 112; + mp_src_data = (void*)&daAlinkHIO_hookshot_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 3; + m_u8_num = 4; + m_s16_num = 0; + m_f32_num = 12; + f14 = 1; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_spinner_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Gravity + ctx->genSlider("重力", &m.mGravity, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max fall speed + ctx->genSlider("最大落下速度", &m.mMaxFallSpeed, -100.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Jump rate + ctx->genSlider("ジャンプ比率", &m.mJumpRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Board wait time + ctx->genSlider("乗込待ち時間", &m.mBoardWaitTime, 0, 1000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Ride move time + ctx->genSlider("乗り移動時間", &m.mRideMoveTime, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Ride speed + ctx->genSlider("乗り速度", &m.mRideSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Ride decel max + ctx->genSlider("乗り減速最大", &m.mDecelSpeedMax, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Ride decel min + ctx->genSlider("乗り減速最小", &m.mDecelSpeedMin, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Ride decel rate + ctx->genSlider("乗り減速率", &m.mDecelRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Ride rot max + ctx->genSlider("乗り旋回最大", &m.mRideRotAngleMax, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Ride rot min + ctx->genSlider("乗り旋回最小", &m.mRideRotAngleMin, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Kick + daAlinkHIO_setAnmGenMessage(&m.mKickAnm, ctx, "蹴り", 21.0f, 1); + // Boss ride move time + ctx->genSlider("ボス乗り移動時間", &m.mBossRideMoveTime, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Boss ride speed + ctx->genSlider("ボス乗り速度", &m.mBossRideSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_spinner_c::daAlinkHIO_spinner_c() { + static const char plabel[] = "const daAlinkHIO_spinner_c1 daAlinkHIO_spinner_c0::m = {\n"; + m_len = 64; + mp_src_data = (void*)&daAlinkHIO_spinner_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 6; + m_f32_num = 8; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_ironBall_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Idle A speed + ctx->genSlider("待機Ａ速度", &m.mWaitAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Foot position ratio + ctx->genSlider("足位置比率", &m.mFeetPosRatio, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Walk A speed max + ctx->genSlider("歩きＡ速度最大", &m.mWalkAnmSpeedMax, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Walk A speed min + ctx->genSlider("歩きＡ速度最小", &m.mWalkAnmSpeedMin, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Prepare A speed + ctx->genSlider("準備Ａ速度", &m.mPrepareAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Prepare interpolation + ctx->genSlider("準備補間", &m.mPrepareInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Swing A speed + ctx->genSlider("回しＡ速度", &m.mTurnAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Swing interpolation + ctx->genSlider("回し補間", &m.mTurnInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Pre-throw A speed + ctx->genSlider("投げ前Ａ速度", &m.mPreThrowAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Pre-throw interpolation + ctx->genSlider("投げ前補間", &m.mPreThrowAnmInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Throw A speed + ctx->genSlider("投げＡ速度", &m.mThrowAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Throw interpolation + ctx->genSlider("投げ補間", &m.mThrowInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Pull A speed + ctx->genSlider("引きＡ速度", &m.mPullAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Pull interpolation + ctx->genSlider("引き補間", &m.mPullInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Catch + daAlinkHIO_setAnmGenMessage(&m.mCatchAnm, ctx, "キャッチ", 19.0f, 1); + // Ball gravity + ctx->genSlider("球重力", &m.mBallGravity, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Ball max fall speed + ctx->genSlider("球最大落下速度", &m.mBallMaxFallSpeed, -300.0f, 0.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Throw ball gravity + ctx->genSlider("投げ球重力", &m.mThrowBallGravity, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Throw ball speed Z + ctx->genSlider("投げ球速度Ｚ", &m.mThrowSpeedZ, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Throw ball speed Y + ctx->genSlider("投げ球速度Ｙ", &m.mThrowSpeedY, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Return ball gravity + ctx->genSlider("戻り球重力", &m.mReturnBallGravity, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Chain speed rate + ctx->genSlider("鎖速度率", &m.mChainSpeedRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Chain gravity + ctx->genSlider("鎖重力", &m.mChainGravity, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Throw chain gravity + ctx->genSlider("投げ鎖重力", &m.mThrowChainGravity, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Throw chain accel Z + ctx->genSlider("投げ鎖付加速度Ｚ", &m.mThrowChainAccelZ, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Throw chain accel Y + ctx->genSlider("投げ鎖付加速度Ｙ", &m.mThrowChainAccelY, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Throw chain add num + ctx->genSlider("投げ鎖追加数", &m.mThrowChainNum, 0, 100, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Return chain accel Y + ctx->genSlider("戻り鎖付加速度Ｙ", &m.mReturnChainAccelY, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Return chain add rate + ctx->genSlider("戻り鎖付加率", &m.mReturnChainRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Return chain reduce num + ctx->genSlider("戻り鎖減少数", &m.mReturnChainRemoveNum, 0, 100, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack radius + ctx->genSlider("攻撃半径", &m.mAttackRadius, 0.0f, 200.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_ironBall_c::daAlinkHIO_ironBall_c() { + static const char plabel[] = "const daAlinkHIO_ironBall_c1 daAlinkHIO_ironBall_c0::m = {\n"; + m_len = 140; + mp_src_data = (void*)&daAlinkHIO_ironBall_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 29; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_copyRod_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Swing + daAlinkHIO_setAnmGenMessage(&m.mSwingAnm, ctx, "振り", 19.0f, 1); + // Swing end + daAlinkHIO_setAnmGenMessage(&m.mBigSwingAnm, ctx, "振り大", 39.0f, 1); + // Ball speed + ctx->genSlider("ボール速度", &m.mBallSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Ball return speed + ctx->genSlider("ボール戻速度", &m.mBallReturnSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Ball fly distance + ctx->genSlider("ボール飛距離", &m.mBallMaxDistance, 0.0f, 10000.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Boss battle ball fly distance + ctx->genSlider("ボス戦ボール飛距離", &m.mBossBallMaxDistance, 0.0f, 10000.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); +} + +daAlinkHIO_copyRod_c::daAlinkHIO_copyRod_c() { + static const char plabel[] = "const daAlinkHIO_copyRod_c1 daAlinkHIO_copyRod_c0::m = {\n"; + m_len = 56; + mp_src_data = (void*)&daAlinkHIO_copyRod_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 4; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_pickUp_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Grab + daAlinkHIO_setAnmGenMessage(&m.mGrabAnm, ctx, "掴み", 18.0f, 1); + // Place + daAlinkHIO_setReverseAnmGenMessage(&m.mPlaceAnm, ctx, "置く", 18.0f, 1); +} + +daAlinkHIO_pickUp_c::daAlinkHIO_pickUp_c() { + static const char plabel[] = "const daAlinkHIO_pickUp_c1 daAlinkHIO_pickUp_c0::m = {\n"; + m_len = 48; + mp_src_data = (void*)&daAlinkHIO_pickUp_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 2; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_board_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max speed + ctx->genSlider("最大速度", &m.mMaxSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Paddling acceleration + ctx->genSlider("漕ぎ加速", &m.mPushAccel, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Paddling max speed + ctx->genSlider("漕ぎ最大速度", &m.mMaxPushSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Start min speed + ctx->genSlider("開始最低速度", &m.mStartMinSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Start add speed + ctx->genSlider("開始追加速度", &m.mStartAddSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Min jump Y speed + ctx->genSlider("最低ジャンプＹ速度", &m.mMinJumpSpeedY, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Max jump Y speed + ctx->genSlider("最高ジャンプＹ速度", &m.mMaxJumpSpeedY, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Stand A speed + ctx->genSlider("立ちＡ速度", &m.mStandAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Stand interpolation + ctx->genSlider("立ち補間", &m.mStandInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Sit A speed + ctx->genSlider("座りＡ速度", &m.mSitAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Sit interpolation + ctx->genSlider("座り補間", &m.mSitInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Paddling max A speed + ctx->genSlider("漕ぎ最高Ａ速度", &m.mPushAnmMaxSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Paddling min A speed + ctx->genSlider("漕ぎ最小Ａ速度", &m.mPushAnmMinSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Paddling interpolation + ctx->genSlider("漕ぎ補間", &m.mPushInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Fast paddling switch speed + ctx->genSlider("早漕ぎ切替速度", &m.mFastPushSwitchSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Fast paddling interpolation + ctx->genSlider("早漕ぎ補間", &m.mFastPushInterpolation, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Fly out / Jump + daAlinkHIO_setAnmGenMessage(&m.mJumpAnm, ctx, "飛出", 9.0f, 0); + // Airborne + daAlinkHIO_setAnmGenMessage(&m.mAirborneAnm, ctx, "滞空", 14.0f, 0); + // Land + daAlinkHIO_setAnmGenMessage(&m.mLandAnm, ctx, "着地", 24.0f, 0); + // Rotation slash + daAlinkHIO_setAnmGenMessage(&m.mSpinAnm, ctx, "回転斬り", 24.0f, 0); + // Rotation slash min jump Y speed + ctx->genSlider("回転斬最低ジャンプＹ速度", &m.mSpinMinJumpSpeedY, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Rotation slash max jump Y speed + ctx->genSlider("回転斬最高ジャンプＹ速度", &m.mSpinMaxJumpSpeedY, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Dedicated effect max speed + ctx->genSlider("専用エフェクト最大速度", &m.mEffectMaxSpeed, 0.1f, 200.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); +} + +daAlinkHIO_board_c::daAlinkHIO_board_c() { + static const char plabel[] = "const daAlinkHIO_board_c1 daAlinkHIO_board_c0::m = {\n"; + m_len = 156; + mp_src_data = (void*)&daAlinkHIO_board_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 19; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_bottle_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, (JOREventListener*)0x0, 0xffff, 0xffff, 0x200, 0x18); + // Start drink + daAlinkHIO_setAnmGenMessage(&m.mStartDrinkAnm, ctx, "飲む始め", 56.0f, 0); + // End drink + daAlinkHIO_setAnmGenMessage(&m.mEndDrinkAnm, ctx, "飲み終", 39.0f, 0); + // Milk end drink + daAlinkHIO_setAnmGenMessage(&m.mEndDrinkAnm, ctx, "ミルク飲み終", 86.0f, 0); + // Open + daAlinkHIO_setAnmGenMessage(&m.mOpenBottleAnm, ctx, "開ける", 49.0f, 0); + // Scoop + daAlinkHIO_setAnmGenMessage(&m.mScoopAnm, ctx, "すくう", 54.0f, 0); + // Swing down + daAlinkHIO_setAnmGenMessage(&m.mSwingDownAnm, ctx, "下振り", 24.0f, 1); + // Swing side + daAlinkHIO_setAnmGenMessage(&m.mSwingSideAnm, ctx, "横振り", 19.0f, 1); + // Medicine + daAlinkHIO_setAnmGenMessage(&m.mDrinkNastyAnm, ctx, "くすり", 29.0f, 0); + // Get + daAlinkHIO_setAnmGenMessage(&m.mGetAnm, ctx, "ゲット", 47.0f, 0); +} + +daAlinkHIO_bottle_c::daAlinkHIO_bottle_c() { + static const char plabel[] = "const daAlinkHIO_bottle_c1 daAlinkHIO_bottle_c0::m = {\n"; + m_len = 180; + mp_src_data = (void*)&daAlinkHIO_bottle_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 9; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 0; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_item_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Bow + ctx->genNode("弓", &mBow, 0, 0); + // Boomerang + ctx->genNode("ブーメラン", &mBoomerang, 0, 0); + // Bomb + ctx->genNode("爆弾", &mBomb, 0, 0); + // Lantern PL + ctx->genNode("カンテラＰＬ", &mLanternPL, 0, 0); + // Lantern + ctx->genNode("カンテラ", &mLantern, 0, 0); + // Fire Mage Chain + ctx->genNode("火魔人鎖", &mFmChain, 0, 0); + // Iron Boots + ctx->genNode("アイアンブーツ", &mIronBoots, 0, 0); + // Picked up item + ctx->genNode("拾い物", &mPickUp, 0, 0); + // Board + ctx->genNode("ボード", &mBoard, 0, 0); + // Bottle + ctx->genNode("ビン", &mBottle, 0, 0); + // Hookshot + ctx->genNode("フックショット", &mHookshot, 0, 0); + // Spinner + ctx->genNode("スピナー", &mSpinner, 0, 0); + // Iron Ball + ctx->genNode("鉄球", &mIronBall, 0, 0); + // Copy Rod + ctx->genNode("コピーロッド", &mCopyRod, 0, 0); + // Zora Armor PL + ctx->genNode("ゾーラ服ＰＬ", &mZoraArmorPL, 0, 0); + // Bag hold equip + daAlinkHIO_setAnmGenMessage(&m.mOneHandEquipAnm, ctx, "片手装備", 12.0f, 1); + // Bag hold quick release A speed + ctx->genSlider("片手早解除Ａ速度", &m.mOneHandReleaseAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Two-hand hold equip + daAlinkHIO_setAnmGenMessage(&m.mTwoHandEquipAnm, ctx, "両手装備", 14.0f, 1); + // Two-hand hold quick release A speed + ctx->genSlider("両手早解除Ａ速度", &m.mTwoHandReleaseAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Item first-person long press time + ctx->genSlider("アイテム主観長押時間", &m.mItemFPTransitionTimer, 0, 0x78, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // First-person downward max min move interval + ctx->genSlider("主観下方最大", &m.mItemFPMaxUnk, 0, 0x4000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // First-person camera downward max min move interval + ctx->genSlider("主観上方最大", &m.mItemFPUpMaxUnk, -0x4000, 0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // First-person upward max min move interval + ctx->genSlider("Wii主観カメラ下方最大", &m.mWiiItemFPDownMaxUnk, 0, 0x4000, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // First-person camera upward max min move interval + ctx->genSlider("Wii主観カメラ上方最大", &m.mWiiItemFPUpMaxUnk, -0x4000, 0, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); +} + +daAlinkHIO_item_c::daAlinkHIO_item_c() + : mBow(), mBoomerang(), mBomb(), mLanternPL(0), mLantern(), mFmChain(), mIronBoots(), mPickUp(), + mBoard(), mBottle(), mHookshot(), mSpinner(), mIronBall(), mCopyRod(), mZoraArmorPL(2) { + static const char plabel[] = "const daAlinkHIO_item_c1 daAlinkHIO_item_c0::m = {\n"; + m_len = 60; + mp_src_data = (void*)&daAlinkHIO_item_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 6; + m_f32_num = 2; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +daAlinkHIO_copyRod_c::~daAlinkHIO_copyRod_c() {} +daAlinkHIO_ironBall_c::~daAlinkHIO_ironBall_c() {} +daAlinkHIO_spinner_c::~daAlinkHIO_spinner_c() {} +daAlinkHIO_hookshot_c::~daAlinkHIO_hookshot_c() {} +daAlinkHIO_bottle_c::~daAlinkHIO_bottle_c() {} +daAlinkHIO_board_c::~daAlinkHIO_board_c() {} +daAlinkHIO_pickUp_c::~daAlinkHIO_pickUp_c() {} +daAlinkHIO_magneBoots_c::~daAlinkHIO_magneBoots_c() {} +daAlinkHIO_fmChain_c::~daAlinkHIO_fmChain_c() {} +daAlinkHIO_kandelaar_c::~daAlinkHIO_kandelaar_c() {} +daAlinkHIO_light_c::~daAlinkHIO_light_c() {} +daAlinkHIO_bomb_c::~daAlinkHIO_bomb_c() {} +daAlinkHIO_boom_c::~daAlinkHIO_boom_c() {} +daAlinkHIO_bow_c::~daAlinkHIO_bow_c() {} + +void daAlinkHIO_ladder_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18); + // Climb up start A speed + ctx->genSlider("登開始Ａ速度", &m.mClimbUpStartASpeed, 0.0f, 10.0f, 0, NULL, 0xFFFF, 0xFFFF, + 0x200, 0x18); + // Climb up start interpolation + ctx->genSlider("登開始補間", &m.mClimbUpStartInterp, 0.0f, 10.0f, 0, NULL, 0xFFFF, 0xFFFF, + 0x200, 0x18); + // Climb up end A speed + ctx->genSlider("登終了Ａ速度", &m.mClimbUpEndASpeed, 0.0f, 10.0f, 0, NULL, 0xFFFF, 0xFFFF, + 0x200, 0x18); + // Climb up end CF (transition frame?) + ctx->genSlider("登終了ＣＦ", &m.mClimbUpEndCF, 0.0f, 45.0f, 0, NULL, 0xFFFF, 0xFFFF, 0x200, + 0x18); + // Climb up end interpolation + ctx->genSlider("登終了補間", &m.mClimbUpEndInterp, 0.0f, 10.0f, 0, NULL, 0xFFFF, 0xFFFF, 0x200, + 0x18); + // Climb down start A speed + ctx->genSlider("降開始Ａ速度", &m.mClimbDownStartASpeed, 0.0f, 10.0f, 0, NULL, 0xFFFF, 0xFFFF, + 0x200, 0x18); + // Climb down start interpolation + ctx->genSlider("降開始補間", &m.mClimbDownStartInterp, 0.0f, 10.0f, 0, NULL, 0xFFFF, 0xFFFF, + 0x200, 0x18); + // Climb down end A speed + ctx->genSlider("降終了Ａ速度", &m.mClimbDownEndASpeed, 0.0f, 10.0f, 0, NULL, 0xFFFF, 0xFFFF, + 0x200, 0x18); + // Climb down end CF (transition frame?) + ctx->genSlider("降終了ＣＦ", &m.mClimbDownEndCF, 0.0f, 20.0f, 0, NULL, 0xFFFF, 0xFFFF, 0x200, + 0x18); + // Climb down end interpolation + ctx->genSlider("降終了補間", &m.mClimbDownEndInterp, 0.0f, 10.0f, 0, NULL, 0xFFFF, 0xFFFF, + 0x200, 0x18); + // Movement minimum A speed + ctx->genSlider("移動最低Ａ速度", &m.mMoveMinASpeed, 0.0f, 10.0f, 0, NULL, 0xFFFF, 0xFFFF, 0x200, + 0x18); + // Movement maximum speed + ctx->genSlider("移動最高Ａ速度", &m.mMoveMaxSpeed, 0.0f, 10.0f, 0, NULL, 0xFFFF, 0xFFFF, 0x200, + 0x18); + // Movement interpolation + ctx->genSlider("移動補間", &m.mMoveInterp, 0.0f, 10.0f, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18); + // Wall attach animation + daAlinkHIO_setAnmGenMessage(&m.mWallAttachAnm, ctx, "壁飛付", 13.0f, 1); + // Wall approach offset + ctx->genSlider("壁飛付オフセット", &m.mWallApproachOffset, 0.0f, 300.0f, 0, NULL, 0xFFFF, + 0xFFFF, 0x200, 0x18); + // Wall attach miss animation + daAlinkHIO_setAnmGenMessage(&m.mWallAttachMissAnm, ctx, "壁飛付ミス", 47.0f, 1); + // Wall vertical movement minimum anm speed + ctx->genSlider("壁縦移動最低Ａ速度", &m.mWallVerticalMinAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xFFFF, + 0xFFFF, 0x200, 0x18); + // Wall vertical movement maximum anm speed + ctx->genSlider("壁縦移動最高Ａ速度", &m.mWallVerticalMaxAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xFFFF, + 0xFFFF, 0x200, 0x18); + // Wall horizontal movement minimum anm speed + ctx->genSlider("壁横移動最低Ａ速度", &m.mWallHorizontalMinAnmSpeed, 0.0f, 10.0f, 0, NULL, + 0xFFFF, 0xFFFF, 0x200, 0x18); + // Wall horizontal movement maximum anm speed + ctx->genSlider("壁横移動最高Ａ速度", &m.mWallHorizontalMaxAnmSpeed, 0.0f, 10.0f, 0, NULL, + 0xFFFF, 0xFFFF, 0x200, 0x18); +} + +daAlinkHIO_ladder_c::daAlinkHIO_ladder_c() { + static const char plabel[] = "const daAlinkHIO_ladder_c1 daAlinkHIO_ladder_c0::m = {\n"; + m_len = 112; + mp_src_data = (void*)&daAlinkHIO_ladder_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 18; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_roofHang_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Roof hang + daAlinkHIO_setAnmGenMessage(&m.mRoofHangAnm, ctx, "張付", 34.0f, 1); + // Standby A speed + ctx->genSlider("待機Ａ速度", &m.mStandbyASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Standby interpolation + ctx->genSlider("待機補間", &m.mStandbyInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Vertical movement minimum A speed + ctx->genSlider("縦移動最低Ａ速度", &m.mVertMoveMinASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Vertical movement maximum A speed + ctx->genSlider("縦移動最高Ａ速度", &m.mVertMoveMaxASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Vertical movement interpolation + ctx->genSlider("縦移動補間", &m.mVertMoveInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Vertical movement minimum speed + ctx->genSlider("縦移動最低速度", &m.mVertMoveMinSpeed, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Vertical movement maximum speed + ctx->genSlider("縦移動最高速度", &m.mVertMoveMaxSpeed, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Horizontal movement minimum A speed + ctx->genSlider("横移動最低Ａ速度", &m.mHorizMoveMinASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Horizontal movement maximum A speed + ctx->genSlider("横移動最高Ａ速度", &m.mHorizMoveMaxASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Horizontal movement interpolation + ctx->genSlider("横移動補間", &m.mHorizMoveInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Turn angle rate + ctx->genSlider("旋回角度率", &m.mTurnAngleRate, 0, 0x14, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Maximum turn angle + ctx->genSlider("旋回角度最大", &m.mMaxTurnAngle, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Minimum turn angle + ctx->genSlider("旋回角度最小", &m.mMinTurnAngle, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Invert A speed + ctx->genSlider("反転Ａ速度", &m.mInvertASpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Invert interpolation + ctx->genSlider("反転補間", &m.mInvertInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_roofHang_c::daAlinkHIO_roofHang_c() { + static const char plabel[] = "const daAlinkHIO_roofHang_c1 daAlinkHIO_roofHang_c0::m = {\n"; + m_len = 76; + mp_src_data = (void*)&daAlinkHIO_roofHang_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 4; + m_f32_num = 12; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_grab_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Force weight specification + ctx->genSlider("強制重さ指定", &m.mForceWeightSpec, 0, 3, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Preparation + daAlinkHIO_setAnmGenMessage(&m.mPrepareAnm, ctx, "準備", 4.0f, 0); + // Lift up + daAlinkHIO_setAnmGenMessage(&m.mLiftAnm, ctx, "持上", 9.0f, 1); + // Throw + daAlinkHIO_setAnmGenMessage(&m.mThrowAnm, ctx, "投げる", 39.0f, 1); + // Carry + daAlinkHIO_setAnmGenMessage(&m.mCarryAnm, ctx, "運び", 12.0f, 1); + // Lift back + daAlinkHIO_setReverseAnmGenMessage(&m.mLiftBackAnm, ctx, "持ち上げ後", 9.0f, 0); + // Stand reverse + daAlinkHIO_setReverseAnmGenMessage(&m.mStandReverseAnm, ctx, "立つ", 4.0f, 1); + // Recoil + daAlinkHIO_setAnmGenMessage(&m.mRecoilAnm, ctx, "反動", 19.0f, 1); + // Failure + daAlinkHIO_setAnmGenMessage(&m.mFailAnm, ctx, "失敗", 19.0f, 1); + // Failure stop time + ctx->genSlider("失敗停止時間", &m.mFailStopTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Carry lift + daAlinkHIO_setAnmGenMessage(&m.mCarryLiftAnm, ctx, "抱え上げ", 39.0f, 0); + // Carry place reverse + daAlinkHIO_setReverseAnmGenMessage(&m.mCarryPlaceReverseAnm, ctx, "抱え置き", 39.0f, 1); + // Iron ball throw + daAlinkHIO_setAnmGenMessage(&m.mIronBallThrowAnm, ctx, "鉄玉投げ", 49.0f, 1); +} + +daAlinkHIO_grab_c::daAlinkHIO_grab_c() { + static const char plabel[] = "const daAlinkHIO_grab_c1 daAlinkHIO_grab_c0::m = {\n"; + m_len = 228; + mp_src_data = (void*)&daAlinkHIO_grab_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 11; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 1; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_swim_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Start height + ctx->genSlider("開始高さ", &m.mStartHeight, 0.0f, 200.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Float up height + ctx->genSlider("浮上高さ", &m.mFloatUpHeight, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Float up + daAlinkHIO_setAnmGenMessage(&m.mFloatUpAnm, ctx, "浮上", 25.0f, 1); + // Turn rate + ctx->genSlider("旋回率", &m.mTurnRate, 0, 100, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max turn + ctx->genSlider("旋回最大", &m.mMaxTurn, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Min turn + ctx->genSlider("旋回最小", &m.mMinTurn, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Underwater turn rate + ctx->genSlider("水中旋回率", &m.mUnderwaterTurnRate, 0, 100, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Underwater max turn + ctx->genSlider("水中旋回最大", &m.mUnderwaterMaxTurn, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Underwater min turn + ctx->genSlider("水中旋回最小", &m.mUnderwaterMinTurn, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Forward min speed + ctx->genSlider("前最小速度", &m.mForwardMinSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Forward max speed + ctx->genSlider("前最高速度", &m.mForwardMaxSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Strafe max speed + ctx->genSlider("横最高速度", &m.mStrafeMaxSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Backward max speed + ctx->genSlider("後最高速度", &m.mBackwardMaxSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Underwater max speed + ctx->genSlider("水中最高速度", &m.mUnderwaterMaxSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Underwater button additional speed + ctx->genSlider("水中ボタン追加速度", &m.mUnderwaterButtonAdditionalSpeed, 0.0f, 50.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Underwater fall max speed + ctx->genSlider("水中落下時最高速度", &m.mUnderwaterFallMaxSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Acceleration + ctx->genSlider("加速", &m.mAcceleration, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Deceleration + ctx->genSlider("減速", &m.mDeceleration, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max fall speed + ctx->genSlider("最大落下速度", &m.mMaxFallSpeed, -100.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Standing max fall speed + ctx->genSlider("立ち最大落下速度", &m.mStandingMaxFallSpeed, -100.0f, 0.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Boots gravity + ctx->genSlider("ブーツ重力", &m.mBootsGravity, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Boots max fall speed + ctx->genSlider("ブーツ最大落下速度", &m.mBootsMaxFallSpeed, -100.0f, 0.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Max float up speed + ctx->genSlider("最大浮上速度", &m.mMaxFloatUpSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Buoyancy + ctx->genSlider("浮力", &m.mBuoyancy, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Wait anm speed + ctx->genSlider("待機Ａ速度", &m.mWaitAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Wait interpolation + ctx->genSlider("待機補間", &m.mWaitInterpolation, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Wait up down shake amount + ctx->genSlider("待機上下揺れ量", &m.mWaitUpDownShakeAmount, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Forward min anm speed + ctx->genSlider("前最小Ａ速度", &m.mForwardMinAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Forward max anm speed + ctx->genSlider("前最大Ａ速度", &m.mForwardMaxAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Strafe min anm speed + ctx->genSlider("横最小Ａ速度", &m.mStrafeMinAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Strafe max anm speed + ctx->genSlider("横最大Ａ速度", &m.mStrafeMaxAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Backward min anm speed + ctx->genSlider("後最小Ａ速度", &m.mBackwardMinAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Backward max anm speed + ctx->genSlider("後最大Ａ速度", &m.mBackwardMaxAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Underwater min anm speed + ctx->genSlider("水中最小Ａ速度", &m.mUnderwaterMinAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Underwater max anm speed + ctx->genSlider("水中最大Ａ速度", &m.mUnderwaterMaxAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Underwater additional A speed + ctx->genSlider("水中追加Ａ速度", &m.mUnderwaterAdditionalAnmSpeed, 0.0f, 5.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Movement interpolation + ctx->genSlider("移動補間", &m.mMoveInterpolation, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Climb height + ctx->genSlider("よじ登り高さ", &m.mClimbHeight, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Climb water surface under + ctx->genSlider("よじ登り水面下", &m.mClimbWaterSurfaceUnder, -100.0f, 0.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Normal buoyancy water depth + ctx->genSlider("通常浮力水深", &m.mNormalBuoyancyWaterDepth, 0.0f, 1000.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Zora clothes buoyancy + ctx->genSlider("ゾーラ服浮力", &m.mZoraClothesBuoyancy, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Dive + daAlinkHIO_setAnmGenMessage(&m.mDiveAnm, ctx, "潜り", 23.0f, 0); + // Underwater dive + daAlinkHIO_setAnmGenMessage(&m.mUnderwaterDiveAnm, ctx, "水中潜り", 23.0f, 0); + // Float up swim speed rate + ctx->genSlider("浮上泳ぎ速度率", &m.mFloatUpSwimSpeedRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Dash max speed + ctx->genSlider("Ｄ最高速度", &m.mDashMaxSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Dash deceleration + ctx->genSlider("Ｄ減速", &m.mDashDeceleration, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Dash min A speed + ctx->genSlider("Ｄ最小Ａ速度", &m.mDashMinAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Dash max A speed + ctx->genSlider("Ｄ最大Ａ速度", &m.mDashMaxAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Dash + daAlinkHIO_setAnmGenMessage(&m.mDashAnm, ctx, "ダッシュ", 37.0f, 0); +} + +daAlinkHIO_swim_c::daAlinkHIO_swim_c() { + static const char plabel[] = "const daAlinkHIO_swim_c1 daAlinkHIO_swim_c0::m = {\n"; + m_len = 252; + mp_src_data = (void*)&daAlinkHIO_swim_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 8; + m_f32_num = 39; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlMove_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max speed + ctx->genSlider("最高速度", &m.mMaxSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Idle A speed + ctx->genSlider("待機Ａ速度", &m.mIdleAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Walk A speed + ctx->genSlider("歩きＡ速度", &m.mWalkAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Brisk walk A speed + ctx->genSlider("速歩Ａ速度", &m.mBriskWalkAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Run A speed + ctx->genSlider("走りＡ速度", &m.mRunAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Quick run A speed + ctx->genSlider("速走Ａ速度", &m.mQuickRunAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Idle to walk rate + ctx->genSlider("待機→歩き率", &m.mIdleToWalkRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Walk to brisk walk rate + ctx->genSlider("歩き→速歩率", &m.mWalkToBriskWalkRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Standby run to run rate + ctx->genSlider("待走→走り率", &m.mStandbyRunToRunRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Run to quick run rate + ctx->genSlider("走り→速走率", &m.mRunToQuickRunRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Run A minimum blend rate + ctx->genSlider("走りＡ最低合成率", &m.mRunAnmMinBlendRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Normal interpolation + ctx->genSlider("通常補間", &m.mNormalInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Walk-run interpolation + ctx->genSlider("歩き走り補間", &m.mWalkRunInterpolation, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Idle interpolation + ctx->genSlider("待機補間", &m.mIdleInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Turn maximum + ctx->genSlider("旋回最大", &m.mTurnMax, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Turn minimum + ctx->genSlider("旋回最小", &m.mTurnMin, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Turn angle rate + ctx->genSlider("旋回角度率", &m.mTurnAngleRate, 0, 0x14, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Acceleration + ctx->genSlider("加速", &m.mAcceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Deceleration + ctx->genSlider("減速", &m.mDeceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Slip + daAlinkHIO_setAnmGenMessage(&m.mSlipAnm, ctx, "滑り", 14.0f, 0); + // Slip start rate + ctx->genSlider("滑り開始率", &m.mSlipStartRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Slip initial speed rate + ctx->genSlider("滑り初速率", &m.mSlipInitSpeedRate, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Slip deceleration + ctx->genSlider("滑り減速", &m.mSlipDeceleration, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Reverse turn + daAlinkHIO_setAnmGenMessage(&m.mReverseAnm, ctx, "反転", 14.0f, 1); + // Idle reverse start frame + ctx->genSlider("待機反転開始Ｆ", &m.mIdleReverseStartFrame, 0.0f, 14.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Reverse speed + ctx->genSlider("反転速度", &m.mReverseSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Reverse fall height + ctx->genSlider("反転落下高さ", &m.mReverseFallHeight, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Reverse fall interpolation + ctx->genSlider("反転落下補間", &m.mReverseFallInterpolation, 0.0f, 30.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Gaze max speed + ctx->genSlider("注目最高速度", &m.mGazeMaxSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Gaze idle A speed + ctx->genSlider("注目待機Ａ速度", &m.mGazeIdleAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // A Dash + daAlinkHIO_setAnmGenMessage(&m.mADashAnm, ctx, "Ａダッシュ", 19.0f, 1); + // A Dash duration + ctx->genSlider("Ａダッシュ時間", &m.mADashDuration, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // A Dash cooldown time + ctx->genSlider("Ａダッシュ禁止時間", &m.mADashCooldownTime, 0, 300, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // A Dash max speed + ctx->genSlider("Ａダッシュ最高速度", &m.mADashMaxSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // A Dash initial speed + ctx->genSlider("Ａダッシュ初速", &m.mADashInitSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // A Dash quick run A speed + ctx->genSlider("Ａダッシュ速走Ａ速度", &m.mADashQuickRunAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // A Dash acceleration + ctx->genSlider("Ａダッシュ加速", &m.mADashAcceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // A Dash duration (slow) + ctx->genSlider("Ａダッシュ時間（遅）", &m.mADashDurationSlow, 0, 300, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // A Dash cooldown time (slow) + ctx->genSlider("Ａダッシュ禁止時間（遅）", &m.mADashCooldownTimeSlow, 0, 300, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // A Dash max speed (slow) + ctx->genSlider("Ａダッシュ最高速度（遅）", &m.mADashMaxSpeedSlow, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // A Dash initial speed (slow) + ctx->genSlider("Ａダッシュ初速（遅）", &m.mADashInitSpeedSlow, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // A Dash quick run A speed (slow) + ctx->genSlider("Ａダッシュ速走Ａ速度（遅）", &m.mADashQuickRunASpeedSlow, 0.0f, 10.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // A Dash acceleration (slow) + ctx->genSlider("Ａダッシュ加速（遅）", &m.mADashAccelerationSlow, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // A Dash duration (slow 2) + ctx->genSlider("Ａダッシュ時間（遅２）", &m.mADashDurationSlow2, 0, 300, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // A Dash cooldown time (slow 2) + ctx->genSlider("Ａダッシュ禁止時間（遅２）", &m.mADashCooldownTimeSlow2, 0, 300, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // A Dash max speed (slow 2) + ctx->genSlider("Ａダッシュ最高速度（遅２）", &m.mADashMaxSpeedSlow2, 0.0f, 100.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // A Dash initial speed (slow 2) + ctx->genSlider("Ａダッシュ初速（遅２）", &m.mADashInitSpeedSlow2, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // A Dash quick run A speed (slow 2) + ctx->genSlider("Ａダッシュ速走Ａ速度（遅２）", &m.mADashQuickRunASpeedSlow2, 0.0f, 10.0f, 0, + NULL, 0xffff, 0xffff, 0x200, 0x18); + // A Dash acceleration (slow 2) + ctx->genSlider("Ａダッシュ加速（遅２）", &m.mADashAccelerationSlow2, 0.0f, 10.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Dash rebound + daAlinkHIO_setAnmGenMessage(&m.mDashReboundAnm, ctx, "ダッシュ跳返", 41.0f, 1); + // Dash rebound horizontal speed + ctx->genSlider("ダッシュ跳返水平速度", &m.mDashReboundHorizontalSpeed, 0.0f, 100.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Dash rebound vertical speed + ctx->genSlider("ダッシュ跳返垂直速度", &m.mDashReboundVerticalSpeed, 0.0f, 100.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_wlMove_c::daAlinkHIO_wlMove_c() { + static const char plabel[] = "const daAlinkHIO_wlMove_c1 daAlinkHIO_wlMove_c0::m = {\n"; + m_len = 256; + mp_src_data = (void*)&daAlinkHIO_wlMove_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 10; + m_f32_num = 39; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_wlMoveNoP_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max speed + ctx->genSlider("最高速度", &m.mMaxSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Idle animation speed + ctx->genSlider("待機Ａ速度", &m.mIdleAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Walk animation speed + ctx->genSlider("歩きＡ速度", &m.mWalkAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Jog animation speed + ctx->genSlider("速歩Ａ速度", &m.mJogAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Run animation speed + ctx->genSlider("走りＡ速度", &m.mRunAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Idle to walk rate + ctx->genSlider("待機→歩き率", &m.mIdleToWalkRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Walk to jog rate + ctx->genSlider("歩き→速歩率", &m.mWalkToJogRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Jog to run rate + ctx->genSlider("待走→走り率", &m.mJogToRunRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Run animation minimum blend rate + ctx->genSlider("走りＡ最低合成率", &m.mRunAnmMinBlendRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Walk run interpolation + ctx->genSlider("歩き走り補間", &m.mWalkRunInterpolation, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Max turn + ctx->genSlider("旋回最大", &m.mTurnMax, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Min turn + ctx->genSlider("旋回最小", &m.mTurnMin, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Turn angle rate + ctx->genSlider("旋回角度率", &m.mTurnAngleRate, 0, 0x14, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Acceleration + ctx->genSlider("加速", &m.mAcceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Deceleration + ctx->genSlider("減速", &m.mDeceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Slide start rate + ctx->genSlider("滑り開始率", &m.mSlideStartRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Slide initial speed + ctx->genSlider("滑り初速率", &m.mSlideInitSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Slide deceleration + ctx->genSlider("滑り減速", &m.mSlideDeceleration, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Reverse speed + ctx->genSlider("反転速度", &m.mReverseSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_wlMoveNoP_c::daAlinkHIO_wlMoveNoP_c() { + static const char plabel[] = "const daAlinkHIO_wlMoveNoP_c1 daAlinkHIO_wlMoveNoP_c0::m = {\n"; + m_len = 72; + mp_src_data = (void*)&daAlinkHIO_wlMoveNoP_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 0; + m_u8_num = 0; + m_s16_num = 4; + m_f32_num = 16; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_wlAtnMove_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max speed + ctx->genSlider("最高速度", &m.mMaxSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Acceleration + ctx->genSlider("加速度", &m.mAcceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Walk animation speed + ctx->genSlider("歩きＡ速度", &m.mWalkAnmSpeed, 0.01f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Run animation speed + ctx->genSlider("走りＡ速度", &m.mRunAnmSpeed, 0.01f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Walk change rate + ctx->genSlider("歩き変更率", &m.mWalkChangeRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Run change rate + ctx->genSlider("走り変更率", &m.mRunChangeRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Turn angle max + ctx->genSlider("旋回角度最大", &m.mTurnAngleMax, 0, 0x4000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Turn angle min + ctx->genSlider("旋回角度最小", &m.mTurnAngleMin, 0, 0x4000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Turn angle rate + ctx->genSlider("旋回角度率", &m.mTurnAngleRate, 0, 0x14, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Deceleration + ctx->genSlider("減速", &m.mDeceleration, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Rear max speed + ctx->genSlider("後方最高速度", &m.mRearMaxSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Rear acceleration + ctx->genSlider("後方加速度", &m.mRearAcceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Rear walk animation speed + ctx->genSlider("後歩Ａ速度", &m.mRearWalkAnmSpeed, 0.01f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Rear walk change rate + ctx->genSlider("後歩変更率", &m.mRearWalkChangeRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Rear deceleration + ctx->genSlider("後方減速", &m.mRearDeceleration, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_wlAtnMove_c::daAlinkHIO_wlAtnMove_c() { + static const char plabel[] = "const daAlinkHIO_wlAtnMove_c1 daAlinkHIO_wlAtnMove_c0::m = {\n"; + m_len = 56; + mp_src_data = (void*)&daAlinkHIO_wlAtnMove_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 0; + m_u8_num = 0; + m_s16_num = 4; + m_f32_num = 12; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_wlHowl_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Howl animation + daAlinkHIO_setAnmGenMessage(&m.mHowlAnm, ctx, "遠吠え", 49.0f, 1); + // Sitting howl animation + daAlinkHIO_setAnmGenMessage(&m.mSittingHowlAnm, ctx, "座遠吠え", 71.0f, 1); + // Threat animation + daAlinkHIO_setAnmGenMessage(&m.mThreatAnm, ctx, "威嚇", 14.0f, 1); + // Threat stance animation + daAlinkHIO_setAnmGenMessage(&m.mThreatStanceAnm, ctx, "威嚇ため", 17.0f, 0); + // Threat move interpolation + ctx->genSlider("威嚇移動補間", &m.mThreatMoveInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Threat move min anm speed + ctx->genSlider("威嚇移動最小Ａ速度", &m.mThreatMoveMinAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Threat move max anm speed + ctx->genSlider("威嚇移動最大Ａ速度", &m.mThreatMoveMaxAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Threat move rate + ctx->genSlider("威嚇移動率", &m.mThreatMoveRate, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_wlHowl_c::daAlinkHIO_wlHowl_c() { + static const char plabel[] = "const daAlinkHIO_wlHowl_c1 daAlinkHIO_wlHowl_c0::m = {\n"; + m_len = 96; + mp_src_data = (void*)&daAlinkHIO_wlHowl_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 4; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlSideStep_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Side jump animation + daAlinkHIO_setAnmGenMessage(&m.mSideJumpAnm, ctx, "横飛", 4.0f, 0); + // Side jump horizontal speed + ctx->genSlider("横飛水平速度", &m.mSideJumpHorizSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Side jump vertical speed + ctx->genSlider("横飛垂直速度", &m.mSideJumpVertSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Side landing animation + daAlinkHIO_setAnmGenMessage(&m.mSideLandAnm, ctx, "横着地", 23.0f, 1); + // Back jump animation + daAlinkHIO_setAnmGenMessage(&m.mBackJumpAnm, ctx, "後飛", 4.0f, 0); + // Back jump horizontal speed + ctx->genSlider("後飛水平速度", &m.mBackJumpHorizSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Back jump vertical speed + ctx->genSlider("後飛垂直速度", &m.mBackJumpVertSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Back landing animation + daAlinkHIO_setAnmGenMessage(&m.mBackLandAnm, ctx, "後着地", 23.0f, 1); + // Fall height + ctx->genSlider("落下高さ", &m.mFallHeight, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Fall interpolation + ctx->genSlider("落下補間", &m.mFallInterp, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_wlSideStep_c::daAlinkHIO_wlSideStep_c() { + static const char plabel[] = "const daAlinkHIO_wlSideStep_c1 daAlinkHIO_wlSideStep_c0::m = {\n"; + m_len = 104; + mp_src_data = (void*)&daAlinkHIO_wlSideStep_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 6; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlBackJump_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Back jump animation + daAlinkHIO_setAnmGenMessage(&m.mBackJumpAnm, ctx, "ジャンプ", 11.0f, 0); + // Back jump horizontal speed + ctx->genSlider("水平速度", &m.mBackJumpHorizSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Back jump vertical speed + ctx->genSlider("垂直速度", &m.mBackJumpVertSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Back landing animation + daAlinkHIO_setAnmGenMessage(&m.mBackLandAnm, ctx, "着地", 28.0f, 1); + // Fall height + ctx->genSlider("落下高さ", &m.mFallHeight, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Fall interpolation + ctx->genSlider("落下補間", &m.mFallInterp, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_wlBackJump_c::daAlinkHIO_wlBackJump_c() { + static const char plabel[] = "const daAlinkHIO_wlBackJump_c1 daAlinkHIO_wlBackJump_c0::m = {\n"; + m_len = 56; + mp_src_data = (void*)&daAlinkHIO_wlBackJump_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 4; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlAutoJump_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Gravity + ctx->genSlider("重力", &m.mGravity, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max fall speed + ctx->genSlider("最大落下速度", &m.mMaxFallSpeed, -300.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Jump animation + daAlinkHIO_setAnmGenMessage(&m.mJumpAnm, ctx, "ジャンプ", 3.0f, 0); + // Climb animation + daAlinkHIO_setAnmGenMessage(&m.mClimbAnm, ctx, "空中", 6.0f, 0); + // Jump limit speed + ctx->genSlider("ジャンプ限度速度", &m.mJumpLimitSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Jump min speed + ctx->genSlider("ジャンプ最低速度", &m.mJumpMinSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Jump max speed + ctx->genSlider("ジャンプ最高速度", &m.mJumpMaxSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Jump speed rate + ctx->genSlider("ジャンプ速度率", &m.mJumpSpeedRate, 0.0f, 5.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Jump angle + ctx->genSlider("ジャンプ角度", &m.mJumpAngle, 0, 0x4000, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Jump fall interpolation + ctx->genSlider("ジャンプ落下補間", &m.mJumpFallInterp, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Always max speed jump + ctx->genCheckBox("必ず最高速度ジャンプ", &m.mAlwaysMaxSpeedJump, '\x01', 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Landing animation + daAlinkHIO_setAnmGenMessage(&m.mLandingAnm, ctx, "着地", 24.0f, 1); + // Normal fall interpolation + ctx->genSlider("通常落下補間", &m.mNormalFallInterp, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Weak jump anm speed + ctx->genSlider("ジャンプA速度(弱)", &m.mWeakJumpAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Weak jump limit speed + ctx->genSlider("ジャンプ限度速度(弱)", &m.mWeakJumpLimitSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Weak jump min speed + ctx->genSlider("ジャンプ最低速度(弱)", &m.mWeakJumpMinSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Weak jump max speed + ctx->genSlider("ジャンプ最高速度(弱)", &m.mWeakJumpMaxSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Weak jump speed rate + ctx->genSlider("ジャンプ速度率(弱)", &m.mWeakJumpSpeedRate, 0.0f, 5.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Weak jump angle + ctx->genSlider("ジャンプ角度(弱)", &m.mWeakJumpAngle, 0, 0x4000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Hang limit height + ctx->genSlider("ぶら下がり限界高さ", &m.mHangLimitHeight, 0.0f, 1000.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); +} + +daAlinkHIO_wlAutoJump_c::daAlinkHIO_wlAutoJump_c() { + static const char plabel[] = "const daAlinkHIO_wlAutoJump_c1 daAlinkHIO_wlAutoJump_c0::m = {\n"; + m_len = 124; + mp_src_data = (void*)&daAlinkHIO_wlAutoJump_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 3; + m_u8_num = 4; + m_s16_num = 2; + m_f32_num = 14; + f14 = 1; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlPush_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Idle Anm Speed + ctx->genSlider("待機Ａ速度", &m.mIdleAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Idle Interpolation + ctx->genSlider("待機補間", &m.mIdleInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Push Anm Speed + ctx->genSlider("押しＡ速度", &m.mPushAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Heavy Push Anm Speed + ctx->genSlider("押しＡ速度（重）", &m.mHeavyPushAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Push Interpolation + ctx->genSlider("押し補間", &m.mPushInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_wlPush_c::daAlinkHIO_wlPush_c() { + static const char plabel[] = "const daAlinkHIO_wlPush_c1 daAlinkHIO_wlPush_c0::m = {\n"; + m_len = 20; + mp_src_data = (void*)&daAlinkHIO_wlPush_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 0; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 5; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlLie_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Sitting animation + daAlinkHIO_setAnmGenMessage(&m.mSittingAnm, ctx, "座り", 14.0f, 1); + // Sitting idle anm speed + ctx->genSlider("座り待機Ａ速度", &m.mSittingIdleAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Sitting idle interp + ctx->genSlider("座り待機補間", &m.mSittingIdleInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Stand up interp + ctx->genSlider("立ち上がり補間", &m.mStandUpInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Prone start animation + daAlinkHIO_setAnmGenMessage(&m.mProneStartAnm, ctx, "伏せ開始", 11.0f, 1); + // Prone min anm speed + ctx->genSlider("伏せ最小Ａ速度", &m.mProneMinAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Prone max anm speed + ctx->genSlider("伏せ最大Ａ速度", &m.mProneMaxAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Prone move interp + ctx->genSlider("伏せ移動補間", &m.mProneMoveInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Prone move rate + ctx->genSlider("伏せ移動率", &m.mProneMoveRate, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Prone turn rate + ctx->genSlider("伏せ旋回率", &m.mProneTurnRate, 0, 100, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Prone turn max + ctx->genSlider("伏せ旋回最大", &m.mProneTurnMax, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Prone turn min + ctx->genSlider("伏せ旋回最小", &m.mProneTurnMin, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_wlLie_c::daAlinkHIO_wlLie_c() { + static const char plabel[] = "const daAlinkHIO_wlLie_c1 daAlinkHIO_wlLie_c0::m = {\n"; + m_len = 76; + mp_src_data = (void*)&daAlinkHIO_wlLie_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 4; + m_f32_num = 7; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_wlWallHang_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Auto walk height + ctx->genSlider("自動歩き高さ", &m.mAutoWalkHeight, 0.0f, 300.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Small jump height + ctx->genSlider("小ジャンプ高さ", &m.mSmallJumpHeight, 0.0f, 300.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Wall grab height + ctx->genSlider("壁掴み高さ", &m.mWallGrabHeight, 0.0f, 300.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Climb height + ctx->genSlider("よじ登り高さ", &m.mClimbHeight, 0.0f, 300.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Hanging foot height + ctx->genSlider("ぶら下がり足位置高さ", &m.mHangingFootHeight, 0.0f, 300.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Jump horizontal speed + ctx->genSlider("ジャンプ水平速度", &m.mJumpHorizontalSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Jump target height offset + ctx->genSlider("ジャンプ目標高さオフセット", &m.mJumpTargetHeightOffset, 0.0f, 200.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Jump to fall interpolation + ctx->genSlider("ジャンプ→落下補間", &m.mJumpToFallInterp, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Pre-grab jump animation + daAlinkHIO_setAnmGenMessage(&m.mPreGrabJumpAnm, ctx, "掴前ジャンプ", 13.0f, 0); + // Wall grab animation + daAlinkHIO_setAnmGenMessage(&m.mWallGrabAnm, ctx, "壁掴み", 5.0f, 0); + // Climb animation + daAlinkHIO_setAnmGenMessage(&m.mClimbAnm, ctx, "よじ登り", 39.0f, 1); + // Fall grab animation + daAlinkHIO_setAnmGenMessage(&m.mFallGrabAnm, ctx, "落下掴み", 39.0f, 0); + // Hanging fall interpolation + ctx->genSlider("ぶら下がり落下補間", &m.mHangingFallInterp, 0.0f, 200.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Ledge climb animation + daAlinkHIO_setAnmGenMessage(&m.mLedgeClimbAnm, ctx, "段差登", 6.0f, 0); + // Ledge land animation + daAlinkHIO_setAnmGenMessage(&m.mLedgeLandAnm, ctx, "段差着地", 16.0f, 1); +} + +daAlinkHIO_wlWallHang_c::daAlinkHIO_wlWallHang_c() { + static const char plabel[] = "const daAlinkHIO_wlWallHang_c1 daAlinkHIO_wlWallHang_c0::m = {\n"; + m_len = 156; + mp_src_data = (void*)&daAlinkHIO_wlWallHang_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 6; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 9; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlDamNormal_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Forward animation + daAlinkHIO_setAnmGenMessage(&m.mForwardAnm, ctx, "前方", 9.0f, 1); + // Backward animation + daAlinkHIO_setAnmGenMessage(&m.mBackwardAnm, ctx, "後方", 9.0f, 1); + // Left animation + daAlinkHIO_setAnmGenMessage(&m.mLeftAnm, ctx, "左方", 9.0f, 1); + // Right animation + daAlinkHIO_setAnmGenMessage(&m.mRightAnm, ctx, "右方", 9.0f, 1); + // Initial speed + ctx->genSlider("初速", &m.mInitSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Attack speed rate + ctx->genSlider("攻撃速度率", &m.mAttackSpeedRate, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Deceleration + ctx->genSlider("減速", &m.mDeceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Ice damage A speed + ctx->genSlider("氷ダメージＡ速度", &m.mIceDamageAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_wlDamNormal_c::daAlinkHIO_wlDamNormal_c() { + static const char plabel[] = + "const daAlinkHIO_wlDamNormal_c1 daAlinkHIO_wlDamNormal_c0::m = {\n"; + m_len = 96; + mp_src_data = (void*)&daAlinkHIO_wlDamNormal_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 4; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlDamLaHu_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Damage interpolation + ctx->genSlider("ダメージ補間", &m.mDamageInterp, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Gravity + ctx->genSlider("重力", &m.mGravity, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Horizontal speed + ctx->genSlider("水平速度", &m.mHorizontalSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Vertical speed + ctx->genSlider("垂直速度", &m.mVerticalSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Deceleration + ctx->genSlider("減速", &m.mDeceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Bounce speed + ctx->genSlider("跳ね返り速度", &m.mBounceSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Body rotation speed + ctx->genSlider("体回転速度", &m.mBodyRotationSpeed, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Front rise animation + daAlinkHIO_setAnmGenMessage(&m.mFrontRiseAnm, ctx, "前起", 49.0f, 1); + // Back rise animation + daAlinkHIO_setAnmGenMessage(&m.mBackRiseAnm, ctx, "後起", 39.0f, 1); + // Left rise animation + daAlinkHIO_setAnmGenMessage(&m.mLeftRiseAnm, ctx, "左起", 34.0f, 1); + // Right rise animation + daAlinkHIO_setAnmGenMessage(&m.mRightRiseAnm, ctx, "右起", 34.0f, 1); +} + +daAlinkHIO_wlDamLaHu_c::daAlinkHIO_wlDamLaHu_c(int param_0) { + static void* baseP[] = { + (void*)&daAlinkHIO_wlDamLarge_c0::m, + (void*)&daAlinkHIO_wlDamHuge_c0::m, + }; + + static const char* plabel[] = { + "const daAlinkHIO_wlDamLaHu_c1 daAlinkHIO_wlDamLarge_c0::m = {\n", + "const daAlinkHIO_wlDamLaHu_c1 daAlinkHIO_wlDamHuge_c0::m = {\n", + }; + + m_len = 108; + mp_src_data = baseP[param_0]; + mp_data = (void*)&m; + m_name_string = plabel[param_0]; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 6; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_wlDamCaught_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Caught time + ctx->genSlider("捕まり時間", &m.mCaughtTime, 0, 1000, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Input decay time + ctx->genSlider("入力減り時間", &m.mInputDecayTime, 0, 0x1e, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Wait additional anm speed + ctx->genSlider("待機追加Ａ速度", &m.mWaitAddAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Wait interpolation + ctx->genSlider("待機補間", &m.mWaitInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_wlDamCaught_c::daAlinkHIO_wlDamCaught_c() { + static const char plabel[] = + "const daAlinkHIO_wlDamCaught_c1 daAlinkHIO_wlDamCaught_c0::m = {\n"; + m_len = 16; + mp_src_data = (void*)&daAlinkHIO_wlDamCaught_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 0; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 3; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlDamFall_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Small damage height + ctx->genSlider("小ダメージ高さ", &m.mSmallDamageHeight, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Large damage height + ctx->genSlider("大ダメージ高さ", &m.mLargeDamageHeight, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Air animation transition height + ctx->genSlider("空中アニメ移行高さ", &m.mAirAnmTransitionHeight, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Air animation interpolation + ctx->genSlider("空中アニメ補間", &m.mAirAnmInterp, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Landing animation + daAlinkHIO_setAnmGenMessage(&m.mLandingAnm, ctx, "着地", 11.0f, 0); + // Small damage landing start frame + ctx->genSlider("小ダメージ着地開始Ｆ", &m.mSmallDamageLandingStartFrame, 0.0f, 11.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Small stop time + ctx->genSlider("小停止時間", &m.mSmallStopTime, 0, 0x96, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Large stop time + ctx->genSlider("大停止時間", &m.mLargeStopTime, 0, 0x96, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Right rise animation + daAlinkHIO_setAnmGenMessage(&m.mRightRiseAnm, ctx, "起上り", 17.0f, 1); +} + +daAlinkHIO_wlDamFall_c::daAlinkHIO_wlDamFall_c() { + static const char plabel[] = "const daAlinkHIO_wlDamFall_c1 daAlinkHIO_wlDamFall_c0::m = {\n"; + m_len = 64; + mp_src_data = (void*)&daAlinkHIO_wlDamFall_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 5; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlDamage_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Normal + ctx->genNode("通常", &mNormal, 0, 0); + // Large + ctx->genNode("大", &mLarge, 0, 0); + // Strong large + ctx->genNode("強大", &mStrongLarge, 0, 0); + // Fall + ctx->genNode("落下", &mFall, 0, 0); + // Capture + ctx->genNode("捕縛", &mCapture, 0, 0); + // Running animation + daAlinkHIO_setAnmGenMessage(&m.mRunningAnm, ctx, "走り", 9.0f, 0); + // Polygon animation + daAlinkHIO_setAnmGenMessage(&m.mPolygonAnm, ctx, "ポリゴン", 9.0f, 1); + // Return wake-up anm speed + ctx->genSlider("復帰起き上がりＡ速度", &m.mReturnWakeupAnmSpeed, 1.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); +} + +daAlinkHIO_wlDamage_c::daAlinkHIO_wlDamage_c() + : mNormal(), mLarge(0), mStrongLarge(1), mFall(), mCapture() { + static const char plabel[] = "const daAlinkHIO_wlDamage_c1 daAlinkHIO_wlDamage_c0::m = {\n"; + m_len = 44; + mp_src_data = (void*)&daAlinkHIO_wlDamage_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 1; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +daAlinkHIO_wlDamCaught_c::~daAlinkHIO_wlDamCaught_c() {} +daAlinkHIO_wlDamFall_c::~daAlinkHIO_wlDamFall_c() {} +daAlinkHIO_wlDamLaHu_c::~daAlinkHIO_wlDamLaHu_c() {} +daAlinkHIO_wlDamNormal_c::~daAlinkHIO_wlDamNormal_c() {} + +void daAlinkHIO_wlSlide_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Sliding angle + ctx->genSlider("滑り角度", &m.mSlidingAngle, 0.0f, 90.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Climbing angle + ctx->genSlider("登坂角度", &m.mClimbingAngle, 0.0f, 90.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Climbing anm speed + ctx->genSlider("登坂Ａ速度", &m.mClimbingAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Climbing max speed + ctx->genSlider("登坂最高速度", &m.mClimbingMaxSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Front slide animation + daAlinkHIO_setAnmGenMessage(&m.mFrontSlideAnm, ctx, "前滑り", 24.0f, 0); + // Back slide animation + daAlinkHIO_setAnmGenMessage(&m.mBackSlideAnm, ctx, "後滑り", 7.0f, 0); + // Max speed + ctx->genSlider("最大速度", &m.mMaxSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Acceleration + ctx->genSlider("加速度", &m.mAcceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Landing animation + daAlinkHIO_setAnmGenMessage(&m.mLandingAnm, ctx, "着地", 14.0f, 1); + // Climbing anm speed (weak) + ctx->genSlider("登坂Ａ速度(弱)", &m.mClimbingAnmSpeedWeak, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Climbing max speed (weak) + ctx->genSlider("登坂最高速度(弱)", &m.mClimbingMaxSpeedWeak, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Slip down acceleration + ctx->genSlider("ずり落ち加速度", &m.mSlipDownAcceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Slip down max speed + ctx->genSlider("ずり落ち最高速度", &m.mSlipDownMaxSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Slip down rotation max + ctx->genSlider("ずり落ち回転最大", (short*)&m.mSlipDownRotationMax, 0, 0x7fff, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Slip down rotation min + ctx->genSlider("ずり落ち回転最小", (short*)&m.mSlipDownRotationMin, 0, 0x7fff, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Slip down recovery animation + daAlinkHIO_setAnmGenMessage(&m.mSlipDownRecoveryAnm, ctx, "ずり落ち復帰", 29.0f, 1); +} + +daAlinkHIO_wlSlide_c::daAlinkHIO_wlSlide_c() { + static const char plabel[] = "const daAlinkHIO_wlSlide_c1 daAlinkHIO_wlSlide_c0::m = {\n"; + m_len = 124; + mp_src_data = (void*)&daAlinkHIO_wlSlide_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 10; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlRope_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Movement Min Anm Speed + ctx->genSlider("移動最小Ａ速度", &m.mMovementMinAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Movement Max Anm Speed + ctx->genSlider("移動最大Ａ速度", &m.mMovementMaxAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Back Movement Max Anm Speed + ctx->genSlider("後移動最大Ａ速度", &m.mBackMovementMaxAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Movement Interpolation + ctx->genSlider("移動補間", &m.mMovementInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Movement Rate + ctx->genSlider("移動率", &m.mMovementRate, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Twist Climb Anm Speed + ctx->genSlider("よじ登りＡ速度", &m.mTwistClimbAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Fall Interpolation + ctx->genSlider("落下補間", &m.mFallInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Twist Climb Interpolation + ctx->genSlider("よじ登り補間", &m.mTwistClimbInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Flip + daAlinkHIO_setAnmGenMessage(&m.mFlipAnm, ctx, "反転", 16.0f, 0); + // Movement Sway Transition Time + ctx->genSlider("移動ふらつき移行時間", &m.mMovementSwayTransitionTime, 0, 0x7fff, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_wlRope_c::daAlinkHIO_wlRope_c() { + static const char plabel[] = "const daAlinkHIO_wlRope_c1 daAlinkHIO_wlRope_c0::m = {\n"; + m_len = 56; + mp_src_data = (void*)&daAlinkHIO_wlRope_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 8; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlAtWait_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Attack animation + daAlinkHIO_setAnmGenMessage(&m.mAttackAnm, ctx, "攻撃", field_0x34, 1); + // Speed + ctx->genSlider("速度", &m.mSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Speed addition F + ctx->genSlider("速度追加Ｆ", &m.mSpeedAddForward, 0.0f, field_0x34, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Attack judgment start F + ctx->genSlider("攻撃判定開始Ｆ", &m.mAttackJudgmentStartForward, 0.0f, field_0x34, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Attack judgment end F + ctx->genSlider("攻撃判定終了Ｆ", &m.mAttackJudgmentEndForward, 0.0f, field_0x34, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Stop time + ctx->genSlider("停止時間", (short*)&m.mStopTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Combo mid start F + ctx->genSlider("コンボ中開始Ｆ", &m.mComboMidStartF, 0.0f, field_0x34 + 1.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Combo mid C F + ctx->genSlider("コンボ中ＣＦ", &m.mComboMidCF, 0.0f, field_0x34 + 1.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Combo mid stop time + ctx->genSlider("コンボ中停止時間", (short*)&m.mComboMidStopTime, 0, 300, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Attack radius offset + ctx->genSlider("攻撃半径オフセット", &m.mAttackRadiusOffset, 0.0f, 200.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Attack radius + ctx->genSlider("攻撃半径", &m.mAttackRadius, 0.0f, 250.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack height + ctx->genSlider("攻撃高さ", &m.mAttackHeight, 0.0f, 250.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_wlAtWait_c::daAlinkHIO_wlAtWait_c(int param_0, float param_1) { + field_0x34 = param_1; + + static void* baseP[] = { + (void*)&daAlinkHIO_wlAtWaLr_c0::m, + (void*)&daAlinkHIO_wlAtWaTl_c0::m, + (void*)&daAlinkHIO_wlAtWaSc_c0::m, + }; + + static const char* plabel[] = { + "const daAlinkHIO_cutNormal_c1 daAlinkHIO_wlAtWaLr_c0::m = {\n", + "const daAlinkHIO_cutNormal_c1 daAlinkHIO_wlAtWaTl_c0::m = {\n", + "const daAlinkHIO_cutNormal_c1 daAlinkHIO_wlAtWaSc_c0::m = {\n", + }; + + m_len = 60; + mp_src_data = baseP[param_0]; + mp_data = (void*)&m; + m_name_string = plabel[param_0]; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 9; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlAtRoll_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Attack animation + daAlinkHIO_setAnmGenMessage(&m.mAttackAnm, ctx, "攻撃", 40.0f, 1); + // Spider thread escape start F + ctx->genSlider("クモ糸脱出時開始Ｆ", &m.mSpiderThreadEscapeStartF, 0.0f, 40.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Attack radius + ctx->genSlider("攻撃半径", &m.mAttackRadius, 0.0f, 1000.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack speed + ctx->genSlider("攻撃速度", &m.mAttackSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_wlAtRoll_c::daAlinkHIO_wlAtRoll_c() { + static const char plabel[] = "const daAlinkHIO_wlAtRoll_c1 daAlinkHIO_wlAtRoll_c0::m = {\n"; + m_len = 32; + mp_src_data = (void*)&daAlinkHIO_wlAtRoll_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 3; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlAtNjump_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Aerial Attack + daAlinkHIO_setAnmGenMessage(&m.mAerialAttackAnm, ctx, "攻撃", 6.0f, 0); + // Attack Initial Speed + ctx->genSlider("攻撃初速", &m.mAttackInitSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Max Horizontal Speed + ctx->genSlider("最高水平速度", &m.mMaxHorizontalSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Min Horizontal Speed + ctx->genSlider("最低水平速度", &m.mMinHorizontalSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Max Vertical Speed + ctx->genSlider("最高垂直速度", &m.mMaxVerticalSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Min Vertical Speed + ctx->genSlider("最低垂直速度", &m.mMinVerticalSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Aerial Anm Speed + ctx->genSlider("空中Ａ速度", &m.mAerialAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Aerial Interpolation + ctx->genSlider("空中補間", &m.mAerialInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack Radius Offset + ctx->genSlider("攻撃半径オフセット", &m.mAttackRadiusOffset, 0.0f, 200.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Attack Radius + ctx->genSlider("攻撃半径", &m.mAttackRadius, 0.0f, 250.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack Height + ctx->genSlider("攻撃高さ", &m.mAttackHeight, 0.0f, 250.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_wlAtNjump_c::daAlinkHIO_wlAtNjump_c() { + static const char plabel[] = "const daAlinkHIO_wlAtNjump_c1 daAlinkHIO_wlAtNjump_c0::m = {\n"; + m_len = 60; + mp_src_data = (void*)&daAlinkHIO_wlAtNjump_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 10; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlAtCjump_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Aerial Attack + daAlinkHIO_setAnmGenMessage(&m.mAerialAttackAnm, ctx, "攻撃", 3.0f, 0); + // Attack Initial Speed + ctx->genSlider("攻撃初速", &m.mAttackInitSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Max Horizontal Speed + ctx->genSlider("最高水平速度", &m.mMaxHorizontalSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Min Horizontal Speed + ctx->genSlider("最低水平速度", &m.mMinHorizontalSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Max Vertical Speed + ctx->genSlider("最高垂直速度", &m.mMaxVerticalSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Min Vertical Speed + ctx->genSlider("最低垂直速度", &m.mMinVerticalSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Aerial Anm Speed + ctx->genSlider("空中Ａ速度", &m.mAerialAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Aerial Interpolation + ctx->genSlider("空中補間", &m.mAerialInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack Radius Offset + ctx->genSlider("攻撃半径オフセット", &m.mAttackRadiusOffset, 0.0f, 200.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Attack Radius + ctx->genSlider("攻撃半径", &m.mAttackRadius, 0.0f, 250.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack Height + ctx->genSlider("攻撃高さ", &m.mAttackHeight, 0.0f, 250.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Flip Kick + daAlinkHIO_setAnmGenMessage(&m.mFlipKickAnm, ctx, "反転蹴り", 7.0f, 0); + // Flip Kick Post Start F + ctx->genSlider("反転蹴り後開始Ｆ", &m.mFlipKickPostStartF, 0.0f, 11.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Flip Kick Post Anm Speed + ctx->genSlider("反転蹴り後Ａ速度", &m.mFlipKickPostAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Hit Decel Rate + ctx->genSlider("ヒット時減速率", &m.mHitDecelRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Hit Min Speed + ctx->genSlider("ヒット時最低速度", &m.mHitMinSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Hit Decel + ctx->genSlider("ヒット時減速", &m.mHitDecel, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_wlAtCjump_c::daAlinkHIO_wlAtCjump_c() { + static const char plabel[] = "const daAlinkHIO_wlAtCjump_c1 daAlinkHIO_wlAtCjump_c0::m = {\n"; + m_len = 100; + mp_src_data = (void*)&daAlinkHIO_wlAtCjump_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 15; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlAtLand_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Normal Landing + daAlinkHIO_setAnmGenMessage(&m.mNormalLandingAnm, ctx, "通常着地", 19.0f, 1); + // Front Slide + daAlinkHIO_setAnmGenMessage(&m.mFrontSlideAnm, ctx, "前滑", 14.0f, 1); + // Back Slide + daAlinkHIO_setAnmGenMessage(&m.mBackSlideAnm, ctx, "後滑", 19.0f, 1); + // Slide Deceleration + ctx->genSlider("滑り減速", &m.mSlideDeceleration, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} +daAlinkHIO_wlAtLand_c::daAlinkHIO_wlAtLand_c() { + static const char plabel[] = "const daAlinkHIO_wlAtLand_c1 daAlinkHIO_wlAtLand_c0::m = {\n"; + m_len = 64; + mp_src_data = (void*)&daAlinkHIO_wlAtLand_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 3; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 1; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlAtDown_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Low Stance + daAlinkHIO_setAnmGenMessage(&m.mLowStanceAnm, ctx, "開始", 3.0f, 0); + // Push Down + daAlinkHIO_setAnmGenMessage(&m.mPushDownAnm, ctx, "滞空", 16.0f, 0); + // Side Roll Movement Width + ctx->genSlider("垂直速度", &m.mSideRollMovementWidth, 0.0f, 200.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Front Roll + daAlinkHIO_setAnmGenMessage(&m.mFrontRollAnm, ctx, "着地", 21.0f, 0); + // Crouch + daAlinkHIO_setAnmGenMessage(&m.mCrouchAnm, ctx, "引き", 49.0f, 0); + // Prone Get Up + daAlinkHIO_setAnmGenMessage(&m.mProneGetUpAnm, ctx, "引き抜き", 8.0f, 0); + // Back Roll + daAlinkHIO_setAnmGenMessage(&m.mBackRollAnm, ctx, "後転", 11.0f, 0); + // Landing Side Roll Movement Width + ctx->genSlider("後転垂直速度", &m.mLandingSideRollMovementWidth, 0.0f, 200.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Landing Front-Back Movement Width + ctx->genSlider("後転水平速度", &m.mLandingFrontBackMovementWidth, 0.0f, 200.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Roll Over + daAlinkHIO_setAnmGenMessage(&m.mRollOverAnm, ctx, "失敗", 84.0f, 1); + // Fall Duration + ctx->genSlider("停止時間", (s16*)&m.mFallDuration, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_wlAtDown_c::daAlinkHIO_wlAtDown_c() { + static const char plabel[] = "const daAlinkHIO_wlAtDown_c1 daAlinkHIO_wlAtDown_c0::m = {\n"; + m_len = 156; + mp_src_data = (void*)&daAlinkHIO_wlAtDown_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 7; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 3; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlAtLock_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Start Radius + ctx->genSlider("開始半径", &m.mStartRadius, 0.0f, 10000.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Max Radius + ctx->genSlider("最大半径", &m.mMaxRadius, 0.0f, 10000.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Radius Acceleration + ctx->genSlider("半径加速", &m.mRadiusAcceleration, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack Speed + ctx->genSlider("攻撃速度", &m.mAttackSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Attack Radius Offset + ctx->genSlider("攻撃半径オフセット", &m.mAttackRadiusOffset, 0.0f, 200.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Attack Radius + ctx->genSlider("攻撃半径", &m.mAttackRadius, 0.0f, 250.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Attack Height + ctx->genSlider("攻撃高さ", &m.mAttackHeight, 0.0f, 250.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Auto Activation Time + ctx->genSlider("自動発動時間", &m.mAutoActivationTime, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Front Landing Anm + daAlinkHIO_setAnmGenMessage(&m.mFrontLandingAnm, ctx, "前着地", 14.0f, 0); + // Rear Landing Anm + daAlinkHIO_setAnmGenMessage(&m.mRearLandingAnm, ctx, "後着地", 19.0f, 0); + // Gravity + ctx->genSlider("重力", &m.mGravity, -15.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max Jump Height + ctx->genSlider("最大ジャンプ高さ", &m.mMaxJumpHeight, 0.0f, 5000.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Max Jump Distance + ctx->genSlider("最大ジャンプ距離", &m.mMaxJumpDistance, 0.0f, 10000.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_wlAtLock_c::daAlinkHIO_wlAtLock_c() { + static const char plabel[] = "const daAlinkHIO_wlAtLock_c1 daAlinkHIO_wlAtLock_c0::m = {\n"; + m_len = 84; + mp_src_data = (void*)&daAlinkHIO_wlAtLock_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 10; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_wlAtBite_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Enemy Bite Throw Anm Speed + ctx->genSlider("敵咥投げＡ速度", &m.mEnemyBiteThrowAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Enemy Bite Throw Interpolation + ctx->genSlider("敵咥投げ補間", &m.mEnemyBiteThrowInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Enemy Bite Throw CF + ctx->genSlider("敵咥投げＣＦ", &m.mEnemyBiteThrowCF, 0.0f, 45.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Bite Attach Time + ctx->genSlider("噛付き時間", &m.mBiteAttachTime, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Bite Preparation + daAlinkHIO_setAnmGenMessage(&m.mBitePreparationAnm, ctx, "噛準備", 5.0f, 0); + // Bite Preparation Mid Start F + ctx->genSlider("噛準備途中開始Ｆ", &m.mBitePreparationMidStartF, 0.0f, 5.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Bite Mid Anm Speed Min + ctx->genSlider("噛中Ａ速度最小", &m.mBiteMidAnmSpeedMin, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Bite Mid Anm Speed Max + ctx->genSlider("噛中Ａ速度最大", &m.mBiteMidAnmSpeedMax, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Bite Mid Anm Speed Acceleration + ctx->genSlider("噛中Ａ速度加速", &m.mBiteMidAnmSpeedAcceleration, 0.0f, 1.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Bite Mid Anm Speed Deceleration + ctx->genSlider("噛中Ａ速度減速", &m.mBiteMidAnmSpeedDeceleration, 0.0f, 1.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Hanging Bite Preparation + daAlinkHIO_setAnmGenMessage(&m.mHangingBitePreparationAnm, ctx, "ぶら下がり噛準備", 31.0f, 0); + // Hanging Bite Mid Anm Speed Min + ctx->genSlider("ぶら下がり噛中Ａ速度最小", &m.mHangingBiteMidAnmSpeedMin, 0.0f, 10.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Hanging Bite Mid Anm Speed Max + ctx->genSlider("ぶら下がり噛中Ａ速度最大", &m.mHangingBiteMidAnmSpeedMax, 0.0f, 10.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Hanging Bite Mid Anm Speed Acceleration + ctx->genSlider("ぶら下がり噛中Ａ速度加速", &m.mHangingBiteMidAnmSpeedAcceleration, 0.0f, 1.0f, + 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Hanging Bite Mid Anm Speed Deceleration + ctx->genSlider("ぶら下がり噛中Ａ速度減速", &m.mHangingBiteMidAnmSpeedDeceleration, 0.0f, 1.0f, + 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_wlAtBite_c::daAlinkHIO_wlAtBite_c() { + static const char plabel[] = "const daAlinkHIO_wlAtBite_c1 daAlinkHIO_wlAtBite_c0::m = {\n"; + m_len = 92; + mp_src_data = (void*)&daAlinkHIO_wlAtBite_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 12; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_wlAttack_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Horizontal + ctx->genNode("左右", &mHorizontalAttack, 0, 0); + // Scratch + ctx->genNode("引掻き", &mScratchAttack, 0, 0); + // Tail + ctx->genNode("尻尾", &mTailAttack, 0, 0); + // Jump + ctx->genNode("ジャンプ", &mWlAtNjump, 0, 0); + // Corkscrew (Kick) + ctx->genNode("きりもみ（蹴り）", &mWlAtCjump, 0, 0); + // Landing + ctx->genNode("着地", &mWlAtLand, 0, 0); + // Rotation + ctx->genNode("回転", &mAtRoll, 0, 0); + // Down + ctx->genNode("ダウン", &mWlAtDown, 0, 0); + // Lock + ctx->genNode("ロック", &mWlAtLock, 0, 0); + // Bite + ctx->genNode("噛付き", &mWlAtBite, 0, 0); + // Attack Preparation Interpolation + ctx->genSlider("攻撃準備補間", &m.mReadyInterpolation, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Charge Time + ctx->genSlider("ため時間", &m.mChargeTime, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Fall Height + ctx->genSlider("落下高さ", &m.mFallHeight, 0.0f, 500.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Fall Interpolation + ctx->genSlider("落下補間", &m.mFallInterpolation, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Combo Duration Time + ctx->genSlider("コンボ持続時間", &m.mComboDuration, 0, 300, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Stationary Attack Distance + ctx->genSlider("その場攻撃距離", &m.mAttackRange, 0.0f, 1000.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Jump Back Landing + daAlinkHIO_setAnmGenMessage(&m.mJumpBackLandAnm, ctx, "跳返着地", 59.0f, 1); + // Jump Back Horizontal Speed + ctx->genSlider("跳返水平速度", &m.mJumpBackSpeedH, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Jump Back Vertical Speed + ctx->genSlider("跳返垂直速度", &m.mJumpBackSpeedV, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // A Attack Vertical Speed + ctx->genSlider("Ａ攻撃垂直速度", &m.mJumpAttackSpeedV, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // A Attack Horizontal Speed + ctx->genSlider("Ａ攻撃水平速度", &m.mJumpAttackSpeedH, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_wlAttack_c::daAlinkHIO_wlAttack_c() + : mHorizontalAttack(0, 41.0f), mScratchAttack(1, 18.0f), mTailAttack(2, 42.0f), mAtRoll(), + mWlAtNjump(), mWlAtCjump(), mWlAtLand(), mWlAtDown(), mWlAtLock(), mWlAtBite() { + static const char plabel[] = "const daAlinkHIO_wlAttack_c1 daAlinkHIO_wlAttack_c0::m = {\n"; + m_len = 56; + mp_src_data = (void*)&daAlinkHIO_wlAttack_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 1; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 8; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +daAlinkHIO_wlAtBite_c::~daAlinkHIO_wlAtBite_c() {} +daAlinkHIO_wlAtLock_c::~daAlinkHIO_wlAtLock_c() {} +daAlinkHIO_wlAtDown_c::~daAlinkHIO_wlAtDown_c() {} +daAlinkHIO_wlAtLand_c::~daAlinkHIO_wlAtLand_c() {} +daAlinkHIO_wlAtCjump_c::~daAlinkHIO_wlAtCjump_c() {} +daAlinkHIO_wlAtNjump_c::~daAlinkHIO_wlAtNjump_c() {} +daAlinkHIO_wlAtRoll_c::~daAlinkHIO_wlAtRoll_c() {} +daAlinkHIO_wlAtWait_c::~daAlinkHIO_wlAtWait_c() {} + +void daAlinkHIO_wlPoint_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Idle Anm Speed + ctx->genSlider("待機Ａ速度", &m.mIdleAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Idle Interpolation + ctx->genSlider("待機補間", &m.mIdleInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Forward Jump + daAlinkHIO_setAnmGenMessage(&m.mForwardJumpAnm, ctx, "前ジャンプ", 6.0f, 0); + // Backward Jump + daAlinkHIO_setAnmGenMessage(&m.mBackwardJumpAnm, ctx, "後ジャンプ", 7.0f, 0); + // Aerial Interpolation + ctx->genSlider("空中補間", &m.mAerialInterpolation, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Jump Speed + ctx->genSlider("ジャンプ速度", &m.mJumpSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Landing + daAlinkHIO_setAnmGenMessage(&m.mLandingAnm, ctx, "着地", 11.0f, 1); + // Failure Jump Speed + ctx->genSlider("失敗時ジャンプ速度", &m.mFailureJumpSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Tag Jump Speed + ctx->genSlider("タグジャンプ速度", &m.mTagJumpSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Tag Landing + daAlinkHIO_setAnmGenMessage(&m.mTagLandingAnm, ctx, "タグ着地", 14.0f, 1); + // Lock Landing Ice Initial Speed + ctx->genSlider("ロック着地氷初期速度", &m.mLockLandingIceInitSpeed, 0.0f, 50.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Lock Landing Ice Deceleration Rate + ctx->genSlider("ロック着地氷減速率", &m.mLockLandingIceDecelRate, 0.0f, 1.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Lock Landing Ice Max Deceleration + ctx->genSlider("ロック着地氷減速最大", &m.mLockLandingIceMaxDecel, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Lock Landing Ice Min Deceleration + ctx->genSlider("ロック着地氷減速最小", &m.mLockLandingIceMinDecel, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Lock Jump Stop Time + ctx->genSlider("ロックジャンプ停止時間", &m.mLockJumpStopTime, 0, 100, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); +} + +daAlinkHIO_wlPoint_c::daAlinkHIO_wlPoint_c() { + static const char plabel[] = "const daAlinkHIO_wlPoint_c1 daAlinkHIO_wlPoint_c0::m = {\n"; + m_len = 124; + mp_src_data = (void*)&daAlinkHIO_wlPoint_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 4; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 10; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_wlChain_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Lowering start + daAlinkHIO_setAnmGenMessage(&m.mLoweringStartAnm, ctx, "下がり始め", 49.0f, 0); + // Wait Anm Speed + ctx->genSlider("待機Ａ速度", &m.mWaitAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Wait Interp + ctx->genSlider("待機補間", &m.mWaitInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Swing Anm Speed + ctx->genSlider("振りＡ速度", &m.mSwingAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Swing Interp + ctx->genSlider("振り補間", &m.mSwingInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Tension Wait Time + ctx->genSlider("引張り待ち時間", &m.mTensionWaitTime, 0, 1000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Fall Speed + ctx->genSlider("落下速度", &m.mFallSpeed, 0.0f, 30.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Release Wait Time + ctx->genSlider("放し待ち時間", &m.mReleaseWaitTime, 0, 1000, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Dig + daAlinkHIO_setAnmGenMessage(&m.mDigAnm, ctx, "掘る", 81.0f, 0); + // Dig fall + daAlinkHIO_setAnmGenMessage(&m.mDigFallAnm, ctx, "掘落下", 47.0f, 0); + // Sniff Anm Speed + ctx->genSlider("嗅ぐＡ速度", &m.mSniffAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Sniff Interp + ctx->genSlider("嗅ぐ補間", &m.mSniffInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +daAlinkHIO_wlChain_c::daAlinkHIO_wlChain_c() { + static const char plabel[] = "const daAlinkHIO_wlChain_c1 daAlinkHIO_wlChain_c0::m = {\n"; + m_len = 92; + mp_src_data = (void*)&daAlinkHIO_wlChain_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 3; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 7; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlSwim_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Start Height + ctx->genSlider("開始高さ", &m.mStartHeight, 0.0f, 200.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Surfacing Height + ctx->genSlider("浮上高さ", &m.mSurfacingHeight, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Surfacing + daAlinkHIO_setAnmGenMessage(&m.mSurfacingAnm, ctx, "浮上", 25.0f, 1); + // Turn Rate + ctx->genSlider("旋回率", &m.mTurnRate, 0, 100, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Turn Max + ctx->genSlider("旋回最大", &m.mTurnMax, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Turn Min + ctx->genSlider("旋回最小", &m.mTurnMin, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Idle Turn Rate + ctx->genSlider("待機旋回率", &m.mIdleTurnRate, 0, 100, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Idle Turn Max + ctx->genSlider("待機旋回最大", &m.mIdleTurnMax, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Idle Turn Min + ctx->genSlider("待機旋回最小", &m.mIdleTurnMin, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Max Speed + ctx->genSlider("最高速度", &m.mMaxSpeed, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Deceleration + ctx->genSlider("減速", &m.mDeceleration, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Max Fall Speed + ctx->genSlider("最大落下速度", &m.mMaxFallSpeed, -100.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Max Surfacing Speed + ctx->genSlider("最大浮上速度", &m.mMaxSurfacingSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Buoyancy + ctx->genSlider("浮力", &m.mBuoyancy, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Idle Anm Speed + ctx->genSlider("待機Ａ速度", &m.mIdleAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Idle Interp + ctx->genSlider("待機補間", &m.mIdleInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Idle Up-Down Sway Amount + ctx->genSlider("待機上下揺れ量", &m.mIdleUpDownSwayAmount, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Move Min Anm Speed + ctx->genSlider("移動最小Ａ速度", &m.mMoveMinAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Move Max Anm Speed + ctx->genSlider("移動最大Ａ速度", &m.mMoveMaxAnmSpeed, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Move Interp + ctx->genSlider("移動補間", &m.mMoveInterp, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Climb Height + ctx->genSlider("よじ登り高さ", &m.mClimbHeight, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Climb Below Water Surface + ctx->genSlider("よじ登り水面下", &m.mClimbBelowWaterSurface, -100.0f, 0.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Max Speed (Weak) + ctx->genSlider("最高速度（弱）", &m.mMaxSpeedWeak, 0.0f, 50.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Deceleration (Weak) + ctx->genSlider("減速（弱）", &m.mDecelerationWeak, 0.0f, 20.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Idle Anm Speed (Weak) + ctx->genSlider("待機Ａ速度（弱）", &m.mIdleAnmSpeedWeak, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Move Min Anm Speed (Weak) + ctx->genSlider("移動最小Ａ速度（弱）", &m.mMoveMinAnmSpeedWeak, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Move Max Anm Speed (Weak) + ctx->genSlider("移動最大Ａ速度（弱）", &m.mMoveMaxAnmSpeedWeak, 0.0f, 10.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Water Splash Idle + daAlinkHIO_setAnmGenMessage(&m.mWaterSplashIdleAnm, ctx, "水弾き待機", 45.0f, 1); + // Heavy Idle Up-Down Sway Amount + ctx->genSlider("重時待機上下揺れ量", &m.mHeavyIdleUpDownSwayAmount, 0.0f, 10.0f, 0, NULL, + 0xffff, 0xffff, 0x200, 0x18); + // Heavy Buoyancy + ctx->genSlider("重時浮力", &m.mHeavyBuoyancy, 0.0f, 10.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Heavy Max Fall Speed + ctx->genSlider("重時最大落下速度", &m.mHeavyMaxFallSpeed, -100.0f, 0.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Heavy Max Surfacing Speed + ctx->genSlider("重時最大浮上速度", &m.mHeavyMaxSurfacingSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, + 0xffff, 0x200, 0x18); + // Dash + daAlinkHIO_setAnmGenMessage(&m.mDashAnm, ctx, "ダッシュ", 31.0f, 1); +} + +daAlinkHIO_wlSwim_c::daAlinkHIO_wlSwim_c() { + static const char plabel[] = "const daAlinkHIO_wlSwim_c1 daAlinkHIO_wlSwim_c0::m = {\n"; + m_len = 168; + mp_src_data = (void*)&daAlinkHIO_wlSwim_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 3; + m_u8_num = 0; + m_s16_num = 6; + m_f32_num = 24; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlGrab_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Pot Grab + daAlinkHIO_setAnmGenMessage(&m.mPotGrabAnm, ctx, "壷咥え", 20.0f, 1); + // Pot Release + daAlinkHIO_setReverseAnmGenMessage(&m.mPotReleaseAnm, ctx, "壷置く", 20.0f, 1); + // Bone Grab + daAlinkHIO_setAnmGenMessage(&m.mBoneGrabAnm, ctx, "骨咥え", 14.0f, 1); + // Bone Release + daAlinkHIO_setReverseAnmGenMessage(&m.mBoneReleaseAnm, ctx, "骨置く", 14.0f, 1); + // Throw + daAlinkHIO_setAnmGenMessage(&m.mThrowAnm, ctx, "投げ", 19.0f, 1); +} + +daAlinkHIO_wlGrab_c::daAlinkHIO_wlGrab_c() { + static const char plabel[] = "const daAlinkHIO_wlGrab_c1 daAlinkHIO_wlGrab_c0::m = {\n"; + m_len = 100; + mp_src_data = (void*)&daAlinkHIO_wlGrab_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 5; + m_u8_num = 0; + m_s16_num = 0; + m_f32_num = 0; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +void daAlinkHIO_wlBall_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Full Body + daAlinkHIO_setAnmGenMessage(&m.mFullBodyAnm, ctx, "全身", 64.0f, 1); + // Neck + daAlinkHIO_setAnmGenMessage(&m.mNeckAnm, ctx, "首", 54.0f, 0); + // Life Orb Gravity + ctx->genSlider("命珠重力", &m.mLifeOrbGravity, -10.0f, 0.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Life Orb Horizontal Speed + ctx->genSlider("命珠水平速度", &m.mLifeOrbHorizSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Life Orb Vertical Speed + ctx->genSlider("命珠垂直速度", &m.mLifeOrbVertSpeed, 0.0f, 100.0f, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // MP Consumption Time + ctx->genSlider("ＭＰ消費時間", &m.mMpConsumptionTime, 0, 0xff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); +} + +daAlinkHIO_wlBall_c::daAlinkHIO_wlBall_c() { + static const char plabel[] = "const daAlinkHIO_wlBall_c1 daAlinkHIO_wlBall_c0::m = {\n"; + m_len = 56; + mp_src_data = (void*)&daAlinkHIO_wlBall_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 2; + m_u8_num = 0; + m_s16_num = 2; + m_f32_num = 3; + f14 = 0; + f18 = 0; + f1c = 1; + checkDataSize(); +} + +void daAlinkHIO_wolf_c::genMessage(JORMContext* ctx) { + // Reset + ctx->genButton("リセット", 0x4000003, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Move + ctx->genNode("移動", &mWlMove, 0, 0); + // Move (Weak) + ctx->genNode("移動(弱)", &mWlMoveNoP, 0, 0); + // Attention Move + ctx->genNode("注目移動", &mWlAtnMove, 0, 0); + // Side Jump + ctx->genNode("横っ飛び", &mWlSideStep, 0, 0); + // Back Jump + ctx->genNode("バックジャンプ", &mWlBackJump, 0, 0); + // Howl / Intimidate + ctx->genNode("遠吠・威嚇", &mWlHowl, 0, 0); + // Auto Jump + ctx->genNode("オートジャンプ", &mWlAutoJump, 0, 0); + // Push + ctx->genNode("押し", &mWlPush, 0, 0); + // Lie Down + ctx->genNode("伏せ", &mWlLie, 0, 0); + // Light + ctx->genNode("ライト", &mLight, 0, 0); + // Wall Grab + ctx->genNode("壁掴み", &mWlWallHang, 0, 0); + // Damage + ctx->genNode("ダメージ", &mWlDamage, 0, 0); + // Slope Slide + ctx->genNode("坂滑り", &mWlSlide, 0, 0); + // Rope Walk + ctx->genNode("綱渡り", &mWlRope, 0, 0); + // Attack + ctx->genNode("攻撃", &mWlAttack, 0, 0); + // Small Platform Jump + ctx->genNode("小足場飛", &mWlPoint, 0, 0); + // Chain, Dig + ctx->genNode("鎖、掘る", &mWlChain, 0, 0); + // Swim + ctx->genNode("泳ぎ", &mWlSwim, 0, 0); + // Grab + ctx->genNode("咥え", &mWlGrab, 0, 0); + // Life Orb + ctx->genNode("命珠", &mWlBall, 0, 0); + // Max Neck Turn H + ctx->genSlider("首横向き最大", &m.mMaxNeckTurnH, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Max Neck Turn Up + ctx->genSlider("首上向き最大", &m.mMaxNeckTurnUp, -0x7fff, 0, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Max Neck Turn Down + ctx->genSlider("首下向き最大", &m.mMaxNeckTurnDown, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Max Tired Neck Turn H + ctx->genSlider("疲れ首横向き最大", &m.mMaxTiredNeckTurnH, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Max Tired Neck Turn Up + ctx->genSlider("疲れ首上向き最大", &m.mMaxTiredNeckTurnUp, -0x7fff, 0, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Max Tired Neck Turn Down + ctx->genSlider("疲れ首下向き最大", &m.mMaxTiredNeckTurnDown, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, + 0x200, 0x18); + // Senses Linger Time + ctx->genSlider("五感余韻時間", &m.mSensesLingerTime, 0, 0x7fff, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Underwater Input Rate + ctx->genSlider("沼キー率", &m.mUnderwaterInputRate, 0.0f, 1.0f, 0, NULL, 0xffff, 0xffff, 0x200, + 0x18); + // Light Drop R + ctx->genSlider("光雫Ｒ", &m.mLightDropR, -0x40, 0x40, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Light Drop G + ctx->genSlider("光雫Ｇ", &m.mLightDropG, -0x40, 0x40, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Light Drop B + ctx->genSlider("光雫Ｂ", &m.mLightDropB, -0x40, 0x40, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); +} + +// NONMATCHING +daAlinkHIO_wolf_c::daAlinkHIO_wolf_c() + : mWlMove(), mWlMoveNoP(), mWlAtnMove(), mWlSideStep(), mWlBackJump(), mWlHowl(), mWlAutoJump(), + mWlPush(), mWlLie(), mLight(1), mWlWallHang(), mWlDamage(), mWlSlide(), mWlRope(), + mWlAttack(), mWlPoint(), mWlChain(), mWlSwim(), mWlGrab(), mWlBall() { + static const char plabel[] = "const daAlinkHIO_wolf_c1 daAlinkHIO_wolf_c0::m = {\n"; + m_len = 24; + mp_src_data = (void*)&daAlinkHIO_wolf_c0::m; + mp_data = (void*)&m; + m_name_string = plabel; + baseCopy(); + m_anm_num = 0; + m_u8_num = 0; + m_s16_num = 10; + m_f32_num = 1; + f14 = 0; + f18 = 0; + f1c = 0; + checkDataSize(); +} + +daAlinkHIO_wlBall_c::~daAlinkHIO_wlBall_c() {} +daAlinkHIO_wlGrab_c::~daAlinkHIO_wlGrab_c() {} +daAlinkHIO_wlSwim_c::~daAlinkHIO_wlSwim_c() {} +daAlinkHIO_wlChain_c::~daAlinkHIO_wlChain_c() {} +daAlinkHIO_wlPoint_c::~daAlinkHIO_wlPoint_c() {} +daAlinkHIO_wlAttack_c::~daAlinkHIO_wlAttack_c() {} +daAlinkHIO_wlRope_c::~daAlinkHIO_wlRope_c() {} +daAlinkHIO_wlSlide_c::~daAlinkHIO_wlSlide_c() {} +daAlinkHIO_wlDamage_c::~daAlinkHIO_wlDamage_c() {} +daAlinkHIO_wlWallHang_c::~daAlinkHIO_wlWallHang_c() {} +daAlinkHIO_wlLie_c::~daAlinkHIO_wlLie_c() {} +daAlinkHIO_wlPush_c::~daAlinkHIO_wlPush_c() {} +daAlinkHIO_wlAutoJump_c::~daAlinkHIO_wlAutoJump_c() {} +daAlinkHIO_wlHowl_c::~daAlinkHIO_wlHowl_c() {} +daAlinkHIO_wlBackJump_c::~daAlinkHIO_wlBackJump_c() {} +daAlinkHIO_wlSideStep_c::~daAlinkHIO_wlSideStep_c() {} +daAlinkHIO_wlAtnMove_c::~daAlinkHIO_wlAtnMove_c() {} +daAlinkHIO_wlMoveNoP_c::~daAlinkHIO_wlMoveNoP_c() {} +daAlinkHIO_wlMove_c::~daAlinkHIO_wlMove_c() {} + +void daAlinkHIO_c::jumpStateUpdate(const cXyz* param_0, const cXyz* param_1, f32 param_2) { + char buf[68]; + + f32 xDiff = param_0->x - param_1->x; + f32 zDiff = param_0->z - param_1->z; + JORMContext* ctx = attachJORMContext(8); + ctx->startUpdateNode(this); + sprintf(buf, "水平距離 %-8.3f", JMAFastSqrt(xDiff * xDiff + zDiff * zDiff)); + ctx->updateLabel(2, 0x4000006, buf); + sprintf(buf, "最頂点 %-8.3f", param_2); + ctx->updateLabel(2, 0x4000007, buf); + ctx->endUpdateNode(); + releaseJORMContext(ctx); +} + +void daAlinkHIO_c::genMessage(JORMContext* ctx) { + // ------ Info Display ------ + ctx->genLabel("------情報表示------", 0x4000001, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Horizontal Distance + ctx->genLabel("水平距離", 0x4000006, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Vertical Distance + ctx->genLabel("最頂点", 0x4000007, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Reset + ctx->genButton("位置", 0x4000002, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Save to File + ctx->genButton("ファイルに保存", 0x4000004, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Load File + ctx->genButton("ファイル読込", 0x4000005, 0, NULL, 0xffff, 0xffff, 0x200, 0x18); + // Basic + ctx->genNode("基本", &mBasic, 0, 0); + // Move + ctx->genNode("移動", &mMove, 0, 0); + // Atn Move + ctx->genNode("注目移動", &mAtnMove, 0, 0); + // No Act Atn Move + ctx->genNode("空注目移動", &mNoActAtnMove, 0, 0); + // Front Roll + ctx->genNode("前転", &mFrontRoll, 0, 0); + // Back Jump + ctx->genNode("バク転", &mBackJump, 0, 0); + // Side Step + ctx->genNode("横っ飛び", &mSideStep, 0, 0); + // Slide + ctx->genNode("坂滑り", &mSlide, 0, 0); + // Cut + ctx->genNode("剣振り", &mCut, 0, 0); + // Guard + ctx->genNode("ガード関連", &mGuard, 0, 0); + // Crouch + ctx->genNode("しゃがみ関連", &mCrouch, 0, 0); + // Auto Jump + ctx->genNode("オートジャンプ", &mAutoJump, 0, 0); + // Wall Hang + ctx->genNode("壁掴み関連", &mWallHang, 0, 0); + // Pushpull + ctx->genNode("押し引き", &mPushpull, 0, 0); + // Damage + ctx->genNode("ダメージ", &mDamage, 0, 0); + // Horse + ctx->genNode("馬", &mHorse, 0, 0); + // Canoe + ctx->genNode("カヌー", &mCanoe, 0, 0); + // Item + ctx->genNode("アイテム", &mItem, 0, 0); + // Ladder, Wall Climb + ctx->genNode("はしご、壁登", &mLadder, 0, 0); + // Ceiling Hang + ctx->genNode("天井ぶら下がり", &mRoofHang, 0, 0); + // Grab + ctx->genNode("持上げ", &mGrab, 0, 0); + // Swim + ctx->genNode("泳ぎ", &mSwim, 0, 0); + // Wolf + ctx->genNode("狼", &mWolf, 0, 0); +} + +void daAlinkHIO_c::readFileData(char* param_0) { + int src; + daAlinkHIO_data_c* top; + src = 0; + + for (top = l_HIO_top; top != NULL; top = top->mpNext) { + cLib_memCpy(top->mp_src_data, param_0 + src, top->m_len); + top->update(); + src += top->m_len; + } +} + +size_t daAlinkHIO_c::makeFileOutData(char* param_0, char* param_1) { + size_t sVar1; + int iVar2; + daAlinkHIO_data_c* top; + iVar2 = 0; + + for (top = l_HIO_top; top != NULL; top = top->mpNext) { + cLib_memCpy(param_0 + iVar2, top->mp_data, top->m_len); + iVar2 += top->m_len; + } + + param_0[iVar2] = 10; + iVar2++; + top = l_HIO_top; + *param_1 = 0; + + for (; top != NULL; top = top->mpNext) { + top->setStructData(param_1); + } + + cLib_memCpy(param_0 + iVar2, param_1, strlen(param_1)); + return iVar2 + strlen(param_1); +} + +void daAlinkHIO_c::listenPropertyEvent(const JORPropertyEvent* event) { + fopAc_ac_c* player = dComIfGp_getPlayer(0); + JORReflexible::listenPropertyEvent(event); + JORFile aJStack_168; + + switch ((u32)event->id) { + case 0x4000002: { + OS_REPORT("X = %f, Y = %f, Z = %f,\n", player->current.pos.x, player->current.pos.y, + player->current.pos.z); + OS_REPORT("SHAPE_ANGLE = %x, %d\n", player->shape_angle.y, player->shape_angle.y); + OS_REPORT("CURRENT_ANGLE = %x, %d\n", player->current.angle.y, player->current.angle.y); + + // "%s, Room No. %d, Start Position %d, Layer %d" + OS_REPORT("%s, 部屋Ｎｏ %d, 開始位置 %d, レイヤー %d\n", dComIfGp_getStartStageName(), + fopAcM_GetRoomNo(player), dComIfGs_getStartPoint(), + dComIfG_play_c::getLayerNo(0)); + break; + } + case 0x4000004: { + if (aJStack_168.open(6, "すべてのファイル(*.*)\0*.*\0", 0, 0, 0) != 0) { + char* buffer1 = new (0x20) char[0x10000]; + char* buffer2 = new (0x20) char[0x10000]; + + if (buffer1 != NULL && buffer2 != NULL) { + size_t uVar5 = makeFileOutData(buffer1, buffer2); + aJStack_168.writeData(buffer1, uVar5); + + // Write area %x\n + OS_REPORT("書き込み領域%x\n", uVar5); + + if (uVar5 > 0x20000) { + // Memory corruption has occurred!!!!! + OS_REPORT("メモリ破壊が起こりました！！！！！\n"); + } + + delete[] buffer1; + delete[] buffer2; + + } else { + if (buffer1 != NULL) { + delete[] buffer1; + } + + if (buffer2 != NULL) { + delete[] buffer2; + } + + // Could not secure the write area + OS_REPORT("書き込み用領域確保できませんでした\n"); + } + + aJStack_168.close(); + } else { + // Cannot open file + OS_REPORT("ファイルが開けません\n"); + } + break; + } + case 0x4000005: { + if (aJStack_168.open(1, "すべてのファイル(*.*)\0*.*\0", (char*)0x0, (char*)0x0, (char*)0x0) != 0) { + char* buffer1 = new (0x20) char[0x10000]; + + if (buffer1 != NULL) { + aJStack_168.readData(buffer1, 0); + readFileData(buffer1); + delete[] buffer1; + } else { + // Could not secure the read area + OS_REPORT("読み込み用領域確保できませんでした\n"); + } + + aJStack_168.close(); + } else { + // The file cannot be opened + OS_REPORT("ファイルが開けません\n"); + } + } + } +} + +#endif diff --git a/src/d/actor/d_a_alink_HIO_data.inc b/src/d/actor/d_a_alink_HIO_data.inc index 9125bc78076..a27867accce 100644 --- a/src/d/actor/d_a_alink_HIO_data.inc +++ b/src/d/actor/d_a_alink_HIO_data.inc @@ -3149,13 +3149,11 @@ const daAlinkHIO_wlAtLock_c1 daAlinkHIO_wlAtLock_c0::m = { 2.0f, 20.0f, }, - { - 120, - 100.0f, - 550.0f, - 25.0f, - 85.0f, - }, + 120, + 100.0f, + 550.0f, + 25.0f, + 85.0f, 80.0f, 60.0f, 120.0f, @@ -3247,13 +3245,11 @@ const daAlinkHIO_wlPoint_c1 daAlinkHIO_wlPoint_c0::m = { 3.0f, 3.0f, }, - { - 20, - 1.0f, - 3.0f, - 5.0f, - 50.0f, - }, + 20, + 1.0f, + 3.0f, + 5.0f, + 50.0f, 45.0f, 65.0f, 15.0f, diff --git a/src/d/actor/d_a_alink_boom.inc b/src/d/actor/d_a_alink_boom.inc index 33f8daedcf2..0395a4e2ed1 100644 --- a/src/d/actor/d_a_alink_boom.inc +++ b/src/d/actor/d_a_alink_boom.inc @@ -117,7 +117,7 @@ BOOL daAlink_c::checkBoomerangCarry(fopAc_ac_c* i_grabActor) { setGrabItemActor(i_grabActor); field_0x33e4 = 38.0f; - setGrabUpperAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setGrabUpperAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); return 1; } @@ -459,7 +459,7 @@ int daAlink_c::procBoomerangMove() { if (field_0x2f98 != 3) { field_0x2f98 = 3; - var_f31 = daAlinkHIO_basic_c0::m.mAnmBlendFactor; + var_f31 = daAlinkHIO_basic_c0::m.mBasicInterpolation; } } else { offModeFlg(1); diff --git a/src/d/actor/d_a_alink_bottle.inc b/src/d/actor/d_a_alink_bottle.inc index 15095721a27..067f90dc8d4 100644 --- a/src/d/actor/d_a_alink_bottle.inc +++ b/src/d/actor/d_a_alink_bottle.inc @@ -290,7 +290,7 @@ int daAlink_c::commonBottleDrink(int param_0) { { if (checkAnmEnd(frameCtrl_p)) { if (mDemo.getDemoMode() == daPy_demo_c::DEMO_UNK_42_e) { - setSingleAnimeParam(ANM_PICK_UP, &daAlinkHIO_pickUp_c0::m.field_0x14); + setSingleAnimeParam(ANM_PICK_UP, &daAlinkHIO_pickUp_c0::m.mPlaceAnm); } else { allUnequip(mKeepItem == fpcNm_ITEM_KANTERA); } diff --git a/src/d/actor/d_a_alink_bow.inc b/src/d/actor/d_a_alink_bow.inc index 6073002231a..6f292b789be 100644 --- a/src/d/actor/d_a_alink_bow.inc +++ b/src/d/actor/d_a_alink_bow.inc @@ -640,7 +640,7 @@ int daAlink_c::procBowMove() { if (field_0x2f98 != 3) { field_0x2f98 = 3; - var_f31 = daAlinkHIO_basic_c0::m.mAnmBlendFactor; + var_f31 = daAlinkHIO_basic_c0::m.mBasicInterpolation; } current.angle.y = shape_angle.y - 0x4000; } else { diff --git a/src/d/actor/d_a_alink_copyrod.inc b/src/d/actor/d_a_alink_copyrod.inc index 2340ab0d4e3..99f52e79de6 100644 --- a/src/d/actor/d_a_alink_copyrod.inc +++ b/src/d/actor/d_a_alink_copyrod.inc @@ -365,7 +365,7 @@ int daAlink_c::procCopyRodMove() { if (field_0x2f98 != 3) { field_0x2f98 = 3; - var_f31 = daAlinkHIO_basic_c0::m.mAnmBlendFactor; + var_f31 = daAlinkHIO_basic_c0::m.mBasicInterpolation; } } else { offModeFlg(1); diff --git a/src/d/actor/d_a_alink_cut.inc b/src/d/actor/d_a_alink_cut.inc index 8d01205b6d4..e75605e5388 100644 --- a/src/d/actor/d_a_alink_cut.inc +++ b/src/d/actor/d_a_alink_cut.inc @@ -177,8 +177,17 @@ bool daAlink_c::checkCutTurnInput() const { /* 800D1424-800D1430 0CBD64 000C+00 7/7 0/0 0/0 .text getCutTurnDirection__9daAlink_cCFv */ +// Debug version is correct, but breaks other versions due no longer inlining int daAlink_c::getCutTurnDirection() const { +#if VERSION == VERSION_SHIELD_DEBUG + if (field_0x3180 < 0) { + return 1; + } else { + return 0; + } +#else return field_0x3180 < 0; +#endif } /* 800D1430-800D1454 0CBD70 0024+00 17/17 0/0 0/0 .text resetCombo__9daAlink_cFi */ diff --git a/src/d/actor/d_a_alink_damage.inc b/src/d/actor/d_a_alink_damage.inc index f97890351dc..320b34c579f 100644 --- a/src/d/actor/d_a_alink_damage.inc +++ b/src/d/actor/d_a_alink_damage.inc @@ -449,7 +449,7 @@ BOOL daAlink_c::checkDamageAction() { if ((!checkModeFlg(0x70C52)) && (!checkWolf()) && (!checkDkCaught2Anime())) { setUpperAnimeBase(getMainBckData(ANM_HORSE_WAIT_D_B)->m_underID); setFacePriAnime(ANM_HORSE_WAIT_D_B); - field_0x30f6 = daAlinkHIO_damCaught_c0::m.field_0x14; + field_0x30f6 = daAlinkHIO_damCaught_c0::m.mGrabDuration; field_0x2f96 = 1; field_0x2f97 = 6; onNoResetFlg1(FLG1_UNK_100000); @@ -831,8 +831,8 @@ int daAlink_c::procDamageInit(dCcD_GObjInf* param_0, int param_1) { var_r29->y, var_r29->z * var_f29 + var_r29->x * var_f30); - mProcVar2.field_0x300c = cLib_minMaxLimit(cM_atan2s(sp88.z, sp88.y), -daAlinkHIO_damNormal_c0::m.field_0x50, daAlinkHIO_damNormal_c0::m.field_0x50); - mProcVar3.field_0x300e = cLib_minMaxLimit(cM_atan2s(sp88.x, -JMAFastSqrt(sp88.y * sp88.y + sp88.z * sp88.z)), -daAlinkHIO_damNormal_c0::m.field_0x52, daAlinkHIO_damNormal_c0::m.field_0x52); + mProcVar2.field_0x300c = cLib_minMaxLimit(cM_atan2s(sp88.z, sp88.y), -daAlinkHIO_damNormal_c0::m.mFrontBackBodyMaxAngle, daAlinkHIO_damNormal_c0::m.mFrontBackBodyMaxAngle); + mProcVar3.field_0x300e = cLib_minMaxLimit(cM_atan2s(sp88.x, -JMAFastSqrt(sp88.y * sp88.y + sp88.z * sp88.z)), -daAlinkHIO_damNormal_c0::m.mLeftRightBodyMaxAngle, daAlinkHIO_damNormal_c0::m.mLeftRightBodyMaxAngle); if (freeze_player) { var_f31 = 0.0f; @@ -850,23 +850,23 @@ int daAlink_c::procDamageInit(dCcD_GObjInf* param_0, int param_1) { int direction = getDirectionFromAngle(cM_atan2s(-sp88.x, -sp88.z)); if (direction == DIR_FORWARD) { - setSingleAnimeParam(ANM_DMG_SMALL_A, &daAlinkHIO_damNormal_c0::m.field_0x0); - field_0x3478 = daAlinkHIO_damNormal_c0::m.field_0x0.mCancelFrame; + setSingleAnimeParam(ANM_DMG_SMALL_A, &daAlinkHIO_damNormal_c0::m.mFrontAnm); + field_0x3478 = daAlinkHIO_damNormal_c0::m.mFrontAnm.mCancelFrame; } else if (direction == DIR_BACKWARD) { - setSingleAnimeParam(ANM_DMG_SMALL_B, &daAlinkHIO_damNormal_c0::m.field_0x14); - field_0x3478 = daAlinkHIO_damNormal_c0::m.field_0x14.mCancelFrame; + setSingleAnimeParam(ANM_DMG_SMALL_B, &daAlinkHIO_damNormal_c0::m.mRearAnm); + field_0x3478 = daAlinkHIO_damNormal_c0::m.mRearAnm.mCancelFrame; } else if (direction == DIR_LEFT) { - setSingleAnimeParam(ANM_DMG_SMALL_LEFT, &daAlinkHIO_damNormal_c0::m.field_0x28); - field_0x3478 = daAlinkHIO_damNormal_c0::m.field_0x28.mCancelFrame; + setSingleAnimeParam(ANM_DMG_SMALL_LEFT, &daAlinkHIO_damNormal_c0::m.mLeftAnm); + field_0x3478 = daAlinkHIO_damNormal_c0::m.mLeftAnm.mCancelFrame; } else { - setSingleAnimeParam(ANM_DMG_SMALL_RIGHT, &daAlinkHIO_damNormal_c0::m.field_0x3C); - field_0x3478 = daAlinkHIO_damNormal_c0::m.field_0x3C.mCancelFrame; + setSingleAnimeParam(ANM_DMG_SMALL_RIGHT, &daAlinkHIO_damNormal_c0::m.mRightAnm); + field_0x3478 = daAlinkHIO_damNormal_c0::m.mRightAnm.mCancelFrame; } current.angle.y = var_r29->atan2sX_Z(); mProcVar4.field_0x3010 = current.angle.y; - mNormalSpeed = var_r29->absXZ() * daAlinkHIO_damNormal_c0::m.field_0x58 + daAlinkHIO_damNormal_c0::m.field_0x54; + mNormalSpeed = var_r29->absXZ() * daAlinkHIO_damNormal_c0::m.mAttackSpeedRate + daAlinkHIO_damNormal_c0::m.mInitialSpeed; if (mNormalSpeed > daAlinkHIO_move_c0::m.mMaxSpeed) { mNormalSpeed = daAlinkHIO_move_c0::m.mMaxSpeed; } @@ -875,7 +875,7 @@ int daAlink_c::procDamageInit(dCcD_GObjInf* param_0, int param_1) { field_0x347c = M_PI / (frame_ctrl->getEnd() - frame_ctrl->getStart()); if (freeze_player) { - frame_ctrl->setRate(daAlinkHIO_damNormal_c0::m.field_0x60); + frame_ctrl->setRate(daAlinkHIO_damNormal_c0::m.mIceDamageASpeed); frame_ctrl->setEnd(7); mNormalSpeed = 0.0f; mProcVar0.mIceFreezeTimer = 90; @@ -898,7 +898,7 @@ int daAlink_c::procDamage() { mBodyAngle.z = -mProcVar3.field_0x300e * var_f31; mBodyAngle.y = 0; - cLib_chaseF(&mNormalSpeed, 0.0f, daAlinkHIO_damNormal_c0::m.field_0x5C); + cLib_chaseF(&mNormalSpeed, 0.0f, daAlinkHIO_damNormal_c0::m.mDeceleration); if (checkFreezeDamage()) { freezeTimerDamage(); @@ -1070,11 +1070,11 @@ int daAlink_c::procCoLargeDamageInit(int param_0, int param_1, s16 param_2, s16 var_r29 = &daAlinkHIO_wlDamHuge_c0::m; } - setSpecialGravity(var_r29->field_0x54, maxFallSpeed, 0); - mProcVar4.field_0x3010 = var_r29->field_0x50; - field_0x3478 = var_r29->field_0x64; - field_0x347c = var_r29->field_0x68; - setSingleAnimeWolfBaseMorf((daAlink_c::daAlink_WANM)field_0x3198, var_r29->field_0x58); + setSpecialGravity(var_r29->mGravity, maxFallSpeed, 0); + mProcVar4.field_0x3010 = var_r29->mBodyRotationSpeed; + field_0x3478 = var_r29->mBounceSpeed; + field_0x347c = var_r29->mDeceleration; + setSingleAnimeWolfBaseMorf((daAlink_c::daAlink_WANM)field_0x3198, var_r29->mDamageInterp); setFaceBasicTexture(FTANM_UNK_91); } else { if (param_1 != 0) { @@ -1083,11 +1083,11 @@ int daAlink_c::procCoLargeDamageInit(int param_0, int param_1, s16 param_2, s16 var_r28 = &daAlinkHIO_damHuge_c0::m; } - setSpecialGravity(var_r28->field_0xA4, maxFallSpeed, 0); - mProcVar4.field_0x3010 = var_r28->field_0xA0; - field_0x3478 = var_r28->field_0xB4; - field_0x347c = var_r28->field_0xB8; - setSingleAnimeBaseMorf((daAlink_c::daAlink_ANM)field_0x3198, var_r28->field_0xA8); + setSpecialGravity(var_r28->mGravity, maxFallSpeed, 0); + mProcVar4.field_0x3010 = var_r28->mBodyRotateRate; + field_0x3478 = var_r28->mBounceSpeed; + field_0x347c = var_r28->mDeceleration; + setSingleAnimeBaseMorf((daAlink_c::daAlink_ANM)field_0x3198, var_r28->mDamageBlend); } if (param_0 < 0) { @@ -1103,11 +1103,11 @@ int daAlink_c::procCoLargeDamageInit(int param_0, int param_1, s16 param_2, s16 speed.y = field_0x340c; } else { if (checkWolf()) { - mNormalSpeed = var_r29->field_0x5C; - speed.y = var_r29->field_0x60; + mNormalSpeed = var_r29->mHorizontalSpeed; + speed.y = var_r29->mVerticalSpeed; } else { - mNormalSpeed = var_r28->field_0xAC; - speed.y = var_r28->field_0xB0; + mNormalSpeed = var_r28->mHorizontalSpeed; + speed.y = var_r28->mVerticalSpeed; } if (param_0 == -6) { @@ -1134,9 +1134,9 @@ int daAlink_c::procCoLargeDamageInit(int param_0, int param_1, s16 param_2, s16 } } else { if (checkWolf()) { - mNormalSpeed = var_r29->field_0x64; + mNormalSpeed = var_r29->mBounceSpeed; } else { - mNormalSpeed = var_r28->field_0xB4; + mNormalSpeed = var_r28->mBounceSpeed; } current.pos.x += 35.0f * cM_ssin(current.angle.y); @@ -1270,7 +1270,7 @@ int daAlink_c::procLargeDamageUpInit(int param_0, int param_1, s16 param_2, s16 setSingleAnimeBase(ANM_DMG_FBW); field_0x32cc = 0x88; - field_0x3478 = var_r30->field_0x14.mCancelFrame; + field_0x3478 = var_r30->mBackGetUpAnm.mCancelFrame; field_0x3480 = 39.0f; field_0x3484 = 1000.0f; } else if (param_0 < 0) { @@ -1288,7 +1288,7 @@ int daAlink_c::procLargeDamageUpInit(int param_0, int param_1, s16 param_2, s16 var_f31 = 1.0f; mProcVar0.field_0x3008 = -1; - field_0x3478 = var_r30->field_0x0.mCancelFrame; + field_0x3478 = var_r30->mFrontGetUpAnm.mCancelFrame; field_0x3480 = 39.0f; field_0x2f9d = 4; field_0x3484 = 18.0f; @@ -1296,14 +1296,14 @@ int daAlink_c::procLargeDamageUpInit(int param_0, int param_1, s16 param_2, s16 if (param_0 == -2) { var_f30 = 0.0f; } else { - var_f30 = daAlinkHIO_damLarge_c0::m.field_0x14.mInterpolation; + var_f30 = daAlinkHIO_damLarge_c0::m.mBackGetUpAnm.mInterpolation; } field_0x3484 = 9.0f; var_r28 = ANM_DMG_LARGE_LAND; var_f29 = 9.0f; var_r27 = -1; - field_0x3478 = var_r30->field_0x14.mCancelFrame; + field_0x3478 = var_r30->mBackGetUpAnm.mCancelFrame; if (param_0 == -5 && mDemo.getParam1() > 0) { mProcVar0.field_0x3008 = mDemo.getParam1(); @@ -1331,27 +1331,27 @@ int daAlink_c::procLargeDamageUpInit(int param_0, int param_1, s16 param_2, s16 field_0x2f9d = 4; if (param_0 == 0x84) { - setSingleAnimeParam(ANM_DMG_LARGE_LAND, &var_r30->field_0x14); - field_0x3478 = var_r30->field_0x14.mCancelFrame; + setSingleAnimeParam(ANM_DMG_LARGE_LAND, &var_r30->mBackGetUpAnm); + field_0x3478 = var_r30->mBackGetUpAnm.mCancelFrame; mProcVar1.field_0x300a = 1; field_0x3480 = 39.0f; field_0x32cc = 0x88; field_0x3484 = 9.0f; } else if (param_0 == 0x85) { - setSingleAnimeParam(ANM_DMG_AIR_LEFT_LAND, &var_r30->field_0x28); - field_0x3478 = var_r30->field_0x28.mCancelFrame; + setSingleAnimeParam(ANM_DMG_AIR_LEFT_LAND, &var_r30->mLeftGetUpAnm); + field_0x3478 = var_r30->mLeftGetUpAnm.mCancelFrame; field_0x3480 = 29.0f; field_0x32cc = 0x89; field_0x3484 = 6.0f; } else if (param_0 == 0x86) { - setSingleAnimeParam(ANM_DMG_AIR_RIGHT_LAND, &var_r30->field_0x3C); - field_0x3478 = var_r30->field_0x3C.mCancelFrame; + setSingleAnimeParam(ANM_DMG_AIR_RIGHT_LAND, &var_r30->mRightGetUpAnm); + field_0x3478 = var_r30->mRightGetUpAnm.mCancelFrame; field_0x3480 = 29.0f; field_0x32cc = 0x8A; field_0x3484 = 6.0f; } else { - setSingleAnimeParam(ANM_DMG_AIR_LAND, &var_r30->field_0x0); - field_0x3478 = var_r30->field_0x0.mCancelFrame; + setSingleAnimeParam(ANM_DMG_AIR_LAND, &var_r30->mFrontGetUpAnm); + field_0x3478 = var_r30->mFrontGetUpAnm.mCancelFrame; field_0x3480 = 39.0f; field_0x32cc = 0x87; field_0x3484 = 18.0f; @@ -1383,7 +1383,7 @@ int daAlink_c::procLargeDamageUp() { return 1; } - setSingleAnime(ANM_DMG_LARGE_LAND, daAlinkHIO_damLarge_c0::m.field_0x14.mSpeed, 9.0f, -1, daAlinkHIO_damLarge_c0::m.field_0x14.mInterpolation); + setSingleAnime(ANM_DMG_LARGE_LAND, daAlinkHIO_damLarge_c0::m.mBackGetUpAnm.mSpeed, 9.0f, -1, daAlinkHIO_damLarge_c0::m.mBackGetUpAnm.mInterpolation); field_0x3198 = -3; field_0x347c = 2.0f / (field_0x3478 - 9.0f); } @@ -1492,19 +1492,19 @@ int daAlink_c::procCoLargeDamageWallInit(int param_0, int param_1, s16 param_2, if (param_0 == 0x84) { field_0x3198 = 0x88; - setSingleAnimeParam(ANM_DMG_LARGE_LAND, &var_r28->field_0x64); + setSingleAnimeParam(ANM_DMG_LARGE_LAND, &var_r28->mBackWallHitAnm); field_0x3080 = temp_r29 - 0x4000; } else if (param_0 == 0x85) { field_0x3198 = 0x89; - setSingleAnimeParam(ANM_DMG_AIR_LEFT_LAND, &var_r28->field_0x78); + setSingleAnimeParam(ANM_DMG_AIR_LEFT_LAND, &var_r28->mLeftWallHitAnm); field_0x3082 = temp_r29 - 0x4000; } else if (param_0 == 0x86) { field_0x3198 = 0x8A; - setSingleAnimeParam(ANM_DMG_AIR_RIGHT_LAND, &var_r28->field_0x8C); + setSingleAnimeParam(ANM_DMG_AIR_RIGHT_LAND, &var_r28->mRightWallHitAnm); field_0x3082 = 0x4000 - temp_r29; } else { field_0x3198 = 0x87; - setSingleAnimeParam(ANM_DMG_AIR_LAND, &var_r28->field_0x50); + setSingleAnimeParam(ANM_DMG_AIR_LAND, &var_r28->mFrontWallHitAnm); field_0x3080 = 0x4000 - temp_r29; } } @@ -1544,9 +1544,9 @@ int daAlink_c::procCoPolyDamageInit() { commonProcInit(PROC_POLY_DAMAGE); if (checkWolf()) { - setSingleAnimeWolfParam(WANM_DMG_SMALL, &daAlinkHIO_wlDamage_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_DMG_SMALL, &daAlinkHIO_wlDamage_c0::m.mPolygonAnm); voiceStart(Z2SE_WL_V_DAMAGE); - field_0x3478 = daAlinkHIO_wlDamage_c0::m.field_0x14.mCancelFrame; + field_0x3478 = daAlinkHIO_wlDamage_c0::m.mPolygonAnm.mCancelFrame; } else { setSingleAnimeParam(ANM_DMG, &daAlinkHIO_damage_c0::m.mFloorDmgAnm); field_0x3478 = daAlinkHIO_damage_c0::m.mFloorDmgAnm.mCancelFrame; @@ -1769,7 +1769,7 @@ int daAlink_c::procCoElecDamage() { /* 800DB5B0-800DB610 0D5EF0 0060+00 2/2 0/0 0/0 .text procStEscapeInit__9daAlink_cFv */ int daAlink_c::procStEscapeInit() { commonProcInit(PROC_HUMAN_ST_ESCAPE); - setSingleAnimeParam(ANM_FROZEN_FREE, &daAlinkHIO_damCaught_c0::m.field_0x0); + setSingleAnimeParam(ANM_FROZEN_FREE, &daAlinkHIO_damCaught_c0::m.mEscapeAnm); mUnderFrameCtrl[0].setFrame(7.0f); getNowAnmPackUnder(UNDER_0)->setFrame(7.0f); @@ -1785,7 +1785,7 @@ int daAlink_c::procStEscape() { if (frameCtrl->checkAnmEnd()) { checkNextAction(0); - } else if (frameCtrl->getFrame() > daAlinkHIO_damCaught_c0::m.field_0x0.mCancelFrame) { + } else if (frameCtrl->getFrame() > daAlinkHIO_damCaught_c0::m.mEscapeAnm.mCancelFrame) { onModeFlg(4); checkNextAction(1); } @@ -1808,7 +1808,7 @@ int daAlink_c::procDkCaughtInit(fpc_ProcID param_0) { field_0x28f8 = param_0; mNormalSpeed = 0.0f; - mProcVar0.field_0x3008 = daAlinkHIO_damCaught_c0::m.field_0x14; + mProcVar0.field_0x3008 = daAlinkHIO_damCaught_c0::m.mGrabDuration; fopAc_ac_c* temp_r3 = fopAcM_SearchByID(field_0x28f8); if (temp_r3 != NULL) { @@ -1870,11 +1870,11 @@ int daAlink_c::procDkCaught() { mProcVar0.field_0x3008--; if (escapeTrigger()) { - mProcVar0.field_0x3008 -= daAlinkHIO_damCaught_c0::m.field_0x16; + mProcVar0.field_0x3008 -= daAlinkHIO_damCaught_c0::m.mInputFadeTime; } if (checkInputOnR() && abs((s16)(mStickAngle - mPrevStickAngle)) > 0x1000) { - mProcVar0.field_0x3008 -= daAlinkHIO_damCaught_c0::m.field_0x16; + mProcVar0.field_0x3008 -= daAlinkHIO_damCaught_c0::m.mInputFadeTime; } if (mProcVar0.field_0x3008 < 0) { @@ -1905,7 +1905,7 @@ int daAlink_c::procScreamWaitInit() { setScreamWaitAnime(); } else { setSingleAnimeBaseSpeed(ANM_WAIT, daAlinkHIO_move_c0::m.mWaitAnmSpeed, - daAlinkHIO_basic_c0::m.mAnmBlendFactor); + daAlinkHIO_basic_c0::m.mBasicInterpolation); mProcVar2.field_0x300c = 0; } @@ -2062,18 +2062,18 @@ int daAlink_c::procCoSwimFreezeReturnInit() { f32 var_f31; if (checkWolf()) { - setSingleAnimeWolfBaseSpeed(WANM_SWIM_WAIT, daAlinkHIO_wlDamNormal_c0::m.field_0x5C, + setSingleAnimeWolfBaseSpeed(WANM_SWIM_WAIT, daAlinkHIO_wlDamNormal_c0::m.mIceDamageAnmSpeed, 10.0f); mUnderFrameCtrl[0].setEnd(3); mUnderFrameCtrl[0].setAttribute(0); setFaceBasicTexture(FTANM_UNK_90); mMidnaAnm = 1; - var_f31 = daAlinkHIO_wlSwim_c0::m.field_0x48; + var_f31 = daAlinkHIO_wlSwim_c0::m.mStartHeight; } else { - setSingleAnime(ANM_SWIM_DMG_FREEZE, daAlinkHIO_damNormal_c0::m.field_0x60, + setSingleAnime(ANM_SWIM_DMG_FREEZE, daAlinkHIO_damNormal_c0::m.mIceDamageASpeed, 0.0f, 5, 10.0f); voiceStart(Z2SE_AL_V_DAMAGE_FREEZE); - var_f31 = daAlinkHIO_swim_c0::m.mInitHeight; + var_f31 = daAlinkHIO_swim_c0::m.mStartHeight; } seStartOnlyReverb(Z2SE_AL_FREEZE); diff --git a/src/d/actor/d_a_alink_demo.inc b/src/d/actor/d_a_alink_demo.inc index 7253cd0466d..9f43f141e3d 100644 --- a/src/d/actor/d_a_alink_demo.inc +++ b/src/d/actor/d_a_alink_demo.inc @@ -495,7 +495,7 @@ void daAlink_c::setDemoMoveData(u32* o_mode, cXyz const* i_goal) { f32 temp_f28; f32 var_f27; if (checkWolf()) { - var_f27 = daAlinkHIO_wlMoveNoP_c0::m.field_0x8 / daAlinkHIO_move_c0::m.mMaxSpeed; + var_f27 = daAlinkHIO_wlMoveNoP_c0::m.mMaxSpeed / daAlinkHIO_move_c0::m.mMaxSpeed; var_f27 *= var_f27; } else { var_f27 = 1.0f; @@ -862,12 +862,12 @@ void daAlink_c::resetDemoBck() { mFaceBtkHeap.resetIdx(); if (checkWolf()) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMoveNoP_c0::m.field_0x14, - daAlinkHIO_wlMove_c0::m.field_0x94); + setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMoveNoP_c0::m.mIdleAnmSpeed, + daAlinkHIO_wlMove_c0::m.mNormalInterpolation); setFaceBasicAnime(ANM_WAIT); } else { setSingleAnimeBaseSpeed(ANM_WAIT, daAlinkHIO_move_c0::m.mWaitAnmSpeed, - daAlinkHIO_basic_c0::m.mAnmBlendFactor); + daAlinkHIO_basic_c0::m.mBasicInterpolation); } } @@ -1742,12 +1742,12 @@ int daAlink_c::procCoTalkInit() { mNormalSpeed = 0.0f; if (var_r30 == 0) { - setBlendWolfMoveAnime(daAlinkHIO_wlMove_c0::m.field_0xBC); + setBlendWolfMoveAnime(daAlinkHIO_wlMove_c0::m.mIdleInterpolation); } else { if (var_r30 == 1) { field_0x2f99 = 13; setSingleAnimeWolfBaseSpeed(WANM_CROUCH_WALK, 0.0f, - daAlinkHIO_wlLie_c0::m.field_0x40); + daAlinkHIO_wlLie_c0::m.mProneMoveInterp); } else { field_0x2f99 = 13; daPy_frameCtrl_c* frameCtrl_p = mUnderFrameCtrl; @@ -1924,9 +1924,9 @@ int daAlink_c::procCoUnequipInit() { mProcVar3.field_0x300e = 0; if (checkWolf()) { - setBlendWolfMoveAnime(daAlinkHIO_wlMove_c0::m.field_0x94); + setBlendWolfMoveAnime(daAlinkHIO_wlMove_c0::m.mNormalInterpolation); } else { - setBlendMoveAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setBlendMoveAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); if (mDemo.getParam1() == 0) { if (mEquipItem != fpcNm_ITEM_NONE) { @@ -2340,7 +2340,7 @@ int daAlink_c::procCoGetItem() { field_0x2f99 = 12; if (checkWolf()) { - setBlendWolfMoveAnime(daAlinkHIO_wlMove_c0::m.field_0x94); + setBlendWolfMoveAnime(daAlinkHIO_wlMove_c0::m.mNormalInterpolation); } else { if (mEquipItem == fpcNm_ITEM_KANTERA) { field_0x2f94 = 0; @@ -2352,7 +2352,7 @@ int daAlink_c::procCoGetItem() { 3.0f); field_0x2f99 = 0x60; } else { - setBlendMoveAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setBlendMoveAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); } } } @@ -2422,7 +2422,7 @@ int daAlink_c::procDoorOpenInit() { f32 start_f = 0.0f; s16 end_f = -1; - field_0x3478 = daAlinkHIO_basic_c0::m.mAnmBlendFactor; + field_0x3478 = daAlinkHIO_basic_c0::m.mBasicInterpolation; mProcVar0.field_0x3008 = 0; if (mDemo.getParam0() == 4) { @@ -2555,9 +2555,9 @@ int daAlink_c::procCoLookWaitInit() { mNormalSpeed = 0.0f; if (checkWolf()) { - setBlendWolfMoveAnime(daAlinkHIO_wlMove_c0::m.field_0x94); + setBlendWolfMoveAnime(daAlinkHIO_wlMove_c0::m.mNormalInterpolation); } else { - setBlendMoveAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setBlendMoveAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); } current.angle.y = shape_angle.y; @@ -2598,8 +2598,8 @@ int daAlink_c::procCoDemoPushPullWaitInit() { if (checkWolf()) { setSingleAnimeWolfBase(WANM_WAIT_PP); } else { - setSingleAnimeBaseSpeed(ANM_WAIT_PUSH_PULL, daAlinkHIO_pushpull_c0::m.field_0x10, - daAlinkHIO_pushpull_c0::m.field_0x14); + setSingleAnimeBaseSpeed(ANM_WAIT_PUSH_PULL, daAlinkHIO_pushpull_c0::m.mStandbyASpeed, + daAlinkHIO_pushpull_c0::m.mStandbyInterpolation); } mNormalSpeed = 0.0f; @@ -2616,15 +2616,15 @@ int daAlink_c::procCoDemoPushMoveInit() { if (mDemo.getParam0() != 0) { setSingleAnimeWolfBase(WANM_PUSH); } else { - setSingleAnimeWolf(WANM_PUSH_LIGHT, daAlinkHIO_wlPush_c0::m.field_0x8, - 0.0f, 24, daAlinkHIO_wlPush_c0::m.field_0xC); + setSingleAnimeWolf(WANM_PUSH_LIGHT, daAlinkHIO_wlPush_c0::m.mPushAnmSpeed, + 0.0f, 24, daAlinkHIO_wlPush_c0::m.mPushInterp); } } else { if (mDemo.getParam0() != 0) { setSingleAnimeBase(ANM_PUSH); } else { - setSingleAnimeBaseSpeed(ANM_PUSH_LIGHT, daAlinkHIO_pushpull_c0::m.field_0x18, - daAlinkHIO_pushpull_c0::m.field_0x1C); + setSingleAnimeBaseSpeed(ANM_PUSH_LIGHT, daAlinkHIO_pushpull_c0::m.mPushASpeed, + daAlinkHIO_pushpull_c0::m.mPushInterpolation); } } @@ -2701,7 +2701,7 @@ int daAlink_c::procDemoBoomerangCatch() { dComIfGp_evmng_cutEnd(mAlinkStaffId); if (checkAnmEnd(mUnderFrameCtrl)) { - setBlendMoveAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setBlendMoveAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); } return 1; } @@ -2728,7 +2728,7 @@ int daAlink_c::procCoDeadInit(int param_0) { if (checkNoResetFlg2(FLG2_FORCE_GAMEOVER)) { if (param_0) { if (checkWolf()) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMove_c0::m.field_0x70, 3.0f); + setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMove_c0::m.mIdleAnmSpeed, 3.0f); } else { setSingleAnimeBaseSpeed(ANM_WAIT, daAlinkHIO_move_c0::m.mWaitAnmSpeed, 3.0f); } @@ -2990,9 +2990,9 @@ int daAlink_c::procCoCaughtInit() { } if (checkWolf()) { - setSingleAnimeWolfBaseMorf(WANM_WAIT_START, daAlinkHIO_wlDamCaught_c0::m.field_0x8); + setSingleAnimeWolfBaseMorf(WANM_WAIT_START, daAlinkHIO_wlDamCaught_c0::m.mWaitInterp); } else { - setSingleAnimeBaseMorf(ANM_WAIT_START, daAlinkHIO_damCaught_c0::m.field_0x1C); + setSingleAnimeBaseMorf(ANM_WAIT_START, daAlinkHIO_damCaught_c0::m.mStandbyInterp); } if (chk_40000) { @@ -3142,7 +3142,7 @@ int daAlink_c::procCoFogDeadInit() { if (checkWolf()) { setSingleAnimeWolfBaseSpeed(WANM_FALL_LAND, 0.0f, - daAlinkHIO_wlDamFall_c0::m.field_0x3C); + daAlinkHIO_wlDamFall_c0::m.mAirAnmInterp); } else { setSingleAnimeBaseSpeed(ANM_DMG_FALL, 0.0f, daAlinkHIO_damFall_c0::m.mFallAnmMorf); @@ -3194,8 +3194,8 @@ int daAlink_c::procWolfSmellWaitInit() { return 1; } - setSingleAnimeWolfBaseSpeed(WANM_SMELL, daAlinkHIO_wlChain_c0::m.field_0x54, - daAlinkHIO_wlChain_c0::m.field_0x58); + setSingleAnimeWolfBaseSpeed(WANM_SMELL, daAlinkHIO_wlChain_c0::m.mSniffAnmSpeed, + daAlinkHIO_wlChain_c0::m.mSniffInterp); current.angle.y = shape_angle.y; mNormalSpeed = 0.0f; return 1; @@ -3352,7 +3352,7 @@ int daAlink_c::procCoGetReadySitInit() { commonProcInit(PROC_GET_READY_SIT); if (checkWolf()) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMove_c0::m.field_0x70, 3.0f); + setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMove_c0::m.mIdleAnmSpeed, 3.0f); mProcVar2.field_0x300c = 1; } else { setSingleAnime(ANM_TRES_OPEN_SMALL, 1.0f, 36.0f, -1, 3.0f); @@ -3462,13 +3462,13 @@ int daAlink_c::procWolfSnowEscape() { if (mProcVar2.field_0x300c == 0) { mProcVar2.field_0x300c = 1; - setSingleAnimeWolfParam(WANM_SLIDE_FORWARD_START, &daAlinkHIO_wlSlide_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_SLIDE_FORWARD_START, &daAlinkHIO_wlSlide_c0::m.mFrontSlideAnm); field_0x3588 = l_wolfBaseAnime; field_0x3478 = 1.0f / (f32)frameCtrl_p->getEnd(); field_0x2f99 = 13; voiceStart(Z2SE_WL_V_SLIP_ROLL); } else { - setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMove_c0::m.field_0x70, 3.0f); + setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMove_c0::m.mIdleAnmSpeed, 3.0f); field_0x2f99 = 0x30; mProcVar3.field_0x300e = 1; } @@ -4103,7 +4103,7 @@ int daAlink_c::procDungeonWarpSceneStartInit() { setSpecialGravity(0.0f, maxFallSpeed, 0); setSingleAnimeBaseSpeed(ANM_WAIT, daAlinkHIO_move_c0::m.mWaitAnmSpeed, - daAlinkHIO_basic_c0::m.mAnmBlendFactor); + daAlinkHIO_basic_c0::m.mBasicInterpolation); if (checkDungeon() && !checkLv7DungeonShop()) { createNpcTks(¤t.pos, fopAcM_GetRoomNo(this), 4); @@ -4341,7 +4341,7 @@ int daAlink_c::procCoWarpInit(int param_0, int param_1) { deleteEquipItem(FALSE, TRUE); if (checkWolf()) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMove_c0::m.field_0x70, 3.0f); + setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMove_c0::m.mIdleAnmSpeed, 3.0f); } else { setSingleAnimeBaseSpeed(ANM_WAIT, daAlinkHIO_move_c0::m.mWaitAnmSpeed, 3.0f); } @@ -4463,7 +4463,7 @@ int daAlink_c::procCoWarp() { f32 var_f1; if (checkWolf()) { - var_f1 = daAlinkHIO_wlAutoJump_c0::m.field_0x58; + var_f1 = daAlinkHIO_wlAutoJump_c0::m.mGravity; } else { var_f1 = daAlinkHIO_autoJump_c0::m.mGravity; } @@ -4571,7 +4571,7 @@ int daAlink_c::commonLargeDamageUpInit(int param_0, int param_1, s16 param_2, s1 /* 80120534-80120580 11AE74 004C+00 4/4 0/0 0/0 .text commonFallInit__9daAlink_cFi */ int daAlink_c::commonFallInit(int param_0) { if (checkWolf()) { - return procWolfFallInit(param_0, daAlinkHIO_wlAutoJump_c0::m.field_0x54); + return procWolfFallInit(param_0, daAlinkHIO_wlAutoJump_c0::m.mNormalFallInterp); } else { return procFallInit(param_0, daAlinkHIO_autoJump_c0::m.mFallInterpolation); } diff --git a/src/d/actor/d_a_alink_effect.inc b/src/d/actor/d_a_alink_effect.inc index f7f01f4604d..3e89bf1ce66 100644 --- a/src/d/actor/d_a_alink_effect.inc +++ b/src/d/actor/d_a_alink_effect.inc @@ -440,9 +440,9 @@ void daAlink_c::setEffect() { if (checkWolf()) { spB8.x += 40.0f * cM_ssin(current.angle.y); spB8.z += 40.0f * cM_scos(current.angle.y); - spAC.y -= daAlinkHIO_wlSwim_c0::m.field_0x48; + spAC.y -= daAlinkHIO_wlSwim_c0::m.mStartHeight; } else { - spAC.y -= daAlinkHIO_swim_c0::m.mInitHeight; + spAC.y -= daAlinkHIO_swim_c0::m.mStartHeight; } spB8.y = mWaterY; diff --git a/src/d/actor/d_a_alink_grab.inc b/src/d/actor/d_a_alink_grab.inc index 56f8ef8ae56..e70be29945e 100644 --- a/src/d/actor/d_a_alink_grab.inc +++ b/src/d/actor/d_a_alink_grab.inc @@ -93,7 +93,7 @@ BOOL daAlink_c::setForceGrab(fopAc_ac_c* p_actor, int param_1, int param_2) { deleteEquipItem(TRUE, FALSE); setGrabItemActor(p_actor); field_0x33e4 = 38.0f; - setGrabUpperAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setGrabUpperAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); return true; } @@ -159,7 +159,7 @@ void daAlink_c::setGrabUpperAnime(f32 param_0) { if (checkZoraWearAbility()) { param_0 *= 1.0f / daAlinkHIO_magneBoots_c0::m.mZoraWaterAnmSpeed; } else { - param_0 *= 1.0f / daAlinkHIO_magneBoots_c0::m.mWaterStartWalkAnmRate; + param_0 *= 1.0f / daAlinkHIO_magneBoots_c0::m.mWaterWalkAnmRate; } } @@ -745,9 +745,9 @@ int daAlink_c::procGrabReadyInit() { } if (checkGrabCarryActor()) { - setSingleAnime(ANM_CARRY, daAlinkHIO_grab_c0::m.field_0x8C.mSpeed, daAlinkHIO_grab_c0::m.field_0x8C.mStartFrame, 9, daAlinkHIO_grab_c0::m.field_0x8C.mInterpolation); + setSingleAnime(ANM_CARRY, daAlinkHIO_grab_c0::m.mFailAnm.mSpeed, daAlinkHIO_grab_c0::m.mFailAnm.mStartFrame, 9, daAlinkHIO_grab_c0::m.mFailAnm.mInterpolation); mProcVar3.field_0x300e = 1; - field_0x347c = 1.0f / (9.0f - daAlinkHIO_grab_c0::m.field_0x8C.mStartFrame); + field_0x347c = 1.0f / (9.0f - daAlinkHIO_grab_c0::m.mFailAnm.mStartFrame); f32 var_f31; if (fopAcM_GetName(mGrabItemAcKeep.getActor()) == PROC_DO) { @@ -759,8 +759,8 @@ int daAlink_c::procGrabReadyInit() { field_0x33ec = 4.0f * ((var_f31 * mGrabItemAcKeep.getActor()->scale.x) - 1.0f); } else { field_0x33ec = 0.0f; - setSingleAnimeParam(ANM_GRAB_UP_START, &daAlinkHIO_grab_c0::m.field_0x0); - field_0x347c = 1.0f / (daAlinkHIO_grab_c0::m.field_0x0.mEndFrame - daAlinkHIO_grab_c0::m.field_0x0.mStartFrame); + setSingleAnimeParam(ANM_GRAB_UP_START, &daAlinkHIO_grab_c0::m.mPrepareAnm); + field_0x347c = 1.0f / (daAlinkHIO_grab_c0::m.mPrepareAnm.mEndFrame - daAlinkHIO_grab_c0::m.mPrepareAnm.mStartFrame); mProcVar3.field_0x300e = 0; } @@ -781,15 +781,15 @@ int daAlink_c::procGrabReady() { if (checkAnmEnd(&mUnderFrameCtrl[0])) { if (field_0x3198 != 0) { - setSingleAnime(ANM_PICK_UP_LARGE_START, daAlinkHIO_grab_c0::m.field_0x78.mSpeed, daAlinkHIO_grab_c0::m.field_0x78.mStartFrame, daAlinkHIO_grab_c0::m.field_0x78.mCancelFrame, daAlinkHIO_grab_c0::m.field_0x78.mInterpolation); + setSingleAnime(ANM_PICK_UP_LARGE_START, daAlinkHIO_grab_c0::m.mRecoilAnm.mSpeed, daAlinkHIO_grab_c0::m.mRecoilAnm.mStartFrame, daAlinkHIO_grab_c0::m.mRecoilAnm.mCancelFrame, daAlinkHIO_grab_c0::m.mRecoilAnm.mInterpolation); field_0x3198 = 0; } else { procGrabUpInit(); } } else if (mProcVar3.field_0x300e != 0) { - setCarryArmAngle(field_0x347c * (mUnderFrameCtrl[0].getFrame() - daAlinkHIO_grab_c0::m.field_0x8C.mStartFrame), 0.0f); + setCarryArmAngle(field_0x347c * (mUnderFrameCtrl[0].getFrame() - daAlinkHIO_grab_c0::m.mFailAnm.mStartFrame), 0.0f); } else { - setCarryArmAngle(0.0f, field_0x347c * (mUnderFrameCtrl[0].getFrame() - daAlinkHIO_grab_c0::m.field_0x0.mStartFrame)); + setCarryArmAngle(0.0f, field_0x347c * (mUnderFrameCtrl[0].getFrame() - daAlinkHIO_grab_c0::m.mPrepareAnm.mStartFrame)); } return 1; @@ -801,11 +801,11 @@ int daAlink_c::procGrabUpInit() { commonProcInit(PROC_GRAB_UP); if (checkGrabCarryActor()) { - setSingleAnime(ANM_CARRY, daAlinkHIO_grab_c0::m.field_0x8C.mSpeed, 9.0f + daAlinkHIO_grab_c0::m.field_0x8C.mSpeed, daAlinkHIO_grab_c0::m.field_0x8C.mEndFrame, 0.0f); + setSingleAnime(ANM_CARRY, daAlinkHIO_grab_c0::m.mFailAnm.mSpeed, 9.0f + daAlinkHIO_grab_c0::m.mFailAnm.mSpeed, daAlinkHIO_grab_c0::m.mFailAnm.mEndFrame, 0.0f); mProcVar3.field_0x300e = 1; setCarryArmAngle(1.0f, 0.0f); } else { - setSingleAnimeParam(ANM_GRAB_UP, &daAlinkHIO_grab_c0::m.field_0x14); + setSingleAnimeParam(ANM_GRAB_UP, &daAlinkHIO_grab_c0::m.mLiftBackAnm); mProcVar3.field_0x300e = 0; setCarryArmAngle(0.0f, 1.0f); } @@ -834,7 +834,7 @@ int daAlink_c::procGrabUp() { return checkNextAction(0); } - if (checkAnmEnd(temp_r29) || (checkInputOnR() && (temp_r29->getFrame() > daAlinkHIO_grab_c0::m.field_0x14.mCancelFrame))) { + if (checkAnmEnd(temp_r29) || (checkInputOnR() && (temp_r29->getFrame() > daAlinkHIO_grab_c0::m.mLiftBackAnm.mCancelFrame))) { onResetFlg0(RFLG0_GRAB_UP_END); if (fopAcM_CheckCarryType(temp_r3, fopAcM_CARRY(fopAcM_CARRY_UNK_40 | fopAcM_CARRY_HEAVY | fopAcM_CARRY_TYPE_1))) { @@ -875,13 +875,13 @@ int daAlink_c::procGrabMiss() { int daAlink_c::procGrabThrowInit(int param_0) { if (checkModeFlg(0x400)) { if (checkGrabHeavyActor()) { - setUpperAnimeParam(0x17B, UPPER_2, &daAlinkHIO_grab_c0::m.field_0xC8); + setUpperAnimeParam(0x17B, UPPER_2, &daAlinkHIO_grab_c0::m.mIronBallThrowAnm); field_0x343c = 14.0f; } else if (checkGrabAnimeSide()) { - setUpperAnimeParam(0x51, UPPER_2, &daAlinkHIO_grab_c0::m.field_0xB4); + setUpperAnimeParam(0x51, UPPER_2, &daAlinkHIO_grab_c0::m.mCarryPlaceReverseAnm); field_0x343c = 4.0f; } else { - setUpperAnimeParam(0x170, UPPER_2, &daAlinkHIO_grab_c0::m.field_0x3C); + setUpperAnimeParam(0x170, UPPER_2, &daAlinkHIO_grab_c0::m.mLiftAnm); field_0x343c = 5.0f; } @@ -894,9 +894,9 @@ int daAlink_c::procGrabThrowInit(int param_0) { } if (checkGrabHeavyActor()) { - setSingleAnimeParam(ANM_THROW_HEAVY, &daAlinkHIO_grab_c0::m.field_0xC8); + setSingleAnimeParam(ANM_THROW_HEAVY, &daAlinkHIO_grab_c0::m.mIronBallThrowAnm); field_0x343c = 14.0f; - field_0x347c = daAlinkHIO_grab_c0::m.field_0xC8.mCancelFrame; + field_0x347c = daAlinkHIO_grab_c0::m.mIronBallThrowAnm.mCancelFrame; mProcVar2.field_0x300c = 2; } else if (checkGrabSideActor()) { f32 var_f31; @@ -906,15 +906,15 @@ int daAlink_c::procGrabThrowInit(int param_0) { var_f31 = daAlinkHIO_noActAtnMove_c0::m.mWaitAnmSpeed; } - setSingleAnimeBaseSpeed(ANM_ATN_WAIT_RIGHT, var_f31, daAlinkHIO_basic_c0::m.mAnmBlendFactor); - setUpperAnimeParam(0x51, UPPER_0, &daAlinkHIO_grab_c0::m.field_0xB4); + setSingleAnimeBaseSpeed(ANM_ATN_WAIT_RIGHT, var_f31, daAlinkHIO_basic_c0::m.mBasicInterpolation); + setUpperAnimeParam(0x51, UPPER_0, &daAlinkHIO_grab_c0::m.mCarryPlaceReverseAnm); field_0x343c = 4.0f; - field_0x347c = daAlinkHIO_grab_c0::m.field_0xB4.mCancelFrame; + field_0x347c = daAlinkHIO_grab_c0::m.mCarryPlaceReverseAnm.mCancelFrame; mProcVar2.field_0x300c = 1; } else { - setSingleAnimeParam(ANM_THROW, &daAlinkHIO_grab_c0::m.field_0x3C); + setSingleAnimeParam(ANM_THROW, &daAlinkHIO_grab_c0::m.mLiftAnm); field_0x343c = 5.0f; - field_0x347c = daAlinkHIO_grab_c0::m.field_0x3C.mCancelFrame; + field_0x347c = daAlinkHIO_grab_c0::m.mLiftAnm.mCancelFrame; mProcVar2.field_0x300c = 0; } @@ -980,15 +980,15 @@ int daAlink_c::procGrabPutInit() { if (checkGrabCarryActor()) { field_0x3198 = 0; - setSingleAnime(ANM_CARRY, daAlinkHIO_grab_c0::m.field_0xA0.mSpeed, 9.0f, daAlinkHIO_grab_c0::m.field_0xA0.mEndFrame, daAlinkHIO_grab_c0::m.field_0xA0.mInterpolation); + setSingleAnime(ANM_CARRY, daAlinkHIO_grab_c0::m.mCarryLiftAnm.mSpeed, 9.0f, daAlinkHIO_grab_c0::m.mCarryLiftAnm.mEndFrame, daAlinkHIO_grab_c0::m.mCarryLiftAnm.mInterpolation); mProcVar3.field_0x300e = 1; - field_0x347c = 1.0f / (daAlinkHIO_grab_c0::m.field_0xA0.mEndFrame - 9.0f); - field_0x3480 = 1.0f / (daAlinkHIO_grab_c0::m.field_0xA0.mEndFrame - field_0x3478); + field_0x347c = 1.0f / (daAlinkHIO_grab_c0::m.mCarryLiftAnm.mEndFrame - 9.0f); + field_0x3480 = 1.0f / (daAlinkHIO_grab_c0::m.mCarryLiftAnm.mEndFrame - field_0x3478); } else { mProcVar3.field_0x300e = 0; field_0x3198 = 0; - setSingleAnimeParam(ANM_GRAB_UP, &daAlinkHIO_grab_c0::m.field_0x50); - field_0x347c = 1.0f / (daAlinkHIO_grab_c0::m.field_0x50.mEndFrame - daAlinkHIO_grab_c0::m.field_0x50.mStartFrame); + setSingleAnimeParam(ANM_GRAB_UP, &daAlinkHIO_grab_c0::m.mThrowAnm); + field_0x347c = 1.0f / (daAlinkHIO_grab_c0::m.mThrowAnm.mEndFrame - daAlinkHIO_grab_c0::m.mThrowAnm.mStartFrame); } if (mGrabItemAcKeep.getActor() != NULL) { @@ -1037,7 +1037,7 @@ int daAlink_c::procGrabPut() { } setCarryArmAngle(1.0f - (field_0x347c * (temp_r28->getFrame() - 9.0f)), var_f31); } else { - setCarryArmAngle(0.0f, field_0x347c * (temp_r28->getFrame() - daAlinkHIO_grab_c0::m.field_0x50.mStartFrame)); + setCarryArmAngle(0.0f, field_0x347c * (temp_r28->getFrame() - daAlinkHIO_grab_c0::m.mThrowAnm.mStartFrame)); } return 1; @@ -1060,7 +1060,7 @@ int daAlink_c::procGrabWaitInit() { return 0; } - f32 var_f31 = daAlinkHIO_basic_c0::m.mAnmBlendFactor; + f32 var_f31 = daAlinkHIO_basic_c0::m.mBasicInterpolation; if (!checkGrabAnime()) { setGrabUpperAnime(-1.0f); } else { @@ -1071,12 +1071,12 @@ int daAlink_c::procGrabWaitInit() { if (checkZoraWearAbility() ) { var_f31 *= 1.0f / daAlinkHIO_magneBoots_c0::m.mZoraWaterAnmSpeed; } else { - var_f31 *= 1.0f / daAlinkHIO_magneBoots_c0::m.mWaterStartWalkAnmRate; + var_f31 *= 1.0f / daAlinkHIO_magneBoots_c0::m.mWaterWalkAnmRate; } } if (checkAttentionLock() && (checkGrabAnimeUp() || checkGrabAnimeSide())) { - setBlendAtnMoveAnime(daAlinkHIO_basic_c0::m.mAnmBlendFactor); + setBlendAtnMoveAnime(daAlinkHIO_basic_c0::m.mBasicInterpolation); } else { setBlendMoveAnime(var_f31); } @@ -1117,7 +1117,7 @@ int daAlink_c::procGrabWait() { */ int daAlink_c::procGrabReboundInit(int param_0) { commonProcInit(PROC_GRAB_REBOUND); - setSingleAnimeParam(ANM_PICK_UP_LARGE, &daAlinkHIO_grab_c0::m.field_0x64); + setSingleAnimeParam(ANM_PICK_UP_LARGE, &daAlinkHIO_grab_c0::m.mCarryAnm); mNormalSpeed = 0.0f; field_0x3198 = param_0; @@ -1141,10 +1141,10 @@ int daAlink_c::procGrabRebound() { if (field_0x3198 != 0) { if (field_0x2060->getOldFrameRate() < 0.1f) { - setWaterInAnmRate(temp_r30, daAlinkHIO_grab_c0::m.field_0x64.mSpeed); + setWaterInAnmRate(temp_r30, daAlinkHIO_grab_c0::m.mCarryAnm.mSpeed); field_0x3198 = 0; } - } else if (checkAnmEnd(temp_r30) || (checkInputOnR() && (temp_r30->getFrame() > daAlinkHIO_grab_c0::m.field_0x64.mCancelFrame))) { + } else if (checkAnmEnd(temp_r30) || (checkInputOnR() && (temp_r30->getFrame() > daAlinkHIO_grab_c0::m.mCarryAnm.mCancelFrame))) { initGrabNextMode(); } @@ -1156,14 +1156,14 @@ int daAlink_c::procGrabStandInit() { commonProcInit(PROC_GRAB_STAND); if (checkUnderMove0BckNoArc(ANM_CARRY)) { - setSingleAnime(ANM_CARRY, daAlinkHIO_grab_c0::m.field_0xA0.mSpeed, daAlinkHIO_grab_c0::m.field_0xA0.mStartFrame, (9.0f + daAlinkHIO_grab_c0::m.field_0xA0.mSpeed), 0.0f); - field_0x3478 = daAlinkHIO_grab_c0::m.field_0xA0.mCancelFrame; - field_0x347c = 1.0f / (9.0f - daAlinkHIO_grab_c0::m.field_0xA0.mStartFrame); + setSingleAnime(ANM_CARRY, daAlinkHIO_grab_c0::m.mCarryLiftAnm.mSpeed, daAlinkHIO_grab_c0::m.mCarryLiftAnm.mStartFrame, (9.0f + daAlinkHIO_grab_c0::m.mCarryLiftAnm.mSpeed), 0.0f); + field_0x3478 = daAlinkHIO_grab_c0::m.mCarryLiftAnm.mCancelFrame; + field_0x347c = 1.0f / (9.0f - daAlinkHIO_grab_c0::m.mCarryLiftAnm.mStartFrame); mProcVar3.field_0x300e = 1; setCarryArmAngle(1.0f, 0.0f); } else { - setSingleAnimeParam(ANM_GRAB_UP_START, &daAlinkHIO_grab_c0::m.field_0x28); - field_0x3478 = daAlinkHIO_grab_c0::m.field_0x28.mCancelFrame; + setSingleAnimeParam(ANM_GRAB_UP_START, &daAlinkHIO_grab_c0::m.mStandReverseAnm); + field_0x3478 = daAlinkHIO_grab_c0::m.mStandReverseAnm.mCancelFrame; mProcVar3.field_0x300e = 0; } @@ -1184,7 +1184,7 @@ int daAlink_c::procGrabStand() { onModeFlg(4); if (!checkNextAction(1) && mProcVar3.field_0x300e != 0) { - setCarryArmAngle(field_0x347c * (mUnderFrameCtrl[0].getFrame() - daAlinkHIO_grab_c0::m.field_0xA0.mStartFrame), 0.0f); + setCarryArmAngle(field_0x347c * (mUnderFrameCtrl[0].getFrame() - daAlinkHIO_grab_c0::m.mCarryLiftAnm.mStartFrame), 0.0f); } } @@ -1295,7 +1295,7 @@ int daAlink_c::procPickUpInit() { fopAcM_onSwitch(field_0x27f4, 0x3F); var_r29 = 0; } else { - setSingleAnimeParam(ANM_PICK_UP, &daAlinkHIO_pickUp_c0::m.field_0x0); + setSingleAnimeParam(ANM_PICK_UP, &daAlinkHIO_pickUp_c0::m.mGrabAnm); mProcVar3.field_0x300e = 0; mProcVar4.field_0x3010 = 0; var_r29 = 1; @@ -1330,7 +1330,7 @@ int daAlink_c::procPickUp() { } } else if (checkAnmEnd(temp_r30)) { checkNextAction(0); - } else if (temp_r30->getFrame() > daAlinkHIO_pickUp_c0::m.field_0x0.mCancelFrame) { + } else if (temp_r30->getFrame() > daAlinkHIO_pickUp_c0::m.mGrabAnm.mCancelFrame) { onModeFlg(4); checkNextAction(1); } else if (temp_r30->checkPass(9.0f)) { @@ -1352,7 +1352,7 @@ int daAlink_c::procPickPutInit(int param_0) { commonProcInit(PROC_PICK_PUT); mNormalSpeed = 0.0f; - setSingleAnimeParam(ANM_PICK_UP, &daAlinkHIO_pickUp_c0::m.field_0x14); + setSingleAnimeParam(ANM_PICK_UP, &daAlinkHIO_pickUp_c0::m.mPlaceAnm); if (mItemAcKeep.getActor() != NULL) { field_0x37c8 = mItemAcKeep.getActor()->current.pos; @@ -1389,7 +1389,7 @@ int daAlink_c::procPickPut() { if (checkAnmEnd(temp_r28)) { checkNextAction(0); - } else if (temp_r28->getFrame() < daAlinkHIO_pickUp_c0::m.field_0x14.mCancelFrame) { + } else if (temp_r28->getFrame() < daAlinkHIO_pickUp_c0::m.mPlaceAnm.mCancelFrame) { onModeFlg(4); checkNextAction(1); } else if (temp_r28->checkPass(9.0f)) { @@ -1502,7 +1502,7 @@ int daAlink_c::procFmChainUpInit() { } commonProcInit(PROC_CHAIN_UP); - setSingleAnimeParam(ANM_CHAIN_PICK_UP, &daAlinkHIO_fmChain_c0::m.field_0x0); + setSingleAnimeParam(ANM_CHAIN_PICK_UP, &daAlinkHIO_fmChain_c0::m.mGripAnm); mNormalSpeed = 0.0f; return 1; } @@ -1514,7 +1514,7 @@ int daAlink_c::procFmChainUp() { setGrabStatus(0x96, 2); setShapeAngleToAtnActor(0); - if (checkAnmEnd(temp_r29) || (checkInputOnR() && temp_r29->getFrame() > daAlinkHIO_fmChain_c0::m.field_0x0.mCancelFrame)) { + if (checkAnmEnd(temp_r29) || (checkInputOnR() && temp_r29->getFrame() > daAlinkHIO_fmChain_c0::m.mGripAnm.mCancelFrame)) { u8 temp_r27 = field_0x2fa3; fopAc_ac_c* temp_r28 = field_0x2844.getActor(); @@ -1708,14 +1708,14 @@ f32 daAlink_c::getPushPullAnimeSpeed() { getMoveBGActorName(mPolyInfo1, 0) == PROC_Obj_Bemos) { if (checkWolf()) { - var_f31 = daAlinkHIO_wlPush_c0::m.field_0x10; + var_f31 = daAlinkHIO_wlPush_c0::m.mHeavyPushAnmSpeed; } else { - var_f31 = daAlinkHIO_pushpull_c0::m.field_0x38; + var_f31 = daAlinkHIO_pushpull_c0::m.mPushASpeedHeavy; } } else if (checkWolf()) { - var_f31 = daAlinkHIO_wlPush_c0::m.field_0x8; + var_f31 = daAlinkHIO_wlPush_c0::m.mPushAnmSpeed; } else { - var_f31 = daAlinkHIO_pushpull_c0::m.field_0x18; + var_f31 = daAlinkHIO_pushpull_c0::m.mPushASpeed; } return var_f31; @@ -1734,14 +1734,14 @@ int daAlink_c::procCoPushPullWaitInit(int param_0) { f32 var_f31; if (checkWolf()) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT_PP, daAlinkHIO_wlPush_c0::m.field_0x0, daAlinkHIO_wlPush_c0::m.field_0x4); + setSingleAnimeWolfBaseSpeed(WANM_WAIT_PP, daAlinkHIO_wlPush_c0::m.mIdleAnmSpeed, daAlinkHIO_wlPush_c0::m.mIdleInterp); var_f31 = 50.0f; } else { if (checkEquipAnime()) { resetUpperAnime(UPPER_2, -1.0f); } - setSingleAnimeBaseSpeed(ANM_WAIT_PUSH_PULL, daAlinkHIO_pushpull_c0::m.field_0x10, daAlinkHIO_pushpull_c0::m.field_0x14); + setSingleAnimeBaseSpeed(ANM_WAIT_PUSH_PULL, daAlinkHIO_pushpull_c0::m.mStandbyASpeed, daAlinkHIO_pushpull_c0::m.mStandbyInterpolation); var_f31 = 50.0f; } @@ -1815,7 +1815,7 @@ int daAlink_c::procCoPushMoveInit(int param_0, int param_1) { setSingleAnimeWolfBase(WANM_PUSH_START); var_f31 = 1.0f; } else { - setSingleAnimeWolf(WANM_PUSH_LIGHT, var_f31, 0.0f, 24, daAlinkHIO_wlPush_c0::m.field_0xC); + setSingleAnimeWolf(WANM_PUSH_LIGHT, var_f31, 0.0f, 24, daAlinkHIO_wlPush_c0::m.mPushInterp); } field_0x3478 = 17.0f; @@ -1824,7 +1824,7 @@ int daAlink_c::procCoPushMoveInit(int param_0, int param_1) { setSingleAnimeBase(ANM_PUSH_START); var_f31 = 1.0f; } else { - setSingleAnimeBaseSpeed(ANM_PUSH_LIGHT, var_f31, daAlinkHIO_pushpull_c0::m.field_0x1C); + setSingleAnimeBaseSpeed(ANM_PUSH_LIGHT, var_f31, daAlinkHIO_pushpull_c0::m.mPushInterpolation); } field_0x3478 = 15.0f; @@ -1953,7 +1953,7 @@ int daAlink_c::procPullMoveInit(int param_0) { setSingleAnimeBase(ANM_PULL_START); } else { var_f31 = getPushPullAnimeSpeed(); - setSingleAnimeBaseSpeed(ANM_PULL_LIGHT, var_f31, daAlinkHIO_pushpull_c0::m.field_0x24); + setSingleAnimeBaseSpeed(ANM_PULL_LIGHT, var_f31, daAlinkHIO_pushpull_c0::m.mPullInterpolation); } mUnderFrameCtrl[0].setRate(var_f31); diff --git a/src/d/actor/d_a_alink_hang.inc b/src/d/actor/d_a_alink_hang.inc index f0d8c605df1..2b5ef8eeeda 100644 --- a/src/d/actor/d_a_alink_hang.inc +++ b/src/d/actor/d_a_alink_hang.inc @@ -291,12 +291,12 @@ int daAlink_c::procHangStartInit() { if (checkHangFootWall()) { if (!hang_ready && cM_rnd() < 0.7f) { - setSingleAnimeParam(ANM_CLIMB_HANG_MISS, &daAlinkHIO_ladder_c0::m.field_0x14); - field_0x3478 = daAlinkHIO_ladder_c0::m.field_0x14.mCancelFrame; + setSingleAnimeParam(ANM_CLIMB_HANG_MISS, &daAlinkHIO_ladder_c0::m.mWallAttachMissAnm); + field_0x3478 = daAlinkHIO_ladder_c0::m.mWallAttachMissAnm.mCancelFrame; voiceStart(Z2SE_AL_V_FOOT_MISS); } else { - setSingleAnimeParam(ANM_CLIMB_HANG, &daAlinkHIO_ladder_c0::m.field_0x0); - field_0x3478 = daAlinkHIO_ladder_c0::m.field_0x0.mCancelFrame; + setSingleAnimeParam(ANM_CLIMB_HANG, &daAlinkHIO_ladder_c0::m.mWallAttachAnm); + field_0x3478 = daAlinkHIO_ladder_c0::m.mWallAttachAnm.mCancelFrame; voiceStart(Z2SE_AL_V_JUMP_HANG); } @@ -488,8 +488,8 @@ int daAlink_c::procHangWaitInit() { commonProcInit(PROC_HANG_WAIT); if (checkNoResetFlg2(FLG2_UNK_2000) && checkHangFootWall()) { - setSingleAnime(ANM_CLIMB_HANG, 0.0f, daAlinkHIO_ladder_c0::m.field_0x0.mEndFrame, - daAlinkHIO_ladder_c0::m.field_0x0.mEndFrame, 5.0f); + setSingleAnime(ANM_CLIMB_HANG, 0.0f, daAlinkHIO_ladder_c0::m.mWallAttachAnm.mEndFrame, + daAlinkHIO_ladder_c0::m.mWallAttachAnm.mEndFrame, 5.0f); field_0x2f92 = 0xFE; field_0x2f93 = 0xFE; } else { @@ -1203,7 +1203,7 @@ int daAlink_c::setLadderInit() { if (checkModeFlg(0x40000)) { setLadderPos(getLadderUnitCount() - 2); - while (mWaterY - current.pos.y > daAlinkHIO_swim_c0::m.mInitHeight) { + while (mWaterY - current.pos.y > daAlinkHIO_swim_c0::m.mStartHeight) { current.pos.y += 37.5f; } @@ -1281,8 +1281,8 @@ void daAlink_c::setLadderPos(int param_0) { /* 800FD288-800FD2AC 0F7BC8 0024+00 2/2 0/0 0/0 .text getLadderMoveAnmSpeed__9daAlink_cFv */ f32 daAlink_c::getLadderMoveAnmSpeed() { - return getAnmSpeedStickRate(daAlinkHIO_ladder_c0::m.field_0x48, - daAlinkHIO_ladder_c0::m.field_0x4C); + return getAnmSpeedStickRate(daAlinkHIO_ladder_c0::m.mMoveMinASpeed, + daAlinkHIO_ladder_c0::m.mMoveMaxSpeed); } /* 800FD2AC-800FD4A8 0F7BEC 01FC+00 3/3 0/0 0/0 .text changeLadderMoveProc__9daAlink_cFi @@ -1384,8 +1384,8 @@ int daAlink_c::procLadderUpStartInit() { mNormalSpeed = 0.0f; speedF = 0.0f; - setSingleAnimeBaseSpeed(ANM_LADDER_UP_START, daAlinkHIO_ladder_c0::m.field_0x28, - daAlinkHIO_ladder_c0::m.field_0x2C); + setSingleAnimeBaseSpeed(ANM_LADDER_UP_START, daAlinkHIO_ladder_c0::m.mClimbUpStartASpeed, + daAlinkHIO_ladder_c0::m.mClimbUpStartInterp); field_0x2f99 = 0x10; field_0x3588 = l_waitBaseAnime; dComIfGp_setPlayerStatus0(0, 0x2000000); @@ -1431,8 +1431,8 @@ int daAlink_c::procLadderUpEndInit(int param_0) { commonProcInit(PROC_LADDER_UP_END); daAlink_ANM anm_id = param_0 != 0 ? ANM_LADDER_UP_END_LEFT : ANM_LADDER_UP_END_RIGHT; - setSingleAnimeBaseSpeed(anm_id, daAlinkHIO_ladder_c0::m.field_0x30, - daAlinkHIO_ladder_c0::m.field_0x34); + setSingleAnimeBaseSpeed(anm_id, daAlinkHIO_ladder_c0::m.mClimbUpEndASpeed, + daAlinkHIO_ladder_c0::m.mClimbUpEndInterp); field_0x2f99 = 14; setSpecialGravity(0.0f, maxFallSpeed, 0); @@ -1459,7 +1459,7 @@ int daAlink_c::procLadderUpEnd() { if (checkAnmEnd(frame_ctrl)) { checkNextAction(0); - } else if (!(frame_ctrl->getFrame() > daAlinkHIO_ladder_c0::m.field_0x58) || + } else if (!(frame_ctrl->getFrame() > daAlinkHIO_ladder_c0::m.mClimbUpEndCF) || !checkNextAction(1)) { if (frame_ctrl->getFrame() >= 23.0f) { @@ -1493,8 +1493,8 @@ int daAlink_c::procLadderDownStartInit() { shape_angle.y = field_0x306e + 0x8000; current.angle.y = field_0x306e; - setSingleAnimeBaseSpeed(ANM_LADDER_DOWN_START, daAlinkHIO_ladder_c0::m.field_0x38, - daAlinkHIO_ladder_c0::m.field_0x3C); + setSingleAnimeBaseSpeed(ANM_LADDER_DOWN_START, daAlinkHIO_ladder_c0::m.mClimbDownStartASpeed, + daAlinkHIO_ladder_c0::m.mClimbDownStartInterp); field_0x2f99 = 0x10; field_0x3588 = l_waitBaseAnime; dComIfGp_setPlayerStatus0(0, 0x2000000); @@ -1548,8 +1548,8 @@ int daAlink_c::procLadderDownEndInit(int param_0) { commonProcInit(PROC_LADDER_DOWN_END); daAlink_ANM anm_id = param_0 != 0 ? ANM_LADDER_DOWN_END_LEFT : ANM_LADDER_DOWN_END_RIGHT; - setSingleAnimeBaseSpeed(anm_id, daAlinkHIO_ladder_c0::m.field_0x40, - daAlinkHIO_ladder_c0::m.field_0x44); + setSingleAnimeBaseSpeed(anm_id, daAlinkHIO_ladder_c0::m.mClimbDownEndASpeed, + daAlinkHIO_ladder_c0::m.mClimbDownEndInterp); field_0x2f99 = 14; setSpecialGravity(0.0f, maxFallSpeed, 0); @@ -1571,7 +1571,7 @@ int daAlink_c::procLadderDownEnd() { if (checkAnmEnd(frame_ctrl)) { checkNextAction(0); - } else if (!(frame_ctrl->getFrame() > daAlinkHIO_ladder_c0::m.field_0x54) || + } else if (!(frame_ctrl->getFrame() > daAlinkHIO_ladder_c0::m.mClimbDownEndCF) || !checkNextAction(1)) { if (frame_ctrl->getFrame() >= 11.0f) { @@ -1629,7 +1629,7 @@ int daAlink_c::procLadderMoveInit(int param_0, int param_1, cXyz* param_2) { } } - setSingleAnimeBaseSpeed(anm, anm_speed, daAlinkHIO_ladder_c0::m.field_0x50); + setSingleAnimeBaseSpeed(anm, anm_speed, daAlinkHIO_ladder_c0::m.mMoveInterp); field_0x2f98 = param_1; if (!param_1) { @@ -1679,14 +1679,14 @@ int daAlink_c::procLadderMove() { /* 800FE010-800FE034 0F8950 0024+00 3/3 0/0 0/0 .text getClimbMoveUpDownAnmSpeed__9daAlink_cFv */ f32 daAlink_c::getClimbMoveUpDownAnmSpeed() { - return getAnmSpeedStickRate(daAlinkHIO_ladder_c0::m.field_0x64, - daAlinkHIO_ladder_c0::m.field_0x68); + return getAnmSpeedStickRate(daAlinkHIO_ladder_c0::m.mWallVerticalMinAnmSpeed, + daAlinkHIO_ladder_c0::m.mWallVerticalMaxAnmSpeed); } /* 800FE034-800FE058 0F8974 0024+00 4/4 0/0 0/0 .text getClimbMoveSideAnmSpeed__9daAlink_cFv */ f32 daAlink_c::getClimbMoveSideAnmSpeed() { - return getAnmSpeedStickRate(daAlinkHIO_ladder_c0::m.field_0x5C, - daAlinkHIO_ladder_c0::m.field_0x60); + return getAnmSpeedStickRate(daAlinkHIO_ladder_c0::m.mWallHorizontalMinAnmSpeed, + daAlinkHIO_ladder_c0::m.mWallHorizontalMaxAnmSpeed); } /* 800FE058-800FE114 0F8998 00BC+00 9/9 0/0 0/0 .text checkClimbCode__9daAlink_cFR13cBgS_PolyInfo @@ -2145,12 +2145,12 @@ int daAlink_c::procClimbUpStartInit(int param_0) { mNormalSpeed = 0.0f; if (param_0 || var_r29 || cM_rnd() < 0.3f) { - setSingleAnimeParam(ANM_CLIMB_HANG, &daAlinkHIO_ladder_c0::m.field_0x0); - field_0x3478 = daAlinkHIO_ladder_c0::m.field_0x0.mCancelFrame; + setSingleAnimeParam(ANM_CLIMB_HANG, &daAlinkHIO_ladder_c0::m.mWallAttachAnm); + field_0x3478 = daAlinkHIO_ladder_c0::m.mWallAttachAnm.mCancelFrame; voiceStart(Z2SE_AL_V_JUMP_HANG); } else { - setSingleAnimeParam(ANM_CLIMB_HANG_MISS, &daAlinkHIO_ladder_c0::m.field_0x14); - field_0x3478 = daAlinkHIO_ladder_c0::m.field_0x14.mCancelFrame; + setSingleAnimeParam(ANM_CLIMB_HANG_MISS, &daAlinkHIO_ladder_c0::m.mWallAttachMissAnm); + field_0x3478 = daAlinkHIO_ladder_c0::m.mWallAttachMissAnm.mCancelFrame; voiceStart(Z2SE_AL_V_FOOT_MISS); } @@ -2158,7 +2158,7 @@ int daAlink_c::procClimbUpStartInit(int param_0) { dComIfGp_setPlayerStatus0(0, 8); if (param_0) { - current.pos.y = field_0x34ec.y + daAlinkHIO_ladder_c0::m.field_0x6C; + current.pos.y = field_0x34ec.y + daAlinkHIO_ladder_c0::m.mWallApproachOffset; } field_0x2f99 = 2; @@ -2226,12 +2226,12 @@ int daAlink_c::procClimbDownStartInit(s16 param_0) { deleteEquipItem(TRUE, FALSE); if (cM_rnd() < 0.7f) { - setSingleAnimeParam(ANM_CLIMB_HANG, &daAlinkHIO_ladder_c0::m.field_0x0); - field_0x3478 = daAlinkHIO_ladder_c0::m.field_0x0.mCancelFrame; + setSingleAnimeParam(ANM_CLIMB_HANG, &daAlinkHIO_ladder_c0::m.mWallAttachAnm); + field_0x3478 = daAlinkHIO_ladder_c0::m.mWallAttachAnm.mCancelFrame; mProcVar0.field_0x3008 = 0; } else { - setSingleAnimeParam(ANM_CLIMB_HANG_MISS, &daAlinkHIO_ladder_c0::m.field_0x14); - field_0x3478 = daAlinkHIO_ladder_c0::m.field_0x14.mCancelFrame; + setSingleAnimeParam(ANM_CLIMB_HANG_MISS, &daAlinkHIO_ladder_c0::m.mWallAttachMissAnm); + field_0x3478 = daAlinkHIO_ladder_c0::m.mWallAttachMissAnm.mCancelFrame; mProcVar0.field_0x3008 = 1; voiceStart(Z2SE_AL_V_FOOT_MISS); } @@ -2614,14 +2614,14 @@ int daAlink_c::procClimbToRoof() { /* 801005CC-801005F0 0FAF0C 0024+00 2/2 0/0 0/0 .text getRoofHangFMoveAnmSpeed__9daAlink_cCFv */ f32 daAlink_c::getRoofHangFMoveAnmSpeed() const { - return getAnmSpeedStickRate(daAlinkHIO_roofHang_c0::m.field_0x24, - daAlinkHIO_roofHang_c0::m.field_0x28); + return getAnmSpeedStickRate(daAlinkHIO_roofHang_c0::m.mVertMoveMinASpeed, + daAlinkHIO_roofHang_c0::m.mVertMoveMaxASpeed); } /* 801005F0-80100614 0FAF30 0024+00 2/2 0/0 0/0 .text getRoofHangSMoveAnmSpeed__9daAlink_cCFv */ f32 daAlink_c::getRoofHangSMoveAnmSpeed() const { - return getAnmSpeedStickRate(daAlinkHIO_roofHang_c0::m.field_0x38, - daAlinkHIO_roofHang_c0::m.field_0x3C); + return getAnmSpeedStickRate(daAlinkHIO_roofHang_c0::m.mHorizMoveMinASpeed, + daAlinkHIO_roofHang_c0::m.mHorizMoveMaxASpeed); } /* 80100614-80100668 0FAF54 0054+00 3/3 0/0 0/0 .text @@ -2734,7 +2734,7 @@ int daAlink_c::checkNextActionRoofHang() { int daAlink_c::procRoofHangStartInit(cBgS_PolyInfo const& param_0, cXyz const& param_1, int param_2) { commonProcInit(PROC_ROOF_HANG_START); - setSingleAnimeParam(ANM_ROOF_HANG, &daAlinkHIO_roofHang_c0::m.field_0x0); + setSingleAnimeParam(ANM_ROOF_HANG, &daAlinkHIO_roofHang_c0::m.mRoofHangAnm); mPolyInfo2.SetPolyInfo(param_0); current.pos = param_1; @@ -2766,7 +2766,7 @@ int daAlink_c::procRoofHangStart() { if (mProcVar0.field_0x3008 == 0 && (checkAnmEnd(frame_ctrl) || (checkInputOnR() && - frame_ctrl->getFrame() > daAlinkHIO_roofHang_c0::m.field_0x0.mCancelFrame))) + frame_ctrl->getFrame() > daAlinkHIO_roofHang_c0::m.mRoofHangAnm.mCancelFrame))) { checkNextActionRoofHang(); } else if (checkAnmEnd(frame_ctrl)) { @@ -2797,7 +2797,7 @@ int daAlink_c::procRoofHangWaitInit(int param_0) { } } - setSingleAnimeBaseSpeed(ANM_ROOF_HANG_WAIT, daAlinkHIO_roofHang_c0::m.field_0x1C, daAlinkHIO_roofHang_c0::m.field_0x20); + setSingleAnimeBaseSpeed(ANM_ROOF_HANG_WAIT, daAlinkHIO_roofHang_c0::m.mStandbyASpeed, daAlinkHIO_roofHang_c0::m.mStandbyInterp); current.angle.y = shape_angle.y; setSpecialGravity(0.0f, maxFallSpeed, 0); @@ -2846,7 +2846,7 @@ int daAlink_c::procRoofHangFrontMoveInit() { frame = mUnderFrameCtrl[0].getFrame(); } - setSingleAnimeBaseSpeed(ANM_ROOF_HANG_MOVE, anm_speed, daAlinkHIO_roofHang_c0::m.field_0x2C); + setSingleAnimeBaseSpeed(ANM_ROOF_HANG_MOVE, anm_speed, daAlinkHIO_roofHang_c0::m.mVertMoveInterp); if (frame >= 0) { mUnderFrameCtrl[0].setFrame(frame); @@ -2875,9 +2875,9 @@ int daAlink_c::procRoofHangFrontMove() { checkNextActionRoofHang(); } else { if (!checkAttentionLock()) { - cLib_addCalcAngleS(¤t.angle.y, field_0x2fe2, daAlinkHIO_roofHang_c0::m.field_0x14, - daAlinkHIO_roofHang_c0::m.field_0x16, - daAlinkHIO_roofHang_c0::m.field_0x18); + cLib_addCalcAngleS(¤t.angle.y, field_0x2fe2, daAlinkHIO_roofHang_c0::m.mTurnAngleRate, + daAlinkHIO_roofHang_c0::m.mMaxTurnAngle, + daAlinkHIO_roofHang_c0::m.mMinTurnAngle); if (field_0x2f98 == 0) { shape_angle.y = current.angle.y; @@ -2893,8 +2893,8 @@ int daAlink_c::procRoofHangFrontMove() { frame = frameCtrl->getFrame(); } - mNormalSpeed = getAnmSpeedStickRate(daAlinkHIO_roofHang_c0::m.field_0x30, - daAlinkHIO_roofHang_c0::m.field_0x34) * + mNormalSpeed = getAnmSpeedStickRate(daAlinkHIO_roofHang_c0::m.mVertMoveMinSpeed, + daAlinkHIO_roofHang_c0::m.mVertMoveMaxSpeed) * cM_fsin((frame * M_PI) * 0.083333336f); if (mNormalSpeed < 0.0f) { mNormalSpeed = 0.0f; @@ -2951,7 +2951,7 @@ int daAlink_c::procRoofHangSideMoveInit() { } setSingleAnimeBaseSpeed(anm_id, getRoofHangSMoveAnmSpeed(), - daAlinkHIO_roofHang_c0::m.field_0x40); + daAlinkHIO_roofHang_c0::m.mHorizMoveInterp); setSpecialGravity(0.0f, maxFallSpeed, 0); f32 tmp_0 = 0.0f; @@ -2996,7 +2996,7 @@ int daAlink_c::procRoofHangTurnInit() { f32 anm_speed; if ((s16)(field_0x2fe2 - shape_angle.y) < 0) { - anm_speed = -daAlinkHIO_roofHang_c0::m.field_0x44; + anm_speed = -daAlinkHIO_roofHang_c0::m.mInvertASpeed; mProcVar0.field_0x3008 = 1; shape_angle.y += 0x8000; setOldRootQuaternion(0, -0x8000, 0); @@ -3005,7 +3005,7 @@ int daAlink_c::procRoofHangTurnInit() { field_0x3478 = 0.0f; field_0x347c = 10.0f; } else { - anm_speed = daAlinkHIO_roofHang_c0::m.field_0x44; + anm_speed = daAlinkHIO_roofHang_c0::m.mInvertASpeed; mProcVar0.field_0x3008 = 0; mProcVar2.field_0x300c = field_0x2fe2 + 0x8000; field_0x3478 = 10.0f; @@ -3013,7 +3013,7 @@ int daAlink_c::procRoofHangTurnInit() { } current.angle.y = shape_angle.y; - setSingleAnimeBaseSpeed(ANM_ROOF_HANG_TURN, anm_speed, daAlinkHIO_roofHang_c0::m.field_0x48); + setSingleAnimeBaseSpeed(ANM_ROOF_HANG_TURN, anm_speed, daAlinkHIO_roofHang_c0::m.mInvertInterp); if (mProcVar0.field_0x3008 != 0) { setFaceBasicTexture(FTANM_UNK_4); @@ -3071,7 +3071,7 @@ void daAlink_c::setRoofHangSwitch() { int daAlink_c::procRoofSwitchHangInit(fopAc_ac_c* param_0) { commonProcInit(PROC_ROOF_SWITCH_HANG); deleteEquipItem(TRUE, FALSE); - setSingleAnimeParam(ANM_ROOF_HANG, &daAlinkHIO_roofHang_c0::m.field_0x0); + setSingleAnimeParam(ANM_ROOF_HANG, &daAlinkHIO_roofHang_c0::m.mRoofHangAnm); setSpecialGravity(0.0f, maxFallSpeed, 0); f32 tmp_0 = 0.0f; @@ -3103,8 +3103,8 @@ int daAlink_c::procRoofSwitchHang() { setRoofHangSwitch(); if (checkAnmEnd(mUnderFrameCtrl)) { - setSingleAnimeBaseSpeed(ANM_ROOF_HANG_WAIT, daAlinkHIO_roofHang_c0::m.field_0x1C, - daAlinkHIO_roofHang_c0::m.field_0x20); + setSingleAnimeBaseSpeed(ANM_ROOF_HANG_WAIT, daAlinkHIO_roofHang_c0::m.mStandbyASpeed, + daAlinkHIO_roofHang_c0::m.mStandbyInterp); mProcVar2.field_0x300c = 1; } else if (mProcVar2.field_0x300c != 0) { setDoStatus(0x33); diff --git a/src/d/actor/d_a_alink_hook.inc b/src/d/actor/d_a_alink_hook.inc index a35d09abe8e..881da65cb88 100644 --- a/src/d/actor/d_a_alink_hook.inc +++ b/src/d/actor/d_a_alink_hook.inc @@ -1507,7 +1507,7 @@ int daAlink_c::procHookshotMove() { if (field_0x2f98 != 2) { field_0x2f98 = 2; - blend = daAlinkHIO_basic_c0::m.mAnmBlendFactor; + blend = daAlinkHIO_basic_c0::m.mBasicInterpolation; } } else { offModeFlg(1); diff --git a/src/d/actor/d_a_alink_horse.inc b/src/d/actor/d_a_alink_horse.inc index 6c5418de5e3..242f5c8f1e8 100644 --- a/src/d/actor/d_a_alink_horse.inc +++ b/src/d/actor/d_a_alink_horse.inc @@ -710,8 +710,8 @@ int daAlink_c::setSyncHorse(int param_0) { s32 dir = getDirectionFromShapeAngle(); if (dir == DIR_FORWARD) { - field_0x3004 = daAlinkHIO_horse_c0::m.mNoWalkTime; - setSingleAnimeParam(ANM_WSTARTH, &daAlinkHIO_horse_c0::m.mWalkAnm); + field_0x3004 = daAlinkHIO_horse_c0::m.mWalkOutProhibitionTime; + setSingleAnimeParam(ANM_WSTARTH, &daAlinkHIO_horse_c0::m.mWalkOutAnm); offNoResetFlg1(FLG1_UNK_1000); } } @@ -755,7 +755,7 @@ int daAlink_c::setSyncHorse(int param_0) { setDoStatus(9); if (doTrigger()) { - field_0x3004 = daAlinkHIO_horse_c0::m.mNoWalkTime; + field_0x3004 = daAlinkHIO_horse_c0::m.mWalkOutProhibitionTime; daAlink_ANM anm; const daAlinkHIO_anm_c* anmparam_p = &daAlinkHIO_horse_c0::m.mWhipAnm; anm = ANM_HORSE_LASH; @@ -829,7 +829,7 @@ int daAlink_c::setSyncHorse(int param_0) { mProcID != PROC_HORSE_CUT_TURN) || field_0x2f8c == 10) { - if ((var_r28 || field_0x3004 != daAlinkHIO_horse_c0::m.mNoWalkTime) && field_0x3004 != 0) { + if ((var_r28 || field_0x3004 != daAlinkHIO_horse_c0::m.mWalkOutProhibitionTime) && field_0x3004 != 0) { field_0x3004--; } @@ -878,8 +878,8 @@ int daAlink_c::setSyncBoar(int param_0) { { int direction = getDirectionFromShapeAngle(); if (direction == DIR_FORWARD || direction == DIR_BACKWARD) { - field_0x3004 = daAlinkHIO_horse_c0::m.mNoWalkTime; - setSingleAnimeParam(ANM_WSTARTH, &daAlinkHIO_horse_c0::m.mWalkAnm); + field_0x3004 = daAlinkHIO_horse_c0::m.mWalkOutProhibitionTime; + setSingleAnimeParam(ANM_WSTARTH, &daAlinkHIO_horse_c0::m.mWalkOutAnm); } } @@ -1067,10 +1067,10 @@ int daAlink_c::setRideSubjectAngle(s16 param_0) { if (mTargetedActor != NULL) { var_r30 = 10000; } else { - var_r30 = daAlinkHIO_horse_c0::m.field_0x58; + var_r30 = daAlinkHIO_horse_c0::m.mSubjectiveDownwardMaxAngle; } - mBodyAngle.x = cLib_minMaxLimit((s16)mBodyAngle.x, daAlinkHIO_horse_c0::m.field_0x5A, var_r30); + mBodyAngle.x = cLib_minMaxLimit((s16)mBodyAngle.x, daAlinkHIO_horse_c0::m.mSubjectiveUpwardMaxAngle, var_r30); s16 temp_r29 = shape_angle.y - param_0; if (checkHorseZelda()) { @@ -1118,7 +1118,7 @@ BOOL daAlink_c::checkHorseGetOffWallCheck(cXyz* i_lineStartPos, cXyz* i_lineEndP return TRUE; } - if (getGroundAngle(&mLinkLinChk, param_2) < -cM_deg2s(daAlinkHIO_wlSlide_c0::m.field_0x5C)) { + if (getGroundAngle(&mLinkLinChk, param_2) < -cM_deg2s(daAlinkHIO_wlSlide_c0::m.mSlidingAngle)) { return TRUE; } @@ -1538,7 +1538,7 @@ int daAlink_c::procHorseRide() { voiceStart(Z2SE_AL_V_RUSH_HORSE); field_0x30a6 = daAlinkHIO_horse_c0::m.mWhipWaitTime; - field_0x3004 = daAlinkHIO_horse_c0::m.mNoWalkTime; + field_0x3004 = daAlinkHIO_horse_c0::m.mWalkOutProhibitionTime; var_r26->onPlayerBackRideLash(); } } else if (mProcVar2.field_0x300c == 0 && checkHorseRide()) { @@ -2158,7 +2158,7 @@ int daAlink_c::procHorseCut() { /* 800F1894-800F194C 0EC1D4 00B8+00 3/3 0/0 0/0 .text procHorseCutChargeReadyInit__9daAlink_cFv */ int daAlink_c::procHorseCutChargeReadyInit() { commonProcInit(PROC_HORSE_CUT_CHARGE_READY); - setUpperAnimeParam(0x96, UPPER_2, &daAlinkHIO_hoCutCharge_c0::m.field_0x0); + setUpperAnimeParam(0x96, UPPER_2, &daAlinkHIO_hoCutCharge_c0::m.mChargeAnm); setFacePriBck(0xE8); field_0x2f96 = 2; @@ -2222,12 +2222,12 @@ int daAlink_c::procHorseCutTurnInit() { resetUnderAnime(UNDER_2, -1.0f); } - setSingleAnimeParam(ANM_HORSE_CUT_TURN, &daAlinkHIO_hoCutCharge_c0::m.field_0x28); + setSingleAnimeParam(ANM_HORSE_CUT_TURN, &daAlinkHIO_hoCutCharge_c0::m.mSpinAnm); setCutType(43); setSyncRide(1); - field_0x3478 = daAlinkHIO_hoCutCharge_c0::m.field_0x50; + field_0x3478 = daAlinkHIO_hoCutCharge_c0::m.mSpinAttackRadius; setCylAtParam(getSwordAtType(), dCcG_At_Spl_UNK_1, 3, 1, 3, field_0x3478 * 0.5f, 200.0f); - mProcVar4.field_0x3010 = daAlinkHIO_hoCutCharge_c0::m.field_0x3E; + mProcVar4.field_0x3010 = daAlinkHIO_hoCutCharge_c0::m.mSpinStopTime; voiceStart(Z2SE_AL_V_KAITEN); setCutWaterDropEffect(); setHorseZeldaDamage(); @@ -2246,7 +2246,7 @@ int daAlink_c::procHorseCutTurn() { procHorseWaitInit(); field_0x2060->initOldFrameMorf(4.0f, 0, 0x23); } else { - if (temp_r30->getFrame() > daAlinkHIO_hoCutCharge_c0::m.field_0x28.mCancelFrame) { + if (temp_r30->getFrame() > daAlinkHIO_hoCutCharge_c0::m.mSpinAnm.mCancelFrame) { if (orderTalk(1)) { return 1; } @@ -2261,7 +2261,7 @@ int daAlink_c::procHorseCutTurn() { } } - if (temp_r30->getFrame() >= daAlinkHIO_hoCutCharge_c0::m.field_0x48 && temp_r30->getFrame() < daAlinkHIO_hoCutCharge_c0::m.field_0x4C) { + if (temp_r30->getFrame() >= daAlinkHIO_hoCutCharge_c0::m.mSpinAttackStartFrame && temp_r30->getFrame() < daAlinkHIO_hoCutCharge_c0::m.mSpinAttackEndFrame) { if (!checkNoResetFlg0(FLG0_UNK_40)) { seStartSwordCut(Z2SE_AL_KAITENGIRI); } @@ -2296,7 +2296,7 @@ int daAlink_c::procHorseDamageInit(dCcD_GObjInf* param_0) { if (checkUnderMove0BckNoArc(ANM_HORSE_STOP) || checkUnderMove0BckNoArc(ANM_HORSE_STOP_TO_STAND) || checkUnderMove0BckNoArc(ANM_HORSE_STAND) || checkUnderMove0BckNoArc(ANM_HORSE_DASH_B) || checkUnderMove0BckNoArc(ANM_HORSE_DASH_A) || checkUnderMove0BckNoArc(ANM_HORSE_DASH_START)) { mProcVar4.field_0x3010 = 0; mProcVar5.field_0x3012 = 0; - setUpperAnimeParam(anmIdx[4], UPPER_2, &daAlinkHIO_damHorse_c0::m.field_0x0); + setUpperAnimeParam(anmIdx[4], UPPER_2, &daAlinkHIO_damHorse_c0::m.mNoDirectionAnm); } else { cXyz* temp_r29 = getDamageVec(param_0); @@ -2304,11 +2304,11 @@ int daAlink_c::procHorseDamageInit(dCcD_GObjInf* param_0) { f32 temp_f1 = cM_scos(shape_angle.y); cXyz spC((temp_r29->z * -temp_f31) + (temp_r29->x * temp_f1), temp_r29->y, (temp_r29->z * temp_f1) + (temp_r29->x * temp_f31)); - mProcVar4.field_0x3010 = cLib_minMaxLimit(cM_atan2s(spC.z, spC.y), -daAlinkHIO_damHorse_c0::m.field_0x28, daAlinkHIO_damHorse_c0::m.field_0x28); - mProcVar5.field_0x3012 = cLib_minMaxLimit(cM_atan2s(spC.x, -JMAFastSqrt((spC.y * spC.y) + (spC.z * spC.z))), -daAlinkHIO_damHorse_c0::m.field_0x2A, daAlinkHIO_damHorse_c0::m.field_0x2A); + mProcVar4.field_0x3010 = cLib_minMaxLimit(cM_atan2s(spC.z, spC.y), -daAlinkHIO_damHorse_c0::m.mFrontBackBodyMaxAngle, daAlinkHIO_damHorse_c0::m.mFrontBackBodyMaxAngle); + mProcVar5.field_0x3012 = cLib_minMaxLimit(cM_atan2s(spC.x, -JMAFastSqrt((spC.y * spC.y) + (spC.z * spC.z))), -daAlinkHIO_damHorse_c0::m.mLeftRightBodyMaxAngle, daAlinkHIO_damHorse_c0::m.mLeftRightBodyMaxAngle); int direction = getDirectionFromAngle(cM_atan2s(-spC.x, -spC.z)); - setUpperAnimeParam(anmIdx[direction], UPPER_2, &daAlinkHIO_damHorse_c0::m.field_0x14); + setUpperAnimeParam(anmIdx[direction], UPPER_2, &daAlinkHIO_damHorse_c0::m.mWithDirectionAnm); } setFacePriBck(0xEA); diff --git a/src/d/actor/d_a_alink_ironball.inc b/src/d/actor/d_a_alink_ironball.inc index ef2ef93ef92..57aba3a6f7a 100644 --- a/src/d/actor/d_a_alink_ironball.inc +++ b/src/d/actor/d_a_alink_ironball.inc @@ -54,7 +54,7 @@ void daAlink_c::setIronBallWaitUpperAnime(int param_0) { if (!checkIronBallWaitAnime() && !checkIronBallPreSwingAnime() && (mItemVar0.field_0x3018 == 0 || mItemVar0.field_0x3018 == 8) && (param_0 || checkNoUpperAnime())) { setUpperAnimeBaseSpeed(0x19C, daAlinkHIO_ironBall_c0::m.mWaitAnmSpeed, - daAlinkHIO_basic_c0::m.mAnmBlendFactor); + daAlinkHIO_basic_c0::m.mBasicInterpolation); setFacePriBck(0xE8); field_0x2f96 = 254; field_0x2f97 = 5; @@ -997,7 +997,7 @@ int daAlink_c::procIronBallMove() { if (field_0x2f98 != 2) { field_0x2f98 = 2; - var_f31 = daAlinkHIO_basic_c0::m.mAnmBlendFactor; + var_f31 = daAlinkHIO_basic_c0::m.mBasicInterpolation; } } else { offModeFlg(1); diff --git a/src/d/actor/d_a_alink_link.inc b/src/d/actor/d_a_alink_link.inc index c13ff2b7d90..f6a019a7956 100644 --- a/src/d/actor/d_a_alink_link.inc +++ b/src/d/actor/d_a_alink_link.inc @@ -254,8 +254,8 @@ int daAlink_c::procCoSwimSubjectivityInit() { setSubjectMode(); if (checkWolf()) { - setSingleAnimeWolfBaseSpeed(WANM_SWIM_WAIT, daAlinkHIO_wlSwim_c0::m.field_0x88, - daAlinkHIO_wlSwim_c0::m.field_0x68); + setSingleAnimeWolfBaseSpeed(WANM_SWIM_WAIT, daAlinkHIO_wlSwim_c0::m.mIdleAnmSpeedWeak, + daAlinkHIO_wlSwim_c0::m.mIdleInterp); } else { setSingleAnimeBaseSpeed(ANM_SWIM_WAIT, daAlinkHIO_swim_c0::m.mWaitAnmSpeed, daAlinkHIO_swim_c0::m.mWaitInterpolation); diff --git a/src/d/actor/d_a_alink_sumou.inc b/src/d/actor/d_a_alink_sumou.inc index 49f3f884fd8..a9c3b33c5ca 100644 --- a/src/d/actor/d_a_alink_sumou.inc +++ b/src/d/actor/d_a_alink_sumou.inc @@ -281,7 +281,7 @@ int daAlink_c::procSumouMove() { if (mSpeedModifier > 0.0f && checkInputOnR()) { int direction = getDirectionFromAngle(mStickAngle); if (direction == DIR_LEFT || direction == DIR_RIGHT) { - var_r31 = field_0x33ac * (daAlinkHIO_pushpull_c0::m.field_0xE * field_0x33ac); + var_r31 = field_0x33ac * (daAlinkHIO_pushpull_c0::m.mSumoRotationAngle * field_0x33ac); if (direction == DIR_RIGHT) { var_r31 = -var_r31; diff --git a/src/d/actor/d_a_alink_swim.inc b/src/d/actor/d_a_alink_swim.inc index 0544dc834b2..e283fa879d3 100644 --- a/src/d/actor/d_a_alink_swim.inc +++ b/src/d/actor/d_a_alink_swim.inc @@ -38,13 +38,13 @@ bool daAlink_c::getZoraSwim() const { */ f32 daAlink_c::getSwimFrontMaxSpeed() const { if (checkBootsOrArmorHeavy()) { - return daAlinkHIO_swim_c0::m.mUnderwaterMaxSinkSpeed; + return daAlinkHIO_swim_c0::m.mUnderwaterFallMaxSpeed; } else if (checkZoraWearAbility()) { return 14.0f; } else if (checkSwimDashMode()) { - return daAlinkHIO_swim_c0::m.mDMaxSpeed; + return daAlinkHIO_swim_c0::m.mDashMaxSpeed; } else { - return daAlinkHIO_swim_c0::m.mMaxForwardSpeed; + return daAlinkHIO_swim_c0::m.mForwardMaxSpeed; } } @@ -52,13 +52,13 @@ f32 daAlink_c::getSwimFrontMaxSpeed() const { */ f32 daAlink_c::getSwimMaxFallSpeed() const { if (mProcID == PROC_DIVE_JUMP) { - return -daAlinkHIO_swim_c0::m.mMaxUnderwaterSpeed; + return -daAlinkHIO_swim_c0::m.mUnderwaterMaxSpeed; } else if (checkBootsOrArmorHeavy()) { - return daAlinkHIO_swim_c0::m.mBootsMaxSinkSpeed; + return daAlinkHIO_swim_c0::m.mBootsMaxFallSpeed; } else if (getZoraSwim()) { - return daAlinkHIO_swim_c0::m.mMaxSinkSpeed; + return daAlinkHIO_swim_c0::m.mMaxFallSpeed; } else { - return daAlinkHIO_swim_c0::m.mInitMaxSinkSpeed; + return daAlinkHIO_swim_c0::m.mStandingMaxFallSpeed; } } @@ -121,7 +121,7 @@ void daAlink_c::setWaterInAnmRate(daPy_frameCtrl_c* i_frameCtrl, f32 i_rate) { if (checkZoraWearAbility()) { i_rate *= daAlinkHIO_magneBoots_c0::m.mZoraWaterAnmSpeed; } else { - i_rate *= daAlinkHIO_magneBoots_c0::m.mWaterWalkAnmRate; + i_rate *= daAlinkHIO_magneBoots_c0::m.mWaterStartWalkAnmRate; } } @@ -144,7 +144,7 @@ void daAlink_c::swimBgCheck(f32 param_0) { var_r29 = field_0x3080; } else { var_r29 = mProcVar2.field_0x300c; - start_pos.y += daAlinkHIO_wlWallHang_c0::m.field_0x78; + start_pos.y += daAlinkHIO_wlWallHang_c0::m.mAutoWalkHeight; } f32 var_f28 = param_0 * cM_scos(var_r29); @@ -243,7 +243,7 @@ void daAlink_c::setSpeedAndAngleSwim() { var_r28 = shape_angle.y + (16384.0f * cM_ssin(mStickAngle)); } - cLib_addCalcAngleS(&shape_angle.y, var_r28, daAlinkHIO_swim_c0::m.mUnderwaterTurnRate, daAlinkHIO_swim_c0::m.mUnderwaterTurnMax, daAlinkHIO_swim_c0::m.mUnderwaterTurnMin); + cLib_addCalcAngleS(&shape_angle.y, var_r28, daAlinkHIO_swim_c0::m.mUnderwaterTurnRate, daAlinkHIO_swim_c0::m.mUnderwaterMaxTurn, daAlinkHIO_swim_c0::m.mUnderwaterMinTurn); } current.angle.y = shape_angle.y; @@ -252,9 +252,9 @@ void daAlink_c::setSpeedAndAngleSwim() { if (checkInputOnR()) { s16 temp_r29_2 = shape_angle.y; if (checkNoResetFlg0(FLG0_SWIM_UP)) { - cLib_addCalcAngleS(&shape_angle.y, field_0x2fe2, daAlinkHIO_swim_c0::m.mTurnRate, daAlinkHIO_swim_c0::m.mTurnMax, daAlinkHIO_swim_c0::m.mTurnMin); + cLib_addCalcAngleS(&shape_angle.y, field_0x2fe2, daAlinkHIO_swim_c0::m.mTurnRate, daAlinkHIO_swim_c0::m.mMaxTurn, daAlinkHIO_swim_c0::m.mMinTurn); } else { - cLib_addCalcAngleS(&shape_angle.y, field_0x2fe2, daAlinkHIO_swim_c0::m.mUnderwaterTurnRate, daAlinkHIO_swim_c0::m.mUnderwaterTurnMax, daAlinkHIO_swim_c0::m.mUnderwaterTurnMin); + cLib_addCalcAngleS(&shape_angle.y, field_0x2fe2, daAlinkHIO_swim_c0::m.mUnderwaterTurnRate, daAlinkHIO_swim_c0::m.mUnderwaterMaxTurn, daAlinkHIO_swim_c0::m.mUnderwaterMinTurn); } f32 var_f29; @@ -288,9 +288,9 @@ void daAlink_c::setSpeedAndAngleSwim() { s16 temp_r29_3 = current.angle.y; if (checkNoResetFlg0(FLG0_SWIM_UP)) { - cLib_addCalcAngleS(¤t.angle.y, field_0x2fe2, daAlinkHIO_swim_c0::m.mTurnRate, daAlinkHIO_swim_c0::m.mTurnMax, daAlinkHIO_swim_c0::m.mTurnMin); + cLib_addCalcAngleS(¤t.angle.y, field_0x2fe2, daAlinkHIO_swim_c0::m.mTurnRate, daAlinkHIO_swim_c0::m.mMaxTurn, daAlinkHIO_swim_c0::m.mMinTurn); } else { - cLib_addCalcAngleS(¤t.angle.y, field_0x2fe2, daAlinkHIO_swim_c0::m.mUnderwaterTurnRate, daAlinkHIO_swim_c0::m.mUnderwaterTurnMax, daAlinkHIO_swim_c0::m.mUnderwaterTurnMin); + cLib_addCalcAngleS(¤t.angle.y, field_0x2fe2, daAlinkHIO_swim_c0::m.mUnderwaterTurnRate, daAlinkHIO_swim_c0::m.mUnderwaterMaxTurn, daAlinkHIO_swim_c0::m.mUnderwaterMinTurn); } var_f30 = daAlinkHIO_swim_c0::m.mAcceleration * field_0x33a8 * cM_scos((s16)(current.angle.y - temp_r29_3)); @@ -300,8 +300,8 @@ void daAlink_c::setSpeedAndAngleSwim() { } f32 var_f28; - if (daAlinkHIO_swim_c0::m.mMaxForwardSpeed < mNormalSpeed && !checkZoraWearAbility()) { - var_f28 = daAlinkHIO_swim_c0::m.mDDeceleration; + if (daAlinkHIO_swim_c0::m.mForwardMaxSpeed < mNormalSpeed && !checkZoraWearAbility()) { + var_f28 = daAlinkHIO_swim_c0::m.mDashDeceleration; } else { var_f28 = daAlinkHIO_swim_c0::m.mDeceleration; } @@ -376,10 +376,10 @@ int daAlink_c::checkSwimAction(int param_0) { if (getMoveBGActorName(mLinkAcch.m_gnd, NULL) == PROC_Obj_ITA) { var_f31 = 200.0f; } else { - var_f31 = daAlinkHIO_wlSwim_c0::m.field_0x48; + var_f31 = daAlinkHIO_wlSwim_c0::m.mStartHeight; } } else { - var_f31 = daAlinkHIO_swim_c0::m.mInitHeight; + var_f31 = daAlinkHIO_swim_c0::m.mStartHeight; } if (checkNoResetFlg0(FLG0_UNK_80) && !checkNoResetFlg0(FLG0_UNDERWATER) && !checkModeFlg(0x40000) && mProcID != PROC_MAGNE_BOOTS_FLY && ((mProcID != PROC_WOLF_LOCK_ATTACK && mProcID != PROC_WOLF_LOCK_ATTACK_TURN) || mProcVar5.field_0x3012 == 0) && mDemo.getDemoMode() != 0x11) { @@ -389,12 +389,12 @@ int daAlink_c::checkSwimAction(int param_0) { if (checkWolf()) { if (checkWolfDashMode()) { - var_f29 = daAlinkHIO_wlSwim_c0::m.field_0x50; + var_f29 = daAlinkHIO_wlSwim_c0::m.mMaxSpeed; } else { - var_f29 = daAlinkHIO_wlSwim_c0::m.field_0x80; + var_f29 = daAlinkHIO_wlSwim_c0::m.mMaxSpeedWeak; } - var_f28 = daAlinkHIO_wlSwim_c0::m.field_0x58; + var_f28 = daAlinkHIO_wlSwim_c0::m.mMaxFallSpeed; } else { var_f29 = getSwimFrontMaxSpeed(); var_f28 = getSwimMaxFallSpeed(); @@ -524,9 +524,9 @@ int daAlink_c::checkSwimUpAction() { if (!getZoraSwim()) { if (checkWolf()) { - field_0x3480 = daAlinkHIO_wlSwim_c0::m.field_0x48; + field_0x3480 = daAlinkHIO_wlSwim_c0::m.mStartHeight; } else { - cLib_addCalc(&field_0x3480, daAlinkHIO_swim_c0::m.mInitHeight, 0.5f, 15.0f, 1.0f); + cLib_addCalc(&field_0x3480, daAlinkHIO_swim_c0::m.mStartHeight, 0.5f, 15.0f, 1.0f); } } else { field_0x3480 = 65.0f; @@ -534,9 +534,9 @@ int daAlink_c::checkSwimUpAction() { f32 var_f31; if (checkWolf()) { - var_f31 = daAlinkHIO_wlSwim_c0::m.field_0x4C; + var_f31 = daAlinkHIO_wlSwim_c0::m.mSurfacingHeight; } else { - var_f31 = daAlinkHIO_swim_c0::m.mResurfaceHeight; + var_f31 = daAlinkHIO_swim_c0::m.mFloatUpHeight; } if (!checkBootsOrArmorHeavy() && !checkNoResetFlg0(FLG0_SWIM_UP)) { @@ -614,9 +614,9 @@ BOOL daAlink_c::checkSwimFall() { int daAlink_c::checkSwimOutAction() { f32 var_f31; if (checkWolf()) { - var_f31 = daAlinkHIO_wlSwim_c0::m.field_0x48; + var_f31 = daAlinkHIO_wlSwim_c0::m.mStartHeight; } else { - var_f31 = daAlinkHIO_swim_c0::m.mInitHeight; + var_f31 = daAlinkHIO_swim_c0::m.mStartHeight; } if (checkSwimFall()) { @@ -627,10 +627,10 @@ int daAlink_c::checkSwimOutAction() { current.angle.y = sp8.atan2sX_Z(); if (checkWolf()) { - if (mNormalSpeed > daAlinkHIO_wlAutoJump_c0::m.field_0x74) { - mNormalSpeed = daAlinkHIO_wlAutoJump_c0::m.field_0x74; + if (mNormalSpeed > daAlinkHIO_wlAutoJump_c0::m.mWeakJumpMaxSpeed) { + mNormalSpeed = daAlinkHIO_wlAutoJump_c0::m.mWeakJumpMaxSpeed; } - return procWolfFallInit(2, daAlinkHIO_wlAutoJump_c0::m.field_0x54); + return procWolfFallInit(2, daAlinkHIO_wlAutoJump_c0::m.mNormalFallInterp); } else { if (mNormalSpeed > daAlinkHIO_autoJump_c0::m.mMaxJumpSpeed) { mNormalSpeed = daAlinkHIO_autoJump_c0::m.mMaxJumpSpeed; @@ -680,13 +680,13 @@ void daAlink_c::setSwimMoveAnime() { BOOL var_r25 = 0; if (field_0x2f98 == 4) { - f32 temp_f29 = daAlinkHIO_swim_c0::m.mMaxUnderwaterSpeed + daAlinkHIO_swim_c0::m.mUnderwaterButtonSpeed; + f32 temp_f29 = daAlinkHIO_swim_c0::m.mUnderwaterMaxSpeed + daAlinkHIO_swim_c0::m.mUnderwaterButtonAdditionalSpeed; field_0x3478 = daAlinkHIO_swim_c0::m.mUnderwaterMinAnmSpeed; field_0x347c = daAlinkHIO_swim_c0::m.mUnderwaterMaxAnmSpeed; - if (field_0x594 < daAlinkHIO_swim_c0::m.mMaxUnderwaterSpeed) { - field_0x594 = daAlinkHIO_swim_c0::m.mMaxUnderwaterSpeed; + if (field_0x594 < daAlinkHIO_swim_c0::m.mUnderwaterMaxSpeed) { + field_0x594 = daAlinkHIO_swim_c0::m.mUnderwaterMaxSpeed; } else if (doTrigger()) { field_0x594 += 0.75f; if (field_0x594 > temp_f29) { @@ -708,10 +708,10 @@ void daAlink_c::setSwimMoveAnime() { mProcVar5.field_0x3012 = 1; } } else if (!checkSwimMoveHandAnime()) { - cLib_chaseF(&field_0x594, daAlinkHIO_swim_c0::m.mMaxUnderwaterSpeed, 0.4f); + cLib_chaseF(&field_0x594, daAlinkHIO_swim_c0::m.mUnderwaterMaxSpeed, 0.4f); } - var_f31 = 1.0f / daAlinkHIO_swim_c0::m.mMaxUnderwaterSpeed; + var_f31 = 1.0f / daAlinkHIO_swim_c0::m.mUnderwaterMaxSpeed; if (checkZoraWearAbility() && (field_0x3198 == ANM_SWIM_DIVE || (field_0x3198 == ANM_SWIM_ZORA_START && !checkAnmEnd(temp_r28)))) { var_r29 = ANM_SWIM_ZORA_START; @@ -736,9 +736,9 @@ void daAlink_c::setSwimMoveAnime() { } if (checkSwimDashMode()) { - field_0x3478 = daAlinkHIO_swim_c0::m.mDMinAnmSpeed; - field_0x347c = daAlinkHIO_swim_c0::m.mDMaxAnmSpeed; - field_0x594 = daAlinkHIO_swim_c0::m.mDMaxSpeed; + field_0x3478 = daAlinkHIO_swim_c0::m.mDashMinAnmSpeed; + field_0x347c = daAlinkHIO_swim_c0::m.mDashMaxAnmSpeed; + field_0x594 = daAlinkHIO_swim_c0::m.mDashMaxSpeed; } else { field_0x3478 = daAlinkHIO_swim_c0::m.mForwardMinAnmSpeed; field_0x347c = daAlinkHIO_swim_c0::m.mForwardMaxAnmSpeed; @@ -754,7 +754,7 @@ void daAlink_c::setSwimMoveAnime() { if (checkZoraWearAbility()) { field_0x594 = 10.0f; } else { - field_0x594 = daAlinkHIO_swim_c0::m.mMaxBackwardSpeed; + field_0x594 = daAlinkHIO_swim_c0::m.mBackwardMaxSpeed; } var_f31 = 1.0f / field_0x594; @@ -771,7 +771,7 @@ void daAlink_c::setSwimMoveAnime() { if (checkZoraWearAbility()) { field_0x594 = 12.0f; } else { - field_0x594 = daAlinkHIO_swim_c0::m.mMaxStrafeSpeed; + field_0x594 = daAlinkHIO_swim_c0::m.mStrafeMaxSpeed; } var_f31 = 1.0f / field_0x594; @@ -785,7 +785,7 @@ void daAlink_c::setSwimMoveAnime() { if (checkBootsOrArmorHeavy()) { var_r29 = ANM_SWIM_WAIT; - field_0x594 = daAlinkHIO_swim_c0::m.mUnderwaterMaxSinkSpeed; + field_0x594 = daAlinkHIO_swim_c0::m.mUnderwaterFallMaxSpeed; if (mEquipItem != fpcNm_ITEM_NONE && !checkHookshotAnime()) { setDoStatus(4); } @@ -818,7 +818,7 @@ void daAlink_c::setSwimMoveAnime() { if (var_r29 != ANM_SWIM_WAIT && var_r29 != ANM_SWIM_DASH) { f32 temp_f30 = var_f31 * fabsf(mNormalSpeed); if (temp_f30 > 1.0f && field_0x2f98 == 4) { - temp_r28->setRate(daAlinkHIO_swim_c0::m.mUnderwaterMaxAnmSpeed + ((temp_f30 - 1.0f) * daAlinkHIO_swim_c0::m.mUnderwaterButtonAnmSpeed)); + temp_r28->setRate(daAlinkHIO_swim_c0::m.mUnderwaterMaxAnmSpeed + ((temp_f30 - 1.0f) * daAlinkHIO_swim_c0::m.mUnderwaterAdditionalAnmSpeed)); } else { temp_r28->setRate(field_0x3478 + (field_0x347c * temp_f30)); } @@ -915,12 +915,12 @@ void daAlink_c::setSwimUpDownOffset() { f32 var_f1; if (checkWolf()) { if (checkHeavyStateOn(1, 1)) { - var_f1 = daAlinkHIO_wlSwim_c0::m.field_0x98; + var_f1 = daAlinkHIO_wlSwim_c0::m.mHeavyIdleUpDownSwayAmount; } else { - var_f1 = daAlinkHIO_wlSwim_c0::m.field_0x6C; + var_f1 = daAlinkHIO_wlSwim_c0::m.mIdleUpDownSwayAmount; } } else { - var_f1 = daAlinkHIO_swim_c0::m.mWaitVibrationIntensity; + var_f1 = daAlinkHIO_swim_c0::m.mWaitUpDownShakeAmount; } field_0x2b98 = var_f1 * cM_ssin(mProcVar2.field_0x300c); @@ -939,11 +939,11 @@ int daAlink_c::procSwimUpInit() { field_0x3080 = 0; onNoResetFlg0(FLG0_SWIM_UP); mZ2Link.setInWater(false); - setSingleAnimeParam(ANM_SWIM_RESURFACE, &daAlinkHIO_swim_c0::m.mResurfaceAnm); + setSingleAnimeParam(ANM_SWIM_RESURFACE, &daAlinkHIO_swim_c0::m.mFloatUpAnm); dComIfGp_setPlayerStatus0(0, 0x100000); mProcVar0.field_0x3008 = 0; mProcVar4.field_0x3010 = 0; - field_0x3480 = daAlinkHIO_swim_c0::m.mInitHeight; + field_0x3480 = daAlinkHIO_swim_c0::m.mStartHeight; field_0x3000 = 0; seStartMapInfo(Z2SE_AL_OUTOF_WATER); @@ -970,7 +970,7 @@ int daAlink_c::procSwimUp() { } } else if (checkAnmEnd(frame_ctrl)) { procSwimWaitInit(0); - } else if (frame_ctrl->getFrame() > daAlinkHIO_swim_c0::m.mResurfaceAnm.mCancelFrame && + } else if (frame_ctrl->getFrame() > daAlinkHIO_swim_c0::m.mFloatUpAnm.mCancelFrame && checkInputOnR()) { procSwimMoveInit(); @@ -988,7 +988,7 @@ int daAlink_c::procSwimWaitInit(int param_0) { if (checkNoResetFlg0(FLG0_UNDERWATER)) { offNoResetFlg0(FLG0_UNDERWATER); - current.pos.y += daAlinkHIO_swim_c0::m.mInitHeight; + current.pos.y += daAlinkHIO_swim_c0::m.mStartHeight; } commonProcInit(PROC_SWIM_WAIT); @@ -996,10 +996,10 @@ int daAlink_c::procSwimWaitInit(int param_0) { if (param_0) { seStartMapInfo(Z2SE_AL_INTO_WATER); mProcVar4.field_0x3010 = 0; - field_0x3480 = daAlinkHIO_swim_c0::m.mInitHeight; + field_0x3480 = daAlinkHIO_swim_c0::m.mStartHeight; } else if (!mode_40000) { mProcVar4.field_0x3010 = 0; - field_0x3480 = daAlinkHIO_swim_c0::m.mInitHeight; + field_0x3480 = daAlinkHIO_swim_c0::m.mStartHeight; } swimDeleteItem(); @@ -1098,7 +1098,7 @@ int daAlink_c::procSwimMoveInit() { } if (!mode_40000) { - field_0x3480 = daAlinkHIO_swim_c0::m.mInitHeight; + field_0x3480 = daAlinkHIO_swim_c0::m.mStartHeight; mProcVar4.field_0x3010 = 0; } @@ -1185,7 +1185,7 @@ int daAlink_c::procSwimDiveInit() { field_0x2f99 = 0x10; field_0x3588 = l_waitBaseAnime; - field_0x3480 = daAlinkHIO_swim_c0::m.mInitHeight; + field_0x3480 = daAlinkHIO_swim_c0::m.mStartHeight; mProcVar4.field_0x3010 = 0; dComIfGp_setPlayerStatus0(0, 0x100000); @@ -1226,7 +1226,7 @@ int daAlink_c::procSwimDive() { } if (checkAnmEnd(frame_ctrl)) { - speed.y = daAlinkHIO_swim_c0::m.mMaxSinkSpeed; + speed.y = daAlinkHIO_swim_c0::m.mMaxFallSpeed; if (mProcVar2.field_0x300c != 0) { field_0x3080 = 0x2800; @@ -1272,7 +1272,7 @@ int daAlink_c::procSwimHookshotSubjectInit() { mProcVar0.field_0x3008 = 0; field_0x594 = getSwimFrontMaxSpeed(); - field_0x3480 = daAlinkHIO_swim_c0::m.mInitHeight; + field_0x3480 = daAlinkHIO_swim_c0::m.mStartHeight; mProcVar4.field_0x3010 = 0; field_0x30d0 = 0; @@ -1350,7 +1350,7 @@ int daAlink_c::procSwimHookshotMoveInit() { field_0x3080 = 0; } - field_0x3480 = daAlinkHIO_swim_c0::m.mInitHeight; + field_0x3480 = daAlinkHIO_swim_c0::m.mStartHeight; mProcVar4.field_0x3010 = 0; field_0x30d0 = 0; @@ -1437,16 +1437,16 @@ int daAlink_c::procSwimDamageInit(dCcD_GObjInf* param_0) { } f32 scale = - temp_r30->abs() * daAlinkHIO_damSwim_c0::m.field_0x80 + daAlinkHIO_damSwim_c0::m.field_0x7C; - if (scale > daAlinkHIO_damSwim_c0::m.field_0x88) { - scale = daAlinkHIO_damSwim_c0::m.field_0x88; + temp_r30->abs() * daAlinkHIO_damSwim_c0::m.mAttackSpeedRate + daAlinkHIO_damSwim_c0::m.mInitialSpeed; + if (scale > daAlinkHIO_damSwim_c0::m.mMaxSpeed) { + scale = daAlinkHIO_damSwim_c0::m.mMaxSpeed; } field_0x3750 = temp_r30->normZP(); field_0x3750 *= scale; if (getZoraSwim()) { - setUpperAnimeParam(0xBF, UPPER_2, &daAlinkHIO_damSwim_c0::m.field_0x50); + setUpperAnimeParam(0xBF, UPPER_2, &daAlinkHIO_damSwim_c0::m.mSinkAnm); setFacePriBck(0xEA); setFacePriTexture(FTANM_UNK_27); return 1; @@ -1458,36 +1458,36 @@ int daAlink_c::procSwimDamageInit(dCcD_GObjInf* param_0) { temp_r30->z * cM_scos(shape_angle.y) + temp_r30->x * cM_ssin(shape_angle.y)); mProcVar0.field_0x3008 = - cLib_minMaxLimit(cM_atan2s(sp24.z, sp24.y), (s16)-daAlinkHIO_damSwim_c0::m.field_0x78, - (s16)daAlinkHIO_damSwim_c0::m.field_0x78); + cLib_minMaxLimit(cM_atan2s(sp24.z, sp24.y), (s16)-daAlinkHIO_damSwim_c0::m.mFrontBackBodyMaxAngle, + (s16)daAlinkHIO_damSwim_c0::m.mFrontBackBodyMaxAngle); mProcVar1.field_0x300a = cLib_minMaxLimit( cM_atan2s(sp24.x, -JMAFastSqrt(sp24.y * sp24.y + sp24.z * sp24.z)), - (s16)-daAlinkHIO_damSwim_c0::m.field_0x7A, (s16)daAlinkHIO_damSwim_c0::m.field_0x7A); + (s16)-daAlinkHIO_damSwim_c0::m.mLeftRightBodyMaxAngle, (s16)daAlinkHIO_damSwim_c0::m.mLeftRightBodyMaxAngle); int dir = getDirectionFromAngle(cM_atan2s(-sp24.x, -sp24.z)); if (bvar4) { - setSingleAnimeParam(ANM_SWIM_DMG_FREEZE, &daAlinkHIO_damSwim_c0::m.field_0x64); - field_0x3478 = daAlinkHIO_damSwim_c0::m.field_0x64.mCancelFrame; + setSingleAnimeParam(ANM_SWIM_DMG_FREEZE, &daAlinkHIO_damSwim_c0::m.mSurfaceAnm); + field_0x3478 = daAlinkHIO_damSwim_c0::m.mSurfaceAnm.mCancelFrame; mProcVar0.field_0x3008 = 0; mProcVar1.field_0x300a = 0; } else if (dir == DIR_FORWARD) { - setSingleAnimeParam(ANM_SWIM_DMG_FRONT, &daAlinkHIO_damSwim_c0::m.field_0x0); - field_0x3478 = daAlinkHIO_damSwim_c0::m.field_0x0.mCancelFrame; + setSingleAnimeParam(ANM_SWIM_DMG_FRONT, &daAlinkHIO_damSwim_c0::m.mFrontAnm); + field_0x3478 = daAlinkHIO_damSwim_c0::m.mFrontAnm.mCancelFrame; } else if (dir == DIR_BACKWARD) { - setSingleAnimeParam(ANM_SWIM_DMG_BACK, &daAlinkHIO_damSwim_c0::m.field_0x14); - field_0x3478 = daAlinkHIO_damSwim_c0::m.field_0x14.mCancelFrame; + setSingleAnimeParam(ANM_SWIM_DMG_BACK, &daAlinkHIO_damSwim_c0::m.mRearAnm); + field_0x3478 = daAlinkHIO_damSwim_c0::m.mRearAnm.mCancelFrame; } else if (dir == DIR_LEFT) { - setSingleAnimeParam(ANM_SWIM_DMG_LEFT, &daAlinkHIO_damSwim_c0::m.field_0x28); - field_0x3478 = daAlinkHIO_damSwim_c0::m.field_0x28.mCancelFrame; + setSingleAnimeParam(ANM_SWIM_DMG_LEFT, &daAlinkHIO_damSwim_c0::m.mLeftAnm); + field_0x3478 = daAlinkHIO_damSwim_c0::m.mLeftAnm.mCancelFrame; } else { - setSingleAnimeParam(ANM_SWIM_DMG_RIGHT, &daAlinkHIO_damSwim_c0::m.field_0x3C); - field_0x3478 = daAlinkHIO_damSwim_c0::m.field_0x3C.mCancelFrame; + setSingleAnimeParam(ANM_SWIM_DMG_RIGHT, &daAlinkHIO_damSwim_c0::m.mRightAnm); + field_0x3478 = daAlinkHIO_damSwim_c0::m.mRightAnm.mCancelFrame; } mNormalSpeed = 0.0f; field_0x347c = M_PI / (mUnderFrameCtrl->getEnd() - mUnderFrameCtrl->getStart()); - field_0x3480 = daAlinkHIO_swim_c0::m.mInitHeight; + field_0x3480 = daAlinkHIO_swim_c0::m.mStartHeight; current.angle.y = shape_angle.y; return 1; diff --git a/src/d/actor/d_a_alink_whistle.inc b/src/d/actor/d_a_alink_whistle.inc index 78d17bfbb87..8655e9744d9 100644 --- a/src/d/actor/d_a_alink_whistle.inc +++ b/src/d/actor/d_a_alink_whistle.inc @@ -290,7 +290,7 @@ int daAlink_c::procCoHorseCallWaitInit(int param_0) { } if (checkWolf()) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMove_c0::m.field_0x70, 3.0f); + setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMove_c0::m.mIdleAnmSpeed, 3.0f); } else { setSingleAnimeBaseSpeed(ANM_WAIT, daAlinkHIO_move_c0::m.mWaitAnmSpeed, 3.0f); } diff --git a/src/d/actor/d_a_alink_wolf.inc b/src/d/actor/d_a_alink_wolf.inc index 7def8779256..f887ab2baea 100644 --- a/src/d/actor/d_a_alink_wolf.inc +++ b/src/d/actor/d_a_alink_wolf.inc @@ -202,12 +202,12 @@ void daAlink_c::changeWolf() { field_0x598 = 115.0f; mLinkAcch.SetRoofCrrHeight(field_0x598); - field_0x594 = daAlinkHIO_wlMove_c0::m.field_0x64; + field_0x594 = daAlinkHIO_wlMove_c0::m.mMaxSpeed; - l_autoUpHeight = daAlinkHIO_wlWallHang_c0::m.field_0x78 + 0.01f; + l_autoUpHeight = daAlinkHIO_wlWallHang_c0::m.mAutoWalkHeight + 0.01f; l_autoDownHeight = -l_autoUpHeight; - field_0x3470 = cM_scos(cM_deg2s(daAlinkHIO_wlSlide_c0::m.field_0x5C)); - field_0x3122 = cM_deg2s(daAlinkHIO_wlSlide_c0::m.field_0x60); + field_0x3470 = cM_scos(cM_deg2s(daAlinkHIO_wlSlide_c0::m.mSlidingAngle)); + field_0x3122 = cM_deg2s(daAlinkHIO_wlSlide_c0::m.mClimbingAngle); field_0x3458 = -60.0f; field_0x345c = -130.0f; @@ -633,23 +633,23 @@ void daAlink_c::setSpeedAndAngleWolf() { s16 var_r29; s16 var_r28; if (checkWolfDashMode()) { - var_r30 = daAlinkHIO_wlMove_c0::m.field_0x54; - var_r29 = daAlinkHIO_wlMove_c0::m.field_0x50; - var_r28 = daAlinkHIO_wlMove_c0::m.field_0x52; + var_r30 = daAlinkHIO_wlMove_c0::m.mTurnAngleRate; + var_r29 = daAlinkHIO_wlMove_c0::m.mTurnMax; + var_r28 = daAlinkHIO_wlMove_c0::m.mTurnMin; if (checkWolfSlowDash()) { - var_f30 = daAlinkHIO_wlMove_c0::m.field_0xEC; + var_f30 = daAlinkHIO_wlMove_c0::m.mADashAccelerationSlow; } else if (field_0x2fc7 == 2) { - var_f30 = daAlinkHIO_wlMove_c0::m.field_0xFC; + var_f30 = daAlinkHIO_wlMove_c0::m.mADashAccelerationSlow2; } else { - var_f30 = daAlinkHIO_wlMove_c0::m.field_0xD0; + var_f30 = daAlinkHIO_wlMove_c0::m.mADashAcceleration; } - var_f29 = daAlinkHIO_wlMove_c0::m.field_0x6C; + var_f29 = daAlinkHIO_wlMove_c0::m.mDeceleration; } else { - var_r30 = daAlinkHIO_wlMoveNoP_c0::m.field_0x4; - var_r29 = daAlinkHIO_wlMoveNoP_c0::m.field_0x0; - var_r28 = daAlinkHIO_wlMoveNoP_c0::m.field_0x2; - var_f30 = daAlinkHIO_wlMoveNoP_c0::m.field_0xC; - var_f29 = daAlinkHIO_wlMoveNoP_c0::m.field_0x10; + var_r30 = daAlinkHIO_wlMoveNoP_c0::m.mTurnAngleRate; + var_r29 = daAlinkHIO_wlMoveNoP_c0::m.mTurnMax; + var_r28 = daAlinkHIO_wlMoveNoP_c0::m.mTurnMin; + var_f30 = daAlinkHIO_wlMoveNoP_c0::m.mAcceleration; + var_f29 = daAlinkHIO_wlMoveNoP_c0::m.mDeceleration; } BOOL temp_r31 = checkEventRun(); @@ -671,8 +671,8 @@ void daAlink_c::setSpeedAndAngleWolf() { var_r26 = 1; } } else if (mProcID == PROC_WOLF_MOVE && - ((checkWolfDashMode() && temp_f27 > daAlinkHIO_wlMove_c0::m.field_0xA0) || - (!checkWolfDashMode() && temp_f27 > daAlinkHIO_wlMoveNoP_c0::m.field_0x38))) + ((checkWolfDashMode() && temp_f27 > daAlinkHIO_wlMove_c0::m.mSlipStartRate) || + (!checkWolfDashMode() && temp_f27 > daAlinkHIO_wlMoveNoP_c0::m.mSlideStartRate))) { return; } else { @@ -762,18 +762,18 @@ void daAlink_c::setSpeedAndAngleWolfAtn() { f32 var_f30; f32 var_f29; if (field_0x2f98 == 1) { - var_f30 = daAlinkHIO_wlAtnMove_c0::m.field_0x30; - var_f29 = daAlinkHIO_wlAtnMove_c0::m.field_0x34; + var_f30 = daAlinkHIO_wlAtnMove_c0::m.mRearAcceleration; + var_f29 = daAlinkHIO_wlAtnMove_c0::m.mRearDeceleration; } else { - var_f30 = daAlinkHIO_wlAtnMove_c0::m.field_0x1C; - var_f29 = daAlinkHIO_wlAtnMove_c0::m.field_0x20; + var_f30 = daAlinkHIO_wlAtnMove_c0::m.mAcceleration; + var_f29 = daAlinkHIO_wlAtnMove_c0::m.mDeceleration; } s16 var_r29; if (checkFmChainGrabAnime()) { var_r29 = 1000; } else { - var_r29 = daAlinkHIO_wlAtnMove_c0::m.field_0x0; + var_r29 = daAlinkHIO_wlAtnMove_c0::m.mTurnAngleMax; } s16 var_r27; @@ -798,8 +798,8 @@ void daAlink_c::setSpeedAndAngleWolfAtn() { } s16 temp_r28 = current.angle.y; - cLib_addCalcAngleS(¤t.angle.y, var_r27, daAlinkHIO_wlAtnMove_c0::m.field_0x4, var_r29, - daAlinkHIO_wlAtnMove_c0::m.field_0x2); + cLib_addCalcAngleS(¤t.angle.y, var_r27, daAlinkHIO_wlAtnMove_c0::m.mTurnAngleRate, var_r29, + daAlinkHIO_wlAtnMove_c0::m.mTurnAngleMin); if (wolfSideBgCheck(temp_r28)) { current.angle.y = temp_r28; @@ -836,8 +836,8 @@ void daAlink_c::setSpeedAndAngleWolfAtn() { var_r26 = current.angle.y; } - cLib_addCalcAngleS(&shape_angle.y, var_r26, daAlinkHIO_wlAtnMove_c0::m.field_0x4, - var_r29 * 2, daAlinkHIO_wlAtnMove_c0::m.field_0x2 * 2); + cLib_addCalcAngleS(&shape_angle.y, var_r26, daAlinkHIO_wlAtnMove_c0::m.mTurnAngleRate, + var_r29 * 2, daAlinkHIO_wlAtnMove_c0::m.mTurnAngleMin * 2); } setNormalSpeedF(var_f31, var_f29); @@ -879,27 +879,27 @@ void daAlink_c::setBlendWolfMoveAnime(f32 param_0) { f32 sp34, sp30, sp2C, sp28, sp24, sp20, sp1C, sp18, sp14, sp10; if (checkWolfDashMode()) { - sp20 = daAlinkHIO_wlMove_c0::m.field_0x88; - sp14 = daAlinkHIO_wlMove_c0::m.field_0x98; - sp1C = daAlinkHIO_wlMove_c0::m.field_0x84; - sp18 = daAlinkHIO_wlMove_c0::m.field_0x8C; - sp34 = daAlinkHIO_wlMove_c0::m.field_0x70; - sp30 = daAlinkHIO_wlMove_c0::m.field_0x74; - sp2C = daAlinkHIO_wlMove_c0::m.field_0x78; - sp28 = daAlinkHIO_wlMove_c0::m.field_0x7C; - sp24 = daAlinkHIO_wlSlide_c0::m.field_0x64; - sp10 = daAlinkHIO_wlMove_c0::m.field_0x9C; + sp20 = daAlinkHIO_wlMove_c0::m.mWalkToBriskWalkRate; + sp14 = daAlinkHIO_wlMove_c0::m.mWalkRunInterpolation; + sp1C = daAlinkHIO_wlMove_c0::m.mIdleToWalkRate; + sp18 = daAlinkHIO_wlMove_c0::m.mStandbyRunToRunRate; + sp34 = daAlinkHIO_wlMove_c0::m.mIdleAnmSpeed; + sp30 = daAlinkHIO_wlMove_c0::m.mWalkAnmSpeed; + sp2C = daAlinkHIO_wlMove_c0::m.mBriskWalkAnmSpeed; + sp28 = daAlinkHIO_wlMove_c0::m.mRunAnmSpeed; + sp24 = daAlinkHIO_wlSlide_c0::m.mClimbingAnmSpeed; + sp10 = daAlinkHIO_wlMove_c0::m.mRunAnmMinBlendRate; } else { - sp20 = daAlinkHIO_wlMoveNoP_c0::m.field_0x28; - sp14 = daAlinkHIO_wlMoveNoP_c0::m.field_0x30; - sp1C = daAlinkHIO_wlMoveNoP_c0::m.field_0x24; - sp18 = daAlinkHIO_wlMoveNoP_c0::m.field_0x2C; - sp34 = daAlinkHIO_wlMoveNoP_c0::m.field_0x14; - sp30 = daAlinkHIO_wlMoveNoP_c0::m.field_0x18; - sp2C = daAlinkHIO_wlMoveNoP_c0::m.field_0x1C; - sp28 = daAlinkHIO_wlMoveNoP_c0::m.field_0x20; - sp24 = daAlinkHIO_wlSlide_c0::m.field_0x6C; - sp10 = daAlinkHIO_wlMoveNoP_c0::m.field_0x34; + sp20 = daAlinkHIO_wlMoveNoP_c0::m.mWalkToJogRate; + sp14 = daAlinkHIO_wlMoveNoP_c0::m.mWalkRunInterpolation; + sp1C = daAlinkHIO_wlMoveNoP_c0::m.mIdleToWalkRate; + sp18 = daAlinkHIO_wlMoveNoP_c0::m.mJogToRunRate; + sp34 = daAlinkHIO_wlMoveNoP_c0::m.mIdleAnmSpeed; + sp30 = daAlinkHIO_wlMoveNoP_c0::m.mWalkAnmSpeed; + sp2C = daAlinkHIO_wlMoveNoP_c0::m.mJogAnmSpeed; + sp28 = daAlinkHIO_wlMoveNoP_c0::m.mRunAnmSpeed; + sp24 = daAlinkHIO_wlSlide_c0::m.mClimbingAnmSpeedWeak; + sp10 = daAlinkHIO_wlMoveNoP_c0::m.mRunAnmMinBlendRate; } if (temp_f30 < sp20 || checkAttentionState() || checkHeavyStateOn(1, 1) || checkSlope()) { @@ -949,7 +949,7 @@ void daAlink_c::setBlendWolfMoveAnime(f32 param_0) { if (checkAttentionState()) { var_r27 = WANM_ATN; - sp34 = daAlinkHIO_wlMove_c0::m.field_0xB8; + sp34 = daAlinkHIO_wlMove_c0::m.mGazeIdleAnmSpeed; } else if (checkWindSpeedOnXZ() && !checkEventRun()) { var_r27 = WANM_WAIT_WIND; sp34 = 1.0f; @@ -997,7 +997,7 @@ void daAlink_c::setBlendWolfMoveAnime(f32 param_0) { if (!checkWolfDashMode()) { setDoubleAnimeWolf(1.0f, sp28, sp28, WANM_DASH_A, WANM_DASH_A, 1, param_0); } else { - var_f31 = (temp_f30 - sp18) / (daAlinkHIO_wlMove_c0::m.field_0x90 - sp18); + var_f31 = (temp_f30 - sp18) / (daAlinkHIO_wlMove_c0::m.mRunToQuickRunRate - sp18); if (var_f31 > 1.0f) { var_f31 = 1.0f; } @@ -1005,14 +1005,14 @@ void daAlink_c::setBlendWolfMoveAnime(f32 param_0) { f32 spC; if (checkNoResetFlg1(FLG1_DASH_MODE)) { if (checkWolfSlowDash() != 0) { - spC = daAlinkHIO_wlMove_c0::m.field_0xE8; + spC = daAlinkHIO_wlMove_c0::m.mADashQuickRunASpeedSlow; } else if (field_0x2fc7 == 2) { - spC = daAlinkHIO_wlMove_c0::m.field_0xF8; + spC = daAlinkHIO_wlMove_c0::m.mADashQuickRunASpeedSlow2; } else { - spC = daAlinkHIO_wlMove_c0::m.field_0xCC; + spC = daAlinkHIO_wlMove_c0::m.mADashQuickRunAnmSpeed; } } else { - spC = daAlinkHIO_wlMove_c0::m.field_0x80; + spC = daAlinkHIO_wlMove_c0::m.mQuickRunAnmSpeed; } setDoubleAnimeWolf(var_f31, sp28, spC, WANM_DASH_A, WANM_DASH_B, 1, param_0); @@ -1136,8 +1136,8 @@ void daAlink_c::setBlendWolfAtnMoveAnime(f32 param_0) { f32 var_f31 = fabsf((mNormalSpeed * cM_scos(var_r28)) / field_0x594); f32 var_f30; - if (var_f31 < daAlinkHIO_wlAtnMove_c0::m.field_0x10) { - var_f30 = var_f31 / daAlinkHIO_wlAtnMove_c0::m.field_0x10; + if (var_f31 < daAlinkHIO_wlAtnMove_c0::m.mWalkChangeRate) { + var_f30 = var_f31 / daAlinkHIO_wlAtnMove_c0::m.mWalkChangeRate; int var_r27; if (checkModeFlg(1)) { var_r27 = 2; @@ -1149,24 +1149,24 @@ void daAlink_c::setBlendWolfAtnMoveAnime(f32 param_0) { f32 var_f28; if (checkWolfAtnWait()) { var_r26 = WANM_ATN; - var_f28 = daAlinkHIO_wlMove_c0::m.field_0xB8; + var_f28 = daAlinkHIO_wlMove_c0::m.mGazeIdleAnmSpeed; } else { var_r26 = WANM_WAIT; - var_f28 = daAlinkHIO_wlMoveNoP_c0::m.field_0x14; + var_f28 = daAlinkHIO_wlMoveNoP_c0::m.mIdleAnmSpeed; } - setDoubleAnimeWolf(var_f30, var_f28, daAlinkHIO_wlAtnMove_c0::m.field_0x8, var_r26, + setDoubleAnimeWolf(var_f30, var_f28, daAlinkHIO_wlAtnMove_c0::m.mWalkAnmSpeed, var_r26, WANM_ATN_LOCK_WALK_FRONT, var_r27, param_0); - } else if (var_f31 < daAlinkHIO_wlAtnMove_c0::m.field_0x14) { + } else if (var_f31 < daAlinkHIO_wlAtnMove_c0::m.mRunChangeRate) { var_f30 = - (var_f31 - daAlinkHIO_wlAtnMove_c0::m.field_0x10) / - (daAlinkHIO_wlAtnMove_c0::m.field_0x14 - daAlinkHIO_wlAtnMove_c0::m.field_0x10); - setDoubleAnimeWolf(var_f30, daAlinkHIO_wlAtnMove_c0::m.field_0x8, - daAlinkHIO_wlAtnMove_c0::m.field_0xC, WANM_ATN_LOCK_WALK_FRONT, + (var_f31 - daAlinkHIO_wlAtnMove_c0::m.mWalkChangeRate) / + (daAlinkHIO_wlAtnMove_c0::m.mRunChangeRate - daAlinkHIO_wlAtnMove_c0::m.mWalkChangeRate); + setDoubleAnimeWolf(var_f30, daAlinkHIO_wlAtnMove_c0::m.mWalkAnmSpeed, + daAlinkHIO_wlAtnMove_c0::m.mRunAnmSpeed, WANM_ATN_LOCK_WALK_FRONT, WANM_ATN_LOCK_RUN, 3, param_0); } else { - setDoubleAnimeWolf(1.0f, daAlinkHIO_wlAtnMove_c0::m.field_0xC, - daAlinkHIO_wlAtnMove_c0::m.field_0xC, WANM_ATN_LOCK_RUN, + setDoubleAnimeWolf(1.0f, daAlinkHIO_wlAtnMove_c0::m.mRunAnmSpeed, + daAlinkHIO_wlAtnMove_c0::m.mRunAnmSpeed, WANM_ATN_LOCK_RUN, WANM_ATN_LOCK_RUN, 3, param_0); } } @@ -1175,7 +1175,7 @@ void daAlink_c::setBlendWolfAtnMoveAnime(f32 param_0) { /* 8012933C-8012948C 123C7C 0150+00 1/1 0/0 0/0 .text setBlendWolfAtnBackMoveAnime__9daAlink_cFf */ void daAlink_c::setBlendWolfAtnBackMoveAnime(f32 param_0) { - field_0x594 = daAlinkHIO_wlAtnMove_c0::m.field_0x2C; + field_0x594 = daAlinkHIO_wlAtnMove_c0::m.mRearMaxSpeed; f32 var_f28; if (field_0x3174 == 8) { @@ -1189,8 +1189,8 @@ void daAlink_c::setBlendWolfAtnBackMoveAnime(f32 param_0) { field_0x2fc1 = 3; - if (temp_f31 < daAlinkHIO_wlAtnMove_c0::m.field_0x28) { - f32 temp_f29 = temp_f31 / daAlinkHIO_wlAtnMove_c0::m.field_0x28; + if (temp_f31 < daAlinkHIO_wlAtnMove_c0::m.mRearWalkChangeRate) { + f32 temp_f29 = temp_f31 / daAlinkHIO_wlAtnMove_c0::m.mRearWalkChangeRate; int var_r29; if (checkModeFlg(1)) { @@ -1202,17 +1202,17 @@ void daAlink_c::setBlendWolfAtnBackMoveAnime(f32 param_0) { daAlink_WANM var_r28; if (checkWolfAtnWait()) { var_r28 = WANM_ATN; - var_f30 = daAlinkHIO_wlMove_c0::m.field_0xB8; + var_f30 = daAlinkHIO_wlMove_c0::m.mGazeIdleAnmSpeed; } else { var_r28 = WANM_WAIT; - var_f30 = daAlinkHIO_wlMoveNoP_c0::m.field_0x14; + var_f30 = daAlinkHIO_wlMoveNoP_c0::m.mIdleAnmSpeed; } - setDoubleAnimeWolf(temp_f29, var_f30, daAlinkHIO_wlAtnMove_c0::m.field_0x24, var_r28, + setDoubleAnimeWolf(temp_f29, var_f30, daAlinkHIO_wlAtnMove_c0::m.mRearWalkAnmSpeed, var_r28, WANM_ATN_LOCK_WALK_BACK, var_r29, param_0); } else { - setDoubleAnimeWolf(1.0f, daAlinkHIO_wlAtnMove_c0::m.field_0x24, - daAlinkHIO_wlAtnMove_c0::m.field_0x24, WANM_ATN_LOCK_WALK_BACK, + setDoubleAnimeWolf(1.0f, daAlinkHIO_wlAtnMove_c0::m.mRearWalkAnmSpeed, + daAlinkHIO_wlAtnMove_c0::m.mRearWalkAnmSpeed, WANM_ATN_LOCK_WALK_BACK, WANM_ATN_LOCK_WALK_BACK, 3, param_0); } } @@ -1246,7 +1246,7 @@ int daAlink_c::setDoubleAnimeWolf(f32 param_0, f32 param_1, f32 param_2, } if (var_r30 != 0 && param_6 < 0.0f) { - param_6 = daAlinkHIO_wlMove_c0::m.field_0x94; + param_6 = daAlinkHIO_wlMove_c0::m.mNormalInterpolation; } commonDoubleAnime(var_r29, NULL, var_r28, NULL, param_0, param_1, param_2, param_5); @@ -1344,7 +1344,7 @@ void daAlink_c::setSingleAnimeWolfParam(daAlink_c::daAlink_WANM i_anmID, int daAlink_c::checkWolfLandAction(int param_0) { f32 temp_f31 = 0.0099999998f * (mFallHeight - current.pos.y); - if (checkNoLandDamageSlidePolygon() || temp_f31 < daAlinkHIO_wlDamFall_c0::m.field_0x2C) { + if (checkNoLandDamageSlidePolygon() || temp_f31 < daAlinkHIO_wlDamFall_c0::m.mSmallDamageHeight) { if (param_0 != 0) { procWolfLandDamageInit(0); } else if (mProcID == PROC_WOLF_JUMP_ATTACK || mProcID == PROC_WOLF_DASH_REVERSE) { @@ -1354,7 +1354,7 @@ int daAlink_c::checkWolfLandAction(int param_0) { } } else { int var_r4; - if (temp_f31 < daAlinkHIO_wlDamFall_c0::m.field_0x30) { + if (temp_f31 < daAlinkHIO_wlDamFall_c0::m.mLargeDamageHeight) { var_r4 = 1; } else { var_r4 = 2; @@ -1445,28 +1445,28 @@ int daAlink_c::checkNextActionWolf(int param_0) { if (checkSlope()) { if (checkWolfDashMode()) { - field_0x594 = daAlinkHIO_wlSlide_c0::m.field_0x68; + field_0x594 = daAlinkHIO_wlSlide_c0::m.mClimbingMaxSpeed; } else { - field_0x594 = daAlinkHIO_wlSlide_c0::m.field_0x70; + field_0x594 = daAlinkHIO_wlSlide_c0::m.mClimbingMaxSpeedWeak; } } else if (checkFmChainGrabAnime()) { field_0x594 = 13.0f; } else if (mTargetedActor != NULL) { - field_0x594 = daAlinkHIO_wlAtnMove_c0::m.field_0x18; + field_0x594 = daAlinkHIO_wlAtnMove_c0::m.mMaxSpeed; } else if (checkAttentionState()) { - field_0x594 = daAlinkHIO_wlMove_c0::m.field_0xB4; + field_0x594 = daAlinkHIO_wlMove_c0::m.mGazeMaxSpeed; } else if (checkNoResetFlg1(FLG1_DASH_MODE)) { if (checkWolfSlowDash()) { - field_0x594 = daAlinkHIO_wlMove_c0::m.field_0xE0; + field_0x594 = daAlinkHIO_wlMove_c0::m.mADashMaxSpeedSlow; } else if (field_0x2fc7 == 2) { - field_0x594 = daAlinkHIO_wlMove_c0::m.field_0xF0; + field_0x594 = daAlinkHIO_wlMove_c0::m.mADashMaxSpeedSlow2; } else { - field_0x594 = daAlinkHIO_wlMove_c0::m.field_0xC8; + field_0x594 = daAlinkHIO_wlMove_c0::m.mADashMaxSpeed; } } else if (checkWolfDashMode()) { - field_0x594 = daAlinkHIO_wlMove_c0::m.field_0x64; + field_0x594 = daAlinkHIO_wlMove_c0::m.mMaxSpeed; } else { - field_0x594 = daAlinkHIO_wlMoveNoP_c0::m.field_0x8; + field_0x594 = daAlinkHIO_wlMoveNoP_c0::m.mMaxSpeed; } if (checkWolfGroundSpecialMode()) { @@ -1524,9 +1524,9 @@ int daAlink_c::checkNextActionWolf(int param_0) { abs(field_0x3180) < 0x5000 && cLib_distanceAngleS(field_0x2fe2, current.angle.y) > 0x7000 && ((checkWolfDashMode() && - speedF / field_0x594 > daAlinkHIO_wlMove_c0::m.field_0xA0) || + speedF / field_0x594 > daAlinkHIO_wlMove_c0::m.mSlipStartRate) || (!checkWolfDashMode() && - speedF / field_0x594 > daAlinkHIO_wlMoveNoP_c0::m.field_0x38))) + speedF / field_0x594 > daAlinkHIO_wlMoveNoP_c0::m.mSlideStartRate))) { var_r30 = procWolfSlipInit(); } else { @@ -2419,9 +2419,9 @@ int daAlink_c::procWolfServiceWaitInit(int param_0) { field_0x3198 = 0; mProcVar2.field_0x300c = 0; } else { - setSingleAnimeWolf(WANM_SIT, 1.0f, daAlinkHIO_wlLie_c0::m.field_0x0.mStartFrame, - daAlinkHIO_wlLie_c0::m.field_0x0.mEndFrame, - daAlinkHIO_wlLie_c0::m.field_0x0.mInterpolation); + setSingleAnimeWolf(WANM_SIT, 1.0f, daAlinkHIO_wlLie_c0::m.mSittingAnm.mStartFrame, + daAlinkHIO_wlLie_c0::m.mSittingAnm.mEndFrame, + daAlinkHIO_wlLie_c0::m.mSittingAnm.mInterpolation); field_0x3198 = 0; mProcVar2.field_0x300c = 1; } @@ -2454,7 +2454,7 @@ int daAlink_c::procWolfServiceWait() { field_0x3198 = 0; mProcVar2.field_0x300c = 0; } else if (mProcVar2.field_0x300c != 0) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT_SIT, daAlinkHIO_wlLie_c0::m.field_0x44, daAlinkHIO_wlLie_c0::m.field_0x48); + setSingleAnimeWolfBaseSpeed(WANM_WAIT_SIT, daAlinkHIO_wlLie_c0::m.mSittingIdleAnmSpeed, daAlinkHIO_wlLie_c0::m.mSittingIdleInterp); } else if (mProcVar4.field_0x3010 == 0) { setSingleAnimeWolfBase(WANM_SERVICE_WAIT_D); } else { @@ -2564,7 +2564,7 @@ int daAlink_c::procWolfWaitInit() { } commonProcInit(PROC_WOLF_WAIT); - setBlendWolfMoveAnime(daAlinkHIO_wlMove_c0::m.field_0xBC); + setBlendWolfMoveAnime(daAlinkHIO_wlMove_c0::m.mIdleInterpolation); current.angle.y = shape_angle.y; field_0x2f98 = 4; mNormalSpeed = 0.0f; @@ -2600,7 +2600,7 @@ int daAlink_c::procWolfMoveInit() { return 0; } - setBlendWolfMoveAnime(daAlinkHIO_wlMove_c0::m.field_0x94); + setBlendWolfMoveAnime(daAlinkHIO_wlMove_c0::m.mNormalInterpolation); setFootEffectProcType(3); return 1; @@ -2610,8 +2610,8 @@ int daAlink_c::procWolfMoveInit() { int daAlink_c::procWolfMove() { if (!checkNextActionWolf(0) && !checkFrontWallTypeAction()) { if (mDemo.getDemoMode() == 2) { - if (mNormalSpeed > field_0x594 * daAlinkHIO_wlMoveNoP_c0::m.field_0x28) { - mNormalSpeed = field_0x594 * daAlinkHIO_wlMoveNoP_c0::m.field_0x28; + if (mNormalSpeed > field_0x594 * daAlinkHIO_wlMoveNoP_c0::m.mWalkToJogRate) { + mNormalSpeed = field_0x594 * daAlinkHIO_wlMoveNoP_c0::m.mWalkToJogRate; } } @@ -2625,7 +2625,7 @@ int daAlink_c::procWolfMove() { /* 8012D474-8012D590 127DB4 011C+00 1/1 0/0 0/0 .text procWolfDashInit__9daAlink_cFv */ int daAlink_c::procWolfDashInit() { commonProcInit(PROC_WOLF_DASH); - setSingleAnimeWolfParam(WANM_DASH_START, &daAlinkHIO_wlMove_c0::m.field_0x28); + setSingleAnimeWolfParam(WANM_DASH_START, &daAlinkHIO_wlMove_c0::m.mADashAnm); setFootEffectProcType(3); current.angle.y = shape_angle.y; @@ -2634,25 +2634,25 @@ int daAlink_c::procWolfDashInit() { mProcVar3.field_0x300e = 0; if (checkWolfSlowDash()) { - field_0x30d0 = daAlinkHIO_wlMove_c0::m.field_0x5A; - field_0x594 = daAlinkHIO_wlMove_c0::m.field_0xE0; + field_0x30d0 = daAlinkHIO_wlMove_c0::m.mADashDurationSlow; + field_0x594 = daAlinkHIO_wlMove_c0::m.mADashMaxSpeedSlow; - if (mNormalSpeed < daAlinkHIO_wlMove_c0::m.field_0xE4) { - mNormalSpeed = daAlinkHIO_wlMove_c0::m.field_0xE4; + if (mNormalSpeed < daAlinkHIO_wlMove_c0::m.mADashInitSpeedSlow) { + mNormalSpeed = daAlinkHIO_wlMove_c0::m.mADashInitSpeedSlow; } } else if (field_0x2fc7 == 2) { - field_0x594 = daAlinkHIO_wlMove_c0::m.field_0xF0; - field_0x594 = daAlinkHIO_wlMove_c0::m.field_0xF0; + field_0x594 = daAlinkHIO_wlMove_c0::m.mADashMaxSpeedSlow2; + field_0x594 = daAlinkHIO_wlMove_c0::m.mADashMaxSpeedSlow2; - if (mNormalSpeed < daAlinkHIO_wlMove_c0::m.field_0xF4) { - mNormalSpeed = daAlinkHIO_wlMove_c0::m.field_0xF4; + if (mNormalSpeed < daAlinkHIO_wlMove_c0::m.mADashInitSpeedSlow2) { + mNormalSpeed = daAlinkHIO_wlMove_c0::m.mADashInitSpeedSlow2; } } else { - field_0x30d0 = daAlinkHIO_wlMove_c0::m.field_0x56; - field_0x594 = daAlinkHIO_wlMove_c0::m.field_0xC8; + field_0x30d0 = daAlinkHIO_wlMove_c0::m.mADashDuration; + field_0x594 = daAlinkHIO_wlMove_c0::m.mADashMaxSpeed; - if (mNormalSpeed < daAlinkHIO_wlMove_c0::m.field_0xD4) { - mNormalSpeed = daAlinkHIO_wlMove_c0::m.field_0xD4; + if (mNormalSpeed < daAlinkHIO_wlMove_c0::m.mADashInitSpeed) { + mNormalSpeed = daAlinkHIO_wlMove_c0::m.mADashInitSpeed; } } @@ -2670,17 +2670,17 @@ int daAlink_c::procWolfDash() { f32 step_amount; if (checkWolfSlowDash()) { - step_amount = daAlinkHIO_wlMove_c0::m.field_0xEC; + step_amount = daAlinkHIO_wlMove_c0::m.mADashAccelerationSlow; } else if (field_0x2fc7 == 2) { - step_amount = daAlinkHIO_wlMove_c0::m.field_0xFC; + step_amount = daAlinkHIO_wlMove_c0::m.mADashAccelerationSlow2; } else { - step_amount = daAlinkHIO_wlMove_c0::m.field_0xD0; + step_amount = daAlinkHIO_wlMove_c0::m.mADashAcceleration; } cLib_chaseF(&mNormalSpeed, field_0x594, step_amount); if (checkInputOnR()) { - cLib_addCalcAngleS(¤t.angle.y, field_0x2fe2, daAlinkHIO_wlMove_c0::m.field_0x54, - daAlinkHIO_wlMove_c0::m.field_0x50, daAlinkHIO_wlMove_c0::m.field_0x52); + cLib_addCalcAngleS(¤t.angle.y, field_0x2fe2, daAlinkHIO_wlMove_c0::m.mTurnAngleRate, + daAlinkHIO_wlMove_c0::m.mTurnMax, daAlinkHIO_wlMove_c0::m.mTurnMin); shape_angle.y = current.angle.y; } @@ -2698,25 +2698,25 @@ int daAlink_c::procWolfDash() { } if (checkWolfSlowDash()) { - field_0x30d2 = daAlinkHIO_wlMove_c0::m.field_0x5C; + field_0x30d2 = daAlinkHIO_wlMove_c0::m.mADashCooldownTimeSlow; } else if (field_0x2fc7 == 2) { - field_0x30d2 = daAlinkHIO_wlMove_c0::m.field_0x60; + field_0x30d2 = daAlinkHIO_wlMove_c0::m.mADashCooldownTimeSlow2; } else { - field_0x30d2 = daAlinkHIO_wlMove_c0::m.field_0x58; + field_0x30d2 = daAlinkHIO_wlMove_c0::m.mADashCooldownTime; } return checkNextActionWolf(0); - } else if (frameCtrl_p->getFrame() > daAlinkHIO_wlMove_c0::m.field_0x28.mCancelFrame) { + } else if (frameCtrl_p->getFrame() > daAlinkHIO_wlMove_c0::m.mADashAnm.mCancelFrame) { if (mProcVar3.field_0x300e != 0) { return checkWolfAttackAction(); } if (checkWolfSlowDash()) { - field_0x30d2 = daAlinkHIO_wlMove_c0::m.field_0x5C; + field_0x30d2 = daAlinkHIO_wlMove_c0::m.mADashCooldownTimeSlow; } else if (field_0x2fc7 == 2) { - field_0x30d2 = daAlinkHIO_wlMove_c0::m.field_0x60; + field_0x30d2 = daAlinkHIO_wlMove_c0::m.mADashCooldownTimeSlow2; } else { - field_0x30d2 = daAlinkHIO_wlMove_c0::m.field_0x58; + field_0x30d2 = daAlinkHIO_wlMove_c0::m.mADashCooldownTime; } checkNextActionWolf(1); @@ -2736,9 +2736,9 @@ int daAlink_c::procWolfDash() { /* 8012D8C0-8012DA5C 128200 019C+00 2/2 0/0 0/0 .text procWolfDashReverseInit__9daAlink_cFi */ int daAlink_c::procWolfDashReverseInit(int param_0) { commonProcInit(PROC_WOLF_DASH_REVERSE); - setSingleAnimeWolf(WANM_ATTACK_RECOIL_GROUND, daAlinkHIO_wlMove_c0::m.field_0x3C.mSpeed, - daAlinkHIO_wlMove_c0::m.field_0x3C.mStartFrame, 5, - daAlinkHIO_wlMove_c0::m.field_0x3C.mInterpolation); + setSingleAnimeWolf(WANM_ATTACK_RECOIL_GROUND, daAlinkHIO_wlMove_c0::m.mDashReboundAnm.mSpeed, + daAlinkHIO_wlMove_c0::m.mDashReboundAnm.mStartFrame, 5, + daAlinkHIO_wlMove_c0::m.mDashReboundAnm.mInterpolation); if (param_0) { current.angle.y = field_0x3102 + 0x8000; @@ -2752,8 +2752,8 @@ int daAlink_c::procWolfDashReverseInit(int param_0) { mProcVar2.field_0x300c = 1; } else { - mNormalSpeed = daAlinkHIO_wlMove_c0::m.field_0xD8; - speed.y = daAlinkHIO_wlMove_c0::m.field_0xDC; + mNormalSpeed = daAlinkHIO_wlMove_c0::m.mDashReboundHorizontalSpeed; + speed.y = daAlinkHIO_wlMove_c0::m.mDashReboundVerticalSpeed; current.angle.y += 0x8000; mProcVar2.field_0x300c = 0; } @@ -2778,7 +2778,7 @@ int daAlink_c::procWolfDashReverse() { if (!checkModeFlg(0x2)) { if (checkAnmEnd(frameCtrl_p)) { checkNextActionWolf(0); - } else if (frameCtrl_p->getFrame() > daAlinkHIO_wlMove_c0::m.field_0x3C.mCancelFrame) { + } else if (frameCtrl_p->getFrame() > daAlinkHIO_wlMove_c0::m.mDashReboundAnm.mCancelFrame) { checkNextActionWolf(1); } } else if (mProcVar2.field_0x300c != 0) { @@ -2791,10 +2791,10 @@ int daAlink_c::procWolfDashReverse() { } mNormalSpeed = 0.0f; - frameCtrl_p->setFrame(daAlinkHIO_wlMove_c0::m.field_0x3C.mSpeed + frameCtrl_p->getFrame()); + frameCtrl_p->setFrame(daAlinkHIO_wlMove_c0::m.mDashReboundAnm.mSpeed + frameCtrl_p->getFrame()); getNowAnmPackUnder(UNDER_0)->setFrame(frameCtrl_p->getFrame()); - frameCtrl_p->setRate(daAlinkHIO_wlMove_c0::m.field_0x3C.mSpeed); - frameCtrl_p->setEnd(daAlinkHIO_wlMove_c0::m.field_0x3C.mEndFrame); + frameCtrl_p->setRate(daAlinkHIO_wlMove_c0::m.mDashReboundAnm.mSpeed); + frameCtrl_p->setEnd(daAlinkHIO_wlMove_c0::m.mDashReboundAnm.mEndFrame); current.angle.y = shape_angle.y; offModeFlg(0x2); @@ -2815,7 +2815,7 @@ int daAlink_c::procWolfAtnActorMoveInit() { } setWolfAtnMoveDirection(); - setBlendWolfAtnMoveAnime(daAlinkHIO_wlMove_c0::m.field_0x94); + setBlendWolfAtnMoveAnime(daAlinkHIO_wlMove_c0::m.mNormalInterpolation); if (checkWolfAtnWait()) { voiceStartLevel(Z2SE_WL_V_ROAR); @@ -2859,12 +2859,12 @@ int daAlink_c::procWolfWaitTurnInit() { f32 anm_speed; if (checkWolfDashMode()) { - anm_speed = daAlinkHIO_wlMove_c0::m.field_0x74; + anm_speed = daAlinkHIO_wlMove_c0::m.mWalkAnmSpeed; } else { - anm_speed = daAlinkHIO_wlMoveNoP_c0::m.field_0x18; + anm_speed = daAlinkHIO_wlMoveNoP_c0::m.mWalkAnmSpeed; } - setSingleAnimeWolfBaseSpeed(WANM_WALK_A, anm_speed, daAlinkHIO_wlMove_c0::m.field_0x94); + setSingleAnimeWolfBaseSpeed(WANM_WALK_A, anm_speed, daAlinkHIO_wlMove_c0::m.mNormalInterpolation); if (checkEventRun()) { mNormalSpeed = 0.0f; @@ -2879,9 +2879,9 @@ int daAlink_c::procWolfWaitTurnInit() { int daAlink_c::procWolfWaitTurn() { f32 step_amount; if (checkWolfDashMode()) { - step_amount = daAlinkHIO_wlMove_c0::m.field_0x6C; + step_amount = daAlinkHIO_wlMove_c0::m.mDeceleration; } else { - step_amount = daAlinkHIO_wlMoveNoP_c0::m.field_0x10; + step_amount = daAlinkHIO_wlMoveNoP_c0::m.mDeceleration; } cLib_chaseF(&mNormalSpeed, 0.0f, step_amount); @@ -2934,9 +2934,9 @@ int daAlink_c::procWolfSideStepInit(int param_0) { } current.angle.y = shape_angle.y + 0x8000; - setSingleAnimeWolfParam(WANM_BACK_JUMP_START, &daAlinkHIO_wlSideStep_c0::m.field_0x28); - mNormalSpeed = daAlinkHIO_wlSideStep_c0::m.field_0x58; - speed.y = daAlinkHIO_wlSideStep_c0::m.field_0x5C; + setSingleAnimeWolfParam(WANM_BACK_JUMP_START, &daAlinkHIO_wlSideStep_c0::m.mBackJumpAnm); + mNormalSpeed = daAlinkHIO_wlSideStep_c0::m.mBackJumpHorizSpeed; + speed.y = daAlinkHIO_wlSideStep_c0::m.mBackJumpVertSpeed; mProcVar1.field_0x300a = 0; } else { shape_angle.y = field_0x2fe4; @@ -2950,9 +2950,9 @@ int daAlink_c::procWolfSideStepInit(int param_0) { current.angle.y = shape_angle.y - 0x4000; } - setSingleAnimeWolfParam(jump_anm, &daAlinkHIO_wlSideStep_c0::m.field_0x0); - mNormalSpeed = daAlinkHIO_wlSideStep_c0::m.field_0x50; - speed.y = daAlinkHIO_wlSideStep_c0::m.field_0x54; + setSingleAnimeWolfParam(jump_anm, &daAlinkHIO_wlSideStep_c0::m.mSideJumpAnm); + mNormalSpeed = daAlinkHIO_wlSideStep_c0::m.mSideJumpHorizSpeed; + speed.y = daAlinkHIO_wlSideStep_c0::m.mSideJumpVertSpeed; mProcVar1.field_0x300a = 1; } @@ -2966,8 +2966,8 @@ int daAlink_c::procWolfSideStepInit(int param_0) { int daAlink_c::procWolfSideStep() { if (mProcVar1.field_0x300a == 0) { cLib_addCalcAngleS( - &shape_angle.y, mProcVar2.field_0x300c, daAlinkHIO_wlAtnMove_c0::m.field_0x4, - daAlinkHIO_wlAtnMove_c0::m.field_0x0, daAlinkHIO_wlAtnMove_c0::m.field_0x2); + &shape_angle.y, mProcVar2.field_0x300c, daAlinkHIO_wlAtnMove_c0::m.mTurnAngleRate, + daAlinkHIO_wlAtnMove_c0::m.mTurnAngleMax, daAlinkHIO_wlAtnMove_c0::m.mTurnAngleMin); current.angle.y = shape_angle.y + 0x8000; } else if (mTargetedActor != NULL) { cLib_addCalcAngleS(&shape_angle.y, fopAcM_searchActorAngleY(this, mTargetedActor), 5, 0x5E8, @@ -2987,10 +2987,10 @@ int daAlink_c::procWolfSideStep() { } if (mDemo.getDemoMode() != 0x10 && - current.pos.y < mLastJumpPos.y - daAlinkHIO_wlSideStep_c0::m.field_0x60) + current.pos.y < mLastJumpPos.y - daAlinkHIO_wlSideStep_c0::m.mFallHeight) { field_0x2f98 = 0; - return procWolfFallInit(2, daAlinkHIO_wlSideStep_c0::m.field_0x64); + return procWolfFallInit(2, daAlinkHIO_wlSideStep_c0::m.mFallInterp); } mProcVar3.field_0x300e = 1; @@ -3002,15 +3002,15 @@ int daAlink_c::procWolfSideStepLandInit(s16 param_0) { commonProcInit(PROC_WOLF_SIDESTEP_LAND); if (field_0x2f98 == 1) { - setSingleAnimeWolfParam(WANM_BACK_JUMP_END, &daAlinkHIO_wlSideStep_c0::m.field_0x3C); - field_0x3478 = daAlinkHIO_wlSideStep_c0::m.field_0x3C.mCancelFrame; + setSingleAnimeWolfParam(WANM_BACK_JUMP_END, &daAlinkHIO_wlSideStep_c0::m.mBackLandAnm); + field_0x3478 = daAlinkHIO_wlSideStep_c0::m.mBackLandAnm.mCancelFrame; field_0x2fcc = 10; } else { field_0x2fcc = 0; setSingleAnimeWolfParam(field_0x2f98 == 2 ? WANM_SIDE_JUMP_LEFT_END : WANM_SIDE_JUMP_RIGHT_END, - &daAlinkHIO_wlSideStep_c0::m.field_0x14); - field_0x3478 = daAlinkHIO_wlSideStep_c0::m.field_0x14.mCancelFrame; + &daAlinkHIO_wlSideStep_c0::m.mSideLandAnm); + field_0x3478 = daAlinkHIO_wlSideStep_c0::m.mSideLandAnm.mCancelFrame; } mProcVar5.field_0x3012 = param_0; @@ -3054,23 +3054,23 @@ int daAlink_c::procWolfBackJumpInit(int param_0) { commonProcInit(PROC_WOLF_BACKJUMP); if (param_0 == 1) { - setSingleAnimeWolfParam(WANM_BACKFLIP_START, &daAlinkHIO_wlAtDown_c0::m.field_0x50); - mNormalSpeed = daAlinkHIO_wlAtDown_c0::m.field_0x94; - speed.y = daAlinkHIO_wlAtDown_c0::m.field_0x98; + setSingleAnimeWolfParam(WANM_BACKFLIP_START, &daAlinkHIO_wlAtDown_c0::m.mBackRollAnm); + mNormalSpeed = daAlinkHIO_wlAtDown_c0::m.mLandingSideRollMovementWidth; + speed.y = daAlinkHIO_wlAtDown_c0::m.mLandingFrontBackMovementWidth; voiceStart(Z2SE_WL_V_BREATH_JUMP); } else { if (param_0 == 2) { - setSingleAnimeWolf(WANM_BACKFLIP_START, daAlinkHIO_wlAtCjump_c0::m.field_0x44, - daAlinkHIO_wlAtCjump_c0::m.field_0x40, - daAlinkHIO_wlBackJump_c0::m.field_0x0.mEndFrame, - daAlinkHIO_wlBackJump_c0::m.field_0x0.mInterpolation); + setSingleAnimeWolf(WANM_BACKFLIP_START, daAlinkHIO_wlAtCjump_c0::m.mFlipKickPostAnmSpeed, + daAlinkHIO_wlAtCjump_c0::m.mFlipKickPostStartF, + daAlinkHIO_wlBackJump_c0::m.mBackJumpAnm.mEndFrame, + daAlinkHIO_wlBackJump_c0::m.mBackJumpAnm.mInterpolation); } else { - setSingleAnimeWolfParam(WANM_BACKFLIP_START, &daAlinkHIO_wlBackJump_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_BACKFLIP_START, &daAlinkHIO_wlBackJump_c0::m.mBackJumpAnm); voiceStart(Z2SE_WL_V_BREATH_JUMP); } - mNormalSpeed = daAlinkHIO_wlBackJump_c0::m.field_0x28; - speed.y = daAlinkHIO_wlBackJump_c0::m.field_0x2C; + mNormalSpeed = daAlinkHIO_wlBackJump_c0::m.mBackJumpHorizSpeed; + speed.y = daAlinkHIO_wlBackJump_c0::m.mBackJumpVertSpeed; } if (mTargetedActor != NULL && param_0 == 0) { @@ -3094,8 +3094,8 @@ int daAlink_c::procWolfBackJumpInit(int param_0) { /* 8012E508-8012E5F4 128E48 00EC+00 1/0 0/0 0/0 .text procWolfBackJump__9daAlink_cFv */ int daAlink_c::procWolfBackJump() { - cLib_addCalcAngleS(&shape_angle.y, mProcVar2.field_0x300c, daAlinkHIO_wlAtnMove_c0::m.field_0x4, - daAlinkHIO_wlAtnMove_c0::m.field_0x0, daAlinkHIO_wlAtnMove_c0::m.field_0x2); + cLib_addCalcAngleS(&shape_angle.y, mProcVar2.field_0x300c, daAlinkHIO_wlAtnMove_c0::m.mTurnAngleRate, + daAlinkHIO_wlAtnMove_c0::m.mTurnAngleMax, daAlinkHIO_wlAtnMove_c0::m.mTurnAngleMin); current.angle.y = shape_angle.y - -0x8000; if (mProcVar4.field_0x3010 != 0) { @@ -3107,10 +3107,10 @@ int daAlink_c::procWolfBackJump() { if (mUnderFrameCtrl[0].checkAnmEnd() && mLinkAcch.ChkGroundHit()) { procWolfBackJumpLandInit(mProcVar5.field_0x3012, mProcVar4.field_0x3010); } else if (mDemo.getDemoMode() != 0x10 && - current.pos.y < mLastJumpPos.y - daAlinkHIO_wlBackJump_c0::m.field_0x30) + current.pos.y < mLastJumpPos.y - daAlinkHIO_wlBackJump_c0::m.mFallHeight) { field_0x2f98 = 0; - procWolfFallInit(2, daAlinkHIO_wlBackJump_c0::m.field_0x34); + procWolfFallInit(2, daAlinkHIO_wlBackJump_c0::m.mFallInterp); } return 1; @@ -3119,7 +3119,7 @@ int daAlink_c::procWolfBackJump() { /* 8012E5F4-8012E684 128F34 0090+00 1/1 0/0 0/0 .text procWolfBackJumpLandInit__9daAlink_cFss */ int daAlink_c::procWolfBackJumpLandInit(s16 param_0, s16 param_1) { commonProcInit(PROC_WOLF_BACKJUMP_LAND); - setSingleAnimeWolfParam(WANM_BACKFLIP_END, &daAlinkHIO_wlBackJump_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_BACKFLIP_END, &daAlinkHIO_wlBackJump_c0::m.mBackLandAnm); mNormalSpeed = 0.0f; field_0x2f9d = 4; setFootEffectProcType(2); @@ -3152,7 +3152,7 @@ int daAlink_c::procWolfBackJumpLand() { } else { checkNextActionWolf(0); } - } else if (frameCtrl->getFrame() > daAlinkHIO_wlBackJump_c0::m.field_0x14.mCancelFrame) { + } else if (frameCtrl->getFrame() > daAlinkHIO_wlBackJump_c0::m.mBackLandAnm.mCancelFrame) { checkNextActionWolf(1); } @@ -3168,13 +3168,13 @@ int daAlink_c::procWolfHowlInit(int param_0) { commonProcInit(PROC_WOLF_HOWL); if (param_0 != 0) { - setSingleAnimeWolfParam(WANM_HOWL_SIT, &daAlinkHIO_wlHowl_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_HOWL_SIT, &daAlinkHIO_wlHowl_c0::m.mSittingHowlAnm); onModeFlg(0x800000); - field_0x3478 = daAlinkHIO_wlHowl_c0::m.field_0x14.mCancelFrame; + field_0x3478 = daAlinkHIO_wlHowl_c0::m.mSittingHowlAnm.mCancelFrame; mProcVar3.field_0x300e = 1; } else { - setSingleAnimeWolfParam(WANM_HOWL, &daAlinkHIO_wlHowl_c0::m.field_0x0); - field_0x3478 = daAlinkHIO_wlHowl_c0::m.field_0x0.mCancelFrame; + setSingleAnimeWolfParam(WANM_HOWL, &daAlinkHIO_wlHowl_c0::m.mHowlAnm); + field_0x3478 = daAlinkHIO_wlHowl_c0::m.mHowlAnm.mCancelFrame; mProcVar3.field_0x300e = 0; } @@ -3232,25 +3232,25 @@ int daAlink_c::procWolfAutoJumpInit(int param_0) { s16 var_r30; if (checkWolfDashMode() && field_0x2fc7 != 3) { - var_f1 = daAlinkHIO_wlAutoJump_c0::m.field_0x00.mSpeed; - field_0x594 = daAlinkHIO_wlAutoJump_c0::m.field_0x70; - var_f31 = daAlinkHIO_wlAutoJump_c0::m.field_0x48; - var_f30 = daAlinkHIO_wlAutoJump_c0::m.field_0x4c; - var_r30 = daAlinkHIO_wlAutoJump_c0::m.field_0x40; + var_f1 = daAlinkHIO_wlAutoJump_c0::m.mJumpAnm.mSpeed; + field_0x594 = daAlinkHIO_wlAutoJump_c0::m.mJumpMaxSpeed; + var_f31 = daAlinkHIO_wlAutoJump_c0::m.mJumpMinSpeed; + var_f30 = daAlinkHIO_wlAutoJump_c0::m.mJumpSpeedRate; + var_r30 = daAlinkHIO_wlAutoJump_c0::m.mJumpAngle; onNoResetFlg2(FLG2_WOLF_DASH_AUTO_JUMP); } else { - var_f1 = daAlinkHIO_wlAutoJump_c0::m.field_0x60; - field_0x594 = daAlinkHIO_wlAutoJump_c0::m.field_0x74; - var_f31 = daAlinkHIO_wlAutoJump_c0::m.field_0x68; - var_f30 = daAlinkHIO_wlAutoJump_c0::m.field_0x6c; - var_r30 = daAlinkHIO_wlAutoJump_c0::m.field_0x42; + var_f1 = daAlinkHIO_wlAutoJump_c0::m.mWeakJumpAnmSpeed; + field_0x594 = daAlinkHIO_wlAutoJump_c0::m.mWeakJumpMaxSpeed; + var_f31 = daAlinkHIO_wlAutoJump_c0::m.mWeakJumpMinSpeed; + var_f30 = daAlinkHIO_wlAutoJump_c0::m.mWeakJumpSpeedRate; + var_r30 = daAlinkHIO_wlAutoJump_c0::m.mWeakJumpAngle; } setSingleAnimeWolf(WANM_JUMP_ATTACK_START, var_f1, - daAlinkHIO_wlAutoJump_c0::m.field_0x00.mStartFrame, - daAlinkHIO_wlAutoJump_c0::m.field_0x00.mEndFrame, - daAlinkHIO_wlAutoJump_c0::m.field_0x00.mInterpolation); - if (speedF > field_0x594 || param_0 || daAlinkHIO_wlAutoJump_c0::m.field_0x3c == true) { + daAlinkHIO_wlAutoJump_c0::m.mJumpAnm.mStartFrame, + daAlinkHIO_wlAutoJump_c0::m.mJumpAnm.mEndFrame, + daAlinkHIO_wlAutoJump_c0::m.mJumpAnm.mInterpolation); + if (speedF > field_0x594 || param_0 || daAlinkHIO_wlAutoJump_c0::m.mAlwaysMaxSpeedJump == true) { speedF = field_0x594; } else if (speedF < var_f31) { speedF = var_f31; @@ -3298,27 +3298,27 @@ int daAlink_c::procWolfAutoJump() { daPy_frameCtrl_c* frameCtrl_p = mUnderFrameCtrl; if (!checkUnderMove0BckNoArcWolf(WANM_FALL_LAND) && - (mFallHeight - current.pos.y) * 0.01f > daAlinkHIO_wlDamFall_c0::m.field_0x38) + (mFallHeight - current.pos.y) * 0.01f > daAlinkHIO_wlDamFall_c0::m.mAirAnmTransitionHeight) { field_0x2f99 = 12; - setSingleAnimeWolfBaseSpeed(WANM_FALL_LAND, 0.0f, daAlinkHIO_wlDamFall_c0::m.field_0x3C); + setSingleAnimeWolfBaseSpeed(WANM_FALL_LAND, 0.0f, daAlinkHIO_wlDamFall_c0::m.mAirAnmInterp); } else if (checkUnderMove0BckNoArcWolf(WANM_JUMP_ATTACK_START)) { if (speed.y < -gravity) { field_0x2f99 = 12; - setSingleAnimeWolfParam(WANM_JUMP_ATTACK, &daAlinkHIO_wlAutoJump_c0::m.field_0x28); + setSingleAnimeWolfParam(WANM_JUMP_ATTACK, &daAlinkHIO_wlAutoJump_c0::m.mClimbAnm); } else if (checkAnmEnd(frameCtrl_p)) { field_0x2f99 = 12; setSingleAnimeWolf(WANM_JUMP_ATTACK, 0.0f, - daAlinkHIO_wlAutoJump_c0::m.field_0x28.mStartFrame, - daAlinkHIO_wlAutoJump_c0::m.field_0x28.mEndFrame, - daAlinkHIO_wlAutoJump_c0::m.field_0x28.mInterpolation); + daAlinkHIO_wlAutoJump_c0::m.mClimbAnm.mStartFrame, + daAlinkHIO_wlAutoJump_c0::m.mClimbAnm.mEndFrame, + daAlinkHIO_wlAutoJump_c0::m.mClimbAnm.mInterpolation); mProcVar2.field_0x300c = 0; } } else if (mProcVar2.field_0x300c == 0 && checkUnderMove0BckNoArcWolf(WANM_JUMP_ATTACK) && speed.y < -gravity) { mProcVar2.field_0x300c = 1; - frameCtrl_p->setRate(daAlinkHIO_wlAutoJump_c0::m.field_0x28.mSpeed); + frameCtrl_p->setRate(daAlinkHIO_wlAutoJump_c0::m.mClimbAnm.mSpeed); } return 1; @@ -3409,10 +3409,10 @@ int daAlink_c::procWolfFall() { } if (!checkUnderMove0BckNoArcWolf(WANM_FALL_LAND) && - (mFallHeight - current.pos.y) * 0.01f > daAlinkHIO_wlDamFall_c0::m.field_0x38) + (mFallHeight - current.pos.y) * 0.01f > daAlinkHIO_wlDamFall_c0::m.mAirAnmTransitionHeight) { field_0x2f99 = 12; - setSingleAnimeWolfBaseSpeed(WANM_FALL_LAND, 0.0f, daAlinkHIO_wlDamFall_c0::m.field_0x3C); + setSingleAnimeWolfBaseSpeed(WANM_FALL_LAND, 0.0f, daAlinkHIO_wlDamFall_c0::m.mAirAnmInterp); } return 1; @@ -3424,8 +3424,8 @@ int daAlink_c::procWolfLandInit() { mNormalSpeed = 0.0f; field_0x2f99 = 12; - setSingleAnimeWolfParam(WANM_JUMP_ATTACK_END, &daAlinkHIO_wlAutoJump_c0::m.field_0x14); - field_0x3478 = daAlinkHIO_wlAutoJump_c0::m.field_0x14.mCancelFrame; + setSingleAnimeWolfParam(WANM_JUMP_ATTACK_END, &daAlinkHIO_wlAutoJump_c0::m.mLandingAnm); + field_0x3478 = daAlinkHIO_wlAutoJump_c0::m.mLandingAnm.mCancelFrame; mProcVar2.field_0x300c = 1; field_0x2f9d = 4; @@ -3461,14 +3461,14 @@ int daAlink_c::procWolfSitInit(int param_0) { if (param_0 != 0 && !checkUnderMove0BckNoArcWolf(WANM_WAIT_SIT) && !checkUnderMove0BckNoArcWolf(WANM_HOWL_SIT)) { - setSingleAnimeWolfParam(WANM_SIT, &daAlinkHIO_wlLie_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_SIT, &daAlinkHIO_wlLie_c0::m.mSittingAnm); field_0x3198 = 0; } else { field_0x3198 = 1; if (!checkUnderMove0BckNoArcWolf(WANM_WAIT_SIT)) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT_SIT, daAlinkHIO_wlLie_c0::m.field_0x44, - daAlinkHIO_wlLie_c0::m.field_0x48); + setSingleAnimeWolfBaseSpeed(WANM_WAIT_SIT, daAlinkHIO_wlLie_c0::m.mSittingIdleAnmSpeed, + daAlinkHIO_wlLie_c0::m.mSittingIdleInterp); } } @@ -3481,14 +3481,14 @@ int daAlink_c::procWolfSit() { daPy_frameCtrl_c* frameCtrl = mUnderFrameCtrl; cLib_chaseF(&mNormalSpeed, 0.0f, - checkWolfDashMode() ? daAlinkHIO_wlMove_c0::m.field_0x6C : - daAlinkHIO_wlMoveNoP_c0::m.field_0x10); + checkWolfDashMode() ? daAlinkHIO_wlMove_c0::m.mDeceleration : + daAlinkHIO_wlMoveNoP_c0::m.mDeceleration); if (!spActionButton() && mDemo.getDemoMode() != 0xF) { checkNextActionWolfFromLie(); } else if (frameCtrl->checkAnmEnd()) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT_SIT, daAlinkHIO_wlLie_c0::m.field_0x44, - daAlinkHIO_wlLie_c0::m.field_0x48); + setSingleAnimeWolfBaseSpeed(WANM_WAIT_SIT, daAlinkHIO_wlLie_c0::m.mSittingIdleAnmSpeed, + daAlinkHIO_wlLie_c0::m.mSittingIdleInterp); field_0x3198 = 1; } @@ -3499,7 +3499,7 @@ int daAlink_c::procWolfSit() { */ int daAlink_c::procWolfStepMoveInit() { commonProcInit(PROC_WOLF_STEP_MOVE); - setSingleAnimeWolfParam(WANM_BUMP_START, &daAlinkHIO_wlWallHang_c0::m.field_0x50); + setSingleAnimeWolfParam(WANM_BUMP_START, &daAlinkHIO_wlWallHang_c0::m.mLedgeClimbAnm); field_0x3478 = 0.5f * mNormalSpeed; mNormalSpeed = 0.0f; mProcVar2.field_0x300c = 0; @@ -3523,7 +3523,7 @@ int daAlink_c::procWolfStepMove() { return checkNextActionWolf(0); } - if (frameCtrl_p->getFrame() > daAlinkHIO_wlWallHang_c0::m.field_0x64.mCancelFrame) { + if (frameCtrl_p->getFrame() > daAlinkHIO_wlWallHang_c0::m.mLedgeLandAnm.mCancelFrame) { mNormalSpeed = field_0x3478; if (checkNextActionWolf(1)) { @@ -3533,7 +3533,7 @@ int daAlink_c::procWolfStepMove() { mNormalSpeed = 0.0f; } } else if (checkAnmEnd(frameCtrl_p)) { - setSingleAnimeWolfParam(WANM_BUMP_END, &daAlinkHIO_wlWallHang_c0::m.field_0x64); + setSingleAnimeWolfParam(WANM_BUMP_END, &daAlinkHIO_wlWallHang_c0::m.mLedgeLandAnm); current.pos.set(field_0x34ec.x + cM_ssin(shape_angle.y) * 2.0f, field_0x34ec.y, field_0x34ec.z + cM_scos(shape_angle.y) * 2.0f); field_0x2f99 = 0x50; @@ -3546,12 +3546,12 @@ int daAlink_c::procWolfStepMove() { /* 8012F634-8012F6EC 129F74 00B8+00 1/1 0/0 0/0 .text procWolfSlipInit__9daAlink_cFv */ int daAlink_c::procWolfSlipInit() { commonProcInit(PROC_WOLF_SLIP); - setSingleAnimeWolfParam(WANM_SLIP, &daAlinkHIO_wlMove_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_SLIP, &daAlinkHIO_wlMove_c0::m.mSlipAnm); if (checkWolfDashMode()) { - mNormalSpeed = speedF * daAlinkHIO_wlMove_c0::m.field_0xA4; + mNormalSpeed = speedF * daAlinkHIO_wlMove_c0::m.mSlipInitSpeedRate; } else { - mNormalSpeed = speedF * daAlinkHIO_wlMoveNoP_c0::m.field_0x3C; + mNormalSpeed = speedF * daAlinkHIO_wlMoveNoP_c0::m.mSlideInitSpeed; } current.angle.y = shape_angle.y; @@ -3568,9 +3568,9 @@ int daAlink_c::procWolfSlip() { f32 var_f2; if (checkWolfDashMode()) { - var_f2 = daAlinkHIO_wlMove_c0::m.field_0xA8; + var_f2 = daAlinkHIO_wlMove_c0::m.mSlipDeceleration; } else { - var_f2 = daAlinkHIO_wlMoveNoP_c0::m.field_0x40; + var_f2 = daAlinkHIO_wlMoveNoP_c0::m.mSlideDeceleration; } cLib_chaseF(&mNormalSpeed, 0.0f, var_f2); @@ -3606,24 +3606,24 @@ int daAlink_c::procWolfSlipTurnInit(int param_0) { f32 var_f31; if (param_0) { - var_f31 = daAlinkHIO_wlMove_c0::m.field_0x14.mStartFrame; + var_f31 = daAlinkHIO_wlMove_c0::m.mReverseAnm.mStartFrame; current.angle.y = shape_angle.y + 0x8000; if (checkWolfDashMode()) { - field_0x347c = daAlinkHIO_wlMove_c0::m.field_0xAC; + field_0x347c = daAlinkHIO_wlMove_c0::m.mReverseSpeed; } else { - field_0x347c = daAlinkHIO_wlMoveNoP_c0::m.field_0x44; + field_0x347c = daAlinkHIO_wlMoveNoP_c0::m.mReverseSpeed; } } else { - var_f31 = daAlinkHIO_wlMove_c0::m.field_0xB0; + var_f31 = daAlinkHIO_wlMove_c0::m.mIdleReverseStartFrame; current.angle.y = field_0x2fe2; setOldRootQuaternion(0, (shape_angle.y - current.angle.y) - 0x8000, 0); shape_angle.y = current.angle.y + 0x8000; field_0x347c = 10.0f; } - setSingleAnimeWolf(WANM_TURN, daAlinkHIO_wlMove_c0::m.field_0x14.mSpeed, var_f31, 12, - daAlinkHIO_wlMove_c0::m.field_0x14.mInterpolation); + setSingleAnimeWolf(WANM_TURN, daAlinkHIO_wlMove_c0::m.mReverseAnm.mSpeed, var_f31, 12, + daAlinkHIO_wlMove_c0::m.mReverseAnm.mInterpolation); voiceStart(Z2SE_WL_V_BREATH_JUMP); mNormalSpeed = 0.0f; @@ -3651,12 +3651,12 @@ int daAlink_c::procWolfSlipTurn() { mNormalSpeed = field_0x347c; setJumpMode(); } else if (checkModeFlg(2) && - current.pos.y < mLastJumpPos.y - daAlinkHIO_wlMove_c0::m.field_0xC0) + current.pos.y < mLastJumpPos.y - daAlinkHIO_wlMove_c0::m.mReverseFallHeight) { setOldRootQuaternion(0, -0x8000, 0); shape_angle.y = current.angle.y; field_0x2fe6 = shape_angle.y; - procWolfFallInit(2, daAlinkHIO_wlMove_c0::m.field_0xC4); + procWolfFallInit(2, daAlinkHIO_wlMove_c0::m.mReverseFallInterpolation); } return 1; @@ -3667,11 +3667,11 @@ int daAlink_c::procWolfSlipTurnLandInit() { commonProcInit(PROC_WOLF_SLIP_TURN_LAND); daPy_frameCtrl_c* frameCtrl = mUnderFrameCtrl; - setFrameCtrl(frameCtrl, 0, 0, daAlinkHIO_wlMove_c0::m.field_0x14.mEndFrame, - daAlinkHIO_wlMove_c0::m.field_0x14.mSpeed, - frameCtrl->getFrame() + daAlinkHIO_wlMove_c0::m.field_0x14.mSpeed); + setFrameCtrl(frameCtrl, 0, 0, daAlinkHIO_wlMove_c0::m.mReverseAnm.mEndFrame, + daAlinkHIO_wlMove_c0::m.mReverseAnm.mSpeed, + frameCtrl->getFrame() + daAlinkHIO_wlMove_c0::m.mReverseAnm.mSpeed); - mNormalSpeed = 0.25f * daAlinkHIO_wlMoveNoP_c0::m.field_0x8; + mNormalSpeed = 0.25f * daAlinkHIO_wlMoveNoP_c0::m.mMaxSpeed; field_0x2f99 = 5; setFootEffectProcType(2); field_0x2f9d = 8; @@ -3688,7 +3688,7 @@ int daAlink_c::procWolfSlipTurnLand() { if (frameCtrl->checkAnmEnd()) { checkNextActionWolf(0); - } else if (frameCtrl->getFrame() > daAlinkHIO_wlMove_c0::m.field_0x14.mCancelFrame) { + } else if (frameCtrl->getFrame() > daAlinkHIO_wlMove_c0::m.mReverseAnm.mCancelFrame) { checkNextActionWolf(1); } @@ -3700,11 +3700,11 @@ int daAlink_c::procWolfSlideReadyInit(s16 i_angle, int param_1) { commonProcInit(PROC_WOLF_SLIDE_READY); field_0x3090 = 8; current.angle.y = i_angle; - setSingleAnimeWolfParam(WANM_SLIDE_FORWARD_START, &daAlinkHIO_wlSlide_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_SLIDE_FORWARD_START, &daAlinkHIO_wlSlide_c0::m.mFrontSlideAnm); voiceStart(Z2SE_WL_V_SLIP_ROLL); mNormalSpeed = 0.0f; - field_0x594 = daAlinkHIO_wlSlide_c0::m.field_0x54; + field_0x594 = daAlinkHIO_wlSlide_c0::m.mMaxSpeed; field_0x3588 = l_wolfBaseAnime; field_0x3478 = 1.0f / mUnderFrameCtrl[0].getEnd(); mProcVar2.field_0x300c = 0; @@ -3755,17 +3755,17 @@ int daAlink_c::procWolfSlideInit(s16 i_angle, int param_1) { field_0x814.SetWeight(0xFF); field_0x3090 = 8; current.angle.y = i_angle; - setSingleAnimeWolfParam(WANM_SLIDE_BACKWARD, &daAlinkHIO_wlSlide_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_SLIDE_BACKWARD, &daAlinkHIO_wlSlide_c0::m.mBackSlideAnm); if (param_1) { - mUnderFrameCtrl[0].setFrame(daAlinkHIO_wlSlide_c0::m.field_0x14.mEndFrame); - getNowAnmPackUnder(UNDER_0)->setFrame(daAlinkHIO_wlSlide_c0::m.field_0x14.mEndFrame); + mUnderFrameCtrl[0].setFrame(daAlinkHIO_wlSlide_c0::m.mBackSlideAnm.mEndFrame); + getNowAnmPackUnder(UNDER_0)->setFrame(daAlinkHIO_wlSlide_c0::m.mBackSlideAnm.mEndFrame); } dComIfGp_setPlayerStatus1(0, 0x200); field_0x2f9d = 0x78; setFootEffectProcType(1); - field_0x594 = daAlinkHIO_wlSlide_c0::m.field_0x54; + field_0x594 = daAlinkHIO_wlSlide_c0::m.mMaxSpeed; return 1; } @@ -3778,7 +3778,7 @@ int daAlink_c::procWolfSlide() { cLib_addCalcAngleS(¤t.angle.y, var_r30, 4, 0x1000, 0x400); cLib_addCalcAngleS(&shape_angle.y, current.angle.y + 0x8000, 4, 0x1000, 0x400); - mNormalSpeed += daAlinkHIO_wlSlide_c0::m.field_0x58 * + mNormalSpeed += daAlinkHIO_wlSlide_c0::m.mAcceleration * ((1.0f - slide_poly.mNormal.y) * 0.5f + 1.0f) * cM_scos(current.angle.y - var_r30); if (mNormalSpeed > field_0x594) { @@ -3798,7 +3798,7 @@ int daAlink_c::procWolfSlide() { */ int daAlink_c::procWolfSlideLandInit() { commonProcInit(PROC_WOLF_SLIDE_LAND); - setSingleAnimeWolfParam(WANM_SLIDE_BACKWARD_END, &daAlinkHIO_wlSlide_c0::m.field_0x28); + setSingleAnimeWolfParam(WANM_SLIDE_BACKWARD_END, &daAlinkHIO_wlSlide_c0::m.mLandingAnm); mNormalSpeed *= 0.5f; field_0x814.SetWeight(0xFF); @@ -3814,7 +3814,7 @@ int daAlink_c::procWolfSlideLand() { if (frameCtrl->checkAnmEnd()) { current.angle.y = shape_angle.y; checkNextActionWolf(0); - } else if (frameCtrl->getFrame() > daAlinkHIO_wlSlide_c0::m.field_0x28.mCancelFrame) { + } else if (frameCtrl->getFrame() > daAlinkHIO_wlSlide_c0::m.mLandingAnm.mCancelFrame) { s16 old_angle = current.angle.y; current.angle.y = shape_angle.y; @@ -3833,8 +3833,8 @@ int daAlink_c::procWolfWaitSlipInit() { return 0; } - setSingleAnimeWolfBaseSpeed(WANM_ATN, daAlinkHIO_wlMove_c0::m.field_0xB8, - daAlinkHIO_wlMove_c0::m.field_0xBC); + setSingleAnimeWolfBaseSpeed(WANM_ATN, daAlinkHIO_wlMove_c0::m.mGazeIdleAnmSpeed, + daAlinkHIO_wlMove_c0::m.mIdleInterpolation); mNormalSpeed = 0.0f; setWolfWaitSlip(); field_0x2f9d = 120; @@ -3867,9 +3867,9 @@ int daAlink_c::procWolfWaitSlip() { if (!checkNextActionWolf(0)) { f32 temp_f1 = setWolfWaitSlip(); - mNormalSpeed = var_f31 + (daAlinkHIO_wlSlide_c0::m.field_0x74 * (temp_f1 + 1.0f)); - if (mNormalSpeed > daAlinkHIO_wlSlide_c0::m.field_0x78) { - mNormalSpeed = daAlinkHIO_wlSlide_c0::m.field_0x78; + mNormalSpeed = var_f31 + (daAlinkHIO_wlSlide_c0::m.mSlipDownAcceleration * (temp_f1 + 1.0f)); + if (mNormalSpeed > daAlinkHIO_wlSlide_c0::m.mSlipDownMaxSpeed) { + mNormalSpeed = daAlinkHIO_wlSlide_c0::m.mSlipDownMaxSpeed; } field_0x2f9d = 0x78; @@ -3881,8 +3881,8 @@ int daAlink_c::procWolfWaitSlip() { var_r4 = current.angle.y; } - cLib_addCalcAngleS(&shape_angle.y, var_r4, 4, daAlinkHIO_wlSlide_c0::m.field_0x50, - daAlinkHIO_wlSlide_c0::m.field_0x52); + cLib_addCalcAngleS(&shape_angle.y, var_r4, 4, daAlinkHIO_wlSlide_c0::m.mSlipDownRotationMax, + daAlinkHIO_wlSlide_c0::m.mSlipDownRotationMin); seStartMapInfoLevel(Z2SE_FN_WOLF_SLIP); } @@ -3892,7 +3892,7 @@ int daAlink_c::procWolfWaitSlip() { /* 80130440-801304D4 12AD80 0094+00 2/2 0/0 0/0 .text procWolfSlopeStartInit__9daAlink_cFi */ int daAlink_c::procWolfSlopeStartInit(int param_0) { commonProcInit(PROC_WOLF_SLOPE_START); - setSingleAnimeWolfParam(WANM_SLIDE_W, &daAlinkHIO_wlSlide_c0::m.field_0x3C); + setSingleAnimeWolfParam(WANM_SLIDE_W, &daAlinkHIO_wlSlide_c0::m.mSlipDownRecoveryAnm); field_0x3588 = l_wolfBaseAnime; mNormalSpeed = 0.0f; current.angle.y = shape_angle.y; @@ -3910,7 +3910,7 @@ int daAlink_c::procWolfSlopeStart() { if (frameCtrl->checkAnmEnd()) { checkNextActionWolf(0); - } else if (frameCtrl->getFrame() > daAlinkHIO_wlSlide_c0::m.field_0x3C.mCancelFrame) { + } else if (frameCtrl->getFrame() > daAlinkHIO_wlSlide_c0::m.mSlipDownRecoveryAnm.mCancelFrame) { if (!checkNextActionWolf(1)) { field_0x2f99 = 5; } @@ -3962,8 +3962,8 @@ void daAlink_c::setWolfHowlNotHappen(int param_0) { if (!checkUnderMove0BckNoArcWolf(WANM_HOWL_END)) { if (param_0 != 0) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT_SIT, daAlinkHIO_wlLie_c0::m.field_0x44, - daAlinkHIO_wlLie_c0::m.field_0x48); + setSingleAnimeWolfBaseSpeed(WANM_WAIT_SIT, daAlinkHIO_wlLie_c0::m.mSittingIdleAnmSpeed, + daAlinkHIO_wlLie_c0::m.mSittingIdleInterp); } else { setSingleAnimeWolfBase(WANM_SERVICE_WAIT_D); } @@ -4067,14 +4067,14 @@ int daAlink_c::procWolfHowlDemoInit() { if (!checkUnderMove0BckNoArcWolf(WANM_WAIT_SIT) && !checkUnderMove0BckNoArcWolf(WANM_LISTEN) && !checkUnderMove0BckNoArcWolf(WANM_HOWL_SIT)) { - setSingleAnimeWolfParam(WANM_SIT, &daAlinkHIO_wlLie_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_SIT, &daAlinkHIO_wlLie_c0::m.mSittingAnm); field_0x347c = -1.0f; } else { field_0x347c = 10.0f; if (mProcVar4.field_0x3010 == 0) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT_SIT, daAlinkHIO_wlLie_c0::m.field_0x44, - daAlinkHIO_wlLie_c0::m.field_0x48); + setSingleAnimeWolfBaseSpeed(WANM_WAIT_SIT, daAlinkHIO_wlLie_c0::m.mSittingIdleAnmSpeed, + daAlinkHIO_wlLie_c0::m.mSittingIdleInterp); } else { setSingleAnimeWolfBase(WANM_LISTEN); setFaceBasicTexture(FTANM_UNK_A2); @@ -4135,8 +4135,8 @@ int daAlink_c::procWolfHowlDemo() { setSingleAnimeWolfBase(WANM_LISTEN); setFaceBasicTexture(FTANM_UNK_A2); } else { - setSingleAnimeWolfBaseSpeed(WANM_WAIT_SIT, daAlinkHIO_wlLie_c0::m.field_0x44, - daAlinkHIO_wlLie_c0::m.field_0x48); + setSingleAnimeWolfBaseSpeed(WANM_WAIT_SIT, daAlinkHIO_wlLie_c0::m.mSittingIdleAnmSpeed, + daAlinkHIO_wlLie_c0::m.mSittingIdleInterp); } field_0x347c = 1.0f; @@ -4162,7 +4162,7 @@ int daAlink_c::procWolfHowlDemo() { { if (!checkUnderMove0BckNoArcWolf(WANM_HOWL_SIT) || mProcVar1.field_0x300a == 0) { mProcVar1.field_0x300a = 1; - setSingleAnimeWolfParam(WANM_HOWL_SIT, &daAlinkHIO_wlHowl_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_HOWL_SIT, &daAlinkHIO_wlHowl_c0::m.mSittingHowlAnm); } else { if (frameCtrl_p->getFrame() > 56.0f) { frameCtrl_p->setFrame((frameCtrl_p->getFrame() - 56.0f) + 38.0f); @@ -4186,8 +4186,8 @@ int daAlink_c::procWolfHowlDemo() { setSingleAnimeWolfBase(WANM_LISTEN); setFaceBasicTexture(FTANM_UNK_A2); } else if (checkAnmEnd(frameCtrl_p)) { - setSingleAnimeWolfBaseSpeed(WANM_WAIT_SIT, daAlinkHIO_wlLie_c0::m.field_0x44, - daAlinkHIO_wlLie_c0::m.field_0x48); + setSingleAnimeWolfBaseSpeed(WANM_WAIT_SIT, daAlinkHIO_wlLie_c0::m.mSittingIdleAnmSpeed, + daAlinkHIO_wlLie_c0::m.mSittingIdleInterp); } } @@ -4356,7 +4356,7 @@ f32 daAlink_c::getWolfRopeMoveSpeed() { frame -= 13.5f; } - return daAlinkHIO_wlRope_c0::m.field_0x24 * frameCtrl->getRate() * cM_fsin(0.23271057f * frame); + return daAlinkHIO_wlRope_c0::m.mMovementRate * frameCtrl->getRate() * cM_fsin(0.23271057f * frame); } /* 80131718-801319F0 12C058 02D8+00 6/6 0/0 0/0 .text setWolfRopePosY__9daAlink_cFv */ @@ -4476,7 +4476,7 @@ int daAlink_c::procWolfRopeMoveInit(int param_0, int param_1) { mProcVar2.field_0x300c = initWolfRopeShapeAngle(); current.angle.y = shape_angle.y; - setSingleAnimeWolfBaseSpeed(WANM_ROPE_WALK, 0.0f, daAlinkHIO_wlRope_c0::m.field_0x20); + setSingleAnimeWolfBaseSpeed(WANM_ROPE_WALK, 0.0f, daAlinkHIO_wlRope_c0::m.mMovementInterpolation); if (param_0) { mUnderFrameCtrl[0].setFrame(13.5f); getNowAnmPackUnder(UNDER_0)->setFrame(13.5f); @@ -4507,8 +4507,8 @@ int daAlink_c::procWolfRopeMove() { daObjCrope_c* temp_r29 = (daObjCrope_c*)field_0x280c.getActor(); int var_r27 = 0; - f32 temp_f26 = getAnmSpeedStickRate(daAlinkHIO_wlRope_c0::m.field_0x18, daAlinkHIO_wlRope_c0::m.field_0x1C); - f32 temp_f25 = -1.0f * getAnmSpeedStickRate(daAlinkHIO_wlRope_c0::m.field_0x18, daAlinkHIO_wlRope_c0::m.field_0x34); + f32 temp_f26 = getAnmSpeedStickRate(daAlinkHIO_wlRope_c0::m.mMovementMinAnmSpeed, daAlinkHIO_wlRope_c0::m.mMovementMaxAnmSpeed); + f32 temp_f25 = -1.0f * getAnmSpeedStickRate(daAlinkHIO_wlRope_c0::m.mMovementMinAnmSpeed, daAlinkHIO_wlRope_c0::m.mBackMovementMaxAnmSpeed); if (temp_r28->getRate() > 0.0f) { temp_r28->setRate(temp_f26); @@ -4673,8 +4673,8 @@ int daAlink_c::procWolfRopeHangInit(int param_0) { if (param_0 != 4) { mProcVar3.field_0x300e = 0; - setSingleAnimeWolf(WANM_HANG, daAlinkHIO_wlRope_c0::m.field_0x28, 0.0f, 16, - daAlinkHIO_wlRope_c0::m.field_0x2C); + setSingleAnimeWolf(WANM_HANG, daAlinkHIO_wlRope_c0::m.mTwistClimbAnmSpeed, 0.0f, 16, + daAlinkHIO_wlRope_c0::m.mFallInterpolation); rope_p->rideKeep(); } else { mProcVar3.field_0x300e = 1; @@ -4689,8 +4689,8 @@ int daAlink_c::procWolfRopeHangInit(int param_0) { climb_anm = WANM_ROPE_CLIMB_LEFT; } - setSingleAnimeWolfBaseSpeed(climb_anm, daAlinkHIO_wlRope_c0::m.field_0x28, - daAlinkHIO_wlRope_c0::m.field_0x30); + setSingleAnimeWolfBaseSpeed(climb_anm, daAlinkHIO_wlRope_c0::m.mTwistClimbAnmSpeed, + daAlinkHIO_wlRope_c0::m.mTwistClimbInterpolation); rope_p->setFrontJoint(19); rope_p->setBackJoint(23); current.pos = rope_p->getPlayerNearPos(); @@ -4756,7 +4756,7 @@ int daAlink_c::procWolfRopeHang() { var_r27 = WANM_ROPE_CLIMB_RIGHT; } - setSingleAnimeWolfBaseSpeed(var_r27, daAlinkHIO_wlRope_c0::m.field_0x28, daAlinkHIO_wlRope_c0::m.field_0x30); + setSingleAnimeWolfBaseSpeed(var_r27, daAlinkHIO_wlRope_c0::m.mTwistClimbAnmSpeed, daAlinkHIO_wlRope_c0::m.mTwistClimbInterpolation); } f32 temp_f31 = temp_r28->getFrame(); @@ -4770,7 +4770,7 @@ int daAlink_c::procWolfRopeHang() { current.pos.z -= 80.0f * cM_scos(shape_angle.y); field_0x2060->getOldFrameTransInfo(0)->mTranslate.z += 80.0f; - return procWolfFallInit(2, daAlinkHIO_wlAutoJump_c0::m.field_0x54); + return procWolfFallInit(2, daAlinkHIO_wlAutoJump_c0::m.mNormalFallInterp); } } @@ -4844,7 +4844,7 @@ int daAlink_c::procWolfRopeHang() { */ int daAlink_c::procWolfRopeTurnInit() { commonProcInit(PROC_WOLF_ROPE_TURN); - setSingleAnimeWolfParam(WANM_ROPE_TURN, &daAlinkHIO_wlRope_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_ROPE_TURN, &daAlinkHIO_wlRope_c0::m.mFlipAnm); voiceStart(Z2SE_WL_V_BREATH_JUMP); setSpecialGravity(0.0f, maxFallSpeed, 0); speed.y = 0.0f; @@ -5026,7 +5026,7 @@ int daAlink_c::procWolfRopeSubjectivityInit() { commonProcInit(PROC_WOLF_ROPE_SUBJECTIVITY); if (!checkUnderMove0BckNoArcWolf(WANM_ROPE_WALK)) { - setSingleAnimeWolfBaseSpeed(WANM_ROPE_WALK, 0.0f, daAlinkHIO_wlRope_c0::m.field_0x20); + setSingleAnimeWolfBaseSpeed(WANM_ROPE_WALK, 0.0f, daAlinkHIO_wlRope_c0::m.mMovementInterpolation); } mProcVar2.field_0x300c = initWolfRopeShapeAngle(); @@ -5100,12 +5100,12 @@ int daAlink_c::procWolfRopeSubjectivity() { int daAlink_c::getWolfTagJumpTime() const { int time; if (mProcID == PROC_WOLF_TAG_JUMP) { - time = mProcVar0.field_0x3008 + (int)((daAlinkHIO_wlPoint_c0::m.field_0x28.mCancelFrame - - daAlinkHIO_wlPoint_c0::m.field_0x28.mStartFrame) / - daAlinkHIO_wlPoint_c0::m.field_0x28.mSpeed); + time = mProcVar0.field_0x3008 + (int)((daAlinkHIO_wlPoint_c0::m.mLandingAnm.mCancelFrame - + daAlinkHIO_wlPoint_c0::m.mLandingAnm.mStartFrame) / + daAlinkHIO_wlPoint_c0::m.mLandingAnm.mSpeed); } else { time = (int)(checkMidnaLockJumpPoint()->abs(current.pos) / - daAlinkHIO_wlPoint_c0::m.field_0x68); + daAlinkHIO_wlPoint_c0::m.mTagJumpSpeed); } time -= 2; @@ -5152,7 +5152,7 @@ const cXyz* daAlink_c::checkMidnaLockJumpPoint() const { int daAlink_c::procWolfTagJumpInit(fopAc_ac_c* param_0) { commonProcInit(PROC_WOLF_TAG_JUMP); - field_0x3480 = daAlinkHIO_wlPoint_c0::m.field_0x68; + field_0x3480 = daAlinkHIO_wlPoint_c0::m.mTagJumpSpeed; field_0x3198 = 0; if (param_0 == NULL) { @@ -5175,7 +5175,7 @@ int daAlink_c::procWolfTagJumpInit(fopAc_ac_c* param_0) { mProcVar1.field_0x300a = ((daTagWljump_c*)param_0)->getNotSlideFlg(); } - setSingleAnimeWolf(WANM_JUMP_ATTACK_START, daAlinkHIO_wlAutoJump_c0::m.field_0x60, daAlinkHIO_wlAutoJump_c0::m.field_0x00.mStartFrame, daAlinkHIO_wlAutoJump_c0::m.field_0x00.mEndFrame, daAlinkHIO_wlAutoJump_c0::m.field_0x00.mInterpolation); + setSingleAnimeWolf(WANM_JUMP_ATTACK_START, daAlinkHIO_wlAutoJump_c0::m.mWeakJumpAnmSpeed, daAlinkHIO_wlAutoJump_c0::m.mJumpAnm.mStartFrame, daAlinkHIO_wlAutoJump_c0::m.mJumpAnm.mEndFrame, daAlinkHIO_wlAutoJump_c0::m.mJumpAnm.mInterpolation); field_0x3588 = l_wolfBaseAnime; cXyz sp8 = field_0x37c8 - current.pos; @@ -5222,7 +5222,7 @@ int daAlink_c::procWolfTagJump() { mProcVar0.field_0x3008--; if (mProcVar0.field_0x3008 < 0) { - if (temp_r29 == NULL || temp_r29->getLockPos() == NULL || mProcVar0.field_0x3008 < -daAlinkHIO_wlPoint_c0::m.field_0x50.mEndFrame) { + if (temp_r29 == NULL || temp_r29->getLockPos() == NULL || mProcVar0.field_0x3008 < -daAlinkHIO_wlPoint_c0::m.mLockJumpStopTime) { procWolfWaitInit(); } else { if (field_0x3198 == 0) { @@ -5239,11 +5239,11 @@ int daAlink_c::procWolfTagJump() { mProcVar5.field_0x3012 = 1; } - if (mProcVar5.field_0x3012 && (checkModeFlg(0x100) || checkAnmEnd(temp_r28) || temp_r28->getFrame() > daAlinkHIO_wlPoint_c0::m.field_0x28.mCancelFrame)) { + if (mProcVar5.field_0x3012 && (checkModeFlg(0x100) || checkAnmEnd(temp_r28) || temp_r28->getFrame() > daAlinkHIO_wlPoint_c0::m.mLandingAnm.mCancelFrame)) { procWolfTagJumpInit(temp_r29); } else if (checkAnmEnd(temp_r28)) { onModeFlg(0x100); - setSingleAnimeWolfBaseSpeed(WANM_WAIT_B, daAlinkHIO_wlPoint_c0::m.field_0x50.mSpeed, daAlinkHIO_wlPoint_c0::m.field_0x50.mStartFrame); + setSingleAnimeWolfBaseSpeed(WANM_WAIT_B, daAlinkHIO_wlPoint_c0::m.mIdleAnmSpeed, daAlinkHIO_wlPoint_c0::m.mIdleInterpolation); } } @@ -5261,7 +5261,7 @@ int daAlink_c::procWolfTagJump() { if (checkUnderMove0BckNoArcWolf(WANM_JUMP_ATTACK_START) && checkAnmEnd(temp_r28)) { field_0x2f99 = 0xC; - setSingleAnimeWolfBaseSpeed(WANM_JUMP_ATTACK, 0.0f, daAlinkHIO_wlAutoJump_c0::m.field_0x28.mInterpolation); + setSingleAnimeWolfBaseSpeed(WANM_JUMP_ATTACK, 0.0f, daAlinkHIO_wlAutoJump_c0::m.mClimbAnm.mInterpolation); } if (mProcVar0.field_0x3008 == 0) { @@ -5278,7 +5278,7 @@ int daAlink_c::procWolfTagJump() { if (mProcVar1.field_0x300a != 0) { field_0x2f99 = 0x50; - setSingleAnimeWolfParam(WANM_JUMP_B_END, &daAlinkHIO_wlPoint_c0::m.field_0x28); + setSingleAnimeWolfParam(WANM_JUMP_B_END, &daAlinkHIO_wlPoint_c0::m.mLandingAnm); mNormalSpeed = 0.0f; speed = cXyz::Zero; @@ -5294,14 +5294,14 @@ int daAlink_c::procWolfTagJump() { procWolfTagJumpLandInit(NULL); } } else if (field_0x3198 != 0) { - procWolfFallInit(2, daAlinkHIO_wlAutoJump_c0::m.field_0x54); + procWolfFallInit(2, daAlinkHIO_wlAutoJump_c0::m.mNormalFallInterp); } else { current.pos.x -= 50.0f * cM_ssin(shape_angle.y); current.pos.z -= 50.0f * cM_scos(shape_angle.y); procWolfTagJumpLandInit(NULL); } } else { - procWolfFallInit(2, daAlinkHIO_wlAutoJump_c0::m.field_0x54); + procWolfFallInit(2, daAlinkHIO_wlAutoJump_c0::m.mNormalFallInterp); } } @@ -5312,10 +5312,10 @@ int daAlink_c::procWolfTagJump() { * procWolfTagJumpLandInit__9daAlink_cFP10fopAc_ac_c */ int daAlink_c::procWolfTagJumpLandInit(fopAc_ac_c* param_0) { commonProcInit(PROC_WOLF_TAG_JUMP_LAND); - setSingleAnimeWolfParam(WANM_ATTACK_A_END_FRONT, &daAlinkHIO_wlPoint_c0::m.field_0x3C); + setSingleAnimeWolfParam(WANM_ATTACK_A_END_FRONT, &daAlinkHIO_wlPoint_c0::m.mTagLandingAnm); if (mGndPolySpecialCode == dBgW_SPCODE_ICE) { - mNormalSpeed = daAlinkHIO_wlPoint_c0::m.field_0x6C; + mNormalSpeed = daAlinkHIO_wlPoint_c0::m.mLockLandingIceInitSpeed; } else { mNormalSpeed = 0.0f; } @@ -5345,7 +5345,7 @@ int daAlink_c::procWolfTagJumpLand() { onResetFlg0(RFLG0_UNK_20000); field_0x3738 = *wljump_p->getLockPos(); - if (frameCtrl_p->getFrame() > daAlinkHIO_wlPoint_c0::m.field_0x3C.mCancelFrame) { + if (frameCtrl_p->getFrame() > daAlinkHIO_wlPoint_c0::m.mTagLandingAnm.mCancelFrame) { setDoStatus(0x93); if (doTrigger()) { @@ -5355,13 +5355,13 @@ int daAlink_c::procWolfTagJumpLand() { } field_0x2f99 = 4; - if (cLib_addCalc(&mNormalSpeed, 0.0f, daAlinkHIO_wlPoint_c0::m.field_0x70, - daAlinkHIO_wlPoint_c0::m.field_0x74, - daAlinkHIO_wlPoint_c0::m.field_0x78) < 3.0f) + if (cLib_addCalc(&mNormalSpeed, 0.0f, daAlinkHIO_wlPoint_c0::m.mLockLandingIceDecelRate, + daAlinkHIO_wlPoint_c0::m.mLockLandingIceMaxDecel, + daAlinkHIO_wlPoint_c0::m.mLockLandingIceMinDecel) < 3.0f) { if (checkAnmEnd(frameCtrl_p)) { checkNextActionWolf(0); - } else if (!(frameCtrl_p->getFrame() > daAlinkHIO_wlPoint_c0::m.field_0x3C.mCancelFrame) || + } else if (!(frameCtrl_p->getFrame() > daAlinkHIO_wlPoint_c0::m.mTagLandingAnm.mCancelFrame) || !checkNextActionWolf(1)) { field_0x2f9d = 0x78; @@ -5405,14 +5405,14 @@ int daAlink_c::procWolfGiantPuzzleInit() { return 0; } - setBlendWolfMoveAnime(daAlinkHIO_wlMove_c0::m.field_0xBC); + setBlendWolfMoveAnime(daAlinkHIO_wlMove_c0::m.mIdleInterpolation); current.angle.y = shape_angle.y; field_0x2f98 = 4; mProcVar2.mPuzzleAimAngle = shape_angle.y; field_0x3478 = 0.0f; - field_0x347c = daAlinkHIO_wlMoveNoP_c0::m.field_0x10; - field_0x594 = daAlinkHIO_wlMoveNoP_c0::m.field_0x8; + field_0x347c = daAlinkHIO_wlMoveNoP_c0::m.mDeceleration; + field_0x594 = daAlinkHIO_wlMoveNoP_c0::m.mMaxSpeed; offWolfEyeUp(); return 1; @@ -5447,7 +5447,7 @@ int daAlink_c::procWolfGiantPuzzle() { if (fabsf(dComIfG_Bgsp().GroundCross(&mLinkGndChk) - current.pos.y) < 0.1f && fopAcIt_Judge((fopAcIt_JudgeFunc)daAlink_searchGiant, &gnd_chk_pos) == NULL) { - field_0x347c = daAlinkHIO_wlMoveNoP_c0::m.field_0xC; + field_0x347c = daAlinkHIO_wlMoveNoP_c0::m.mAcceleration; field_0x3478 = field_0x594; } } else if (direction == DIR_LEFT) { @@ -5464,8 +5464,8 @@ int daAlink_c::procWolfGiantPuzzle() { if (mProcVar2.mPuzzleAimAngle != shape_angle.y) { cLib_addCalcAngleS( - &shape_angle.y, mProcVar2.mPuzzleAimAngle, daAlinkHIO_wlMoveNoP_c0::m.field_0x4, - daAlinkHIO_wlMoveNoP_c0::m.field_0x0, daAlinkHIO_wlMoveNoP_c0::m.field_0x2); + &shape_angle.y, mProcVar2.mPuzzleAimAngle, daAlinkHIO_wlMoveNoP_c0::m.mTurnAngleRate, + daAlinkHIO_wlMoveNoP_c0::m.mTurnMax, daAlinkHIO_wlMoveNoP_c0::m.mTurnMin); current.angle.y = shape_angle.y; } @@ -5495,9 +5495,9 @@ int daAlink_c::changeWolfHangEndProc() { f32 var_f1; if (checkNoResetFlg0(FLG0_UNK_80) && mWaterY > field_0x33d8) { - var_f1 = daAlinkHIO_wlSwim_c0::m.field_0x48 + daAlinkHIO_wlSwim_c0::m.field_0x94; + var_f1 = daAlinkHIO_wlSwim_c0::m.mStartHeight + daAlinkHIO_wlSwim_c0::m.mClimbBelowWaterSurface; } else { - var_f1 = daAlinkHIO_wlWallHang_c0::m.field_0x88; + var_f1 = daAlinkHIO_wlWallHang_c0::m.mHangingFootHeight; } if (current.pos.y < (field_0x33d8 + var_f1) - 1.0f) { @@ -5510,7 +5510,7 @@ int daAlink_c::changeWolfHangEndProc() { current.pos.z -= cM_scos(shape_angle.y) * 50.0f; onNoResetFlg2(FLG2_UNK_200); - procWolfFallInit(2, daAlinkHIO_wlWallHang_c0::m.field_0x98); + procWolfFallInit(2, daAlinkHIO_wlWallHang_c0::m.mHangingFallInterp); return 1; } } @@ -5522,9 +5522,9 @@ int daAlink_c::changeWolfHangEndProc() { */ int daAlink_c::procWolfHangReadyInit() { commonProcInit(PROC_WOLF_HANG_READY); - setSingleAnimeWolf(WANM_VJMP_START, daAlinkHIO_wlWallHang_c0::m.field_0x0.mSpeed, - daAlinkHIO_wlWallHang_c0::m.field_0x0.mStartFrame, 12, - daAlinkHIO_wlWallHang_c0::m.field_0x0.mInterpolation); + setSingleAnimeWolf(WANM_VJMP_START, daAlinkHIO_wlWallHang_c0::m.mPreGrabJumpAnm.mSpeed, + daAlinkHIO_wlWallHang_c0::m.mPreGrabJumpAnm.mStartFrame, 12, + daAlinkHIO_wlWallHang_c0::m.mPreGrabJumpAnm.mInterpolation); field_0x3198 = field_0x2f91; mProcVar2.field_0x300c = field_0x306e + 0x8000; @@ -5600,10 +5600,10 @@ int daAlink_c::procWolfHangWallCatchInit(int param_0) { commonProcInit(PROC_WOLF_HANG_WALL_CATCH); if (param_0 == 8 && var_r29 != 6) { - setSingleAnimeWolfParam(WANM_VJMP_CLIMB, &daAlinkHIO_wlWallHang_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_VJMP_CLIMB, &daAlinkHIO_wlWallHang_c0::m.mClimbAnm); mProcVar3.field_0x300e = 1; } else { - setSingleAnimeWolfParam(WANM_VJMP_CLIMB_HANG, &daAlinkHIO_wlWallHang_c0::m.field_0x3C); + setSingleAnimeWolfParam(WANM_VJMP_CLIMB_HANG, &daAlinkHIO_wlWallHang_c0::m.mWallGrabAnm); mProcVar3.field_0x300e = 0; } @@ -5648,14 +5648,14 @@ int daAlink_c::procWolfHangWallCatch() { if (mProcVar3.field_0x300e == 0) { if (field_0x3174 == 6) { if (mProcVar4.field_0x3010 == 0) { - setSingleAnimeWolf(WANM_HANG, daAlinkHIO_wlWallHang_c0::m.field_0x28.mSpeed, - 35.0f, daAlinkHIO_wlWallHang_c0::m.field_0x28.mEndFrame, + setSingleAnimeWolf(WANM_HANG, daAlinkHIO_wlWallHang_c0::m.mFallGrabAnm.mSpeed, + 35.0f, daAlinkHIO_wlWallHang_c0::m.mFallGrabAnm.mEndFrame, 5.0f); mProcVar4.field_0x3010 = 1; } } else { - setSingleAnimeWolf(WANM_VJMP_CLIMB, daAlinkHIO_wlWallHang_c0::m.field_0x14.mSpeed, - 17.0f, daAlinkHIO_wlWallHang_c0::m.field_0x14.mEndFrame, 2.0f); + setSingleAnimeWolf(WANM_VJMP_CLIMB, daAlinkHIO_wlWallHang_c0::m.mClimbAnm.mSpeed, + 17.0f, daAlinkHIO_wlWallHang_c0::m.mClimbAnm.mEndFrame, 2.0f); mProcVar3.field_0x300e = 1; } } else { @@ -5669,7 +5669,7 @@ int daAlink_c::procWolfHangWallCatch() { onNoResetFlg1(FLG1_UNK_20); } } else if (mProcVar3.field_0x300e != 0 && - frameCtrl_p->getFrame() > daAlinkHIO_wlWallHang_c0::m.field_0x14.mCancelFrame && + frameCtrl_p->getFrame() > daAlinkHIO_wlWallHang_c0::m.mClimbAnm.mCancelFrame && checkNextActionWolf(1)) { onNoResetFlg1(FLG1_UNK_20); @@ -5708,7 +5708,7 @@ int daAlink_c::procWolfHangFallStartInit(cM3dGPla* param_0) { shape_angle.y = var_r30 + 0x8000; current.angle.y = shape_angle.y; - setSingleAnimeWolfParam(WANM_HANG, &daAlinkHIO_wlWallHang_c0::m.field_0x28); + setSingleAnimeWolfParam(WANM_HANG, &daAlinkHIO_wlWallHang_c0::m.mFallGrabAnm); f32 sin = cM_ssin(shape_angle.y); f32 cos = cM_scos(shape_angle.y); @@ -5764,7 +5764,7 @@ int daAlink_c::procWolfHangFallStart() { /* 80136064-801360EC 1309A4 0088+00 1/1 0/0 0/0 .text setWolfHeadDamage__9daAlink_cFv */ void daAlink_c::setWolfHeadDamage() { - setUpperAnimeParam(0x2A7, UPPER_2, &daAlinkHIO_wlDamage_c0::m.field_0x0); + setUpperAnimeParam(0x2A7, UPPER_2, &daAlinkHIO_wlDamage_c0::m.mRunningAnm); seStartOnlyReverb(Z2SE_AL_DAMAGE_NORMAL); freeGrabItem(); setFacePriTexture(FTANM_UNK_90); @@ -5792,17 +5792,17 @@ int daAlink_c::procWolfDamageInit(dCcD_GObjInf* param_0) { int temp_r3 = getDirectionFromAngle(cM_atan2s(-sp8.x, -sp8.z)); if (temp_r3 == DIR_FORWARD) { - setSingleAnimeWolfParam(WANM_DMG_FRONT, &daAlinkHIO_wlDamNormal_c0::m.field_0x0); - field_0x3478 = daAlinkHIO_wlDamNormal_c0::m.field_0x0.mCancelFrame; + setSingleAnimeWolfParam(WANM_DMG_FRONT, &daAlinkHIO_wlDamNormal_c0::m.mForwardAnm); + field_0x3478 = daAlinkHIO_wlDamNormal_c0::m.mForwardAnm.mCancelFrame; } else if (temp_r3 == DIR_BACKWARD) { - setSingleAnimeWolfParam(WANM_DMG_BACK, &daAlinkHIO_wlDamNormal_c0::m.field_0x14); - field_0x3478 = daAlinkHIO_wlDamNormal_c0::m.field_0x14.mCancelFrame; + setSingleAnimeWolfParam(WANM_DMG_BACK, &daAlinkHIO_wlDamNormal_c0::m.mBackwardAnm); + field_0x3478 = daAlinkHIO_wlDamNormal_c0::m.mBackwardAnm.mCancelFrame; } else if (temp_r3 == DIR_LEFT) { - setSingleAnimeWolfParam(WANM_DMG_LEFT, &daAlinkHIO_wlDamNormal_c0::m.field_0x28); - field_0x3478 = daAlinkHIO_wlDamNormal_c0::m.field_0x28.mCancelFrame; + setSingleAnimeWolfParam(WANM_DMG_LEFT, &daAlinkHIO_wlDamNormal_c0::m.mLeftAnm); + field_0x3478 = daAlinkHIO_wlDamNormal_c0::m.mLeftAnm.mCancelFrame; } else { - setSingleAnimeWolfParam(WANM_DMG_RIGHT, &daAlinkHIO_wlDamNormal_c0::m.field_0x3C); - field_0x3478 = daAlinkHIO_wlDamNormal_c0::m.field_0x3C.mCancelFrame; + setSingleAnimeWolfParam(WANM_DMG_RIGHT, &daAlinkHIO_wlDamNormal_c0::m.mRightAnm); + field_0x3478 = daAlinkHIO_wlDamNormal_c0::m.mRightAnm.mCancelFrame; } setFaceBasicTexture(FTANM_UNK_90); @@ -5810,15 +5810,15 @@ int daAlink_c::procWolfDamageInit(dCcD_GObjInf* param_0) { current.angle.y = var_r30->atan2sX_Z(); mProcVar4.field_0x3010 = current.angle.y; - mNormalSpeed = daAlinkHIO_wlDamNormal_c0::m.field_0x50 + (daAlinkHIO_wlDamNormal_c0::m.field_0x54 * var_r30->absXZ()); - if (mNormalSpeed > daAlinkHIO_wlMove_c0::m.field_0x64) { - mNormalSpeed = daAlinkHIO_wlMove_c0::m.field_0x64; + mNormalSpeed = daAlinkHIO_wlDamNormal_c0::m.mInitSpeed + (daAlinkHIO_wlDamNormal_c0::m.mAttackSpeedRate * var_r30->absXZ()); + if (mNormalSpeed > daAlinkHIO_wlMove_c0::m.mMaxSpeed) { + mNormalSpeed = daAlinkHIO_wlMove_c0::m.mMaxSpeed; } field_0x3588 = l_wolfBaseAnime; if (param_0 == NULL || (param_0->GetTgHitGObj() != NULL && param_0->GetTgHitGObj()->GetAtMtrl() == dCcD_MTRL_ICE)) { - mUnderFrameCtrl[0].setRate(daAlinkHIO_wlDamNormal_c0::m.field_0x5C); + mUnderFrameCtrl[0].setRate(daAlinkHIO_wlDamNormal_c0::m.mIceDamageAnmSpeed); mUnderFrameCtrl[0].setEnd(3); mNormalSpeed = 0.0f; mProcVar0.field_0x3008 = 90; @@ -5841,7 +5841,7 @@ int daAlink_c::procWolfDamageInit(dCcD_GObjInf* param_0) { int daAlink_c::procWolfDamage() { daPy_frameCtrl_c* frameCtrl_p = mUnderFrameCtrl; - cLib_chaseF(&mNormalSpeed, 0.0f, daAlinkHIO_wlDamNormal_c0::m.field_0x58); + cLib_chaseF(&mNormalSpeed, 0.0f, daAlinkHIO_wlDamNormal_c0::m.mDeceleration); field_0x2f99 = 5; if (checkFreezeDamage()) { @@ -5915,14 +5915,14 @@ int daAlink_c::procWolfLargeDamageUpInit(int param_0, int param_1, s16 param_2, mProcVar5.field_0x3012 = 1; } } else { - var_f30 = daAlinkHIO_wlDamLarge_c0::m.field_0x0.mInterpolation; + var_f30 = daAlinkHIO_wlDamLarge_c0::m.mFrontRiseAnm.mInterpolation; } var_r28 = WANM_DMG_AIR_FRONT_GETUP; var_f29 = 16.0f; var_r27 = -1; - field_0x3478 = daAlinkHIO_wlDamLarge_c0::m.field_0x0.mCancelFrame; + field_0x3478 = daAlinkHIO_wlDamLarge_c0::m.mFrontRiseAnm.mCancelFrame; if (param_0 == -4) { onNoResetFlg2(FLG2_PRESSED_DAMAGE); @@ -5936,7 +5936,7 @@ int daAlink_c::procWolfLargeDamageUpInit(int param_0, int param_1, s16 param_2, var_f31 = 0.0f; } else { mProcVar0.field_0x3008 = 1; - var_f31 = daAlinkHIO_wlDamage_c0::m.field_0x28; + var_f31 = daAlinkHIO_wlDamage_c0::m.mReturnWakeupAnmSpeed; } offModeFlg(0x10008000); @@ -5955,28 +5955,28 @@ int daAlink_c::procWolfLargeDamageUpInit(int param_0, int param_1, s16 param_2, field_0x2f9d = 4; if (param_0 == 0x29) { - setSingleAnimeWolfParam(WANM_DMG_AIR_BACK_GETUP, &var_r30->field_0x14); + setSingleAnimeWolfParam(WANM_DMG_AIR_BACK_GETUP, &var_r30->mBackRiseAnm); setFaceBasicTexture(FTANM_UNK_92); - field_0x3478 = var_r30->field_0x14.mCancelFrame; + field_0x3478 = var_r30->mBackRiseAnm.mCancelFrame; field_0x347c = 16.0f; field_0x3198 = 1; field_0x3484 = 15.0; } else if (param_0 == 0x2A) { - setSingleAnimeWolfParam(WANM_DMG_AIR_LEFT_GETUP, &var_r30->field_0x28); + setSingleAnimeWolfParam(WANM_DMG_AIR_LEFT_GETUP, &var_r30->mLeftRiseAnm); setFaceBasicTexture(FTANM_UNK_93); - field_0x3478 = var_r30->field_0x28.mCancelFrame; + field_0x3478 = var_r30->mLeftRiseAnm.mCancelFrame; field_0x347c = 11.0f; field_0x3484 = 13.0f; } else if (param_0 == 0x2B) { - setSingleAnimeWolfParam(WANM_DMG_AIR_RIGHT_GETUP, &var_r30->field_0x3C); + setSingleAnimeWolfParam(WANM_DMG_AIR_RIGHT_GETUP, &var_r30->mRightRiseAnm); setFaceBasicTexture(FTANM_UNK_93); - field_0x3478 = var_r30->field_0x3C.mCancelFrame; + field_0x3478 = var_r30->mRightRiseAnm.mCancelFrame; field_0x347c = 11.0f; field_0x3484 = 13.0f; } else { - setSingleAnimeWolfParam(WANM_DMG_AIR_FRONT_GETUP, &var_r30->field_0x0); + setSingleAnimeWolfParam(WANM_DMG_AIR_FRONT_GETUP, &var_r30->mFrontRiseAnm); setFaceBasicTexture(FTANM_UNK_92); - field_0x3478 = var_r30->field_0x0.mCancelFrame; + field_0x3478 = var_r30->mFrontRiseAnm.mCancelFrame; field_0x347c = 9.0f; field_0x3484 = 13.0f; } @@ -6018,7 +6018,7 @@ int daAlink_c::procWolfLargeDamageUp() { if (checkNoResetFlg2(FLG2_PRESSED_DAMAGE)) { return 1; } - temp_r29->setRate(daAlinkHIO_wlDamLarge_c0::m.field_0x0.mSpeed); + temp_r29->setRate(daAlinkHIO_wlDamLarge_c0::m.mFrontRiseAnm.mSpeed); } if (mProcVar0.field_0x3008 > 0) { @@ -6026,7 +6026,7 @@ int daAlink_c::procWolfLargeDamageUp() { if (mProcVar0.field_0x3008 == 0) { mProcVar0.field_0x3008 = -1; - temp_r29->setRate(daAlinkHIO_wlDamage_c0::m.field_0x28); + temp_r29->setRate(daAlinkHIO_wlDamage_c0::m.mReturnWakeupAnmSpeed); temp_r29->offEndFlg(); } } else { @@ -6072,12 +6072,12 @@ int daAlink_c::procWolfLandDamageInit(int param_0) { setLandDamagePoint(8); } - var_f31 = daAlinkHIO_wlDamFall_c0::m.field_0x0.mStartFrame; + var_f31 = daAlinkHIO_wlDamFall_c0::m.mLandingAnm.mStartFrame; mProcVar0.field_0x3008 = daAlinkHIO_damFall_c0::m.mBigStopTime; dComIfGp_getVibration().StartShock(5, 31, cXyz(0.0f, 1.0f, 0.0f)); } else { - var_f31 = daAlinkHIO_wlDamFall_c0::m.field_0x34; - mProcVar0.field_0x3008 = daAlinkHIO_wlDamFall_c0::m.field_0x28; + var_f31 = daAlinkHIO_wlDamFall_c0::m.mSmallDamageLandingStartFrame; + mProcVar0.field_0x3008 = daAlinkHIO_wlDamFall_c0::m.mSmallStopTime; if (param_0 == 1) { if (!checkEventRun()) { @@ -6098,9 +6098,9 @@ int daAlink_c::procWolfLandDamageInit(int param_0) { voiceStart(Z2SE_WL_V_LAND_DAMAGE); } - setSingleAnimeWolf(WANM_FALL_LAND, daAlinkHIO_wlDamFall_c0::m.field_0x0.mSpeed, var_f31, - daAlinkHIO_wlDamFall_c0::m.field_0x0.mEndFrame, - daAlinkHIO_wlDamFall_c0::m.field_0x0.mInterpolation); + setSingleAnimeWolf(WANM_FALL_LAND, daAlinkHIO_wlDamFall_c0::m.mLandingAnm.mSpeed, var_f31, + daAlinkHIO_wlDamFall_c0::m.mLandingAnm.mEndFrame, + daAlinkHIO_wlDamFall_c0::m.mLandingAnm.mInterpolation); setFaceBasicTexture(FTANM_UNK_95); field_0x3198 = 0; field_0x2f9d = 4; @@ -6115,14 +6115,14 @@ int daAlink_c::procWolfLandDamage() { if (field_0x3198 != 0) { if (frameCtrl->checkAnmEnd()) { checkNextActionWolf(0); - } else if (frameCtrl->getFrame() > daAlinkHIO_wlDamFall_c0::m.field_0x14.mCancelFrame) { + } else if (frameCtrl->getFrame() > daAlinkHIO_wlDamFall_c0::m.mRightRiseAnm.mCancelFrame) { checkNextActionWolf(1); } } else if (frameCtrl->checkAnmEnd()) { if (mProcVar0.field_0x3008 > 0) { mProcVar0.field_0x3008--; } else { - setSingleAnimeWolfParam(WANM_FALL_LAND_START, &daAlinkHIO_wlDamFall_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_FALL_LAND_START, &daAlinkHIO_wlDamFall_c0::m.mRightRiseAnm); setFaceBasicTexture(FTANM_UNK_96); field_0x3198 = 1; } @@ -6147,8 +6147,8 @@ int daAlink_c::procWolfScreamWaitInit() { if (checkEndResetFlg1(ERFLG1_UNK_2)) { setWolfScreamWaitAnime(); } else { - setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMoveNoP_c0::m.field_0x14, - daAlinkHIO_wlMove_c0::m.field_0xBC); + setSingleAnimeWolfBaseSpeed(WANM_WAIT, daAlinkHIO_wlMoveNoP_c0::m.mIdleAnmSpeed, + daAlinkHIO_wlMove_c0::m.mIdleInterpolation); mProcVar2.field_0x300c = 0; } @@ -6169,15 +6169,15 @@ int daAlink_c::procWolfScreamWait() { if (frameCtrl->checkAnmEnd()) { checkNextActionWolf(0); - } else if (frameCtrl->getFrame() > daAlinkHIO_wlDamLarge_c0::m.field_0x0.mCancelFrame) { + } else if (frameCtrl->getFrame() > daAlinkHIO_wlDamLarge_c0::m.mFrontRiseAnm.mCancelFrame) { checkNextActionWolf(1); } } else { mProcVar3.field_0x300e = 1; setSingleAnimeWolf(WANM_DMG_AIR_FRONT_GETUP, - daAlinkHIO_wlDamLarge_c0::m.field_0x0.mSpeed, 20.0f, - daAlinkHIO_wlDamLarge_c0::m.field_0x0.mEndFrame, - daAlinkHIO_wlDamLarge_c0::m.field_0x0.mInterpolation); + daAlinkHIO_wlDamLarge_c0::m.mFrontRiseAnm.mSpeed, 20.0f, + daAlinkHIO_wlDamLarge_c0::m.mFrontRiseAnm.mEndFrame, + daAlinkHIO_wlDamLarge_c0::m.mFrontRiseAnm.mInterpolation); field_0x2f99 = 13; } } else if (mProcVar2.field_0x300c == 0 && checkEndResetFlg1(ERFLG1_UNK_2)) { @@ -6193,8 +6193,8 @@ f32 daAlink_c::getWolfLieMoveAnmSpeed() { return getAnmSpeedStickRate(0.5f, 2.0f); } - return getAnmSpeedStickRate(daAlinkHIO_wlLie_c0::m.field_0x3C, - daAlinkHIO_wlLie_c0::m.field_0x38); + return getAnmSpeedStickRate(daAlinkHIO_wlLie_c0::m.mProneMinAnmSpeed, + daAlinkHIO_wlLie_c0::m.mProneMaxAnmSpeed); } /* 8013712C-801371A0 131A6C 0074+00 3/3 0/0 0/0 .text getWolfLieMoveSpeed__9daAlink_cFv @@ -6209,7 +6209,7 @@ f32 daAlink_c::getWolfLieMoveSpeed() { var_f1 = frameCtrl_p->getFrame(); } - return daAlinkHIO_wlLie_c0::m.field_0x34 * frameCtrl_p->getRate() * + return daAlinkHIO_wlLie_c0::m.mProneMoveRate * frameCtrl_p->getRate() * cM_fsin(var_f1 * 0.20943952f); } @@ -6242,7 +6242,7 @@ BOOL daAlink_c::checkWolfLieContinue(int param_0) { int daAlink_c::checkNextActionWolfFromLie() { if (checkNextActionWolf(0)) { if (field_0x2f8c == 1 || field_0x2f8c == 2 || field_0x2f8c == 3) { - field_0x2060->initOldFrameMorf(daAlinkHIO_wlLie_c0::m.field_0x30, 0, 40); + field_0x2060->initOldFrameMorf(daAlinkHIO_wlLie_c0::m.mStandUpInterp, 0, 40); } return true; } @@ -6281,7 +6281,7 @@ bool daAlink_c::checkWolfLieCode() { int daAlink_c::procWolfLieStartInit(int param_0) { commonProcInit(PROC_WOLF_LIE_START); field_0x3588 = l_wolfBaseAnime; - setSingleAnimeWolfParam(WANM_CROUCH, &daAlinkHIO_wlLie_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_CROUCH, &daAlinkHIO_wlLie_c0::m.mProneStartAnm); if (param_0) { shape_angle.y = field_0x306e + 0x8000; @@ -6313,7 +6313,7 @@ int daAlink_c::procWolfLieStart() { checkNextActionWolfFromLie(); } else if (checkInputOnR() && (checkAnmEnd(frameCtrl_p) || - frameCtrl_p->getFrame() > daAlinkHIO_wlLie_c0::m.field_0x14.mCancelFrame)) + frameCtrl_p->getFrame() > daAlinkHIO_wlLie_c0::m.mProneStartAnm.mCancelFrame)) { procWolfLieMoveInit(0); } else { @@ -6363,7 +6363,7 @@ int daAlink_c::procWolfLieMoveInit(int param_0) { } current.angle.y = shape_angle.y; - setSingleAnimeWolfBaseSpeed(WANM_CROUCH_WALK, anm_speed, daAlinkHIO_wlLie_c0::m.field_0x40); + setSingleAnimeWolfBaseSpeed(WANM_CROUCH_WALK, anm_speed, daAlinkHIO_wlLie_c0::m.mProneMoveInterp); } field_0x3198 = var_r29 ^ 1; @@ -6474,7 +6474,7 @@ int daAlink_c::procWolfLieMove() { spA = field_0x2fe2 + 0x8000; } - cLib_addCalcAngleS(&shape_angle.y, spA, daAlinkHIO_wlLie_c0::m.field_0x28, daAlinkHIO_wlLie_c0::m.field_0x2A, daAlinkHIO_wlLie_c0::m.field_0x2C); + cLib_addCalcAngleS(&shape_angle.y, spA, daAlinkHIO_wlLie_c0::m.mProneTurnRate, daAlinkHIO_wlLie_c0::m.mProneTurnMax, daAlinkHIO_wlLie_c0::m.mProneTurnMin); } mNormalSpeed = getWolfLieMoveSpeed(); @@ -6620,16 +6620,16 @@ int daAlink_c::procWolfLieAutoMove() { /* 80138000-80138188 132940 0188+00 2/2 0/0 0/0 .text setSpeedAndAngleSwimWolf__9daAlink_cFv */ void daAlink_c::setSpeedAndAngleSwimWolf() { if (checkWolfDashMode()) { - field_0x594 = daAlinkHIO_wlSwim_c0::m.field_0x50; + field_0x594 = daAlinkHIO_wlSwim_c0::m.mMaxSpeed; } else { - field_0x594 = daAlinkHIO_wlSwim_c0::m.field_0x80; + field_0x594 = daAlinkHIO_wlSwim_c0::m.mMaxSpeedWeak; } f32 var_f31; if (checkInputOnR()) { s16 prev_angle = current.angle.y; - cLib_addCalcAngleS(¤t.angle.y, field_0x2fe2, daAlinkHIO_wlSwim_c0::m.field_0x3C, - daAlinkHIO_wlSwim_c0::m.field_0x40, daAlinkHIO_wlSwim_c0::m.field_0x3E); + cLib_addCalcAngleS(¤t.angle.y, field_0x2fe2, daAlinkHIO_wlSwim_c0::m.mTurnRate, + daAlinkHIO_wlSwim_c0::m.mTurnMax, daAlinkHIO_wlSwim_c0::m.mTurnMin); var_f31 = field_0x33a8 * 3.0f * cM_scos(current.angle.y - prev_angle); shape_angle.y = current.angle.y; @@ -6645,15 +6645,15 @@ void daAlink_c::setSpeedAndAngleSwimWolf() { if (mTargetedActor != NULL) { setShapeAngleToAtnActor(0); } else { - cLib_addCalcAngleS(&shape_angle.y, field_0x2fe4, daAlinkHIO_wlSwim_c0::m.field_0x42, - daAlinkHIO_wlSwim_c0::m.field_0x46, - daAlinkHIO_wlSwim_c0::m.field_0x44); + cLib_addCalcAngleS(&shape_angle.y, field_0x2fe4, daAlinkHIO_wlSwim_c0::m.mIdleTurnRate, + daAlinkHIO_wlSwim_c0::m.mIdleTurnMax, + daAlinkHIO_wlSwim_c0::m.mIdleTurnMin); } current.angle.y = shape_angle.y; } - setNormalSpeedF(var_f31, daAlinkHIO_wlSwim_c0::m.field_0x54); + setNormalSpeedF(var_f31, daAlinkHIO_wlSwim_c0::m.mDeceleration); if (dComIfGp_checkPlayerStatus0(0, 0x10)) { mNormalSpeed = 0.0f; @@ -6669,12 +6669,12 @@ f32 daAlink_c::getWolfSwimMoveAnmSpeed() { if (checkWolfDashMode()) { anm_speed = - daAlinkHIO_wlSwim_c0::m.field_0x70 + - anm_speed * (daAlinkHIO_wlSwim_c0::m.field_0x74 - daAlinkHIO_wlSwim_c0::m.field_0x70); + daAlinkHIO_wlSwim_c0::m.mMoveMinAnmSpeed + + anm_speed * (daAlinkHIO_wlSwim_c0::m.mMoveMaxAnmSpeed - daAlinkHIO_wlSwim_c0::m.mMoveMinAnmSpeed); } else { anm_speed = - daAlinkHIO_wlSwim_c0::m.field_0x8C + - anm_speed * (daAlinkHIO_wlSwim_c0::m.field_0x90 - daAlinkHIO_wlSwim_c0::m.field_0x8C); + daAlinkHIO_wlSwim_c0::m.mMoveMinAnmSpeedWeak + + anm_speed * (daAlinkHIO_wlSwim_c0::m.mMoveMaxAnmSpeedWeak - daAlinkHIO_wlSwim_c0::m.mMoveMinAnmSpeedWeak); } return anm_speed; @@ -6703,14 +6703,14 @@ int daAlink_c::decideDoStatusSwimWolf() { onNoResetFlg1(FLG1_DASH_MODE); if (field_0x2fc7 == 1 || field_0x2fc7 == 3) { - field_0x30d0 = daAlinkHIO_wlMove_c0::m.field_0x5A; + field_0x30d0 = daAlinkHIO_wlMove_c0::m.mADashDurationSlow; } else if (field_0x2fc7 == 2) { - field_0x30d0 = daAlinkHIO_wlMove_c0::m.field_0x5E; + field_0x30d0 = daAlinkHIO_wlMove_c0::m.mADashDurationSlow2; } else { - field_0x30d0 = daAlinkHIO_wlMove_c0::m.field_0x56; + field_0x30d0 = daAlinkHIO_wlMove_c0::m.mADashDuration; } - setSingleAnimeWolfParam(WANM_SWIM_DASH, &daAlinkHIO_wlSwim_c0::m.field_0x28); + setSingleAnimeWolfParam(WANM_SWIM_DASH, &daAlinkHIO_wlSwim_c0::m.mDashAnm); } } @@ -6731,7 +6731,7 @@ int daAlink_c::procWolfSwimUpInit() { onNoResetFlg0(FLG0_SWIM_UP); mZ2Link.setInWater(false); - setSingleAnimeWolfParam(WANM_SWIM_RESURFACE, &daAlinkHIO_wlSwim_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_SWIM_RESURFACE, &daAlinkHIO_wlSwim_c0::m.mSurfacingAnm); setFaceBasicTexture(FTANM_UNK_8E); dComIfGp_setPlayerStatus0(0, 0x100000); seStartMapInfo(Z2SE_WL_OUTOF_WATER); @@ -6742,12 +6742,12 @@ int daAlink_c::procWolfSwimUpInit() { /* 80138484-8013852C 132DC4 00A8+00 1/0 0/0 0/0 .text procWolfSwimUp__9daAlink_cFv */ int daAlink_c::procWolfSwimUp() { daPy_frameCtrl_c* frameCtrl = mUnderFrameCtrl; - setNormalSpeedF(0.0f, daAlinkHIO_wlSwim_c0::m.field_0x54); + setNormalSpeedF(0.0f, daAlinkHIO_wlSwim_c0::m.mDeceleration); if (frameCtrl->checkAnmEnd()) { procWolfSwimWaitInit(0); } else if (checkInputOnR() && - frameCtrl->getFrame() > daAlinkHIO_wlSwim_c0::m.field_0x0.mCancelFrame) + frameCtrl->getFrame() > daAlinkHIO_wlSwim_c0::m.mSurfacingAnm.mCancelFrame) { procWolfSwimMoveInit(); } else { @@ -6764,7 +6764,7 @@ int daAlink_c::procWolfSwimWaitInit(int param_0) { if (mProcID == PROC_WOLF_SWIM_UP) { morf = 0.0f; } else { - morf = daAlinkHIO_wlSwim_c0::m.field_0x68; + morf = daAlinkHIO_wlSwim_c0::m.mIdleInterp; } commonProcInit(PROC_WOLF_SWIM_WAIT); @@ -6779,9 +6779,9 @@ int daAlink_c::procWolfSwimWaitInit(int param_0) { f32 anm_speed; if (checkWolfDashMode()) { - anm_speed = daAlinkHIO_wlSwim_c0::m.field_0x64; + anm_speed = daAlinkHIO_wlSwim_c0::m.mIdleAnmSpeed; } else { - anm_speed = daAlinkHIO_wlSwim_c0::m.field_0x88; + anm_speed = daAlinkHIO_wlSwim_c0::m.mIdleAnmSpeedWeak; } setSingleAnimeWolfBaseSpeed(WANM_SWIM_WAIT, anm_speed, morf); @@ -6807,9 +6807,9 @@ int daAlink_c::procWolfSwimWait() { setSwimUpDownOffset(); if (checkWolfDashMode()) { - mUnderFrameCtrl[0].setRate(daAlinkHIO_wlSwim_c0::m.field_0x64); + mUnderFrameCtrl[0].setRate(daAlinkHIO_wlSwim_c0::m.mIdleAnmSpeed); } else { - mUnderFrameCtrl[0].setRate(daAlinkHIO_wlSwim_c0::m.field_0x88); + mUnderFrameCtrl[0].setRate(daAlinkHIO_wlSwim_c0::m.mIdleAnmSpeedWeak); } if (checkSwimUpAction()) { @@ -6832,7 +6832,7 @@ int daAlink_c::procWolfSwimWait() { int daAlink_c::procWolfSwimMoveInit() { commonProcInit(PROC_WOLF_SWIM_MOVE); setSingleAnimeWolfBaseSpeed(WANM_SWIM, getWolfSwimMoveAnmSpeed(), - daAlinkHIO_wlSwim_c0::m.field_0x78); + daAlinkHIO_wlSwim_c0::m.mMoveInterp); if (checkNoResetFlg0(FLG0_SWIM_UP)) { current.pos.y = mWaterY; @@ -6861,14 +6861,14 @@ int daAlink_c::procWolfSwimMove() { if (checkAnmEnd(mUnderFrameCtrl) && checkWolfSwimDashAnime()) { setSingleAnimeWolfBaseSpeed(WANM_SWIM, getWolfSwimMoveAnmSpeed(), - daAlinkHIO_wlSwim_c0::m.field_0x78); + daAlinkHIO_wlSwim_c0::m.mMoveInterp); if (field_0x2fc7 == 1 || field_0x2fc7 == 3) { - field_0x30d2 = daAlinkHIO_wlMove_c0::m.field_0x5C; + field_0x30d2 = daAlinkHIO_wlMove_c0::m.mADashCooldownTimeSlow; } else if (field_0x2fc7 == 2) { - field_0x30d2 = daAlinkHIO_wlMove_c0::m.field_0x60; + field_0x30d2 = daAlinkHIO_wlMove_c0::m.mADashCooldownTimeSlow2; } else { - field_0x30d2 = daAlinkHIO_wlMove_c0::m.field_0x58; + field_0x30d2 = daAlinkHIO_wlMove_c0::m.mADashCooldownTime; } } @@ -6887,7 +6887,7 @@ int daAlink_c::procWolfSwimMove() { /* 8013890C-80138A18 13324C 010C+00 2/2 0/0 0/0 .text procWolfSwimEndWaitInit__9daAlink_cFi */ int daAlink_c::procWolfSwimEndWaitInit(int param_0) { commonProcInit(PROC_WOLF_SWIM_END_WAIT); - setSingleAnimeWolfParam(WANM_WAIT_SHAKE, &daAlinkHIO_wlSwim_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_WAIT_SHAKE, &daAlinkHIO_wlSwim_c0::m.mWaterSplashIdleAnm); setFaceBasicTexture(FTANM_UNK_8F); mDoMtx_multVecZero(mpLinkModel->getAnmMtx(3), &field_0x37c8); @@ -6937,7 +6937,7 @@ int daAlink_c::procWolfSwimEndWait() { if (checkAnmEnd(frameCtrl_p)) { checkNextActionWolf(0); - } else if (frameCtrl_p->getFrame() > daAlinkHIO_wlSwim_c0::m.field_0x14.mCancelFrame) { + } else if (frameCtrl_p->getFrame() > daAlinkHIO_wlSwim_c0::m.mWaterSplashIdleAnm.mCancelFrame) { checkNextActionWolf(1); } @@ -7007,7 +7007,7 @@ void daAlink_c::setWolfLockDomeModel() { mEquipItem = 0x109; mItemVar0.field_0x3018 = 0; - mSearchBallScale = daAlinkHIO_wlAtLock_c0::m.field_0x28.mSpeed; + mSearchBallScale = daAlinkHIO_wlAtLock_c0::m.mStartRadius; dComIfGp_setPlayerStatus1(0, 0x800000); seStartOnlyReverb(Z2SE_MIDNA_BIND_AREA_OPEN); @@ -7214,7 +7214,7 @@ BOOL daAlink_c::checkWolfAttackAction() { * setWolfEnemyThrowUpperAnime__9daAlink_cFQ29daAlink_c12daAlink_WANMf */ void daAlink_c::setWolfEnemyThrowUpperAnime(daAlink_c::daAlink_WANM i_anmID, f32 param_1) { setUpperAnime(i_anmID == WANM_FLING_LEFT ? (u16)0x2BD : (u16)0x2BE, UPPER_2, - daAlinkHIO_wlAtBite_c0::m.field_0x2C, param_1, -1, -1.0f); + daAlinkHIO_wlAtBite_c0::m.mEnemyBiteThrowAnmSpeed, param_1, -1, -1.0f); } /* 80139600-801396F8 133F40 00F8+00 2/2 0/0 0/0 .text @@ -7287,7 +7287,7 @@ int daAlink_c::procWolfRollAttackCharge() { } else if (field_0x2060->getOldFrameRate() < 0.1f) { procWolfRollAttackMoveInit(); } else { - cLib_chaseF(&mNormalSpeed, 0.0f, daAlinkHIO_wlMoveNoP_c0::m.field_0x10); + cLib_chaseF(&mNormalSpeed, 0.0f, daAlinkHIO_wlMoveNoP_c0::m.mDeceleration); setShapeAngleToAtnActor(0); current.angle.y = shape_angle.y; voiceStartLevel(Z2SE_WL_V_ROAR); @@ -7303,8 +7303,8 @@ int daAlink_c::procWolfRollAttackMoveInit() { onModeFlg(1); } - mProcVar0.field_0x3008 = daAlinkHIO_wlAttack_c0::m.mUnkTime; - mProcVar1.field_0x300a = daAlinkHIO_wlAtLock_c0::m.field_0x28.mEndFrame; + mProcVar0.field_0x3008 = daAlinkHIO_wlAttack_c0::m.mChargeTime; + mProcVar1.field_0x300a = daAlinkHIO_wlAtLock_c0::m.mAutoActivationTime; mProcVar5.field_0x3012 = 30; field_0x3198 = 0; field_0x2fe4 = shape_angle.y; @@ -7352,9 +7352,9 @@ int daAlink_c::procWolfRollAttackMove() { seStartOnlyReverbLevel(Z2SE_MIDNA_BIND_AREA_SUS); mProcVar1.field_0x300a--; - if (mSearchBallScale < daAlinkHIO_wlAtLock_c0::m.field_0x28.mStartFrame && - cLib_chaseF(&mSearchBallScale, daAlinkHIO_wlAtLock_c0::m.field_0x28.mStartFrame, - daAlinkHIO_wlAtLock_c0::m.field_0x28.mInterpolation)) + if (mSearchBallScale < daAlinkHIO_wlAtLock_c0::m.mMaxRadius && + cLib_chaseF(&mSearchBallScale, daAlinkHIO_wlAtLock_c0::m.mMaxRadius, + daAlinkHIO_wlAtLock_c0::m.mRadiusAcceleration)) { mItemVar0.field_0x3018 = 1; } @@ -7437,20 +7437,20 @@ int daAlink_c::procWolfJumpAttackInit(int param_0) { if (param_0 == 1) { setCutType(0x39); - setCylAtParam(0x80000000, dCcG_At_Spl_UNK_1, 3, 4, 3, daAlinkHIO_wlAtCjump_c0::m.field_0x4C, daAlinkHIO_wlAtCjump_c0::m.field_0x50); - field_0x594 = daAlinkHIO_wlAtCjump_c0::m.field_0x2C; - var_f26 = daAlinkHIO_wlAtCjump_c0::m.field_0x30; + setCylAtParam(0x80000000, dCcG_At_Spl_UNK_1, 3, 4, 3, daAlinkHIO_wlAtCjump_c0::m.mAttackRadius, daAlinkHIO_wlAtCjump_c0::m.mAttackHeight); + field_0x594 = daAlinkHIO_wlAtCjump_c0::m.mMaxHorizontalSpeed; + var_f26 = daAlinkHIO_wlAtCjump_c0::m.mMaxVerticalSpeed; if (mTargetedActor != NULL) { - var_f31 = daAlinkHIO_wlAtCjump_c0::m.field_0x34; - var_f28 = daAlinkHIO_wlAtCjump_c0::m.field_0x28; + var_f31 = daAlinkHIO_wlAtCjump_c0::m.mMinVerticalSpeed; + var_f28 = daAlinkHIO_wlAtCjump_c0::m.mAttackInitSpeed; } else { var_f31 = 25.0f; var_f28 = 26.0f; } - var_f27 = daAlinkHIO_wlAtCjump_c0::m.field_0x54; - field_0x3438 = daAlinkHIO_wlAtCjump_c0::m.field_0x48; + var_f27 = daAlinkHIO_wlAtCjump_c0::m.mMinHorizontalSpeed; + field_0x3438 = daAlinkHIO_wlAtCjump_c0::m.mAttackRadiusOffset; voiceStart(Z2SE_WL_V_ATTACK_L); seStartOnlyReverb(Z2SE_WOLFATTACK_WIND_SCREW); @@ -7468,28 +7468,28 @@ int daAlink_c::procWolfJumpAttackInit(int param_0) { } else { if (mComboCutCount == 4) { setCutType(0x32); - setCylAtParam(0x80000000, dCcG_At_Spl_UNK_1, 3, 4, 3, daAlinkHIO_wlAtNjump_c0::m.field_0x30, daAlinkHIO_wlAtNjump_c0::m.field_0x34); + setCylAtParam(0x80000000, dCcG_At_Spl_UNK_1, 3, 4, 3, daAlinkHIO_wlAtNjump_c0::m.mAttackRadius, daAlinkHIO_wlAtNjump_c0::m.mAttackHeight); voiceStart(Z2SE_WL_V_ATTACK_L); seStartOnlyReverb(Z2SE_WOLFATTACK_WIND_SCREW); mProcVar5.field_0x3012 = 1; } else { setCutType(0x31); - setCylAtParam(0x80000000, dCcG_At_Spl_UNK_0, 1, 4, 2, daAlinkHIO_wlAtNjump_c0::m.field_0x30, daAlinkHIO_wlAtNjump_c0::m.field_0x34); + setCylAtParam(0x80000000, dCcG_At_Spl_UNK_0, 1, 4, 2, daAlinkHIO_wlAtNjump_c0::m.mAttackRadius, daAlinkHIO_wlAtNjump_c0::m.mAttackHeight); voiceStart(Z2SE_WL_V_ATTACK_S); seStartOnlyReverb(Z2SE_WOLFATTACK_WIND_S); mProcVar5.field_0x3012 = 0; } - field_0x594 = daAlinkHIO_wlAtNjump_c0::m.field_0x18; - var_f27 = daAlinkHIO_wlAtNjump_c0::m.field_0x38; - var_f26 = daAlinkHIO_wlAtNjump_c0::m.field_0x1C; - var_f31 = daAlinkHIO_wlAtNjump_c0::m.field_0x20; - field_0x3438 = daAlinkHIO_wlAtNjump_c0::m.field_0x2C; - var_f28 = daAlinkHIO_wlAtNjump_c0::m.field_0x14; + field_0x594 = daAlinkHIO_wlAtNjump_c0::m.mMaxHorizontalSpeed; + var_f27 = daAlinkHIO_wlAtNjump_c0::m.mMinHorizontalSpeed; + var_f26 = daAlinkHIO_wlAtNjump_c0::m.mMaxVerticalSpeed; + var_f31 = daAlinkHIO_wlAtNjump_c0::m.mMinVerticalSpeed; + field_0x3438 = daAlinkHIO_wlAtNjump_c0::m.mAttackRadiusOffset; + var_f28 = daAlinkHIO_wlAtNjump_c0::m.mAttackInitSpeed; mProcVar4.field_0x3010 = 0; } - setSingleAnimeWolfParam(WANM_ATTACK_A_START, &daAlinkHIO_wlAtNjump_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_ATTACK_A_START, &daAlinkHIO_wlAtNjump_c0::m.mAerialAttackAnm); if (mTargetedActor != NULL) { shape_angle.y = cLib_targetAngleY(¤t.pos, &mTargetedActor->eyePos); @@ -7558,16 +7558,16 @@ int daAlink_c::procWolfJumpAttackInit(int param_0) { int daAlink_c::procWolfJumpAttack() { daPy_frameCtrl_c* frameCtrl_p = mUnderFrameCtrl; - if (mProcVar3.field_0x300e != 0 && mNormalSpeed > daAlinkHIO_wlAtCjump_c0::m.field_0x5C) { - cLib_chaseF(&mNormalSpeed, daAlinkHIO_wlAtCjump_c0::m.field_0x5C, - daAlinkHIO_wlAtCjump_c0::m.field_0x60); + if (mProcVar3.field_0x300e != 0 && mNormalSpeed > daAlinkHIO_wlAtCjump_c0::m.mHitMinSpeed) { + cLib_chaseF(&mNormalSpeed, daAlinkHIO_wlAtCjump_c0::m.mHitMinSpeed, + daAlinkHIO_wlAtCjump_c0::m.mHitDecel); } if (mAtCyl.ChkAtHit()) { field_0x3198 = 1; if (mProcVar4.field_0x3010 != 0 && mProcVar3.field_0x300e == 0) { - mNormalSpeed *= daAlinkHIO_wlAtCjump_c0::m.field_0x58; + mNormalSpeed *= daAlinkHIO_wlAtCjump_c0::m.mHitDecelRate; mProcVar3.field_0x300e = 1; } } @@ -7619,8 +7619,8 @@ int daAlink_c::procWolfJumpAttack() { if (checkAnmEnd(frameCtrl_p)) { if (mProcVar2.field_0x300c == 0) { mProcVar2.field_0x300c = 1; - setSingleAnimeWolfBaseSpeed(WANM_ATTACK_A, daAlinkHIO_wlAtNjump_c0::m.field_0x24, - daAlinkHIO_wlAtNjump_c0::m.field_0x28); + setSingleAnimeWolfBaseSpeed(WANM_ATTACK_A, daAlinkHIO_wlAtNjump_c0::m.mAerialAnmSpeed, + daAlinkHIO_wlAtNjump_c0::m.mAerialInterpolation); onResetFlg0(RFLG0_UNK_2); } else { onResetFlg0(RFLG0_UNK_2); @@ -7639,7 +7639,7 @@ int daAlink_c::procWolfJumpAttack() { /* 8013A7EC-8013A8A0 13512C 00B4+00 2/2 0/0 0/0 .text procWolfJumpAttackKickInit__9daAlink_cFv */ int daAlink_c::procWolfJumpAttackKickInit() { commonProcInit(PROC_WOLF_JUMP_AT_KICK); - setSingleAnimeWolfParam(WANM_JUMP_KICK, &daAlinkHIO_wlAtCjump_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_JUMP_KICK, &daAlinkHIO_wlAtCjump_c0::m.mFlipKickAnm); f32 tmp_0 = 0.0f; speed.y = tmp_0; @@ -7681,15 +7681,15 @@ int daAlink_c::procWolfJumpAttackSlideLandInit(int param_0, int param_1, int par fopAcM_seenActorAngleY(this, mTargetedActor) > 0x5000) || param_2) { - setSingleAnimeWolfParam(WANM_ATTACK_A_END_BACK, &daAlinkHIO_wlAtLand_c0::m.field_0x28); + setSingleAnimeWolfParam(WANM_ATTACK_A_END_BACK, &daAlinkHIO_wlAtLand_c0::m.mBackSlideAnm); mProcVar2.field_0x300c = 1; field_0x3588.set(-l_wolfBaseAnime.x, l_wolfBaseAnime.y, -l_wolfBaseAnime.z); - field_0x3478 = daAlinkHIO_wlAtLand_c0::m.field_0x28.mCancelFrame; + field_0x3478 = daAlinkHIO_wlAtLand_c0::m.mBackSlideAnm.mCancelFrame; } else { - setSingleAnimeWolfParam(WANM_ATTACK_A_END_FRONT, &daAlinkHIO_wlAtLand_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_ATTACK_A_END_FRONT, &daAlinkHIO_wlAtLand_c0::m.mFrontSlideAnm); mProcVar2.field_0x300c = 0; field_0x3588 = l_wolfBaseAnime; - field_0x3478 = daAlinkHIO_wlAtLand_c0::m.field_0x14.mCancelFrame; + field_0x3478 = daAlinkHIO_wlAtLand_c0::m.mFrontSlideAnm.mCancelFrame; } field_0x2f9d = 4; @@ -7716,7 +7716,7 @@ int daAlink_c::procWolfJumpAttackSlideLand() { daPy_frameCtrl_c* frameCtrl_p = mUnderFrameCtrl; field_0x2f99 = 4; - cLib_addCalc(&mNormalSpeed, 0.0f, 0.3f, daAlinkHIO_wlAtLand_c0::m.field_0x3C, 0.5f); + cLib_addCalc(&mNormalSpeed, 0.0f, 0.3f, daAlinkHIO_wlAtLand_c0::m.mSlideDeceleration, 0.5f); if (mProcVar4.field_0x3010 != 0) { setShapeAngleToAtnActor(0); @@ -7756,7 +7756,7 @@ int daAlink_c::procWolfJumpAttackSlideLand() { * procWolfJumpAttackNormalLandInit__9daAlink_cFi */ int daAlink_c::procWolfJumpAttackNormalLandInit(int param_0) { commonProcInit(PROC_WOLF_JUMP_AT_NORMAL_LAND); - setSingleAnimeWolfParam(WANM_ATTACK_A_END, &daAlinkHIO_wlAtLand_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_ATTACK_A_END, &daAlinkHIO_wlAtLand_c0::m.mNormalLandingAnm); setFootEffectProcType(2); field_0x2f9d = 0x18; @@ -7783,13 +7783,13 @@ int daAlink_c::procWolfJumpAttackNormalLand() { daPy_frameCtrl_c* frameCtrl = mUnderFrameCtrl; field_0x2f99 = 4; - cLib_chaseF(&mNormalSpeed, 0.0f, daAlinkHIO_wlMoveNoP_c0::m.field_0x10); + cLib_chaseF(&mNormalSpeed, 0.0f, daAlinkHIO_wlMoveNoP_c0::m.mDeceleration); setComboReserb(); checkCutTurnCharge(); if (frameCtrl->checkAnmEnd()) { checkNextActionWolf(0); - } else if (frameCtrl->getFrame() > daAlinkHIO_wlAtLand_c0::m.field_0x0.mCancelFrame) { + } else if (frameCtrl->getFrame() > daAlinkHIO_wlAtLand_c0::m.mNormalLandingAnm.mCancelFrame) { if (mProcVar2.field_0x300c != 0) { shape_angle.y -= -0x8000; return procWolfJumpAttackInit(3); @@ -7849,21 +7849,21 @@ int daAlink_c::procWolfWaitAttackInit(int i_attackType) { f32 var_f2; if (mComboCutCount == 4) { - setCylAtParam(0x80000000, dCcG_At_Spl_UNK_1, 3, 4, 3, atk_hio->field_0x34, - atk_hio->field_0x38); - field_0x3478 = atk_hio->field_0x0.mCancelFrame; - mProcVar0.field_0x3008 = atk_hio->field_0x14; - var_f2 = atk_hio->field_0x0.mStartFrame; + setCylAtParam(0x80000000, dCcG_At_Spl_UNK_1, 3, 4, 3, atk_hio->mAttackRadius, + atk_hio->mAttackHeight); + field_0x3478 = atk_hio->mAttackAnm.mCancelFrame; + mProcVar0.field_0x3008 = atk_hio->mStopTime; + var_f2 = atk_hio->mAttackAnm.mStartFrame; } else { - setCylAtParam(0x80000000, dCcG_At_Spl_UNK_0, 1, 4, 2, atk_hio->field_0x34, - atk_hio->field_0x38); - field_0x3478 = atk_hio->field_0x28; - mProcVar0.field_0x3008 = atk_hio->field_0x16; - var_f2 = atk_hio->field_0x2C; + setCylAtParam(0x80000000, dCcG_At_Spl_UNK_0, 1, 4, 2, atk_hio->mAttackRadius, + atk_hio->mAttackHeight); + field_0x3478 = atk_hio->mComboMidCF; + mProcVar0.field_0x3008 = atk_hio->mComboMidStopTime; + var_f2 = atk_hio->mComboMidStartF; } - setSingleAnimeWolf(atk_params->m_anmID, atk_hio->field_0x0.mSpeed, var_f2, - atk_hio->field_0x0.mEndFrame, atk_hio->field_0x0.mInterpolation); + setSingleAnimeWolf(atk_params->m_anmID, atk_hio->mAttackAnm.mSpeed, var_f2, + atk_hio->mAttackAnm.mEndFrame, atk_hio->mAttackAnm.mInterpolation); if (mTargetedActor != NULL) { shape_angle.y = cLib_targetAngleY(¤t.pos, &mTargetedActor->eyePos); @@ -7872,11 +7872,11 @@ int daAlink_c::procWolfWaitAttackInit(int i_attackType) { current.angle.y = shape_angle.y; mProcVar5.field_0x3012 = 0; mProcVar1.field_0x300a = 2; - field_0x347c = atk_hio->field_0x20; - field_0x3480 = atk_hio->field_0x24; - field_0x3484 = atk_hio->field_0x1C; - field_0x3488 = atk_hio->field_0x18; - field_0x3438 = atk_hio->field_0x30; + field_0x347c = atk_hio->mAttackJudgmentStartForward; + field_0x3480 = atk_hio->mAttackJudgmentEndForward; + field_0x3484 = atk_hio->mSpeedAddForward; + field_0x3488 = atk_hio->mSpeed; + field_0x3438 = atk_hio->mAttackRadiusOffset; field_0x307e = daAlinkHIO_wlAttack_c0::m.mComboDuration; field_0x3588 = l_wolfBaseAnime; @@ -7896,7 +7896,7 @@ int daAlink_c::procWolfWaitAttack() { daPy_frameCtrl_c* frameCtrl_p = mUnderFrameCtrl; field_0x2f99 = 5; - cLib_chaseF(&mNormalSpeed, 0.0f, daAlinkHIO_wlMoveNoP_c0::m.field_0x10); + cLib_chaseF(&mNormalSpeed, 0.0f, daAlinkHIO_wlMoveNoP_c0::m.mDeceleration); setComboReserb(); checkCutTurnCharge(); @@ -7980,14 +7980,14 @@ int daAlink_c::procWolfRollAttackInit(int param_0, int param_1) { setCutType(CUT_TYPE_WOLF_TURN_LEFT); } - setSingleAnimeWolfParam(anm, &daAlinkHIO_wlAtRoll_c0::m.field_0x0); - field_0x3478 = daAlinkHIO_wlAtRoll_c0::m.field_0x14; + setSingleAnimeWolfParam(anm, &daAlinkHIO_wlAtRoll_c0::m.mAttackAnm); + field_0x3478 = daAlinkHIO_wlAtRoll_c0::m.mAttackRadius; setCylAtParam(0x40000000, dCcG_At_Spl_UNK_1, 3, 4, 3, field_0x3478 * 0.5f, 155.0f); mNormalSpeed = 0.0f; mProcVar3.field_0x300e = param_1; if (param_1 != 0) { - mUnderFrameCtrl[0].setStart(daAlinkHIO_wlAtRoll_c0::m.field_0x1C); + mUnderFrameCtrl[0].setStart(daAlinkHIO_wlAtRoll_c0::m.mSpiderThreadEscapeStartF); } else { seStartOnlyReverb(Z2SE_WOLFATTACK_WIND_L); voiceStart(Z2SE_WL_V_ATTACK_SPIN); @@ -8011,17 +8011,17 @@ int daAlink_c::procWolfRollAttack() { } daPy_frameCtrl_c* frameCtrl_p = mUnderFrameCtrl; - cLib_chaseF(&mNormalSpeed, 0.0f, daAlinkHIO_wlMoveNoP_c0::m.field_0x10); + cLib_chaseF(&mNormalSpeed, 0.0f, daAlinkHIO_wlMoveNoP_c0::m.mDeceleration); if (checkAnmEnd(frameCtrl_p)) { checkNextActionWolf(0); - } else if (frameCtrl_p->getFrame() > daAlinkHIO_wlAtRoll_c0::m.field_0x0.mCancelFrame) { + } else if (frameCtrl_p->getFrame() > daAlinkHIO_wlAtRoll_c0::m.mAttackAnm.mCancelFrame) { checkNextActionWolf(1); } else if (mProcVar3.field_0x300e == 0 && frameCtrl_p->getFrame() >= 4.0f && frameCtrl_p->getFrame() < 13.0f) { if (!checkNoResetFlg0(FLG0_UNK_40)) { - mNormalSpeed = daAlinkHIO_wlAtRoll_c0::m.field_0x18; + mNormalSpeed = daAlinkHIO_wlAtRoll_c0::m.mAttackSpeed; } onResetFlg0(RFLG0_UNK_2); @@ -8034,7 +8034,7 @@ int daAlink_c::procWolfRollAttack() { /* 8013B528-8013B808 135E68 02E0+00 1/1 0/0 0/0 .text procWolfDownAttackInit__9daAlink_cFv */ int daAlink_c::procWolfDownAttackInit() { commonProcInit(PROC_WOLF_DOWN_ATTACK); - setSingleAnimeWolfParam(WANM_ATTACK_POE_START, &daAlinkHIO_wlAtDown_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_ATTACK_POE_START, &daAlinkHIO_wlAtDown_c0::m.mLowStanceAnm); cXyz sp24(static_cast(mTargetedActor)->getDownPos()); sp24.y += 50.0f; @@ -8055,7 +8055,7 @@ int daAlink_c::procWolfDownAttackInit() { var_f1 = 800.0f; } - speed.y = daAlinkHIO_wlAtDown_c0::m.field_0x90; + speed.y = daAlinkHIO_wlAtDown_c0::m.mSideRollMovementWidth; f32 temp_f3 = speed.y + gravity; f32 var_f0 = temp_f3 * temp_f3 + gravity * 2.0f * (sp24.y - current.pos.y); @@ -8087,7 +8087,7 @@ int daAlink_c::procWolfDownAttack() { } } else if (checkAnmEnd(mUnderFrameCtrl)) { if (checkUnderMove0BckNoArcWolf(WANM_ATTACK_POE_START)) { - setSingleAnimeWolfParam(WANM_ATTACK_POE, &daAlinkHIO_wlAtDown_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_ATTACK_POE, &daAlinkHIO_wlAtDown_c0::m.mPushDownAnm); shape_angle.y = current.angle.y; } } else if (checkUnderMove0BckNoArcWolf(WANM_ATTACK_POE_START)) { @@ -8102,7 +8102,7 @@ int daAlink_c::procWolfDownAttack() { int daAlink_c::procWolfDownAtLandInit(fopEn_enemy_c* i_enemy) { commonProcInit(PROC_WOLF_DOWN_AT_LAND); field_0x280c.setData(i_enemy); - setSingleAnimeWolfParam(WANM_ATTACK_POE_END, &daAlinkHIO_wlAtDown_c0::m.field_0x28); + setSingleAnimeWolfParam(WANM_ATTACK_POE_END, &daAlinkHIO_wlAtDown_c0::m.mFrontRollAnm); field_0x2f9d = 4; setFootEffectProcType(2); @@ -8142,7 +8142,7 @@ int daAlink_c::procWolfDownAtLand() { return procWolfBackJumpInit(1); } - setSingleAnimeWolfParam(WANM_PULL_OUT, &daAlinkHIO_wlAtDown_c0::m.field_0x78); + setSingleAnimeWolfParam(WANM_PULL_OUT, &daAlinkHIO_wlAtDown_c0::m.mProneGetUpAnm); dComIfGp_getVibration().StartShock(2, 15, cXyz(0.0f, 1.0f, 0.0f)); } else if (checkUnderMove0BckNoArcWolf(WANM_ATTACK_POE_END) && (frameCtrl_p->checkPass(9.0f) || frameCtrl_p->checkPass(16.0f))) @@ -8156,7 +8156,7 @@ int daAlink_c::procWolfDownAtLand() { /* 8013BC94-8013BD54 1365D4 00C0+00 1/1 0/0 0/0 .text procWolfDownAtMissLandInit__9daAlink_cFv */ int daAlink_c::procWolfDownAtMissLandInit() { commonProcInit(PROC_WOLF_DOWN_AT_MISS_LAND); - setSingleAnimeWolfParam(WANM_ATTACK_POE_MISS, &daAlinkHIO_wlAtDown_c0::m.field_0x64); + setSingleAnimeWolfParam(WANM_ATTACK_POE_MISS, &daAlinkHIO_wlAtDown_c0::m.mRollOverAnm); setFaceBasicTexture(FTANM_UNK_97); mNormalSpeed = 0.0f; @@ -8180,7 +8180,7 @@ int daAlink_c::procWolfDownAtMissLand() { if (frameCtrl->checkAnmEnd()) { checkNextActionWolf(0); - } else if (frameCtrl->getFrame() > daAlinkHIO_wlAtDown_c0::m.field_0x64.mCancelFrame) { + } else if (frameCtrl->getFrame() > daAlinkHIO_wlAtDown_c0::m.mRollOverAnm.mCancelFrame) { checkNextActionWolf(1); } else if (frameCtrl->getFrame() >= 3.0f && frameCtrl->getFrame() < 8.0f) { seStartMapInfoLevel(Z2SE_FN_WOLF_SLIP); @@ -8193,7 +8193,7 @@ int daAlink_c::procWolfDownAtMissLand() { /* 8013BE24-8013C3E4 136764 05C0+00 2/2 0/0 0/0 .text procWolfLockAttackInit__9daAlink_cFi */ int daAlink_c::procWolfLockAttackInit(int param_0) { commonProcInit(PROC_WOLF_LOCK_ATTACK); - setSingleAnimeWolfParam(WANM_ATTACK_A_START, &daAlinkHIO_wlAtNjump_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_ATTACK_A_START, &daAlinkHIO_wlAtNjump_c0::m.mAerialAttackAnm); if (fopAcM_GetName(mWolfLockAcKeep[0].getActor()) == PROC_E_YMB) { mProcVar5.field_0x3012 = 1; @@ -8222,31 +8222,31 @@ int daAlink_c::procWolfLockAttackInit(int param_0) { if (l_eyePosDelta.y < 10.0f) { l_eyePosDelta.y = 10.0f; - } else if (l_eyePosDelta.y > daAlinkHIO_wlAtLock_c0::m.field_0x4C) { - l_eyePosDelta.y = daAlinkHIO_wlAtLock_c0::m.field_0x4C; + } else if (l_eyePosDelta.y > daAlinkHIO_wlAtLock_c0::m.mMaxJumpHeight) { + l_eyePosDelta.y = daAlinkHIO_wlAtLock_c0::m.mMaxJumpHeight; } f32 var_f30 = l_eyePosDelta.absXZ(); - if (var_f30 > daAlinkHIO_wlAtLock_c0::m.field_0x50) { - var_f30 = daAlinkHIO_wlAtLock_c0::m.field_0x50 / var_f30; + if (var_f30 > daAlinkHIO_wlAtLock_c0::m.mMaxJumpDistance) { + var_f30 = daAlinkHIO_wlAtLock_c0::m.mMaxJumpDistance / var_f30; l_eyePosDelta.x *= var_f30; l_eyePosDelta.z *= var_f30; } f32 var_f29 = l_eyePosDelta.abs(); - f32 var_f31 = var_f29 / daAlinkHIO_wlAtLock_c0::m.field_0x28.mCancelFrame; + f32 var_f31 = var_f29 / daAlinkHIO_wlAtLock_c0::m.mAttackSpeed; if (var_f31 < 1.0f) var_f31 = 1.0f; - f32 var_f28 = daAlinkHIO_wlAtLock_c0::m.field_0x28.mCancelFrame / var_f29; + f32 var_f28 = daAlinkHIO_wlAtLock_c0::m.mAttackSpeed / var_f29; mNormalSpeed = var_f28 * l_eyePosDelta.absXZ(); setSpecialGravity((l_eyePosDelta.y * -2.0f) / (var_f31 * var_f31), maxFallSpeed, 0); speed.y = -gravity * var_f31; mProcVar0.field_0x3008 = var_f31; - setCylAtParam(0x8000000, dCcG_At_Spl_UNK_0, 1, 4, 6, daAlinkHIO_wlAtLock_c0::m.field_0x40, - daAlinkHIO_wlAtLock_c0::m.field_0x44); - field_0x3438 = daAlinkHIO_wlAtLock_c0::m.field_0x3C; + setCylAtParam(0x8000000, dCcG_At_Spl_UNK_0, 1, 4, 6, daAlinkHIO_wlAtLock_c0::m.mAttackRadius, + daAlinkHIO_wlAtLock_c0::m.mAttackHeight); + field_0x3438 = daAlinkHIO_wlAtLock_c0::m.mAttackRadiusOffset; setCutType(CUT_TYPE_WOLF_LOCK); voiceStart(Z2SE_WL_V_ATTACK_THRUST); @@ -8283,15 +8283,15 @@ int daAlink_c::procWolfLockAttack() { mProcVar0.field_0x3008--; if (mProcVar0.field_0x3008 == 0) { - setSpecialGravity(daAlinkHIO_wlAtLock_c0::m.field_0x48, maxFallSpeed, 0); + setSpecialGravity(daAlinkHIO_wlAtLock_c0::m.mGravity, maxFallSpeed, 0); } } else if (mNormalSpeed > 30.0f) { cLib_addCalc(&mNormalSpeed, 30.0f, 0.3f, 5.0f, 1.0f); } if (checkAnmEnd(mUnderFrameCtrl) && checkUnderMove0BckNoArcWolf(WANM_ATTACK_A_START)) { - setSingleAnimeWolfBaseSpeed(WANM_ATTACK_A, daAlinkHIO_wlAtNjump_c0::m.field_0x24, - daAlinkHIO_wlAtNjump_c0::m.field_0x28); + setSingleAnimeWolfBaseSpeed(WANM_ATTACK_A, daAlinkHIO_wlAtNjump_c0::m.mAerialAnmSpeed, + daAlinkHIO_wlAtNjump_c0::m.mAerialInterpolation); } if (mLinkAcch.ChkGroundHit() || (mProcVar5.field_0x3012 != 0 && current.pos.y < mWaterY)) { @@ -8302,8 +8302,8 @@ int daAlink_c::procWolfLockAttack() { if (mWolfLockNum != 0) { procWolfLockAttackTurnInit(mProcVar1.field_0x300a); } else { - if (mNormalSpeed > daAlinkHIO_wlAtNjump_c0::m.field_0x18) { - mNormalSpeed = daAlinkHIO_wlAtNjump_c0::m.field_0x18; + if (mNormalSpeed > daAlinkHIO_wlAtNjump_c0::m.mMaxHorizontalSpeed) { + mNormalSpeed = daAlinkHIO_wlAtNjump_c0::m.mMaxHorizontalSpeed; } procWolfJumpAttackSlideLandInit(0, 0, 0); @@ -8324,11 +8324,11 @@ int daAlink_c::procWolfLockAttackTurnInit(int param_0) { if (abs((s16)(cLib_targetAngleY(¤t.pos, &mWolfLockAcKeep[0].getActor()->eyePos) - shape_angle.y)) > 0x4000) { - setSingleAnimeWolfParam(WANM_ATTACK_A_END_BACK, &daAlinkHIO_wlAtLock_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_ATTACK_A_END_BACK, &daAlinkHIO_wlAtLock_c0::m.mRearLandingAnm); mProcVar2.field_0x300c = 1; field_0x3588.set(-l_wolfBaseAnime.x, l_wolfBaseAnime.y, -l_wolfBaseAnime.z); } else { - setSingleAnimeWolfParam(WANM_ATTACK_A_END_FRONT, &daAlinkHIO_wlAtLock_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_ATTACK_A_END_FRONT, &daAlinkHIO_wlAtLock_c0::m.mFrontLandingAnm); mProcVar2.field_0x300c = 0; field_0x3588 = l_wolfBaseAnime; } @@ -8422,7 +8422,7 @@ int daAlink_c::procWolfAttackReverse() { if (checkAnmEnd(frameCtrl_p)) { checkNextActionWolf(0); - } else if (frameCtrl_p->getFrame() > daAlinkHIO_wlAttack_c0::m.mLandAnm.mCancelFrame) { + } else if (frameCtrl_p->getFrame() > daAlinkHIO_wlAttack_c0::m.mJumpBackLandAnm.mCancelFrame) { checkNextActionWolf(1); } } else if ((mLinkAcch.ChkGroundHit() || checkEndResetFlg2(ERFLG2_UNK_100)) && checkModeFlg(2)) { @@ -8431,7 +8431,7 @@ int daAlink_c::procWolfAttackReverse() { } mNormalSpeed = 0.0f; - setSingleAnimeWolfParam(WANM_ATTACK_RECOIL_END, &daAlinkHIO_wlAttack_c0::m.mLandAnm); + setSingleAnimeWolfParam(WANM_ATTACK_RECOIL_END, &daAlinkHIO_wlAttack_c0::m.mJumpBackLandAnm); setFaceBasicTexture(FTANM_UNK_9B); current.angle.y = shape_angle.y; offModeFlg(2); @@ -8461,8 +8461,8 @@ int daAlink_c::procWolfEnemyThrowInit(int param_0) { var_f31 = 3.0f; } - setSingleAnimeWolf(anm, daAlinkHIO_wlAtBite_c0::m.field_0x2C, var_f31, -1, - daAlinkHIO_wlAtBite_c0::m.field_0x30); + setSingleAnimeWolf(anm, daAlinkHIO_wlAtBite_c0::m.mEnemyBiteThrowAnmSpeed, var_f31, -1, + daAlinkHIO_wlAtBite_c0::m.mEnemyBiteThrowInterpolation); setWolfEnemyThrowUpperAnime(anm, var_f31); field_0x3588 = l_wolfBaseAnime; mNormalSpeed = 0.0f; @@ -8483,7 +8483,7 @@ int daAlink_c::procWolfEnemyThrow() { if (frameCtrl->checkAnmEnd()) { checkNextActionWolf(0); - } else if (frameCtrl->getFrame() > daAlinkHIO_wlAtBite_c0::m.field_0x34) { + } else if (frameCtrl->getFrame() > daAlinkHIO_wlAtBite_c0::m.mEnemyBiteThrowCF) { checkNextActionWolf(1); } @@ -8493,7 +8493,7 @@ int daAlink_c::procWolfEnemyThrow() { /* 8013CCF4-8013CDEC 137634 00F8+00 1/1 0/0 0/0 .text procWolfEnemyHangBiteInit__9daAlink_cFv */ int daAlink_c::procWolfEnemyHangBiteInit() { commonProcInit(PROC_WOLF_ENEMY_HANG_BITE); - setSingleAnimeWolfParam(WANM_CATCH_START, &daAlinkHIO_wlAtBite_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_CATCH_START, &daAlinkHIO_wlAtBite_c0::m.mHangingBitePreparationAnm); f32 tmp_0 = 0.0f; mNormalSpeed = tmp_0; @@ -8505,11 +8505,11 @@ int daAlink_c::procWolfEnemyHangBiteInit() { } else { current.angle.y = shape_angle.y; field_0x2f99 = 0x50; - mProcVar0.field_0x3008 = daAlinkHIO_wlAtBite_c0::m.field_0x28; + mProcVar0.field_0x3008 = daAlinkHIO_wlAtBite_c0::m.mBiteAttachTime; mProcVar1.field_0x300a = 0; mProcVar2.field_0x300c = 0; mProcVar3.field_0x300e = 0; - field_0x3478 = daAlinkHIO_wlAtBite_c0::m.field_0x40; + field_0x3478 = daAlinkHIO_wlAtBite_c0::m.mHangingBiteMidAnmSpeedMin; mProcVar4.field_0x3010 = shape_angle.y; voiceStart(Z2SE_WL_V_BITE_ATTACK); dComIfGp_setPlayerStatus1(0, 0x200000); @@ -8534,7 +8534,7 @@ int daAlink_c::procWolfEnemyHangBite() { if (doTrigger()) { mProcVar3.field_0x300e = 1; - mProcVar0.field_0x3008 = daAlinkHIO_wlAtBite_c0::m.field_0x28; + mProcVar0.field_0x3008 = daAlinkHIO_wlAtBite_c0::m.mBiteAttachTime; } else if (mProcVar0.field_0x3008 != 0) { mProcVar0.field_0x3008--; } @@ -8555,11 +8555,11 @@ int daAlink_c::procWolfEnemyHangBite() { } if (doTrigger()) { - cLib_chaseF(&field_0x3478, daAlinkHIO_wlAtBite_c0::m.field_0x48, - daAlinkHIO_wlAtBite_c0::m.field_0x50); + cLib_chaseF(&field_0x3478, daAlinkHIO_wlAtBite_c0::m.mHangingBiteMidAnmSpeedMax, + daAlinkHIO_wlAtBite_c0::m.mHangingBiteMidAnmSpeedAcceleration); } else { - cLib_chaseF(&field_0x3478, daAlinkHIO_wlAtBite_c0::m.field_0x40, - daAlinkHIO_wlAtBite_c0::m.field_0x58); + cLib_chaseF(&field_0x3478, daAlinkHIO_wlAtBite_c0::m.mHangingBiteMidAnmSpeedMin, + daAlinkHIO_wlAtBite_c0::m.mHangingBiteMidAnmSpeedDeceleration); } if (frameCtrl_p->getRate() < 0.1f) { @@ -8611,15 +8611,15 @@ int daAlink_c::procWolfGrabUpInit() { f32 var_f31; if (!fopAcM_CheckCarryType(field_0x27f4, fopAcM_CARRY_ITEM)) { - setSingleAnimeWolfParam(WANM_PICKUP_A, &daAlinkHIO_wlGrab_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_PICKUP_A, &daAlinkHIO_wlGrab_c0::m.mPotGrabAnm); var_f31 = 120.0f; field_0x3478 = 10.0f; - field_0x347c = daAlinkHIO_wlGrab_c0::m.field_0x0.mCancelFrame; + field_0x347c = daAlinkHIO_wlGrab_c0::m.mPotGrabAnm.mCancelFrame; } else { - setSingleAnimeWolfParam(WANM_PICKUP_B, &daAlinkHIO_wlGrab_c0::m.field_0x28); + setSingleAnimeWolfParam(WANM_PICKUP_B, &daAlinkHIO_wlGrab_c0::m.mBoneGrabAnm); var_f31 = 80.0f; field_0x3478 = 7.0f; - field_0x347c = daAlinkHIO_wlGrab_c0::m.field_0x28.mCancelFrame; + field_0x347c = daAlinkHIO_wlGrab_c0::m.mBoneGrabAnm.mCancelFrame; } setGrabItemActor(field_0x27f4); @@ -8696,13 +8696,13 @@ int daAlink_c::procWolfGrabPutInit() { commonProcInit(PROC_WOLF_GRAB_PUT); if (grab_obj) { - setSingleAnimeWolfParam(WANM_PICKUP_A, &daAlinkHIO_wlGrab_c0::m.field_0x14); + setSingleAnimeWolfParam(WANM_PICKUP_A, &daAlinkHIO_wlGrab_c0::m.mPotReleaseAnm); field_0x3478 = 10.0f; - field_0x347c = daAlinkHIO_wlGrab_c0::m.field_0x14.mCancelFrame; + field_0x347c = daAlinkHIO_wlGrab_c0::m.mPotReleaseAnm.mCancelFrame; } else { - setSingleAnimeWolfParam(WANM_PICKUP_B, &daAlinkHIO_wlGrab_c0::m.field_0x3C); + setSingleAnimeWolfParam(WANM_PICKUP_B, &daAlinkHIO_wlGrab_c0::m.mBoneReleaseAnm); field_0x3478 = 7.0f; - field_0x347c = daAlinkHIO_wlGrab_c0::m.field_0x3C.mCancelFrame; + field_0x347c = daAlinkHIO_wlGrab_c0::m.mBoneReleaseAnm.mCancelFrame; } mNormalSpeed = 0.0f; @@ -8756,7 +8756,7 @@ int daAlink_c::procWolfGrabPut() { */ int daAlink_c::procWolfGrabThrowInit() { commonProcInit(PROC_WOLF_GRAB_THROW); - setSingleAnimeWolfParam(WANM_PICKUP_THROW, &daAlinkHIO_wlGrab_c0::m.field_0x50); + setSingleAnimeWolfParam(WANM_PICKUP_THROW, &daAlinkHIO_wlGrab_c0::m.mThrowAnm); current.angle.y = shape_angle.y; return 1; @@ -8766,7 +8766,7 @@ int daAlink_c::procWolfGrabThrowInit() { int daAlink_c::procWolfGrabThrow() { daPy_frameCtrl_c* frameCtrl = mUnderFrameCtrl; - cLib_chaseF(&mNormalSpeed, 0.0f, daAlinkHIO_wlMoveNoP_c0::m.field_0x10); + cLib_chaseF(&mNormalSpeed, 0.0f, daAlinkHIO_wlMoveNoP_c0::m.mDeceleration); setShapeAngleToAtnActor(0); current.angle.y = shape_angle.y; @@ -8776,7 +8776,7 @@ int daAlink_c::procWolfGrabThrow() { if (frameCtrl->checkAnmEnd()) { checkNextActionWolf(0); - } else if (frameCtrl->getFrame() > daAlinkHIO_wlGrab_c0::m.field_0x50.mCancelFrame) { + } else if (frameCtrl->getFrame() > daAlinkHIO_wlGrab_c0::m.mThrowAnm.mCancelFrame) { checkNextActionWolf(1); } @@ -8937,7 +8937,7 @@ int daAlink_c::procWolfChainUpInit() { } commonProcInit(PROC_WOLF_CHAIN_UP); - setSingleAnimeWolfParam(WANM_PICKUP_B, &daAlinkHIO_wlGrab_c0::m.field_0x28); + setSingleAnimeWolfParam(WANM_PICKUP_B, &daAlinkHIO_wlGrab_c0::m.mBoneGrabAnm); mNormalSpeed = 0.0f; return 1; @@ -8950,7 +8950,7 @@ int daAlink_c::procWolfChainUp() { setWallGrabStatus(0x96, 2); if (frameCtrl->checkAnmEnd() || - (checkInputOnR() && frameCtrl->getFrame() > daAlinkHIO_wlGrab_c0::m.field_0x28.mCancelFrame)) + (checkInputOnR() && frameCtrl->getFrame() > daAlinkHIO_wlGrab_c0::m.mBoneGrabAnm.mCancelFrame)) { u8 old_2fa3 = field_0x2fa3; fopAc_ac_c* old_actor = field_0x2844.getActor(); @@ -9069,7 +9069,7 @@ int daAlink_c::procWolfGanonCatch() { int daAlink_c::procWolfChainReadyInit() { commonProcInit(PROC_WOLF_CHAIN_READY); field_0x280c.setData(field_0x27f4); - setSingleAnimeWolfParam(WANM_ATTACK_A_START, &daAlinkHIO_wlAtNjump_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_ATTACK_A_START, &daAlinkHIO_wlAtNjump_c0::m.mAerialAttackAnm); mNormalSpeed = 0.0f; mProcVar2.field_0x300c = 0; mProcVar3.field_0x300e = 0; @@ -9081,7 +9081,7 @@ int daAlink_c::procWolfChainReadyInit() { int daAlink_c::procWolfChainReady() { daObjWchain_c* chain = static_cast(field_0x280c.getActor()); if (chain == NULL || mLinkAcch.ChkWallHit()) { - return procWolfFallInit(2, daAlinkHIO_wlAutoJump_c0::m.field_0x54); + return procWolfFallInit(2, daAlinkHIO_wlAutoJump_c0::m.mNormalFallInterp); } else if (mUnderFrameCtrl[0].getFrame() < 3.0f) { s16 target_angle_y = cLib_targetAngleY(¤t.pos, &chain->getJumpAimPos()); cLib_addCalcAngleS(&shape_angle.y, target_angle_y, 2, 0x2000, 0x800); @@ -9104,7 +9104,7 @@ int daAlink_c::procWolfChainReady() { if (chain->getJumpAimPos().abs2(field_0x34e0) < 10000.0f) { procWolfChainWaitInit(); } else if (mProcVar0.field_0x3008 == 0) { - procWolfFallInit(2, daAlinkHIO_wlAutoJump_c0::m.field_0x54); + procWolfFallInit(2, daAlinkHIO_wlAutoJump_c0::m.mNormalFallInterp); } } return 1; @@ -9115,7 +9115,7 @@ int daAlink_c::procWolfChainReady() { int daAlink_c::procWolfChainWaitInit() { daObjWchain_c* chain = static_cast(field_0x280c.getActor()); commonProcInit(PROC_WOLF_CHAIN_WAIT); - setSingleAnimeWolfParam(WANM_HANDLE_HANG, &daAlinkHIO_wlChain_c0::m.field_0x0); + setSingleAnimeWolfParam(WANM_HANDLE_HANG, &daAlinkHIO_wlChain_c0::m.mLoweringStartAnm); mProcVar1.field_0x300a = 0; chain->onRide(); field_0x2f99 = 0x50; @@ -9123,7 +9123,7 @@ int daAlink_c::procWolfChainWaitInit() { setSpecialGravity(0.0f, maxFallSpeed, 0); speed.y = 0.0f; mProcVar4.field_0x3010 = 0; - mProcVar0.field_0x3008 = daAlinkHIO_wlChain_c0::m.field_0x3C + 20; + mProcVar0.field_0x3008 = daAlinkHIO_wlChain_c0::m.mTensionWaitTime + 20; field_0x3478 = chain->getPullLength(); current.angle.y = shape_angle.y; if (mNormalSpeed > 30.0f) { @@ -9141,18 +9141,18 @@ int daAlink_c::procWolfChainWaitInit() { /* 8013E80C-8013ED44 13914C 0538+00 1/0 0/0 0/0 .text procWolfChainWait__9daAlink_cFv */ int daAlink_c::procWolfChainWait() { daObjWchain_c* chain = static_cast(field_0x280c.getActor()); - if (chain == NULL || mProcVar0.field_0x3008 <= -daAlinkHIO_wlChain_c0::m.field_0x3E) { + if (chain == NULL || mProcVar0.field_0x3008 <= -daAlinkHIO_wlChain_c0::m.mReleaseWaitTime) { mNormalSpeed = field_0x37c8.absXZ(); current.angle.y = field_0x37c8.atan2sX_Z(); onNoResetFlg2(FLG2_UNK_200); - return procWolfFallInit(2, daAlinkHIO_wlWallHang_c0::m.field_0x98); + return procWolfFallInit(2, daAlinkHIO_wlWallHang_c0::m.mHangingFallInterp); } if (mProcVar4.field_0x3010 == 0) { if (mProcVar0.field_0x3008 > 20) { mProcVar0.field_0x3008--; } else { - field_0x3478 += daAlinkHIO_wlChain_c0::m.field_0x50; + field_0x3478 += daAlinkHIO_wlChain_c0::m.mFallSpeed; if (field_0x3478 > chain->getSwitchOffset()) { chain->onNowSwitchFlg(); mProcVar4.field_0x3010 = 1; @@ -9195,12 +9195,12 @@ int daAlink_c::procWolfChainWait() { f32 f1, f2, f3; if (checkInputOnR()) { anm = WANM_HANDLE_HANG_SW; - f1 = daAlinkHIO_wlChain_c0::m.field_0x40; - f2 = daAlinkHIO_wlChain_c0::m.field_0x44; + f1 = daAlinkHIO_wlChain_c0::m.mWaitAnmSpeed; + f2 = daAlinkHIO_wlChain_c0::m.mWaitInterp; } else { anm = WANM_HANDLE_HANG_WAIT; - f1 = daAlinkHIO_wlChain_c0::m.field_0x48; - f2 = daAlinkHIO_wlChain_c0::m.field_0x4C; + f1 = daAlinkHIO_wlChain_c0::m.mSwingAnmSpeed; + f2 = daAlinkHIO_wlChain_c0::m.mSwingInterp; } if (anm != mUnderAnmHeap[0].getIdx()) { if (mProcVar1.field_0x300a == 0) { @@ -9307,7 +9307,7 @@ int daAlink_c::procWolfDigInit() { field_0x3478 = 100.0f; dCam_getBody()->SetTrimTypeForce(3); } else { - var_r26 = daAlinkHIO_wlChain_c0::m.field_0x14.mEndFrame; + var_r26 = daAlinkHIO_wlChain_c0::m.mDigAnm.mEndFrame; field_0x3478 = 66.0f; } @@ -9319,7 +9319,7 @@ int daAlink_c::procWolfDigInit() { var_r26 = 59; } - setSingleAnimeWolf(WANM_DIG, daAlinkHIO_wlChain_c0::m.field_0x14.mSpeed, var_f31, var_r26, daAlinkHIO_wlChain_c0::m.field_0x14.mInterpolation); + setSingleAnimeWolf(WANM_DIG, daAlinkHIO_wlChain_c0::m.mDigAnm.mSpeed, var_f31, var_r26, daAlinkHIO_wlChain_c0::m.mDigAnm.mInterpolation); mNormalSpeed = 0.0f; field_0x3588 = l_wolfBaseAnime; mProcVar3.mDigChangeArea = false; @@ -9384,7 +9384,7 @@ int daAlink_c::procWolfDig() { setWolfDigEffect(); } else if (checkAnmEnd(frame_ctrl)) { if (mProcVar2.mDigType == 1) { - setSingleAnimeWolfParam(WANM_DIG_IN, &daAlinkHIO_wlChain_c0::m.field_0x28); + setSingleAnimeWolfParam(WANM_DIG_IN, &daAlinkHIO_wlChain_c0::m.mDigFallAnm); mProcVar3.mDigChangeArea = true; setWolfDigEffect(); } else { @@ -9573,8 +9573,8 @@ int daAlink_c::procWolfGetSmellInit() { mDemo.setSpecialDemoType(); commonProcInit(PROC_WOLF_GET_SMELL); - setSingleAnimeWolfBaseSpeed(WANM_SMELL, daAlinkHIO_wlChain_c0::m.field_0x54, - daAlinkHIO_wlChain_c0::m.field_0x58); + setSingleAnimeWolfBaseSpeed(WANM_SMELL, daAlinkHIO_wlChain_c0::m.mSniffAnmSpeed, + daAlinkHIO_wlChain_c0::m.mSniffInterp); voiceStartLevel(Z2SE_WL_V_SNIFF); shape_angle.y = fopAcM_searchActorAngleY(this, field_0x27f4); diff --git a/src/d/actor/d_a_npc_bans.cpp b/src/d/actor/d_a_npc_bans.cpp index 3cd351b500a..ba3e17d4646 100644 --- a/src/d/actor/d_a_npc_bans.cpp +++ b/src/d/actor/d_a_npc_bans.cpp @@ -148,7 +148,7 @@ void daNpc_Bans_HIO_c::listenPropertyEvent(const JORPropertyEvent* event) { JORFile jorFile; int len; - switch (reinterpret_cast(event->id)) { + switch ((u32)event->id) { case 0x40000002: if (jorFile.open(6, "", NULL, NULL, NULL)) { memset(buffer, 0, sizeof(buffer)); diff --git a/src/d/actor/d_a_npc_kn.cpp b/src/d/actor/d_a_npc_kn.cpp index ec40934b655..7776d9e57cd 100644 --- a/src/d/actor/d_a_npc_kn.cpp +++ b/src/d/actor/d_a_npc_kn.cpp @@ -96,7 +96,7 @@ void daNpc_Kn_HIO_c::listenPropertyEvent(const JORPropertyEvent* event) { JORFile aJStack_910; int len; - switch (reinterpret_cast(event->id)) { + switch ((u32)event->id) { case 0x40000002: if (aJStack_910.open(6, "すべてのファイル(*.*)\0*.*\0", NULL, NULL, NULL) != 0) { memset(msg_buffer, 0, sizeof(msg_buffer)); diff --git a/src/d/actor/d_a_npc_toby.cpp b/src/d/actor/d_a_npc_toby.cpp index 78582617b64..40aa78f227e 100644 --- a/src/d/actor/d_a_npc_toby.cpp +++ b/src/d/actor/d_a_npc_toby.cpp @@ -77,7 +77,7 @@ void daNpc_Toby_HIO_c::listenPropertyEvent(const JORPropertyEvent* event) { JORFile aJStack_910; int len; - switch (reinterpret_cast(event->id)) { + switch ((u32)event->id) { case 0x40000002: if (aJStack_910.open(6, "すべてのファイル(*.*)\0*.*\0", NULL, NULL, NULL) != 0) { memset(msg_buffer, 0, 2000); diff --git a/src/d/actor/d_a_npc_wrestler.cpp b/src/d/actor/d_a_npc_wrestler.cpp index bfabc14685a..d73cbc78f49 100644 --- a/src/d/actor/d_a_npc_wrestler.cpp +++ b/src/d/actor/d_a_npc_wrestler.cpp @@ -596,7 +596,7 @@ void daNpcWrestler_HIO_c::listenPropertyEvent(const JORPropertyEvent* event) { JORFile aJStack_910; int len; - switch (reinterpret_cast(event->id)) { + switch ((u32)event->id) { case 0x40000002: if (aJStack_910.open(6, "すべてのファイル(*.*)\0*.*\0", NULL, NULL, NULL) != 0) { memset(msg_buffer, 0, 2000); diff --git a/src/d/actor/d_a_npc_yamid.cpp b/src/d/actor/d_a_npc_yamid.cpp index 24f2da52a33..f014b0fb03a 100644 --- a/src/d/actor/d_a_npc_yamid.cpp +++ b/src/d/actor/d_a_npc_yamid.cpp @@ -54,7 +54,7 @@ void daNpc_yamiD_HIO_c::listenPropertyEvent(const JORPropertyEvent* event) { JORFile aJStack_910; int len; - switch (reinterpret_cast(event->id)) { + switch ((u32)event->id) { case 0x40000002: if (aJStack_910.open(6, "すべてのファイル(*.*)\0*.*\0", NULL, NULL, NULL) != 0) { memset(auStack_7e0, 0, 2000); diff --git a/src/d/actor/d_a_npc_zelda.cpp b/src/d/actor/d_a_npc_zelda.cpp index 7f43c10f280..0423b853b16 100644 --- a/src/d/actor/d_a_npc_zelda.cpp +++ b/src/d/actor/d_a_npc_zelda.cpp @@ -84,7 +84,7 @@ void daNpc_Zelda_HIO_c::listenPropertyEvent(const JORPropertyEvent* event) { JORReflexible::listenPropertyEvent(event); JORFile aJStack_910; - switch (reinterpret_cast(event->id)) { + switch ((u32)event->id) { case 0x40000002: if (aJStack_910.open(6, "", NULL, NULL, NULL) != 0) { memset(auStack_7e0, 0, 2000); diff --git a/src/d/actor/d_a_obj_itamato.cpp b/src/d/actor/d_a_obj_itamato.cpp index f228280f990..2c36cd65604 100644 --- a/src/d/actor/d_a_obj_itamato.cpp +++ b/src/d/actor/d_a_obj_itamato.cpp @@ -62,7 +62,7 @@ void daObj_ItaMato_HIO_c::listenPropertyEvent(const JORPropertyEvent* i_event) { JORReflexible::listenPropertyEvent(i_event); JORFile jorFile; - switch (reinterpret_cast(i_event->id)) { + switch ((u32)i_event->id) { case 0x40000002: if (jorFile.open(6, "すべてのファイル(*.*)", NULL, NULL, NULL)) { memset(buffer, 0, sizeof(buffer)); diff --git a/src/d/actor/d_a_obj_pumpkin.cpp b/src/d/actor/d_a_obj_pumpkin.cpp index 70eb6f0c004..eae5cb482ad 100644 --- a/src/d/actor/d_a_obj_pumpkin.cpp +++ b/src/d/actor/d_a_obj_pumpkin.cpp @@ -46,7 +46,7 @@ void daObj_Pumpkin_HIO_c::listenPropertyEvent(const JORPropertyEvent* event) { JORReflexible::listenPropertyEvent(event); JORFile file_handle; int len; - switch (reinterpret_cast(event->id)) { + switch ((u32)event->id) { case 0x40000002: if (file_handle.open(6, "すべてのファイル(*.*)\0*.*\0", NULL, NULL, NULL) != 0) { memset(msg_buffer, 0, 2000);