From 3d87f6b235ec2ad053ded36eda77ea2d9a9755e9 Mon Sep 17 00:00:00 2001 From: theAzack9 Date: Wed, 29 Oct 2025 11:31:57 +0100 Subject: [PATCH 1/9] Rename unk14 and unk20 in J3DModel to align with function names --- .../JSystem/J3D/J3DGraphAnimator/J3DModel.hpp | 10 ++++----- src/JSystem/J3D/J3DGraphAnimator/J3DModel.cpp | 22 +++++++++---------- src/Map/MapMirror.cpp | 2 +- src/Strategic/liveactor.cpp | 2 +- src/System/TargetArrow.cpp | 2 +- 5 files changed, 19 insertions(+), 19 deletions(-) diff --git a/include/JSystem/J3D/J3DGraphAnimator/J3DModel.hpp b/include/JSystem/J3D/J3DGraphAnimator/J3DModel.hpp index 6b5fd6d9..3410a9ec 100644 --- a/include/JSystem/J3D/J3DGraphAnimator/J3DModel.hpp +++ b/include/JSystem/J3D/J3DGraphAnimator/J3DModel.hpp @@ -244,9 +244,9 @@ class J3DModel { J3DSkinDeform* getSkinDeform() { return mSkinDeform; } // TODO: might be wrong - MtxPtr getBaseTRMtx() { return unk20; } - void setBaseTRMtx(Mtx m) { MTXCopy(m, unk20); } - void setBaseScale(const Vec& scale) { unk14 = scale; } + MtxPtr getBaseTRMtx() { return mBaseMtx; } + void setBaseTRMtx(Mtx m) { MTXCopy(m, mBaseMtx); } + void setBaseScale(const Vec& scale) { mBaseScale = scale; } virtual ~J3DModel(); @@ -255,8 +255,8 @@ class J3DModel { /* 0x08 */ u32 unk8; /* 0x0C */ J3DCalcCallBack unkC; char pad1[0x4]; - /* 0x14 */ Vec unk14; - /* 0x20 */ Mtx unk20; + /* 0x14 */ Vec mBaseScale; + /* 0x20 */ Mtx mBaseMtx; /* 0x50 */ u8* mScaleFlagArr; /* 0x54 */ u8* mEvlpScaleFlagArr; /* 0x58 */ Mtx* mNodeMatrices; diff --git a/src/JSystem/J3D/J3DGraphAnimator/J3DModel.cpp b/src/JSystem/J3D/J3DGraphAnimator/J3DModel.cpp index 0ed08d37..c451a3be 100644 --- a/src/JSystem/J3D/J3DGraphAnimator/J3DModel.cpp +++ b/src/JSystem/J3D/J3DGraphAnimator/J3DModel.cpp @@ -473,16 +473,16 @@ J3DModel::~J3DModel() { } void J3DModel::initialize() { - unkC = nullptr; - unk8 = 0; - mModelData = nullptr; - mDeformData = 0; - mSkinDeform = nullptr; - unk14.x = 1.0; - unk14.y = 1.0; - unk14.z = 1.0; + unkC = nullptr; + unk8 = 0; + mModelData = nullptr; + mDeformData = 0; + mSkinDeform = nullptr; + mBaseScale.x = 1.0; + mBaseScale.y = 1.0; + mBaseScale.z = 1.0; - MTXIdentity(unk20); + MTXIdentity(mBaseMtx); mScaleFlagArr = nullptr; mEvlpScaleFlagArr = nullptr; @@ -688,7 +688,7 @@ void J3DModel::update() // TODO: missing unknown virtual calls j3dSys.setCurrentMtxCalc(mModelData->unk14); - mModelData->unk14->init(unk14, unk20); + mModelData->unk14->init(mBaseScale, mBaseMtx); j3dSys.setTexture(mModelData->getTexture()); mModelData->unk14->recursiveCalc(mModelData->mRootNode); @@ -727,7 +727,7 @@ void J3DModel::calc() // TODO: missing unknown virtual calls j3dSys.setCurrentMtxCalc(mModelData->unk14); - mModelData->unk14->init(unk14, unk20); + mModelData->unk14->init(mBaseScale, mBaseMtx); j3dSys.setTexture(mModelData->getTexture()); mModelData->unk14->recursiveCalc(mModelData->mRootNode); diff --git a/src/Map/MapMirror.cpp b/src/Map/MapMirror.cpp index be117801..2b116856 100644 --- a/src/Map/MapMirror.cpp +++ b/src/Map/MapMirror.cpp @@ -91,7 +91,7 @@ static u8 getVertexFormat(const J3DModelData* model_data, GXAttr attr) void TMirrorModel::setPlane() { - MtxPtr mtx = unk4->unk4->unk20; + MtxPtr mtx = unk4->unk4->mBaseMtx; MTXMultVec(mtx, &unkC, &unkC); MTXMultVecSR(mtx, &unk18, &unk18); VECNormalize(&unk18, &unk18); diff --git a/src/Strategic/liveactor.cpp b/src/Strategic/liveactor.cpp index 1eb4426f..6660378e 100644 --- a/src/Strategic/liveactor.cpp +++ b/src/Strategic/liveactor.cpp @@ -431,7 +431,7 @@ MtxPtr TLiveActor::getTakingMtx() if (!mMActor) return nullptr; - return mMActor->unk4->unk20; + return mMActor->unk4->mBaseMtx; } void TLiveActor::initAnmSound() diff --git a/src/System/TargetArrow.cpp b/src/System/TargetArrow.cpp index 8327283f..a766d7f6 100644 --- a/src/System/TargetArrow.cpp +++ b/src/System/TargetArrow.cpp @@ -33,7 +33,7 @@ void TTargetArrow::setPos(const JGeometry::TVec3& pos) if (!unk10) return; - MtxPtr mat = unk10->getModel()->unk20; + MtxPtr mat = unk10->getModel()->mBaseMtx; mat[0][3] = pos.x; mat[1][3] = pos.y; mat[2][3] = pos.z; From 9080e3bd7951dbafea8f2bceed150a79d26da5d9 Mon Sep 17 00:00:00 2001 From: theAzack9 Date: Tue, 2 Dec 2025 20:38:23 +0100 Subject: [PATCH 2/9] Initial work on watergun --- include/Camera/Camera.hpp | 6 +- include/M3DUtil/MActor.hpp | 2 + include/Player/MarioMain.hpp | 55 +- include/Player/NozzleBase.hpp | 131 ++++ include/Player/NozzleDeform.hpp | 23 + include/Player/NozzleTrigger.hpp | 35 + include/Player/Watergun.hpp | 287 ++++++++ include/Player/Yoshi.hpp | 76 ++ include/System/ParamInst.hpp | 20 +- include/gpMarDirector.hpp | 23 + src/Map/BathWaterManager.cpp | 2 +- src/Player/WaterGun.cpp | 1188 ++++++++++++++++++++++++++++++ 12 files changed, 1833 insertions(+), 15 deletions(-) create mode 100644 include/Player/NozzleBase.hpp create mode 100644 include/Player/NozzleDeform.hpp create mode 100644 include/Player/NozzleTrigger.hpp create mode 100644 include/Player/Watergun.hpp create mode 100644 include/Player/Yoshi.hpp create mode 100644 include/gpMarDirector.hpp diff --git a/include/Camera/Camera.hpp b/include/Camera/Camera.hpp index 34c42907..7b5b845b 100644 --- a/include/Camera/Camera.hpp +++ b/include/Camera/Camera.hpp @@ -17,7 +17,7 @@ class CPolarSubCamera : public JDrama::TLookAtCamera { void execSecureView_(s16, Vec*); bool isLButtonCameraSpecifyMode(int) const; void isLButtonCameraInbetween() const; - void isJetCoaster1stCamera() const; + bool isJetCoaster1stCamera() const; void isTalkCameraSpecifyMode(int) const; void isTalkCameraInbetween() const; void isNormalCameraSpecifyMode(int) const; @@ -131,7 +131,9 @@ class CPolarSubCamera : public JDrama::TLookAtCamera { public: /* 0x50 */ int mMode; - /* 0x54 */ char unk54[0x120 - 0x54]; + /* 0x54 */ char unk54[0xA4 - 0x54]; + /* 0xA4 */ s16 unkA4; + /* 0xA6 */ char unkA6[0x120 - 0xA6]; /* 0x120 */ TMarioGamePad* unk120; /* 0x124 */ JGeometry::TVec3 unk124; /* 0x130 */ char unk130[0xC]; diff --git a/include/M3DUtil/MActor.hpp b/include/M3DUtil/MActor.hpp index a503db80..09b58bfd 100644 --- a/include/M3DUtil/MActor.hpp +++ b/include/M3DUtil/MActor.hpp @@ -22,6 +22,8 @@ class MActorAnmBlk; class MActor { public: + enum AnimationType { BCK, BLK, BPK, BTP, BTK, BRK }; + MActor(MActorAnmData*); void setMActorAnmData(MActorAnmData*); diff --git a/include/Player/MarioMain.hpp b/include/Player/MarioMain.hpp index 4b883831..99768ce4 100644 --- a/include/Player/MarioMain.hpp +++ b/include/Player/MarioMain.hpp @@ -6,8 +6,10 @@ #include #include #include +#include class TLiveActor; +class TWaterGun; class TBGCheckData; class J3DAnmTexPattern; class J3DModelData; @@ -17,6 +19,22 @@ struct TBGWallCheckRecord; // TODO: where should this be? enum E_SIDEWALK_TYPE {}; +// TODO: Where should this be? +#define ATTR_IS_ABOVE_SEWER_FLOOR 0x1 +#define ATTR_IS_VISIBLE 0x2 +#define ATTR_IS_NPC_TALKING 0x8 +#define ATTR_IS_RECENT_LEFT_WATER 0x10 +#define ATTR_IS_GAME_OVER 0x400 +#define ATTR_IS_GROUND_POUND_SIT_UP 0x800 +#define ATTR_HAS_HELMET_FLW_CAMERA 0x1000 +#define ATTR_HAS_HELMET 0x2000 +#define ATTR_IS_FLUDD_EMITTING 0x4000 +#define ATTR_HAS_FLUDD 0x8000 +#define ATTR_IS_SHALLOW_WATER 0x10000 +#define ATTR_IS_WATER 0x20000 +#define ATTR_HAS_SHIRT 0x100000 +#define ATTR_IS_PERFORMING 0x200000 + struct TRidingInfo { const TLiveActor* unk0; Vec localPos; @@ -651,7 +669,7 @@ class TMario : public TTakeActor, public TDrawSyncCallback { bool isWearingCap(); void setDivHelm(); void getWallAngle() const; - void getPumpFrame() const; + f32 getPumpFrame() const; void getCenterAnmMtx(); void getRootAnmMtx(); void getHeadRot(); @@ -781,7 +799,7 @@ class TMario : public TTakeActor, public TDrawSyncCallback { void canBendBody(); void considerRotateJumpStart(); void addVelocity(f32); - u32 onYoshi() const; + s32 onYoshi() const; void getGroundJumpPower() const; void windMove(const JGeometry::TVec3&); void flowMove(const JGeometry::TVec3&); @@ -1079,6 +1097,27 @@ class TMario : public TTakeActor, public TDrawSyncCallback { TBGCheckData* getGroundPlane() const { return mGroundPlane; } + // Fabricated + bool hasAttribute(u32 attribute) const + { + bool hasAttribute; + if ((this->mAttributes & attribute) != 0) { + hasAttribute = true; + } else { + hasAttribute = false; + } + return hasAttribute; + } + + // Fabricated + bool fabricatedActionInline() const + { + if (mAction >= 0x168 && 0x16c >= mAction) { + return true; + } + return false; + } + public: /* 0x74 */ u32 mInput; /* 0x78 */ u32 unk78; @@ -1114,7 +1153,7 @@ class TMario : public TTakeActor, public TDrawSyncCallback { /* 0xF6 */ u16 unkF6; /* 0xF8 */ u16 mLightID; - // u16 _0FA; + /* 0xFA */ u16 unk0FA; /* 0xFC */ u32 unkFC[2]; @@ -1122,7 +1161,7 @@ class TMario : public TTakeActor, public TDrawSyncCallback { /* 0x108 */ u32 unk108[4]; - /* 0x118 */ u32 unk118; // gpMarioFlag points here; + /* 0x118 */ u32 mAttributes; /* 0x11C */ u32 unk11C; @@ -1140,18 +1179,18 @@ class TMario : public TTakeActor, public TDrawSyncCallback { /* 0x38A */ char unk38A[0x5A]; - /* 0x3E4 */ void* mWaterGun; // TWaterGun + /* 0x3E4 */ TWaterGun* mWaterGun; // TWaterGun /* 0x3E8 */ u32 unk3E8; /* 0x3EC */ u32 unk3EC; - /* 0x3F0 */ void* mYoshi; // TYoshi 0x3F0 + /* 0x3F0 */ TYoshi* mYoshi; // TYoshi 0x3F0 /* 0x3F4 */ char unk3F4[0x0FC]; /* 0x4F0 */ JGeometry::TVec3 unk4F0; - void* mGamePad; // TMarioGamePad + /* 0x4FC */ TMarioGamePad* mGamePad; // TMarioGamePad /* 0x500 */ char unk500[0x74]; @@ -1248,5 +1287,7 @@ class TMario : public TTakeActor, public TDrawSyncCallback { }; extern TMario* gpMarioOriginal; +extern TMario* gpMarioAddress; +extern TMario* gpMarioForCallBack; #endif diff --git a/include/Player/NozzleBase.hpp b/include/Player/NozzleBase.hpp new file mode 100644 index 00000000..105445ab --- /dev/null +++ b/include/Player/NozzleBase.hpp @@ -0,0 +1,131 @@ +#ifndef NOZZLEBASE_HPP +#define NOZZLEBASE_HPP + +#include +#include +#include + +class TWaterGun; + +class TNozzleBase { +public: + struct TEmitParams : public TParams { + TEmitParams(const char* prm) + : TParams(prm) + , PARAM_INIT(mRocketType, 0) + , PARAM_INIT(mNum, 1.0f) + , PARAM_INIT(mAttack, 1) + , PARAM_INIT(mDirTremble, 0.0099999998) + , PARAM_INIT(mEmitPow, 40.0) + , PARAM_INIT(mEmitCtrl, 1.0f) + , PARAM_INIT(mPowTremble, 1.0f) + , PARAM_INIT(mSize, 40.0f) + , PARAM_INIT(mSizeTremble, 16.0f) + , PARAM_INIT(mAmountMax, 0x834) + , PARAM_INIT(mReactionPow, 0.0f) + , PARAM_INIT(mReactionY, 0.0f) + , PARAM_INIT(mDecRate, 0) + , PARAM_INIT(mTriggerRate, 0x100) + , PARAM_INIT(mDamageLoss, 0xfa) + , PARAM_INIT(mSuckRate, 0.1f) + , PARAM_INIT(mHitRadius, 50.0f) + , PARAM_INIT(mHitHeight, 80.0f) + , PARAM_INIT(mLAngleBase, 0x1000) + , PARAM_INIT(mLAngleNormal, 12000) + , PARAM_INIT(mLAngleSquat, 12000) + , PARAM_INIT(mLAngleMin, -0x2000) + , PARAM_INIT(mLAngleMax, 0x2000) + , PARAM_INIT(mLAngleChase, 0.1f) + , PARAM_INIT(mSizeMinPressure, 0.0f) + , PARAM_INIT(mSizeMaxPressure, 1.0f) + , PARAM_INIT(mNumMin, 1.0f) + , PARAM_INIT(mAttackMin, 1) + , PARAM_INIT(mDirTrembleMin, 0.0099999998) + , PARAM_INIT(mEmitPowMin, 40.0f) + , PARAM_INIT(mSizeMin, 40.0f) + , PARAM_INIT(mMotorPowMin, 5.0f) + , PARAM_INIT(mMotorPowMax, 25.0f) + , PARAM_INIT(mReactionPowMin, 0.0f) + , PARAM_INIT(mInsidePressureDec, 100.0f) + , PARAM_INIT(mInsidePressureMax, 4500.0f) + , PARAM_INIT(mTriggerTime, 1) + , PARAM_INIT(mType, 0) + , PARAM_INIT(mSideAngleMaxSide, 0x4000) + , PARAM_INIT(mSideAngleMaxFront, 0x4000) + , PARAM_INIT(mSideAngleMaxBack, 0x2000) + , PARAM_INIT(mRButtonMult, 10000.0) + , PARAM_INIT(mEmitPowScale, 10.0f) + + { + } + + /* 0x00 */ TParamRT mRocketType; + /* 0x14 */ TParamRT mNum; + /* 0x28 */ TParamRT mAttack; + /* 0x3C */ TParamRT mDirTremble; + /* 0x50 */ TParamRT mEmitPow; + /* 0x64 */ TParamRT mEmitCtrl; + /* 0x78 */ TParamRT mPowTremble; + /* 0x8C */ TParamRT mSize; + /* 0xA0 */ TParamRT mSizeTremble; + /* 0xB4 */ TParamRT mAmountMax; + /* 0xC8 */ TParamRT mReactionPow; + /* 0xDC */ TParamRT mReactionY; + /* 0xF0 */ TParamRT mDecRate; + /* 0x104 */ TParamRT mTriggerRate; + /* 0x118 */ TParamRT mDamageLoss; + /* 0x12C */ TParamRT mSuckRate; + /* 0x140 */ TParamRT mHitRadius; + /* 0x154 */ TParamRT mHitHeight; + /* 0x168 */ TParamRT mLAngleBase; + /* 0x17C */ TParamRT mLAngleNormal; + /* 0x190 */ TParamRT mLAngleSquat; + /* 0x1A4 */ TParamRT mLAngleMin; + /* 0x1B8 */ TParamRT mLAngleMax; + /* 0x1CC */ TParamRT mLAngleChase; + /* 0x1E0 */ TParamRT mSizeMinPressure; + /* 0x1F4 */ TParamRT mSizeMaxPressure; + /* 0x208 */ TParamRT mNumMin; + /* 0x21C */ TParamRT mAttackMin; + /* 0x230 */ TParamRT mDirTrembleMin; + /* 0x244 */ TParamRT mEmitPowMin; + /* 0x258 */ TParamRT mSizeMin; + /* 0x26C */ TParamRT mMotorPowMin; + /* 0x280 */ TParamRT mMotorPowMax; + /* 0x294 */ TParamRT mReactionPowMin; + /* 0x2A8 */ TParamRT mInsidePressureDec; + /* 0x2BC */ TParamRT mInsidePressureMax; + /* 0x2D0 */ TParamRT mTriggerTime; + /* 0x2E4 */ TParamRT mType; + /* 0x2F8 */ TParamRT mSideAngleMaxSide; + /* 0x30C */ TParamRT mSideAngleMaxFront; + /* 0x320 */ TParamRT mSideAngleMaxBack; + /* 0x334 */ TParamRT mRButtonMult; + /* 0x348 */ TParamRT mEmitPowScale; + } mEmitParams; // 0x0000 + + TNozzleBase(const char* name, const char* prm, TWaterGun* fludd); + + virtual void init(); + virtual inline s32 getNozzleKind() const; + virtual inline s16 getGunAngle() { return this->mGunAngle; } + virtual inline s16 getWaistAngle() { return this->mWaistAngle; } + virtual void movement(const TMarioControllerWork&); + virtual void emitCommon(int, TWaterEmitInfo*); + virtual void emit(int); + virtual void animation(int); + + void calcGunAngle(const TMarioControllerWork&); + + /* 0x368 */ TWaterGun* mFludd; + /* 0x36C */ u16 mAnimState; + /* 0x36E */ s16 mGunAngle; + /* 0x370 */ s16 mWaistAngle; + /* 0x372 */ u16 unk372; + /* 0x374 */ f32 unk374; + /* 0x378 */ f32 unk378; + /* 0x37C */ f32 unk37C; + /* 0x380 */ MActor* mActor; +}; // 0x384 + +#endif diff --git a/include/Player/NozzleDeform.hpp b/include/Player/NozzleDeform.hpp new file mode 100644 index 00000000..a020eabb --- /dev/null +++ b/include/Player/NozzleDeform.hpp @@ -0,0 +1,23 @@ +#ifndef NOZZLEDEFORM_HPP +#define NOZZLEDEFORM_HPP + +#include + +class TNozzleDeform : public TNozzleBase { +public: + TNozzleDeform(const char* name, const char* prm, TWaterGun* fludd) + : TNozzleBase(name, prm, fludd) + , mBomb(name, "/Mario/WaterGun/NozzleDeformBomb.prm", fludd) + { + init(); + } + + virtual s32 getNozzleKind() const; /* override */ + virtual void movement(const TMarioControllerWork&); + virtual void emit(int); + virtual void animation(int); + + TNozzleTrigger mBomb; +}; + +#endif diff --git a/include/Player/NozzleTrigger.hpp b/include/Player/NozzleTrigger.hpp new file mode 100644 index 00000000..b452a8ae --- /dev/null +++ b/include/Player/NozzleTrigger.hpp @@ -0,0 +1,35 @@ +#ifndef NOZZLETRIGGER_HPP +#define NOZZLETRIGGER_HPP + +#include + +class TNozzleTrigger : public TNozzleBase { +public: + // Add constructor + TNozzleTrigger(const char* name, const char* prm, TWaterGun* fludd) + : TNozzleBase(name, prm, fludd) + { + mSoundID = 0xffffffff; + mRumbleOnCharge = false; + mSprayState = INACTIVE; + mAnimState = 0; + mSprayQuarterFramesLeft = 0; + mTriggerFill = 0.0f; + } + + virtual void init(); + virtual s32 getNozzleKind() const { return 1; }; + virtual void movement(const void*); + virtual void emit(int); + virtual void animation(int); + + enum SPRAYSTATE { INACTIVE, ACTIVE, DEAD }; + + bool mRumbleOnCharge; // 0x0384 + s8 mSprayState; // 0x0385 + s16 mSprayQuarterFramesLeft; // 0x0386 + f32 mTriggerFill; // 0x0388 + u32 mSoundID; // 0x038C +}; + +#endif diff --git a/include/Player/Watergun.hpp b/include/Player/Watergun.hpp new file mode 100644 index 00000000..a69593ec --- /dev/null +++ b/include/Player/Watergun.hpp @@ -0,0 +1,287 @@ +#ifndef WATERGUN_HPP +#define WATERGUN_HPP + +#include +#include +#include +#include +#include +#include +#include + +class TWaterGunParams : public TParams { +public: + TWaterGunParams(const char* prm) + : TParams(prm) + , PARAM_INIT(mRocketHeight, 1500.0f) + , PARAM_INIT(mHoverHeight, 160.0f) + , PARAM_INIT(mLAngleNormal, 60.0f) + , PARAM_INIT(mNozzleAngleYSpeed, 1.0f) + , PARAM_INIT(mNozzleAngleYBrake, 0.995f) + , PARAM_INIT(mNozzleAngleYSpeedMax, 0x2000) + , PARAM_INIT(mHoverRotMax, 0x2000) + , PARAM_INIT(mHoverSmooth, 0.05f) + , PARAM_INIT(mChangeSpeed, 0.1f) {}; + TParamRT mRocketHeight; + TParamRT mHoverHeight; + TParamRT mLAngleNormal; + TParamRT mNozzleAngleYSpeed; + TParamRT mNozzleAngleYBrake; + TParamRT mNozzleAngleYSpeedMax; + TParamRT mHoverRotMax; + TParamRT mHoverSmooth; + TParamRT mChangeSpeed; +}; + +struct NozzleJointData { + u8 flags; // TODO: This is likely an enum. 0x1 is used, 0x4 is disabled. + u8 jointIndex; +}; + +struct NozzleData { + /* 0x00 */ u32 _00; // Number of water streams emitted by this nozzle + /* 0x04 */ u32 _04; // Unused padding + /* 0x08 */ const char* mHelmetPath; // Path to optional helmet model (used + // by underwater nozzle) + /* 0x0C */ const char* mPath; // Path to base nozzle model directory + /* 0x10 */ const char* mBmdPath; // Full path to nozzle's BMD model file + /* 0x14 */ u8 mNumEmitters; // Number of water emitter points on the nozzle + /* 0x15 */ u8 _15; // Unknown/padding + /* 0x16 */ NozzleJointData mJoints[3]; // Array of joint data for the nozzle +}; + +// Data structure containing model paths and configuration for each FLUDD nozzle +// type +class TNozzleBmdData { +public: + u8 getEmitterCount(int index) const { return mNozzles[index].mNumEmitters; } + + u8 getFlags(int index, int jointIndex) const + { + return mNozzles[index].mJoints[jointIndex].flags; + } + + u8 getJointIndex(int index, int jointIndex) const + { + return mNozzles[index].mJoints[jointIndex].jointIndex; + } + + u8 setJointIndex(int index, int jointIndex, s32 value) + { + return mNozzles[index].mJoints[jointIndex].jointIndex = value; + } + + const char* getPath(int index) const { return mNozzles[index].mPath; } + const char* getBmdPath(int index) const { return mNozzles[index].mBmdPath; } + + NozzleData mNozzles[6]; +}; +// Define the global variable in .data section +extern TNozzleBmdData nozzleBmdData; + +class TWaterGun { +public: + typedef s8 TNozzleType; + enum { Spray = 0, Rocket, Underwater, Yoshi, Hover, Turbo }; + + TWaterGun(TMario* mario); + + virtual void perform(u32, JDrama::TGraphics*); + + void changeBackup(); + void calcAnimation(JDrama::TGraphics*); + void changeNozzle(TNozzleType, bool); + bool damage(); + void emit(); + TNozzleBase* getCurrentNozzle() const; + MtxPtr getEmitMtx(int); + void getEmitPosDirSpeed(int, JGeometry::TVec3* pos, + JGeometry::TVec3* dir, + JGeometry::TVec3* speed); + MtxPtr getNozzleMtx(); + f32 getPressure(); + f32 getPressureMax(); + void init(); + void initInLoadAfter(); + bool isEmitting(); + bool isPressureOn(); + void movement(); + void rotateProp(f32); + void setAmountToRate(f32); + void setBaseTRMtx(Mtx); + bool suck(); + void startDashEffect(); + void endDashEffect(); + void getMarioUpperStatus(); + + inline MtxPtr getYoshiMtx() + { + TYoshi* yoshi = (TYoshi*)this->mMario->mYoshi; + return yoshi->mActor->unk4->getAnmMtx(yoshi->mJoint); + } + + void decWater() { } + + void checkMax() + { + s32 maxWater = this->getCurrentNozzle()->mEmitParams.mAmountMax.get(); + if (this->mCurrentWater > maxWater) { + this->mCurrentWater = maxWater; + } + } + + bool isYoshiNozzle() const { return this->mCurrentNozzle == (s8)Yoshi; } + + bool hasWater() const { return this->mCurrentWater > 0; } + + u32 getWaterGunAnmId(); + + J3DModel* getModel() { return this->mFluddModel->unk4; } + + void setEmitPt(); + + void finalDrawInitialize(); + void entryAll(); + void createGunBody(); + + // Fabricated + // TODO: Probably not in Watergun + void startSound(u32 id, const Vec* pos) + { + MSoundSESystem::MSoundSE::startSoundActor(id, pos, 0, nullptr, 0, 4); + } + + // Fabricated + // TODO: Probably not in Watergun + inline void playSoundWithInfo(u32 id, const Vec* pos, u32 _unk, f32 _unk2) + { + if (gpMSound->gateCheck(id)) { + MSoundSESystem::MSoundSE::startSoundActorWithInfo( + id, pos, nullptr, _unk2, _unk, 0, nullptr, 0, 4); + } + } + + // Fabricated + inline bool hasFlag(u16 flag) + { + bool hasFlag; + if ((this->mFlags & flag) != 0) { + hasFlag = true; + } else { + hasFlag = false; + } + return hasFlag; + } + + // Fabricated + // TODO: Possibly in each nozzle class? + inline void playSprayNozzleSound(u32 id, f32 val) + { + JGeometry::TVec3* emitPos = &mEmitPos[0]; + playSoundWithInfo(id, emitPos, 0, val); + } + + // Fabricated + // TODO: This is definitely not the structure + // Figure out something better for sound funcs + inline void playSound2(u32 id) + { + JGeometry::TVec3* emitPos = &mEmitPos[0]; + trySound(id, emitPos); + } + + s32 getSuckRate() + { + return (s32)((f32)this->mCurrentPressure + * this->getCurrentNozzle()->mEmitParams.mSuckRate.get()); + } + + s32 getCurrentWater() { return this->mCurrentWater; } + s32 getMaxWater() + { + return this->getCurrentNozzle()->mEmitParams.mAmountMax.get(); + } + + bool isMaxWater() { return this->getCurrentWater() >= this->getMaxWater(); } + + void trySound(u32 id, JGeometry::TVec3* pos) + { + MSound* sound = gpMSound; + if (sound->gateCheck(id)) { + this->startSound(id, pos); + } + } + + void incWater(s32 amount) + { + this->mCurrentWater += amount; + + s32 currentWater = this->getCurrentWater(); + s32 maxWater = this->getMaxWater(); + if (currentWater > maxWater) { + mCurrentWater = maxWater; + } + + if (!isMaxWater()) { + JGeometry::TVec3* emitPos = &this->mEmitPos[0]; + trySound(0xf, emitPos); + } + } + + TNozzleBase* getNozzle(u8 index) { return this->mNozzleList[index]; } + + void triggerPressureMovement(const TMarioControllerWork&); + + u16 mFlags; // 0x0000 + TMario* mMario; // 0x0008 + TNozzleDeform mNozzleDeform; // 0x000C + TNozzleTrigger mNozzleRocket; // 0x0720 + TNozzleBase mNozzleUnderWater; // 0x0AB0 + TNozzleDeform mNozzleYoshiDeform; // 0x0E34 + TNozzleTrigger mNozzleHover; // 0x1548 + TNozzleTrigger mNozzleTurbo; // 0x18D8 + TNozzleBase* mNozzleList[6]; // 0x1C68 + s32 mCurrentWater; // 0x1C80 + u8 mCurrentNozzle; // 0x1C84 + u8 mSecondNozzle; // 0x1C85 + bool mIsEmitWater; // 0x1C86 + u8 unk1C87; // 0x1C87 + u32 unk1C88; // 0x1C88 + u8 mCurrentPressure; // 0x1c8c + u8 mPreviousPressure; // 0x1c8d + u8 unk1C8E; // 0x1c8e + u8 unk1C8F; // 0x1c8f + JGeometry::TVec3 mEmitPos[4]; // 0x1C90 + s16 unk1CC0; // 0x1CC0 + s16 unk1CC2; // 0x1CC2 + s16 unk1CC4; // 0x1CC4 + s16 unk1CC6; // 0x1CC6 + f32 mNozzleSpeedY; // 0x1CC8 + f32 mNozzleSpeedZ; // 0x1CCC + s16 unk1CD0; // 0x1CD0 + s16 unk1CD2; // 0x1CD2 + MActor* mFluddModel; // 0x1CD4 // MActor* + u8 mCurFluddTransformIdx; // 0x1CD8 + u8 unk1CD9; // 0x1CD9 + u16 unk1CDA; // 0x1CDA + f32 unk1CDC; // 0x1CDC + f32 unk1CE0; // 0x1CE0 + u32 unk1CE4; // 0x1CE4 + u32 unk1CE8; // 0x1CE8 + f32 unk1CEC; // 0x1CEC + f32 unk1CF0; // 0x1CF0 + f32 unk1CF4; // 0x1CF4 + u16 unk1CF8; // 0x1CF8 + u16 unk1CFA; // 0x1CFA + f32 mFluddSwitchTween; // 0x1CFC + f32 unk1D00; // 0x1D00 + s16 unk1D04; // 0x1D04 + s16 unk1D06; // 0x1D06 + u32 unk1D08; // 0x1D08 + TWaterEmitInfo* mEmitInfo; // 0x1D0C // TWaterEmitInfo + TMirrorActor* unk1D10; // 0x1D10 + + TWaterGunParams mWatergunParams; // 0x1d14 +}; + +#endif diff --git a/include/Player/Yoshi.hpp b/include/Player/Yoshi.hpp new file mode 100644 index 00000000..47eb6894 --- /dev/null +++ b/include/Player/Yoshi.hpp @@ -0,0 +1,76 @@ +#ifndef YOSHI_HPP +#define YOSHI_HPP + +#include +#include +#include + +class TMario; + +class TYoshi { +public: + enum Color { GREEN, ORANGE, PURPLE, PINK }; + enum State { EGG = 0, DROWNING = 3, DYING = 4, UNMOUNTED = 6, MOUNTED = 8 }; + + bool appearFromEgg(const JGeometry::TVec3&); + void calcAnim(); + void changeAnimation(int id); + bool disappear(); + void doEat(u32 fruitID); + void doSearch(); + void entry(); + void getEmitPosDir(JGeometry::TVec3*, JGeometry::TVec3*) const; + J3DFrameCtrl* getFrameCtrl() const; + MtxPtr getMtxPtrFootL() const; + MtxPtr getMtxPtrFootR() const; + void getOff(bool knockedOff); + void init(TMario*); + void initInLoadAfter(); + void kill(); + void movement(); + bool onYoshi(); + void ride(); + void setEggYoshiPtr(void*); // TEggYoshi* + void thinkAnimation(); + void thinkBtp(int); + void thinkHoldOut(); + void thinkUpper(); + void viewCalc(); + + s8 mState; // 0x0000 + u16 mSubState; // 0x0002 ?? + u32 _01; // 0x0004 + s32 mMaxJuice; // 0x0008 + s32 mCurJuice; // 0x000C + TMario* mMario; // 0x0010 + u32 _02[0xC / 4]; // 0x0014 + JGeometry::TVec3 mTranslation; // 0x0020 + u32 _03[0x8 / 4]; // 0x002C + MActor* mActor; // 0x0034 + u32 _38; // 0x0038 + u16 mJoint; // 0x003c + u16 _3e; // 0x003e + u32 _04[0x44 / 4]; // 0x0040 + f32 mRedComponent; // 0x0084 + f32 mGreenComponent; // 0x0088 + f32 mBlueComponent; // 0x008C + u32 _05[0x28 / 4]; // 0x0090 + u8 mFlutterState; // 0x00B8 + u8 _06; // 0x00B9 + u16 mFlutterTimer; // 0x00BA + u16 mMaxFlutterTimer; // 0x00BC + u16 _07; // 0x00BE + f32 mMaxVSpdStartFlutter; // 0x00C0 + f32 mFlutterAcceleration; // 0x00C4 + u32 _08[0x8 / 4]; // 0x00C8 + s8 mType; // 0x00D0 + u8 _09; // 0x00D1 + u16 _10; // 0x00D2 + u32 _11[0x1C / 4]; // 0x00D4 + void* mEgg; // 0x00F0 + u32 _F4[0x30 / 4]; +}; + +extern JUtility::TColor bodyColor[4]; + +#endif diff --git a/include/System/ParamInst.hpp b/include/System/ParamInst.hpp index 92bc2541..dd54436d 100644 --- a/include/System/ParamInst.hpp +++ b/include/System/ParamInst.hpp @@ -26,20 +26,30 @@ template class TParamT : public TBaseParam { template class TParamRT : public TParamT { public: - TParamRT(TParams* parent, u16 keycode, const char* name, T defaultValue) - : TParamT(parent, keycode, name, defaultValue) + TParamRT(TParams* parent, u16 code, const char* name, T defaultValue) + : TParamT(parent, code, name, defaultValue) { } - inline void set(T param) {}; + inline void set(T param) { value = param; }; + + // Fabricated + TParamRT& operator=(const TParamRT& other) + { + this->keyCode = other.keyCode; + this->name = other.name; + this->next = other.next; + this->value = other.value; + return *this; + } }; class TParamVec : public TParamT > { public: // fabricated AND wrong - TParamVec(TParams* parent, u16 keycode, const char* name, + TParamVec(TParams* parent, u16 code, const char* name, JGeometry::TVec3 defaultValue) - : TParamT >(parent, keycode, name, defaultValue) + : TParamT >(parent, code, name, defaultValue) { } }; diff --git a/include/gpMarDirector.hpp b/include/gpMarDirector.hpp new file mode 100644 index 00000000..9b635b82 --- /dev/null +++ b/include/gpMarDirector.hpp @@ -0,0 +1,23 @@ +#ifndef GPMARDIRECTOR_H +#define GPMARDIRECTOR_H + +#include "GC2D/GCConsole2.hpp" + +extern class TMarDirector { +public: + char pad_000[0x58]; + s32 frameIndex; + char pad_001[0x14]; + int _070; + TGCConsole2* console; + int _078; + u8 map; + u8 _07D; + u8 _07E; + u8 _07F; + u32 _080[0x29]; + u8 mGameState; + +}* gpMarDirector; + +#endif diff --git a/src/Map/BathWaterManager.cpp b/src/Map/BathWaterManager.cpp index 115b9bf8..229cacd5 100644 --- a/src/Map/BathWaterManager.cpp +++ b/src/Map/BathWaterManager.cpp @@ -21,7 +21,7 @@ static void draw_mist(u16 x, u16 y, u16 wd, u16 ht, void* buffer) f32 offset_x = (4.0f / f_wd); f32 offset_y = (2.0f / f_ht); - C_MTXOrtho(m, f_left, f_right, f_top, f_bottom, 0.0f, 1.0f); + C_MTXOrtho(m, f_top, f_bottom, f_left, f_right, 0.0f, 1.0f); PSMTXIdentity(e_m); GXSetTexCopySrc(x, y, wd, ht); GXSetCopyFilter(GX_FALSE, 0, GX_TRUE, vFilter); diff --git a/src/Player/WaterGun.cpp b/src/Player/WaterGun.cpp index e69de29b..40ee4d1f 100644 --- a/src/Player/WaterGun.cpp +++ b/src/Player/WaterGun.cpp @@ -0,0 +1,1188 @@ +#include +#include +#include +#include + +#include +#include + +#include + +#include + +#include +#include + +// Define the global variable in .data section +TNozzleBmdData nozzleBmdData + = { { { 0, // _00 + 0, // _04 + nullptr, // mHelmetPath + "/mario/watergun2/normal_wg", // mPath + "/mario/watergun2/normal_wg/normal_wg.bmd", // mBmdPath + 1, // mNumEmitters + 2, // _15 + { { 1, 0 }, { 4, 0 }, { 4, 0 } } }, + { 0, // _00 + 0, // _04 + nullptr, // mHelmetPath + "/mario/watergun2/rocket_wg", // mPath + "/mario/watergun2/rocket_wg/rocket_wg.bmd", // mBmdPath + 1, // mNumEmitters + 2, // _15 + { { 2, 1 }, { 4, 0 }, { 4, 0 } } }, + { 0, // _00 + 0, // _04 + "/mario/bmd/wg_hel_diver.bmd", // mHelmetPath + "/mario/watergun2/hover_wg", // mPath + "/mario/watergun2/hover_wg/hover_wg.bmd", // mBmdPath + 2, // mNumEmitters + 0xc, // _15 + { { 1, 0 }, { 1, 0 }, { 4, 0 } } }, + { 0, // _00 + 0, // _04 + nullptr, // mHelmetPath + "/mario/watergun2/dummy_wg", // mPath + "/mario/watergun2/dummy_wg/dummy_wg.bmd", // mBmdPath + 1, // mNumEmitters + 2, // _15 + { { 3, 0 }, { 4, 0 }, { 4, 0 } } }, + { 0, // _00 + 0, // _04 + nullptr, // mHelmetPath + "/mario/watergun2/hover_wg", // mPath + "/mario/watergun2/hover_wg/hover_wg.bmd", // mBmdPath + 2, // mNumEmitters + 0xc, // _15 + { { 1, 0 }, { 1, 0 }, { 4, 0 } } }, + { 0, // _00 + 0, // _04 + nullptr, // mHelmetPath + "/mario/watergun2/back_wg", // mPath + "/mario/watergun2/back_wg/back_wg.bmd", // mBmdPath + 1, // mNumEmitters + 2, // _15 + { { 1, 0 }, { 4, 0 }, { 4, 0 } } } } }; + +// TODO: Pretty certain these are defined in header file? +// s32 TNozzleTrigger::getNozzleKind() const { return 1; } +s32 TNozzleDeform::getNozzleKind() const { return 3; } + +TWaterGun::TWaterGun(TMario* mario) + : mNozzleDeform("normal_wg", "/Mario/WaterGun/NozzleDeform.prm", this) + , mNozzleRocket(nullptr, "/Mario/WaterGun/NozzleTrgRocket.prm", this) + , mNozzleUnderWater("hover_wg", "/Mario/WaterGun/NozzleDiving.prm", this) + , mNozzleYoshiDeform("dummy_wg", "/Mario/WaterGun/NozzleYoshiMouth.prm", + this) + , mNozzleHover("hover_wg", "/Mario/WaterGun/NozzleTrgHover.prm", this) + , mNozzleTurbo("back_wg", "/Mario/WaterGun/NozzleTrgTurbo.prm", this) + , mWatergunParams("/Mario/WaterGun.prm") + , mMario(mario) +{ + mWatergunParams.load(mWatergunParams.mPrmPath); + mMario = mario; +} + +static bool NozzleCtrl(J3DNode* node, BOOL param_2) +{ + // TODO: Inlined stack space + if (!param_2) { + if (gpMarioForCallBack != nullptr) { + s16 gunAngle = gpMarioForCallBack->mWaterGun + ->mNozzleList[gpMarioForCallBack->mWaterGun + ->mCurrentNozzle] + ->getGunAngle(); + if (gunAngle < 0) { + Mtx mtx; + // Unused stack space + // volatile u32 unused2[6]; + MsMtxSetRotRPH(mtx, 0.0f, 0.0f, 0.005493164f * gunAngle); + PSMTXConcat(J3DSys::mCurrentMtx, mtx, J3DSys::mCurrentMtx); + } + } + } + return 1; +} + +static bool RotateCtrl(J3DNode* node, BOOL param_2) +{ + if (!param_2 && gpMarioForCallBack != nullptr) { + s16 local1cd0 = gpMarioForCallBack->mWaterGun->unk1CD0; + Mtx mtx; + // Unused stack space + // volatile u32 unused2[7]; + MsMtxSetRotRPH(mtx, 0.005493164f * local1cd0, 0.0f, 0.0f); + PSMTXConcat(J3DSys::mCurrentMtx, mtx, J3DSys::mCurrentMtx); + } + return 1; +} + +static bool WaterGunDivingCtrlL(J3DNode* node, BOOL param_2) +{ + if (!param_2) { + // This looks very weird to me, probably because of some inline? + // I could imagine some s32 getNozzleSpeedY() and + // s16 localXXX = -getNozzleSpeedY(); + s32 nozzleSpeedY = gpMarioForCallBack->mWaterGun->mNozzleSpeedY; + s16 neg = -nozzleSpeedY; + Mtx mtx; + // Unused stack space + // volatile u32 unused2[7]; + MsMtxSetRotRPH(mtx, 0.0f, 0.0f, 0.005493164f * neg); + PSMTXConcat(J3DSys::mCurrentMtx, mtx, J3DSys::mCurrentMtx); + } + return 1; +} + +static bool WaterGunDivingCtrlR(J3DNode* node, BOOL param_2) +{ + if (!param_2) { + // This looks very weird to me, probably because of some inline? + // I could imagine some s32 getNozzleSpeedY() and + // s16 localXXX = -getNozzleSpeedY(); + s32 nozzleSpeedY = gpMarioForCallBack->mWaterGun->mNozzleSpeedZ; + s16 neg = -nozzleSpeedY; + Mtx mtx; + // Unused stack space + // volatile u32 unused2[7]; + MsMtxSetRotRPH(mtx, 0.0f, 0.0f, 0.005493164f * neg); + PSMTXConcat(J3DSys::mCurrentMtx, mtx, J3DSys::mCurrentMtx); + } + return 1; +} + +// TODO: Nozzle deform + +void TWaterGun::init() +{ + mFlags = 0; + mNozzleList[Spray] = &mNozzleDeform; + mNozzleList[Rocket] = &mNozzleRocket; + mNozzleList[Underwater] = &mNozzleUnderWater; + mNozzleList[Yoshi] = &mNozzleYoshiDeform; + mNozzleList[Hover] = &mNozzleHover; + mNozzleList[Turbo] = &mNozzleTurbo; + mCurrentNozzle = Spray; + mSecondNozzle = Hover; + mNozzleRocket.mSoundID = 0x81b; + mNozzleTurbo.mSoundID = 0x814; + mNozzleDeform.mBomb.mSoundID = 0x813; + mCurrentWater = mNozzleList[mCurrentNozzle]->mEmitParams.mAmountMax.get(); + mIsEmitWater = false; + unk1C88 = 0.0f; + mCurrentPressure = 0; + mPreviousPressure = 0; + unk1CEC = 1.0f; + unk1CF0 = 0.1f; + unk1CF4 = 0.0049999999f; + unk1CF8 = 0x168; + unk1CFA = 0; + mFluddSwitchTween = 0.0f; + unk1D00 = 0.0f; + unk1D04 = 0; + unk1D06 = -0x1800; + unk1D08 = 0; + + // mEmitInfo = new TWaterEmitInfo; TODO + + unk1D08 = 0; + mNozzleDeform.mBomb.mRumbleOnCharge = true; + mNozzleYoshiDeform.mBomb.mRumbleOnCharge = true; + + mEmitPos[3].x = mMario->mPosition.x; + mEmitPos[3].y = mMario->mPosition.y; + mEmitPos[3].z = mMario->mPosition.z; + + unk1CC0 = 0; + unk1CC2 = 0; + unk1CC4 = 0; + + mNozzleSpeedY = 0.0f; + unk1CD0 = 0; + unk1CD2 = 0; + + // This is definitely an inlined funciton. Creating a model seems quite + // useful + // TODO: Check if already exists + MActorAnmData* watergunAnmData = new MActorAnmData(); + watergunAnmData->init("/mario/watergun2/body", nullptr); + mFluddModel = new MActor(watergunAnmData); + + void* fluddModelData + = JKRFileLoader::getGlbResource("/mario/watergun2/body/wg_mdl1.bmd"); + J3DModel* fluddModel = new J3DModel( + J3DModelLoaderDataBase::load(fluddModelData, 0x10040000), 0, 1); + mFluddModel->setModel(fluddModel, 0); + + // Requires M3UModelMario at 0x3a8 in TMario + // Missing decompilation + // PSMTXCopy( + // mMario->mModelMario->unk8->mJointArray[mMario->mBindBoneIDArray[0]], + // mFluddModel->unk4->mBaseMtx); + + mFluddModel->unk4->initialize(); + + s32 handleIdx + = mFluddModel->unk4->mModelData->unkB0->getIndex("jnt_G_handle"); + + // unk1CDC is TMultiMtxEffect, but confused from implementation atm + + mCurFluddTransformIdx + = mFluddModel->unk4->mModelData->unkB0->getIndex("nozzle_center"); + + for (int i = 0; i < 6; ++i) { + if (!nozzleBmdData.getPath(i)) { + mNozzleList[i]->mActor = nullptr; + continue; + } + + MActorAnmData* nozzleData = new MActorAnmData(); + nozzleData->init(nozzleBmdData.getPath(i), nullptr); + mNozzleList[i]->mActor = new MActor(nozzleData); + + void* nozzleModelData + = JKRFileLoader::getGlbResource(nozzleBmdData.getBmdPath(i)); + J3DModel* nozzleModel = new J3DModel( + J3DModelLoaderDataBase::load(nozzleModelData, 0x10040000), 0, 1); + mNozzleList[i]->mActor->setModel(nozzleModel, 0); + + // TODO: Figure out + // ResTIMG* img = mFluddModel->unk4->mModelData->unkAC->getResTIMG(0); + // SMS_ChangeTextureAll(mNozzleList[i]->mActor->unk4->mModelData, + // "H_watergun_main_dummy", img); + + mNozzleList[i]->mActor->initDL(); + // Definitely inline potential + if (nozzleBmdData.getFlags(i, 0) != 4) { + s32 jointIdx + = mNozzleList[i]->mActor->unk4->mModelData->unkB0->getIndex( + "null_G_muzzle"); + nozzleBmdData.setJointIndex(i, 0, jointIdx); + } + if (nozzleBmdData.getFlags(i, 1) != 4) { + s32 jointIdx + = mNozzleList[i]->mActor->unk4->mModelData->unkB0->getIndex( + "null_G_muzzle2"); + nozzleBmdData.setJointIndex(i, 1, jointIdx); + } + if (nozzleBmdData.getFlags(i, 2) != 4) { + s32 jointIdx + = mNozzleList[i]->mActor->unk4->mModelData->unkB0->getIndex( + "null_G_muzzle3"); + nozzleBmdData.setJointIndex(i, 2, jointIdx); + } + } + + s32 jointIdx + = mNozzleList[Spray]->mActor->unk4->mModelData->unkB0->getIndex( + "chn_muzzle_l"); + // mNozzleList[Spray] + // ->mActor->unk4->mModelData->mJointNodePointer[jointIdx] + // ->mCallBack = functionPtr; + // 5 more of these + + // PSMTXCopy that requires M3UModelMario at 0x3a8 in TMario + + unk1D10 = new TMirrorActor("水鉄砲in鏡"); + unk1D10->init(mFluddModel->unk4, 4); + + // TODO: Definitely an inlined function + // Another function does the exact same thing + for (int i = 0; i < nozzleBmdData.getEmitterCount(mCurrentNozzle); ++i) { + MtxPtr emitMtx = getEmitMtx(i); + if (emitMtx != nullptr) { + mEmitPos[i].x = emitMtx[0][3]; + mEmitPos[i].y = emitMtx[1][3]; + mEmitPos[i].z = emitMtx[2][3]; + } + } + + // TODO: Continue +} + +void TWaterGun::calcAnimation(JDrama::TGraphics* graphics) +{ + // TODO: Inlined stack space + volatile u32 unused2[12]; + + gpMarioForCallBack = mMario; + J3DFrameCtrl* frameCtrl = mFluddModel->getFrameCtrl(MActor::BCK); + if (mMario == nullptr) { + return; + } + + s32 var380 = mMario->unk380; + if ((var380 & 0x8000) != 0) { + var380 = 0; + } + + // Definitely wrong, possibly a swtich statement, but couldn't make that + // work either + if (var380 == 5) { + // Unused + } else if (var380 >= 5) { + // Unused + } else if (2 <= var380) { + } else { + if (var380 >= 0) { + } else { + if (unk1CEC == 0.0f) { + if (mMario->fabricatedActionInline()) { + mFluddModel->setBck("wg_fepmp"); + } else if (mMario->hasAttribute(ATTR_IS_SHALLOW_WATER + | ATTR_IS_WATER)) { + mFluddModel->setBck("wg_swpmp"); + } else { + // TODO: Cast would be weird here, probably an inlined + // getter that converts to s32 + if ((s32)mMario->unk0FA != 0x33) { + mFluddModel->setBck("wg_hgpmp"); + } else { + mFluddModel->setBck("wg_pump"); + } + } + frameCtrl->setSpeed(0.0f); + frameCtrl->setFrame(mMario->getPumpFrame()); + unk1CFA = unk1CF8; + } else { + mFluddModel->setBck("wg_house"); + if ((0.0f < unk1CEC) + && (unk1CEC = unk1CEC - 0.1f, unk1CEC <= 0.0f)) { + unk1CEC = 0.0f; + } + frameCtrl->setSpeed(0.0f); + frameCtrl->setFrame(unk1CEC * frameCtrl->getEndFrame()); + } + return; + } + } + + if (unk1CFA == 0) { + if (unk1CEC < 1.0f) { + unk1CEC = unk1CEC + unk1CF4; + mFluddModel->setBck("wg_house"); + frameCtrl->setSpeed(0.0f); + frameCtrl->setFrame(unk1CEC * frameCtrl->getEndFrame()); + } else { + unk1CEC = 1.0f; + mFluddModel->setBck("wg_house"); + frameCtrl->setSpeed(0.0f); + frameCtrl->setFrame(unk1CEC * frameCtrl->getEndFrame()); + } + } else { + unk1CFA = unk1CFA - 1; + } +} + +// TODO: Do i really need to explcitly say this? +#pragma dont_inline on +MtxPtr TWaterGun::getEmitMtx(int jointIndex) +{ + volatile u32 unused2[24]; // TODO: A lot of stack space, possibly a lot of + // inlined functions. + MtxPtr result; + if (!this->mMario->onYoshi()) { + result = this->getYoshiMtx(); + } else { + // This entire block is likely an inlined function. + u8 currentNozzle = this->mCurrentNozzle; + s8 flag = nozzleBmdData.getFlags(currentNozzle, jointIndex); + if (flag < 3) { + return this->getCurrentNozzle()->mActor->unk4->getAnmMtx( + nozzleBmdData.getJointIndex(this->mCurrentNozzle, jointIndex)); + } else if (flag == 3) { + return getYoshiMtx(); + } + } + return result; +} +#pragma dont_inline off + +MtxPtr TWaterGun::getNozzleMtx() +{ + return this->mFluddModel->unk4->getAnmMtx(this->mCurFluddTransformIdx); +} + +void TWaterGun::initInLoadAfter() { } + +bool TWaterGun::isEmitting() { return false; } + +void TWaterGun::changeNozzle(TNozzleType nozzleType, bool animate) +{ + f32 usedWater = mCurrentWater + / mNozzleList[mCurrentNozzle]->mEmitParams.mAmountMax.get(); + if (nozzleType == Spray) { + if (animate) { + mFluddSwitchTween = 0.0f; + } + } else { + mSecondNozzle = nozzleType; + if (animate) { + mFluddSwitchTween = 1.0f; + } + } + mCurrentNozzle = nozzleType; + mNozzleList[mCurrentNozzle]->init(); + if (nozzleType == Yoshi) { + mCurrentWater = mMario->mYoshi->_11[0]; + } else { + mCurrentWater + = usedWater + * mNozzleList[mCurrentNozzle]->mEmitParams.mAmountMax.get(); + } +} + +void TWaterGun::movement() +{ + volatile u32 unused2[69]; // TODO: A lot of stack space, possibly a lot of + + bool canSpray; // Not sure if this is correct variable name + if (mCurrentWater == 0) { + canSpray = false; + } else { + s32 kind = getCurrentNozzle()->getNozzleKind(); + if (kind == 1) { + TNozzleTrigger* triggerNozzle + = (TNozzleTrigger*)mNozzleList[mCurrentNozzle]; + if (triggerNozzle->mSprayState == TNozzleTrigger::ACTIVE) { + canSpray = true; + } else { + canSpray = false; + } + } else if (getCurrentNozzle()->unk378 > 0.0f) { + canSpray = true; + } else { + canSpray = false; + } + } + + if (!canSpray) { + unk1CC2 = 0; + unk1CC4 = 0; + } + + mNozzleSpeedY + += (unk1CC2 - mNozzleSpeedY) * mWatergunParams.mChangeSpeed.get(); + mNozzleSpeedZ + += (unk1CC4 - mNozzleSpeedZ) * mWatergunParams.mChangeSpeed.get(); + + TNozzleBase* currentNozzle = this->getCurrentNozzle(); + + rotateProp(currentNozzle->unk378); + + // They do the same thing again?... This is the exact same code as + // rotateProp + if (mCurrentNozzle == 5) { + unk1CD2 += mNozzleList[mCurrentNozzle]->unk378 + * mWatergunParams.mNozzleAngleYSpeed.get(); + unk1CD2 *= mWatergunParams.mNozzleAngleYBrake.get(); + if (mWatergunParams.mHoverRotMax.get() < unk1CD2) { + unk1CD2 = mWatergunParams.mHoverRotMax.get(); + } + unk1CD0 = unk1CD0 + unk1CD2; + } else { + unk1CD2 = 0; + unk1CD0 = 0; + } + + // Yoshi nozzle + if (mCurrentNozzle == 3) { + mCurrentWater = getCurrentNozzle()->mEmitParams.mAmountMax.get(); + } + + if (SMS_isDivingMap()) { + mCurrentWater = getCurrentNozzle()->mEmitParams.mAmountMax.get(); + } + + if (mCurrentNozzle == 3) { + unk1CEC = 0.0f; + } + + // Nozzle swapping + if (unk1D00 != 0.0f) { + f32 unk = mFluddSwitchTween; + f32 sum = unk + unk1D00; + mFluddSwitchTween = sum; + if ((unk < 0.5f) && (0.5f <= sum)) { + u8 curNozzle = mCurrentNozzle; + s32 currentWater = mCurrentWater; + u8 secondNozzle = mSecondNozzle; + f32 maxWater = currentNozzle->mEmitParams.mAmountMax.get(); + f32 waterPercentage = currentWater / maxWater; + + if (secondNozzle != 0) { + mSecondNozzle = secondNozzle; + } + mCurrentNozzle = secondNozzle; + + currentNozzle = this->getCurrentNozzle(); + currentNozzle->init(); // TODO: 2 vtable entry + + if (secondNozzle == 3) { + mCurrentWater + = mMario->mYoshi->_11[0]; // TODO: Proper yoshi stuff + } else { + mCurrentWater = waterPercentage + * currentNozzle->mEmitParams.mAmountMax.get(); + } + } + if ((sum < 0.5f) && (0.5f <= unk)) { + f32 currentWater = (f32)mCurrentWater; + f32 maxWater = currentNozzle->mEmitParams.mAmountMax.get(); + f32 waterPercentage = currentWater / maxWater; + + mCurrentNozzle = 0; + + currentNozzle = this->getCurrentNozzle(); + currentNozzle->init(); // TODO: 2 vtable entry + + mCurrentWater + = waterPercentage * currentNozzle->mEmitParams.mAmountMax.get(); + } + + if (mFluddSwitchTween < 0.0) { + mFluddSwitchTween = 0.0f; + unk1D00 = 0.0f; + } + if (1.0f < mFluddSwitchTween) { + mFluddSwitchTween = 1.0f; + unk1D00 = 0.0f; + } + } + currentNozzle->animation(mCurrentNozzle); +} + +void TNozzleBase::emitCommon(int param_1, TWaterEmitInfo* param_2) +{ + param_2->mAlive.set( + gpModelWaterManager->mWaterParticleTypes[mEmitParams.mType.get()] + ->mAlive.get()); + + JGeometry::TVec3 pos; + JGeometry::TVec3 dir; + JGeometry::TVec3 speed; + mFludd->getEmitPosDirSpeed(param_1, &pos, &dir, &speed); + + // TODO: This feels wrong + // TODO: Fix asm + param_2->mPos.value = pos; + param_2->mV.value = speed; + param_2->mDir.value = dir; + + param_2->mDirTremble = mEmitParams.mDirTremble; + param_2->mPowTremble = mEmitParams.mPowTremble; + param_2->mSize = mEmitParams.mSize; + param_2->mSizeTremble = mEmitParams.mSizeTremble; + param_2->mType = mEmitParams.mType; + param_2->mHitRadius = mEmitParams.mHitRadius; + param_2->mHitHeight = mEmitParams.mHitHeight; +} + +void TNozzleBase::emit(int param_1) +{ + if (mFludd->mCurrentWater > 0 && unk378 != 0.0f) { + TWaterEmitInfo* emitInfo = mFludd->mEmitInfo; + this->emitCommon(param_1, emitInfo); + + unk37C = unk37C + mEmitParams.mNum.get(); + s32 local37cInt = (s32)unk37C; + if (local37cInt != 0) { + unk37C = unk37C - (f32)local37cInt; + emitInfo->mNum.set(local37cInt); + emitInfo->mAttack = mEmitParams.mAttack; + f32 emitCtrl = mEmitParams.mEmitCtrl.get(); + f32 emitPow = mEmitParams.mEmitPow.get(); + emitInfo->mPow.set(emitCtrl * emitPow * unk378 + + emitPow * (1.0f - emitCtrl)); + emitInfo->mFlag.set(0x40); + u16 flags = mFludd->mFlags; + u32 flagResult; + if ((flags & 2) != 0) { + flagResult = 1; + } else { + flagResult = 0; + } + if (flagResult != 0) { + emitInfo->mFlag.set(emitInfo->mFlag.get() | 0x80); + } + + int emittedWater = gpModelWaterManager->emitRequest(*emitInfo); + u32 emittedWaterU32 = (u32)emittedWater & 0xFF; + mFludd->mIsEmitWater = (u8)emittedWater; + f32* unk1C88Ptr = (f32*)&mFludd->unk1C88; + f32 unk1C88 = *unk1C88Ptr; + u8 currentNozzle = mFludd->mCurrentNozzle; + TNozzleBase** nozzleList = mFludd->mNozzleList; + TNozzleBase* currentNozzlePtr = nozzleList[currentNozzle]; + u32 unk1C88U32 = (u32)mFludd->unk1C88; + s16 decRate = currentNozzlePtr->mEmitParams.mDecRate.get(); + f32 emittedWaterF = (f32)emittedWaterU32; + f32 decRateF = (f32)decRate; + f32 unk1C88OldF = (f32)unk1C88U32; + f32 temp = emittedWaterF * decRateF; + f32 temp2 = temp / unk1C88OldF; + *unk1C88Ptr = 10.0f * temp2 + unk1C88; + if (emittedWaterU32 == 0) { + goto skip_velocity; + } + mFludd->mCurrentWater + -= emittedWaterU32 * mEmitParams.mDecRate.get(); + if (mFludd->mCurrentWater < 0) { + mFludd->mCurrentWater = 0; + } + + f32* powPtr = &emitInfo->mPow.value; + JGeometry::TVec3* dirPtr = &emitInfo->mDir.value; + f32 powVal = *powPtr; + s16 faceAngleY = mFludd->mMario->mFaceAngle.y; + f32 cosAngle = JMASCos(faceAngleY); + f32 sinAngle = JMASSin(faceAngleY); + f32 dirX = -dirPtr->x; + f32 dirZ = dirPtr->z; + f32 dirY = dirPtr->y; + f32 reactionPow = powVal * mEmitParams.mReactionPow.get(); + f32 reactionY = mEmitParams.mReactionY.get(); + f32 unkE0 = mEmitParams.mReactionPow.value; + f32 unkF4 = mEmitParams.mReactionY.value; + f32 f31 = powVal * unkE0; + + mFludd->mMario->addVelocity((dirX * sinAngle - dirZ * cosAngle) + * reactionPow); + + f32* velX = &mFludd->mMario->mVel.x; + *velX = -dirPtr->x * reactionPow - *velX; + f32* velZ = &mFludd->mMario->mVel.z; + *velZ = -dirPtr->z * reactionPow - *velZ; + f32* velY = &mFludd->mMario->mVel.y; + *velY = *velY - dirY * powVal * unkF4 * reactionY; + skip_velocity:; + } + } +} + +void TWaterGun::setBaseTRMtx(Mtx mtx) +{ + volatile u32 unused1[10]; + f32 initialAngle = mtx[1][0]; + if (initialAngle < 0.0f) { + initialAngle = -initialAngle; + } + + // Seemingly some adjustment of fluddpack angle + f32 baseAngle = unk1D06; + f32 angleDiff = unk1D04 - unk1D06; + + s16 angle = initialAngle * angleDiff + baseAngle; + + Mtx result; + Vec unused2; + MsMtxSetRotRPH(result, 0.0f, 0.0f, 0.005493164f * angle); + + PSMTXConcat(mtx, result, result); + PSMTXCopy(result, mFluddModel->unk4->mBaseMtx); +} + +// Not sure why this get's inlined aggressively +#pragma dont_inline on +TNozzleBase::TNozzleBase(const char* name, const char* prm, TWaterGun* fludd) + : mEmitParams(prm) + , mFludd(fludd) +{ + mEmitParams.load(mEmitParams.mPrmPath); + this->mAnimState = 2; + this->mGunAngle = 0; + this->unk372 = 0; + this->unk378 = 0.0f; + this->unk37C = 0.0f; +} +#pragma dont_inline off + +void TNozzleBase::init() +{ + this->mAnimState = 2; + this->mGunAngle = 0; + this->unk372 = 0; + this->unk378 = 0.0f; + this->unk37C = 0.0f; +} + +void TNozzleBase::calcGunAngle(const TMarioControllerWork& work) +{ + // volatile u32 unused1[17]; + if (mFludd->mMario == gpMarioAddress + && (gpCamera->isLButtonCameraSpecifyMode(gpCamera->mMode) + || gpCamera->isJetCoaster1stCamera())) { + mGunAngle = gpCamera->unkA4; + return; + } + + s16 angle; + if (mFludd->mMario->mAction == 0xC008220) { + // TODO: Wrong reguster used, using r3 instead of r4 + angle = mGunAngle + + (s16)(mFludd->mMario->mGamePad->mCompSPos[0].y + * mEmitParams.mRButtonMult.get()); + } else { + angle = -mEmitParams.mLAngleBase.get(); + } + + if (angle < mEmitParams.mLAngleMin.get()) { + angle = mEmitParams.mLAngleMin.get(); + } + + if (angle > mEmitParams.mLAngleMax.get()) { + angle = mEmitParams.mLAngleMax.get(); + } + + f32 diff = angle - mGunAngle; + mGunAngle += diff * mEmitParams.mLAngleChase.get(); +} + +// TODO: This has a lot of inline functions, find them and update them +// properly +void TNozzleBase::animation(int param_1) +{ + if (param_1 != 2) { + return; + } + + if (0.0f < this->mFludd->unk1D00) { + this->mAnimState = 4; + } + + if (this->mFludd->unk1D00 < 0.0f) { + this->mAnimState = 3; + } + + switch (this->mAnimState) { + case 0: { + + if (!this->mActor->checkCurBckFromIndex(4)) { + this->mActor->setBckFromIndex(4); + } + J3DFrameCtrl* ctrl = this->mActor->getFrameCtrl(MActor::BCK); + if (ctrl->mCurrentFrame <= (ctrl->mEndFrame - 0.1) + && (ctrl->mFlags & 3) == 0) { + return; + } + this->mAnimState = 1; + break; + } + case 1: { + + if (!this->mActor->checkCurBckFromIndex(2)) { + this->mActor->setBckFromIndex(2); + } + + TWaterGun* fludd = this->mFludd; + bool updateAnimation = false; + if (fludd->mCurrentWater == 0) { + updateAnimation = false; + } else { + u8 gameState = gpMarDirector->mGameState; + if (gameState != 3 && gameState != 4) { + updateAnimation = true; + if (gameState != 1 && gameState != 2) { + updateAnimation = true; + } + + if (!updateAnimation) { + updateAnimation = true; + u32 nozzleKind = fludd->getCurrentNozzle()->getNozzleKind(); + if (nozzleKind == 1) { + TNozzleTrigger* trigger + = (TNozzleTrigger*)fludd->getCurrentNozzle(); + if (trigger->mSprayState == 1) { + updateAnimation = true; + } else { + updateAnimation = false; + } + + } else if (fludd->getCurrentNozzle()->unk378 <= 0.0f) { + updateAnimation = false; + } else { + updateAnimation = true; + } + } + } + } + + if (updateAnimation) { + return; + } + + this->mAnimState = 2; + break; + } + case 2: { + + if (!this->mActor->checkCurBckFromIndex(3)) { + this->mActor->setBckFromIndex(3); + } + TWaterGun* fludd = this->mFludd; + bool updateAnimation = false; + if (fludd->mCurrentWater == 0) { + updateAnimation = false; + } else { + u8 gameState = gpMarDirector->mGameState; + if (gameState != 3 && gameState != 4) { + updateAnimation = true; + if (gameState != 1 && gameState != 2) { + updateAnimation = true; + } + + if (!updateAnimation) { + updateAnimation = true; + u32 nozzleKind = fludd->getCurrentNozzle()->getNozzleKind(); + if (nozzleKind == 1) { + TNozzleTrigger* trigger + = (TNozzleTrigger*)fludd->getCurrentNozzle(); + if (trigger->mSprayState == 1) { + updateAnimation = true; + } else { + updateAnimation = false; + } + + } else if (fludd->getCurrentNozzle()->unk378 <= 0.0f) { + updateAnimation = false; + } else { + updateAnimation = true; + } + } + } + } + + if (updateAnimation) { + this->mAnimState = 0; + } + break; + } + + case 3: { + + J3DFrameCtrl* ctrl = this->mActor->getFrameCtrl(MActor::BCK); + if (!this->mActor->checkCurBckFromIndex(1)) { + this->mActor->setBckFromIndex(1); + } + + // Use external tween value + ctrl->mCurrentFrame = this->mFludd->mFluddSwitchTween * ctrl->mEndFrame; + ctrl->mSpeed = 0.0f; + break; + } + case 4: { + + J3DFrameCtrl* ctrl = this->mActor->getFrameCtrl(MActor::BCK); + if (!this->mActor->checkCurBckFromIndex(0)) { + this->mActor->setBckFromIndex(0); + } + + // Use external tween value + ctrl->mCurrentFrame = this->mFludd->mFluddSwitchTween * ctrl->mEndFrame; + ctrl->mSpeed = 0.0f; + + if (this->mFludd->mFluddSwitchTween < 1.0f) { + return; + } + this->mAnimState = 0; + break; + } + } +} + +void TNozzleTrigger::init() +{ + this->mRumbleOnCharge = false; + this->mSprayState = 0; + mAnimState = 0; + mSprayQuarterFramesLeft = 0; + mTriggerFill = 0.0f; +} + +void TNozzleBase::movement(const TMarioControllerWork& controllerWork) +{ + // TODO: Missing stack space + volatile u32 unused2[2]; + + if (this->mFludd->mCurrentWater <= 0) { + return; + } + s32 var1 = 256.0f * controllerWork.mAnalogL * 150.0f; + + if (var1 > unk372) { + unk378 = (var1 - unk372) * 0.000015258789f; + unk374 = unk378; + unk372 = unk372 + mEmitParams.mTriggerRate.get(); + if (var1 < unk372) { + unk372 = var1; + } + } else { + unk378 = 0.0f; + unk372 = var1; + } + calcGunAngle(controllerWork); +} + +void TWaterGun::perform(u32 flags, JDrama::TGraphics* graphics) +{ + // TODO: Missing stack space + // volatile u32 unused2[24]; + + if ((flags & 0x1) != 0) { + if ((this->mFlags & 0x10) != 0) { + this->mCurrentWater = 0; + } + this->movement(); + } + + if ((flags & 0x2) != 0) { + this->calcAnimation(graphics); + } + + this->mFluddModel->perform(flags, graphics); + + if ((flags & 0x2) != 0) { + MActor* p2 = this->getCurrentNozzle()->mActor; + if (p2 != nullptr) { + PSMTXCopy(this->getModel()->getAnmMtx(this->mCurFluddTransformIdx), + p2->unk4->mBaseMtx); + } + + for (s32 index = 0; + index < nozzleBmdData.getEmitterCount(this->mCurrentNozzle); + index++) { + MtxPtr p1 = this->getEmitMtx(index); + if (p1 != nullptr) { + mEmitPos[index].x = p1[0][3]; + mEmitPos[index].y = p1[1][3]; + mEmitPos[index].z = p1[2][3]; + } + } + } + + if (this->getCurrentNozzle()->mActor) { + this->getCurrentNozzle()->mActor->perform(flags, graphics); + } +} + +TNozzleBase* TWaterGun::getCurrentNozzle() const +{ + return mNozzleList[mCurrentNozzle]; +} + +void TWaterGun::setAmountToRate(f32 rate) +{ + // volatile u32 unused2[7]; // TODO: possibly inlined function + if (this->mCurrentNozzle == 3) { + TNozzleBase* currentNozzle = this->getCurrentNozzle(); + s32 amountMax = currentNozzle->mEmitParams.mAmountMax.get(); + this->mCurrentWater = amountMax; + } else { + TNozzleBase* currentNozzle = this->getCurrentNozzle(); + this->mCurrentWater + = rate * currentNozzle->mEmitParams.mAmountMax.get(); + } +} + +bool TWaterGun::isPressureOn() +{ + // volatile u32 unused2[6]; + if (this->getCurrentNozzle()->getNozzleKind() == 1) { + TNozzleTrigger* triggerNozzle + = (TNozzleTrigger*)this->getCurrentNozzle(); + if (triggerNozzle->mTriggerFill > 0.0f) { + return true; + } + } + return false; +} + +f32 TWaterGun::getPressure() +{ + // TODO: Missing stack space + // volatile u32 unused2[5]; + if (this->getCurrentNozzle()->getNozzleKind() == 1) { + TNozzleTrigger* triggerNozzle + = (TNozzleTrigger*)this->getCurrentNozzle(); + return triggerNozzle->mTriggerFill; + } + return 0.0f; +} + +f32 TWaterGun::getPressureMax() +{ + // TODO: Missing stack space + // volatile u32 unused2[6]; + + if (this->getCurrentNozzle()->getNozzleKind() == 1) { + return this->getCurrentNozzle()->mEmitParams.mInsidePressureMax.get(); + } + + return 0.0f; +} + +// TODO: Figure out why inline happens +#pragma dont_inline on +void TWaterGun::getEmitPosDirSpeed(int index, JGeometry::TVec3* pos, + JGeometry::TVec3* dir, + JGeometry::TVec3* speed) +{ + // TODO: Fix unused stack space + // volatile u32 unused2[6]; + + MtxPtr nozzleEmitMtx = getEmitMtx(index); + pos->set(mEmitPos[index]); + + if (nozzleEmitMtx != nullptr) { + dir->x = nozzleEmitMtx[0][0]; + dir->y = nozzleEmitMtx[1][0]; + dir->z = nozzleEmitMtx[2][0]; + } else { + dir->set(0.0f, 0.0f, 1.0f); + } + + speed->x = mMario->mVel.x * 0.125f; + speed->y = 0.0f; + speed->z = mMario->mVel.z * 0.125f; +} +#pragma dont_inline off + +void TWaterGun::rotateProp(f32 rotation) +{ + if (mCurrentNozzle == 5) { + unk1CD2 += rotation * mWatergunParams.mNozzleAngleYSpeed.get(); + unk1CD2 *= mWatergunParams.mNozzleAngleYBrake.get(); + if (mWatergunParams.mHoverRotMax.get() < unk1CD2) { + unk1CD2 = mWatergunParams.mHoverRotMax.get(); + } + unk1CD0 = unk1CD0 + unk1CD2; + } else { + unk1CD2 = 0; + unk1CD0 = 0; + } +} + +void TWaterGun::triggerPressureMovement( + const TMarioControllerWork& controllerWork) +{ + mCurrentPressure = controllerWork.mAnalogL * 150.0f; + + TNozzleBase* currentNozzle = getCurrentNozzle(); + currentNozzle->movement(controllerWork); + + if (mCurrentPressure > mPreviousPressure) { + mPreviousPressure = mCurrentPressure; + } else if (mPreviousPressure != 0) { + mPreviousPressure -= 1; + } else { + mPreviousPressure = 0; + } +} +void TWaterGun::emit() +{ + // TODO: Missing stack space + // volatile u32 unused1[25]; + + // TODO: Another possible inline to check if emit is possible + if (!mMario->hasAttribute(ATTR_HAS_HELMET_FLW_CAMERA) + && mMario->hasAttribute(ATTR_IS_SHALLOW_WATER | ATTR_IS_WATER)) { + // I can imagine this also being an inline function that checks + // if the emit point is below the water height, but i will leave + // it for now. TODO. + MtxPtr nozzleEmitMtx; + if ((nozzleEmitMtx = getEmitMtx(0)) != nullptr) { + if (nozzleEmitMtx[1][3] < mMario->mFloorPosition.z + 20.0f) { + return; + } + } + } + + if (!mMario->onYoshi()) { + if (this->unk1CEC > 0.0f) { + return; + } + } + + // TODO: Probably an enum + // TODO: Probably inline function? + if (this->hasFlag(0x4)) { + this->mFlags &= ~0x4; + return; + } + + u8 currentNozzleType = mCurrentNozzle; + TNozzleBase* currentNozzle = getNozzle(currentNozzleType); + for (int i = 0; i < nozzleBmdData.getEmitterCount(currentNozzleType); ++i) { + currentNozzle->emit(i); + } + if (mCurrentWater > 0) { + switch (currentNozzleType) { + case Spray: { + playSprayNozzleSound(0x24, getCurrentNozzle()->unk374); + } + case Yoshi: + case Turbo: { + playSprayNozzleSound(0x0, getCurrentNozzle()->unk378); + break; + } + case Underwater: { + playSound2(0x18); + } break; + case Rocket: + break; + case Hover: + if (mIsEmitWater) { + playSound2(0x18); + } + break; + } + } +} +bool TWaterGun::suck() +{ + // TODO: Missing stack space + // volatile u32 unused1[7]; + if (this->isYoshiNozzle()) { + return false; + } else { + s32 suckRate = this->getSuckRate(); + if (suckRate > 0) { + this->incWater(suckRate); + return true; + } + } + return false; +} + +bool TWaterGun::damage() +{ + if (this->hasWater()) { + TNozzleBase* nozzle = this->getCurrentNozzle(); + + this->mCurrentWater -= nozzle->mEmitParams.mDamageLoss.value; + + if (this->mCurrentWater < 0) { + this->mCurrentWater = 0; + } + return true; + } + return false; +} + +void TWaterGun::changeBackup() +{ + // volatile u32 unused2[5]; // TODO: Missing stack space + if (this->mFluddSwitchTween == 0.0f) { + if (gpMSound->gateCheck(0x812)) { + MSoundSESystem::MSoundSE::startSoundSystemSE(0x812, 0, nullptr, 0); + } + this->unk1D00 = mWatergunParams.mChangeSpeed.get(); + } + + if (this->mFluddSwitchTween == 1.0f) { + if (gpMSound->gateCheck(0x811)) { + MSoundSESystem::MSoundSE::startSoundSystemSE(0x811, 0, nullptr, 0); + } + this->unk1D00 = -mWatergunParams.mChangeSpeed.get(); + } +} From 8b84b73938c0e894694c984e9a046f78ee0daf89 Mon Sep 17 00:00:00 2001 From: theAzack9 Date: Mon, 22 Dec 2025 19:43:45 +0100 Subject: [PATCH 3/9] Rename variables + add TNozzleTrigger::movement --- include/Player/NozzleTrigger.hpp | 24 ++++++------- include/Player/Watergun.hpp | 8 ++--- src/Player/WaterGun.cpp | 60 ++++++++++++++++++-------------- 3 files changed, 50 insertions(+), 42 deletions(-) diff --git a/include/Player/NozzleTrigger.hpp b/include/Player/NozzleTrigger.hpp index b452a8ae..3c5fcc2d 100644 --- a/include/Player/NozzleTrigger.hpp +++ b/include/Player/NozzleTrigger.hpp @@ -9,27 +9,27 @@ class TNozzleTrigger : public TNozzleBase { TNozzleTrigger(const char* name, const char* prm, TWaterGun* fludd) : TNozzleBase(name, prm, fludd) { - mSoundID = 0xffffffff; - mRumbleOnCharge = false; - mSprayState = INACTIVE; - mAnimState = 0; - mSprayQuarterFramesLeft = 0; - mTriggerFill = 0.0f; + unk38C = 0xffffffff; + unk384 = false; + unk385 = INACTIVE; + mAnimState = 0; + unk386 = 0; + unk388 = 0.0f; } virtual void init(); virtual s32 getNozzleKind() const { return 1; }; - virtual void movement(const void*); + virtual void movement(const TMarioControllerWork&); virtual void emit(int); virtual void animation(int); enum SPRAYSTATE { INACTIVE, ACTIVE, DEAD }; - bool mRumbleOnCharge; // 0x0384 - s8 mSprayState; // 0x0385 - s16 mSprayQuarterFramesLeft; // 0x0386 - f32 mTriggerFill; // 0x0388 - u32 mSoundID; // 0x038C + bool unk384; // 0x0384 - Do rumble on charge + s8 unk385; // 0x0385 - Spray state + s16 unk386; // 0x0386 - Spray quarterframes left + f32 unk388; // 0x0388 - trigger on fill + u32 unk38C; // 0x038C - SoundID to play on charge }; #endif diff --git a/include/Player/Watergun.hpp b/include/Player/Watergun.hpp index a69593ec..ed4551f9 100644 --- a/include/Player/Watergun.hpp +++ b/include/Player/Watergun.hpp @@ -39,14 +39,14 @@ struct NozzleJointData { }; struct NozzleData { - /* 0x00 */ u32 _00; // Number of water streams emitted by this nozzle - /* 0x04 */ u32 _04; // Unused padding + /* 0x00 */ u32 _00; // Number of water streams emitted by this nozzle + /* 0x04 */ u32 _04; // Unused padding /* 0x08 */ const char* mHelmetPath; // Path to optional helmet model (used // by underwater nozzle) /* 0x0C */ const char* mPath; // Path to base nozzle model directory /* 0x10 */ const char* mBmdPath; // Full path to nozzle's BMD model file - /* 0x14 */ u8 mNumEmitters; // Number of water emitter points on the nozzle - /* 0x15 */ u8 _15; // Unknown/padding + /* 0x14 */ u8 mNumEmitters; // Number of water emitter points on the nozzle + /* 0x15 */ u8 _15; // Unknown/padding /* 0x16 */ NozzleJointData mJoints[3]; // Array of joint data for the nozzle }; diff --git a/src/Player/WaterGun.cpp b/src/Player/WaterGun.cpp index 40ee4d1f..454debc0 100644 --- a/src/Player/WaterGun.cpp +++ b/src/Player/WaterGun.cpp @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -155,18 +155,18 @@ static bool WaterGunDivingCtrlR(J3DNode* node, BOOL param_2) void TWaterGun::init() { - mFlags = 0; - mNozzleList[Spray] = &mNozzleDeform; - mNozzleList[Rocket] = &mNozzleRocket; - mNozzleList[Underwater] = &mNozzleUnderWater; - mNozzleList[Yoshi] = &mNozzleYoshiDeform; - mNozzleList[Hover] = &mNozzleHover; - mNozzleList[Turbo] = &mNozzleTurbo; - mCurrentNozzle = Spray; - mSecondNozzle = Hover; - mNozzleRocket.mSoundID = 0x81b; - mNozzleTurbo.mSoundID = 0x814; - mNozzleDeform.mBomb.mSoundID = 0x813; + mFlags = 0; + mNozzleList[Spray] = &mNozzleDeform; + mNozzleList[Rocket] = &mNozzleRocket; + mNozzleList[Underwater] = &mNozzleUnderWater; + mNozzleList[Yoshi] = &mNozzleYoshiDeform; + mNozzleList[Hover] = &mNozzleHover; + mNozzleList[Turbo] = &mNozzleTurbo; + mCurrentNozzle = Spray; + mSecondNozzle = Hover; + mNozzleRocket.unk38C = 0x81b; + mNozzleTurbo.unk38C = 0x814; + mNozzleDeform.mBomb.unk38C = 0x813; mCurrentWater = mNozzleList[mCurrentNozzle]->mEmitParams.mAmountMax.get(); mIsEmitWater = false; unk1C88 = 0.0f; @@ -185,9 +185,9 @@ void TWaterGun::init() // mEmitInfo = new TWaterEmitInfo; TODO - unk1D08 = 0; - mNozzleDeform.mBomb.mRumbleOnCharge = true; - mNozzleYoshiDeform.mBomb.mRumbleOnCharge = true; + unk1D08 = 0; + mNozzleDeform.mBomb.unk384 = true; + mNozzleYoshiDeform.mBomb.unk384 = true; mEmitPos[3].x = mMario->mPosition.x; mEmitPos[3].y = mMario->mPosition.y; @@ -444,7 +444,7 @@ void TWaterGun::movement() if (kind == 1) { TNozzleTrigger* triggerNozzle = (TNozzleTrigger*)mNozzleList[mCurrentNozzle]; - if (triggerNozzle->mSprayState == TNozzleTrigger::ACTIVE) { + if (triggerNozzle->unk385 == TNozzleTrigger::ACTIVE) { canSpray = true; } else { canSpray = false; @@ -792,7 +792,7 @@ void TNozzleBase::animation(int param_1) if (nozzleKind == 1) { TNozzleTrigger* trigger = (TNozzleTrigger*)fludd->getCurrentNozzle(); - if (trigger->mSprayState == 1) { + if (trigger->unk385 == TNozzleTrigger::ACTIVE) { updateAnimation = true; } else { updateAnimation = false; @@ -837,7 +837,7 @@ void TNozzleBase::animation(int param_1) if (nozzleKind == 1) { TNozzleTrigger* trigger = (TNozzleTrigger*)fludd->getCurrentNozzle(); - if (trigger->mSprayState == 1) { + if (trigger->unk385 == TNozzleTrigger::ACTIVE) { updateAnimation = true; } else { updateAnimation = false; @@ -892,11 +892,19 @@ void TNozzleBase::animation(int param_1) void TNozzleTrigger::init() { - this->mRumbleOnCharge = false; - this->mSprayState = 0; - mAnimState = 0; - mSprayQuarterFramesLeft = 0; - mTriggerFill = 0.0f; + unk384 = false; + unk385 = 0; + mAnimState = 0; + unk386 = 0; + unk388 = 0.0f; +} + +void TNozzleTrigger::movement(const TMarioControllerWork& controllerWork) +{ + // TODO: Missing stack space + volatile u32 unused2[2]; + + calcGunAngle(controllerWork); } void TNozzleBase::movement(const TMarioControllerWork& controllerWork) @@ -990,7 +998,7 @@ bool TWaterGun::isPressureOn() if (this->getCurrentNozzle()->getNozzleKind() == 1) { TNozzleTrigger* triggerNozzle = (TNozzleTrigger*)this->getCurrentNozzle(); - if (triggerNozzle->mTriggerFill > 0.0f) { + if (triggerNozzle->unk388 > 0.0f) { return true; } } @@ -1004,7 +1012,7 @@ f32 TWaterGun::getPressure() if (this->getCurrentNozzle()->getNozzleKind() == 1) { TNozzleTrigger* triggerNozzle = (TNozzleTrigger*)this->getCurrentNozzle(); - return triggerNozzle->mTriggerFill; + return triggerNozzle->unk388; } return 0.0f; } From 0f20be29ff8a54730b8480d496f84002e4651255 Mon Sep 17 00:00:00 2001 From: theAzack9 Date: Thu, 25 Dec 2025 11:34:05 +0100 Subject: [PATCH 4/9] Start TNozzleTrigger::movement --- include/Player/NozzleBase.hpp | 8 +- include/Player/NozzleTrigger.hpp | 8 +- include/Player/Watergun.hpp | 10 +-- include/System/MarioGamePad.hpp | 4 +- src/Player/WaterGun.cpp | 123 ++++++++++++++++++++++++++++++- 5 files changed, 136 insertions(+), 17 deletions(-) diff --git a/include/Player/NozzleBase.hpp b/include/Player/NozzleBase.hpp index 105445ab..8e840d08 100644 --- a/include/Player/NozzleBase.hpp +++ b/include/Player/NozzleBase.hpp @@ -58,7 +58,7 @@ class TNozzleBase { { } - + // TODO: Validate these offsets... /* 0x00 */ TParamRT mRocketType; /* 0x14 */ TParamRT mNum; /* 0x28 */ TParamRT mAttack; @@ -93,9 +93,9 @@ class TNozzleBase { /* 0x26C */ TParamRT mMotorPowMin; /* 0x280 */ TParamRT mMotorPowMax; /* 0x294 */ TParamRT mReactionPowMin; - /* 0x2A8 */ TParamRT mInsidePressureDec; - /* 0x2BC */ TParamRT mInsidePressureMax; - /* 0x2D0 */ TParamRT mTriggerTime; + /* 0x2C0 */ TParamRT mInsidePressureDec; // These should be correct + /* 0x2D4 */ TParamRT mInsidePressureMax; + /* 0x2E8 */ TParamRT mTriggerTime; /* 0x2E4 */ TParamRT mType; /* 0x2F8 */ TParamRT mSideAngleMaxSide; /* 0x30C */ TParamRT mSideAngleMaxFront; diff --git a/include/Player/NozzleTrigger.hpp b/include/Player/NozzleTrigger.hpp index 3c5fcc2d..6c6a6347 100644 --- a/include/Player/NozzleTrigger.hpp +++ b/include/Player/NozzleTrigger.hpp @@ -2,6 +2,7 @@ #define NOZZLETRIGGER_HPP #include +#include class TNozzleTrigger : public TNozzleBase { public: @@ -26,9 +27,10 @@ class TNozzleTrigger : public TNozzleBase { enum SPRAYSTATE { INACTIVE, ACTIVE, DEAD }; bool unk384; // 0x0384 - Do rumble on charge - s8 unk385; // 0x0385 - Spray state - s16 unk386; // 0x0386 - Spray quarterframes left - f32 unk388; // 0x0388 - trigger on fill + u8 unk385; // 0x0385 - Spray state + s16 unk386; // 0x0386 - Spray quarterframes left? (Using mTriggerTime in + // emitParams) + f32 unk388; // 0x0388 - Possibly spray rate u32 unk38C; // 0x038C - SoundID to play on charge }; diff --git a/include/Player/Watergun.hpp b/include/Player/Watergun.hpp index ed4551f9..b3eabb0b 100644 --- a/include/Player/Watergun.hpp +++ b/include/Player/Watergun.hpp @@ -21,7 +21,7 @@ class TWaterGunParams : public TParams { , PARAM_INIT(mNozzleAngleYSpeedMax, 0x2000) , PARAM_INIT(mHoverRotMax, 0x2000) , PARAM_INIT(mHoverSmooth, 0.05f) - , PARAM_INIT(mChangeSpeed, 0.1f) {}; + , PARAM_INIT(mChangeSpeed, 0.1f) { }; TParamRT mRocketHeight; TParamRT mHoverHeight; TParamRT mLAngleNormal; @@ -39,14 +39,14 @@ struct NozzleJointData { }; struct NozzleData { - /* 0x00 */ u32 _00; // Number of water streams emitted by this nozzle - /* 0x04 */ u32 _04; // Unused padding + /* 0x00 */ u32 _00; // Number of water streams emitted by this nozzle + /* 0x04 */ u32 _04; // Unused padding /* 0x08 */ const char* mHelmetPath; // Path to optional helmet model (used // by underwater nozzle) /* 0x0C */ const char* mPath; // Path to base nozzle model directory /* 0x10 */ const char* mBmdPath; // Full path to nozzle's BMD model file - /* 0x14 */ u8 mNumEmitters; // Number of water emitter points on the nozzle - /* 0x15 */ u8 _15; // Unknown/padding + /* 0x14 */ u8 mNumEmitters; // Number of water emitter points on the nozzle + /* 0x15 */ u8 _15; // Unknown/padding /* 0x16 */ NozzleJointData mJoints[3]; // Array of joint data for the nozzle }; diff --git a/include/System/MarioGamePad.hpp b/include/System/MarioGamePad.hpp index 403db2fe..f9daf517 100644 --- a/include/System/MarioGamePad.hpp +++ b/include/System/MarioGamePad.hpp @@ -25,8 +25,8 @@ struct TMarioControllerWork { /* 0x10 */ f32 mStickH; /* 0x14 */ f32 mStickV; /* 0x18 */ f32 mStickDist; - /* 0x1C */ f32 mAnalogL; - /* 0x20 */ f32 mAnalogR; + /* 0x1C */ f32 mAnalogR; + /* 0x20 */ f32 mAnalogL; }; class TMarioGamePad : public JUTGamePad { diff --git a/src/Player/WaterGun.cpp b/src/Player/WaterGun.cpp index 454debc0..8e632bd4 100644 --- a/src/Player/WaterGun.cpp +++ b/src/Player/WaterGun.cpp @@ -11,6 +11,7 @@ #include #include +#include #include // Define the global variable in .data section @@ -902,7 +903,123 @@ void TNozzleTrigger::init() void TNozzleTrigger::movement(const TMarioControllerWork& controllerWork) { // TODO: Missing stack space - volatile u32 unused2[2]; + volatile u32 unused[54]; + + if (mFludd->mCurrentWater <= 0) { + unk385 = TNozzleTrigger::INACTIVE; + unk386 = 0; + unk388 = 0.0f; + return; + } + + if (unk385 == TNozzleTrigger::ACTIVE) { + unk386 -= 1; + + // Very likely an inline + bool check; + if (mFludd->mMario->unk380 == 0) { + check = true; + } else { + check = false; + } + if (!check || unk386 <= 0) { + unk385 = TNozzleTrigger::DEAD; + unk388 = 0.0f; + unk386 = 0; + } + } + // Spam spray sound? + if ((unk384 == true + && (controllerWork.mFrameInput & TMarioControllerWork::A) != 0 + && (controllerWork.mInput & TMarioControllerWork::R) != 0) + && unk385 == TNozzleTrigger::INACTIVE) { + unk385 = TNozzleTrigger::ACTIVE; + if (unk38C != 0xffffffff) { + u32 soundId; + if (unk378 < 1.0f) { + soundId = 0x806; + } else { + soundId = 0x805; + } + bool canPlay = gpMSound->gateCheck(soundId); + if (canPlay) { + MSoundSESystem::MSoundSE::startSoundActor( + soundId, mFludd->mEmitPos[0], 0, nullptr, 0, 4); + } + } + unk386 = mEmitParams.mTriggerTime.get(); + } + + TMario* mario = mFludd->mMario; + + // Most likely some inlined stuff, not matching + bool canSpray; + bool other = true; + if (mario->unk380 == 0) { + canSpray = true; + } else { + canSpray = false; + } + if ((mario->mAttributes & 0x30000) == 0 + && mFludd->mCurrentWater < mEmitParams.mAmountMax.get()) { + canSpray = false; + } + + if (other && canSpray == true) { + unk388 += 150.0f * controllerWork.mAnalogR; + if (!unk384 && unk385 == TNozzleTrigger::INACTIVE) { + // Pretty certain there is some inline function shenanigans here + // Also what? + // if(gpMarDirector->unk58 == (gpMarDirector->unk58 / mario->unk568) + // * mario->unk568) { + SMSRumbleMgr->start((int)0x14, (int)mario->unk564, (f32*)nullptr); + //} + } + if (unk384 && unk385 == TNozzleTrigger::INACTIVE + && controllerWork.mAnalogR > 0.0f) { + bool canPlay = gpMSound->gateCheck(0x4022); + if (canPlay) { + MSoundSESystem::MSoundSE::startSoundActor( + 0x4022, mFludd->mEmitPos[0], 0, nullptr, 0, 4); + } + } + } + unk388 -= mEmitParams.mInsidePressureDec.get(); + if (unk388 < 0.0f) { + unk388 = 0.0f; + } + + if (unk388 > mEmitParams.mInsidePressureMax.get()) { + unk388 = mEmitParams.mInsidePressureMax.get(); + if (!unk384 && unk385 == TNozzleTrigger::INACTIVE) { + unk385 = TNozzleTrigger::ACTIVE; + unk386 = mEmitParams.mTriggerTime.get(); + u32 soundId = unk38C; + if (soundId != 0xffffffff) { + // Non matching: Produces mr r4, r29 instead of addi r4, r29, 0 + const Vec* soundPos = (Vec*)(&mFludd->mEmitPos[0]); + bool canPlay = gpMSound->gateCheck(soundId); + if (canPlay) { + MSoundSESystem::MSoundSE::startSoundActor(soundId, soundPos, + 0, nullptr, 0, 4); + } + } + if (mFludd->mCurrentNozzle == (s8)TWaterGun::Hover) { + SMSRumbleMgr->start((int)0x15, 0x8, (f32*)nullptr); + } + if (mFludd->mCurrentNozzle == (s8)TWaterGun::Rocket + || mFludd->mCurrentNozzle == (s8)TWaterGun::Turbo) { + SMSRumbleMgr->start((int)0x15, 0x14, (f32*)nullptr); + } + } + } + + if (unk385 == TNozzleTrigger::DEAD) { + unk388 = 0.0f; + if (controllerWork.mAnalogR == 0.0f) { + unk385 = TNozzleTrigger::INACTIVE; + } + } calcGunAngle(controllerWork); } @@ -915,7 +1032,7 @@ void TNozzleBase::movement(const TMarioControllerWork& controllerWork) if (this->mFludd->mCurrentWater <= 0) { return; } - s32 var1 = 256.0f * controllerWork.mAnalogL * 150.0f; + s32 var1 = 256.0f * controllerWork.mAnalogR * 150.0f; if (var1 > unk372) { unk378 = (var1 - unk372) * 0.000015258789f; @@ -1073,7 +1190,7 @@ void TWaterGun::rotateProp(f32 rotation) void TWaterGun::triggerPressureMovement( const TMarioControllerWork& controllerWork) { - mCurrentPressure = controllerWork.mAnalogL * 150.0f; + mCurrentPressure = controllerWork.mAnalogR * 150.0f; TNozzleBase* currentNozzle = getCurrentNozzle(); currentNozzle->movement(controllerWork); From 8c3fe662c17caf030af91723812f6a16aeda8e65 Mon Sep 17 00:00:00 2001 From: theAzack9 Date: Thu, 29 Jan 2026 18:28:11 +0100 Subject: [PATCH 5/9] Cleanup to reduce assumptions --- .../JSystem/J3D/J3DGraphAnimator/J3DModel.hpp | 10 +- include/Player/MarioMain.hpp | 7 +- include/Player/NozzleBase.hpp | 12 +- include/Player/NozzleDeform.hpp | 2 +- include/Player/NozzleTrigger.hpp | 25 +- include/Player/Watergun.hpp | 188 +++++------ include/System/ParamInst.hpp | 8 +- include/gpMarDirector.hpp | 2 + src/JSystem/J3D/J3DGraphAnimator/J3DModel.cpp | 22 +- src/Map/MapMirror.cpp | 2 +- src/Player/WaterGun.cpp | 317 +++++++++--------- src/Strategic/liveactor.cpp | 2 +- src/System/Params.cpp | 4 +- src/System/TargetArrow.cpp | 2 +- 14 files changed, 294 insertions(+), 309 deletions(-) diff --git a/include/JSystem/J3D/J3DGraphAnimator/J3DModel.hpp b/include/JSystem/J3D/J3DGraphAnimator/J3DModel.hpp index 3410a9ec..f4137185 100644 --- a/include/JSystem/J3D/J3DGraphAnimator/J3DModel.hpp +++ b/include/JSystem/J3D/J3DGraphAnimator/J3DModel.hpp @@ -244,9 +244,9 @@ class J3DModel { J3DSkinDeform* getSkinDeform() { return mSkinDeform; } // TODO: might be wrong - MtxPtr getBaseTRMtx() { return mBaseMtx; } - void setBaseTRMtx(Mtx m) { MTXCopy(m, mBaseMtx); } - void setBaseScale(const Vec& scale) { mBaseScale = scale; } + MtxPtr getBaseTRMtx() { return unk20; } + void setBaseTRMtx(Mtx m) { MTXCopy(m, unk20); } + void setBaseScale(const Vec& scale) { unk14 = scale; } virtual ~J3DModel(); @@ -255,8 +255,8 @@ class J3DModel { /* 0x08 */ u32 unk8; /* 0x0C */ J3DCalcCallBack unkC; char pad1[0x4]; - /* 0x14 */ Vec mBaseScale; - /* 0x20 */ Mtx mBaseMtx; + /* 0x14 */ Vec unk14; // mBaseScale + /* 0x20 */ Mtx unk20; // mBaseMtx /* 0x50 */ u8* mScaleFlagArr; /* 0x54 */ u8* mEvlpScaleFlagArr; /* 0x58 */ Mtx* mNodeMatrices; diff --git a/include/Player/MarioMain.hpp b/include/Player/MarioMain.hpp index 99768ce4..a51439b8 100644 --- a/include/Player/MarioMain.hpp +++ b/include/Player/MarioMain.hpp @@ -17,9 +17,10 @@ class J3DAnmTransform; struct TBGWallCheckRecord; // TODO: where should this be? -enum E_SIDEWALK_TYPE {}; +enum E_SIDEWALK_TYPE { }; -// TODO: Where should this be? +// TODO: Not quite sure how to structure this +// Please change or comment if you have a better idea :) #define ATTR_IS_ABOVE_SEWER_FLOOR 0x1 #define ATTR_IS_VISIBLE 0x2 #define ATTR_IS_NPC_TALKING 0x8 @@ -1101,7 +1102,7 @@ class TMario : public TTakeActor, public TDrawSyncCallback { bool hasAttribute(u32 attribute) const { bool hasAttribute; - if ((this->mAttributes & attribute) != 0) { + if ((mAttributes & attribute) != 0) { hasAttribute = true; } else { hasAttribute = false; diff --git a/include/Player/NozzleBase.hpp b/include/Player/NozzleBase.hpp index 105445ab..03829dd6 100644 --- a/include/Player/NozzleBase.hpp +++ b/include/Player/NozzleBase.hpp @@ -108,8 +108,8 @@ class TNozzleBase { virtual void init(); virtual inline s32 getNozzleKind() const; - virtual inline s16 getGunAngle() { return this->mGunAngle; } - virtual inline s16 getWaistAngle() { return this->mWaistAngle; } + virtual inline s16 getGunAngle() { return unk36E; } + virtual inline s16 getWaistAngle() { return unk370; } virtual void movement(const TMarioControllerWork&); virtual void emitCommon(int, TWaterEmitInfo*); virtual void emit(int); @@ -118,14 +118,14 @@ class TNozzleBase { void calcGunAngle(const TMarioControllerWork&); /* 0x368 */ TWaterGun* mFludd; - /* 0x36C */ u16 mAnimState; - /* 0x36E */ s16 mGunAngle; - /* 0x370 */ s16 mWaistAngle; + /* 0x36C */ u16 unk36C; // Some animation state + /* 0x36E */ s16 unk36E; // Gun angle + /* 0x370 */ s16 unk370; // Waist angle /* 0x372 */ u16 unk372; /* 0x374 */ f32 unk374; /* 0x378 */ f32 unk378; /* 0x37C */ f32 unk37C; - /* 0x380 */ MActor* mActor; + /* 0x380 */ MActor* unk380; // MActor }; // 0x384 #endif diff --git a/include/Player/NozzleDeform.hpp b/include/Player/NozzleDeform.hpp index a020eabb..b12518fa 100644 --- a/include/Player/NozzleDeform.hpp +++ b/include/Player/NozzleDeform.hpp @@ -17,7 +17,7 @@ class TNozzleDeform : public TNozzleBase { virtual void emit(int); virtual void animation(int); - TNozzleTrigger mBomb; + /* 0x384 */ TNozzleTrigger mBomb; }; #endif diff --git a/include/Player/NozzleTrigger.hpp b/include/Player/NozzleTrigger.hpp index b452a8ae..97a5b1e5 100644 --- a/include/Player/NozzleTrigger.hpp +++ b/include/Player/NozzleTrigger.hpp @@ -9,12 +9,12 @@ class TNozzleTrigger : public TNozzleBase { TNozzleTrigger(const char* name, const char* prm, TWaterGun* fludd) : TNozzleBase(name, prm, fludd) { - mSoundID = 0xffffffff; - mRumbleOnCharge = false; - mSprayState = INACTIVE; - mAnimState = 0; - mSprayQuarterFramesLeft = 0; - mTriggerFill = 0.0f; + unk38C = 0xffffffff; + unk384 = false; + unk385 = INACTIVE; + unk36C = 0; + unk386 = 0; + unk388 = 0.0f; } virtual void init(); @@ -23,13 +23,16 @@ class TNozzleTrigger : public TNozzleBase { virtual void emit(int); virtual void animation(int); + // Inactive = not holding R, Active = charging R, Dead = R Waiting to be + // depressed enum SPRAYSTATE { INACTIVE, ACTIVE, DEAD }; - bool mRumbleOnCharge; // 0x0384 - s8 mSprayState; // 0x0385 - s16 mSprayQuarterFramesLeft; // 0x0386 - f32 mTriggerFill; // 0x0388 - u32 mSoundID; // 0x038C + /* 0x384 */ bool unk384; // mRumbleOnCharge + /* 0x385 */ s8 unk385; // mSprayState, Current spray state + /* 0x386 */ s16 unk386; // mSprayQuarterFramesLeft - Quarter frames left of + // spray (i think) + /* 0x388 */ f32 unk388; // mTriggerFill - How far the trigger has gotten + /* 0x38C */ u32 unk38C; // mSoundID - The sound to play when triggering }; #endif diff --git a/include/Player/Watergun.hpp b/include/Player/Watergun.hpp index a69593ec..47c01912 100644 --- a/include/Player/Watergun.hpp +++ b/include/Player/Watergun.hpp @@ -21,7 +21,7 @@ class TWaterGunParams : public TParams { , PARAM_INIT(mNozzleAngleYSpeedMax, 0x2000) , PARAM_INIT(mHoverRotMax, 0x2000) , PARAM_INIT(mHoverSmooth, 0.05f) - , PARAM_INIT(mChangeSpeed, 0.1f) {}; + , PARAM_INIT(mChangeSpeed, 0.1f) { }; TParamRT mRocketHeight; TParamRT mHoverHeight; TParamRT mLAngleNormal; @@ -81,6 +81,8 @@ extern TNozzleBmdData nozzleBmdData; class TWaterGun { public: + // TODO: I wish these could be combined + // If i make it a named enum, it defaults to 4 bytes size (i think) typedef s8 TNozzleType; enum { Spray = 0, Rocket, Underwater, Yoshi, Hover, Turbo }; @@ -110,40 +112,27 @@ class TWaterGun { void setAmountToRate(f32); void setBaseTRMtx(Mtx); bool suck(); - void startDashEffect(); - void endDashEffect(); - void getMarioUpperStatus(); + void triggerPressureMovement(const TMarioControllerWork&); + + J3DModel* getModel() { return mFluddModel->unk4; } + // Fabricated + // Probably inlined from Yoshi inline MtxPtr getYoshiMtx() { - TYoshi* yoshi = (TYoshi*)this->mMario->mYoshi; + TYoshi* yoshi = (TYoshi*)mMario->mYoshi; return yoshi->mActor->unk4->getAnmMtx(yoshi->mJoint); } - void decWater() { } - + // Fabricated void checkMax() { - s32 maxWater = this->getCurrentNozzle()->mEmitParams.mAmountMax.get(); - if (this->mCurrentWater > maxWater) { - this->mCurrentWater = maxWater; + s32 maxWater = getCurrentNozzle()->mEmitParams.mAmountMax.get(); + if (mCurrentWater > maxWater) { + mCurrentWater = maxWater; } } - bool isYoshiNozzle() const { return this->mCurrentNozzle == (s8)Yoshi; } - - bool hasWater() const { return this->mCurrentWater > 0; } - - u32 getWaterGunAnmId(); - - J3DModel* getModel() { return this->mFluddModel->unk4; } - - void setEmitPt(); - - void finalDrawInitialize(); - void entryAll(); - void createGunBody(); - // Fabricated // TODO: Probably not in Watergun void startSound(u32 id, const Vec* pos) @@ -165,7 +154,7 @@ class TWaterGun { inline bool hasFlag(u16 flag) { bool hasFlag; - if ((this->mFlags & flag) != 0) { + if ((mFlags & flag) != 0) { hasFlag = true; } else { hasFlag = false; @@ -174,114 +163,107 @@ class TWaterGun { } // Fabricated - // TODO: Possibly in each nozzle class? - inline void playSprayNozzleSound(u32 id, f32 val) - { - JGeometry::TVec3* emitPos = &mEmitPos[0]; - playSoundWithInfo(id, emitPos, 0, val); - } - - // Fabricated - // TODO: This is definitely not the structure - // Figure out something better for sound funcs - inline void playSound2(u32 id) - { - JGeometry::TVec3* emitPos = &mEmitPos[0]; - trySound(id, emitPos); - } - s32 getSuckRate() { - return (s32)((f32)this->mCurrentPressure - * this->getCurrentNozzle()->mEmitParams.mSuckRate.get()); + return (s32)((f32)mCurrentPressure + * getCurrentNozzle()->mEmitParams.mSuckRate.get()); } - s32 getCurrentWater() { return this->mCurrentWater; } + // Fabricated + s32 getCurrentWater() { return mCurrentWater; } + // Fabricated s32 getMaxWater() { - return this->getCurrentNozzle()->mEmitParams.mAmountMax.get(); + return getCurrentNozzle()->mEmitParams.mAmountMax.get(); } - bool isMaxWater() { return this->getCurrentWater() >= this->getMaxWater(); } + // Fabricated + bool isMaxWater() { return getCurrentWater() >= getMaxWater(); } + // Fabricated void trySound(u32 id, JGeometry::TVec3* pos) { MSound* sound = gpMSound; if (sound->gateCheck(id)) { - this->startSound(id, pos); + startSound(id, pos); } } + // Fabricated void incWater(s32 amount) { - this->mCurrentWater += amount; + mCurrentWater += amount; - s32 currentWater = this->getCurrentWater(); - s32 maxWater = this->getMaxWater(); + s32 currentWater = getCurrentWater(); + s32 maxWater = getMaxWater(); if (currentWater > maxWater) { mCurrentWater = maxWater; } if (!isMaxWater()) { - JGeometry::TVec3* emitPos = &this->mEmitPos[0]; + JGeometry::TVec3* emitPos = &mEmitPos[0]; trySound(0xf, emitPos); } } - TNozzleBase* getNozzle(u8 index) { return this->mNozzleList[index]; } + // Fabricated + TNozzleBase* getNozzle(u8 index) { return mNozzleList[index]; } - void triggerPressureMovement(const TMarioControllerWork&); + // Fabricated + bool isYoshiNozzle() const { return mCurrentNozzle == (s8)Yoshi; } - u16 mFlags; // 0x0000 - TMario* mMario; // 0x0008 - TNozzleDeform mNozzleDeform; // 0x000C - TNozzleTrigger mNozzleRocket; // 0x0720 - TNozzleBase mNozzleUnderWater; // 0x0AB0 - TNozzleDeform mNozzleYoshiDeform; // 0x0E34 - TNozzleTrigger mNozzleHover; // 0x1548 - TNozzleTrigger mNozzleTurbo; // 0x18D8 - TNozzleBase* mNozzleList[6]; // 0x1C68 - s32 mCurrentWater; // 0x1C80 - u8 mCurrentNozzle; // 0x1C84 - u8 mSecondNozzle; // 0x1C85 - bool mIsEmitWater; // 0x1C86 - u8 unk1C87; // 0x1C87 - u32 unk1C88; // 0x1C88 - u8 mCurrentPressure; // 0x1c8c - u8 mPreviousPressure; // 0x1c8d - u8 unk1C8E; // 0x1c8e - u8 unk1C8F; // 0x1c8f - JGeometry::TVec3 mEmitPos[4]; // 0x1C90 - s16 unk1CC0; // 0x1CC0 - s16 unk1CC2; // 0x1CC2 - s16 unk1CC4; // 0x1CC4 - s16 unk1CC6; // 0x1CC6 - f32 mNozzleSpeedY; // 0x1CC8 - f32 mNozzleSpeedZ; // 0x1CCC - s16 unk1CD0; // 0x1CD0 - s16 unk1CD2; // 0x1CD2 - MActor* mFluddModel; // 0x1CD4 // MActor* - u8 mCurFluddTransformIdx; // 0x1CD8 - u8 unk1CD9; // 0x1CD9 - u16 unk1CDA; // 0x1CDA - f32 unk1CDC; // 0x1CDC - f32 unk1CE0; // 0x1CE0 - u32 unk1CE4; // 0x1CE4 - u32 unk1CE8; // 0x1CE8 - f32 unk1CEC; // 0x1CEC - f32 unk1CF0; // 0x1CF0 - f32 unk1CF4; // 0x1CF4 - u16 unk1CF8; // 0x1CF8 - u16 unk1CFA; // 0x1CFA - f32 mFluddSwitchTween; // 0x1CFC - f32 unk1D00; // 0x1D00 - s16 unk1D04; // 0x1D04 - s16 unk1D06; // 0x1D06 - u32 unk1D08; // 0x1D08 - TWaterEmitInfo* mEmitInfo; // 0x1D0C // TWaterEmitInfo - TMirrorActor* unk1D10; // 0x1D10 - - TWaterGunParams mWatergunParams; // 0x1d14 + // Fabricated + bool hasWater() const { return mCurrentWater > 0; } + + /* 0x0000 */ u16 mFlags; + /* 0x0008 */ TMario* mMario; + /* 0x000C */ TNozzleDeform mNozzleDeform; + /* 0x0720 */ TNozzleTrigger mNozzleRocket; + /* 0x0AB0 */ TNozzleBase mNozzleUnderWater; + /* 0x0E34 */ TNozzleDeform mNozzleYoshiDeform; + /* 0x1548 */ TNozzleTrigger mNozzleHover; + /* 0x18D8 */ TNozzleTrigger mNozzleTurbo; + /* 0x1C68 */ TNozzleBase* mNozzleList[6]; + /* 0x1C80 */ s32 mCurrentWater; + /* 0x1C84 */ u8 mCurrentNozzle; + /* 0x1C85 */ u8 mSecondNozzle; + /* 0x1C86 */ bool mIsEmitWater; + /* 0x1C87 */ u8 unk1C87; + /* 0x1C88 */ u32 unk1C88; + /* 0x1c8c */ u8 mCurrentPressure; + /* 0x1c8d */ u8 mPreviousPressure; + /* 0x1c8e */ u8 unk1C8E; + /* 0x1c8f */ u8 unk1C8F; + /* 0x1C90 */ JGeometry::TVec3 mEmitPos[4]; + /* 0x1CC0 */ s16 unk1CC0; + /* 0x1CC2 */ s16 unk1CC2; + /* 0x1CC4 */ s16 unk1CC4; + /* 0x1CC6 */ s16 unk1CC6; + /* 0x1CC8 */ f32 unk1CC8; // mNozzleSpeedY + /* 0x1CCC */ f32 unk1CCC; // mNozzleSpeedZ + /* 0x1CD0 */ s16 unk1CD0; + /* 0x1CD2 */ s16 unk1CD2; + /* 0x1CD4 */ MActor* mFluddModel; // MActor* + /* 0x1CD8 */ u8 unk1CD8; // mCurFluddTransformIdx + /* 0x1CD9 */ u8 unk1CD9; + /* 0x1CDA */ u16 unk1CDA; + /* 0x1CDC */ f32 unk1CDC; + /* 0x1CE0 */ f32 unk1CE0; + /* 0x1CE4 */ u32 unk1CE4; + /* 0x1CE8 */ u32 unk1CE8; + /* 0x1CEC */ f32 unk1CEC; + /* 0x1CF0 */ f32 unk1CF0; + /* 0x1CF4 */ f32 unk1CF4; + /* 0x1CF8 */ u16 unk1CF8; + /* 0x1CFA */ u16 unk1CFA; + /* 0x1CFC */ f32 unk1CFC; // mFluddSwitchTween + /* 0x1D00 */ f32 unk1D00; + /* 0x1D04 */ s16 unk1D04; + /* 0x1D06 */ s16 unk1D06; + /* 0x1D08 */ u32 unk1D08; + /* 0x1D0C */ TWaterEmitInfo* mEmitInfo; // TWaterEmitInfo + /* 0x1D10 */ TMirrorActor* unk1D10; + /* 0x1d14 */ TWaterGunParams mWatergunParams; }; #endif diff --git a/include/System/ParamInst.hpp b/include/System/ParamInst.hpp index dd54436d..11ca6e48 100644 --- a/include/System/ParamInst.hpp +++ b/include/System/ParamInst.hpp @@ -26,8 +26,8 @@ template class TParamT : public TBaseParam { template class TParamRT : public TParamT { public: - TParamRT(TParams* parent, u16 code, const char* name, T defaultValue) - : TParamT(parent, code, name, defaultValue) + TParamRT(TParams* parent, u16 keycode, const char* name, T defaultValue) + : TParamT(parent, keycode, name, defaultValue) { } @@ -47,9 +47,9 @@ template class TParamRT : public TParamT { class TParamVec : public TParamT > { public: // fabricated AND wrong - TParamVec(TParams* parent, u16 code, const char* name, + TParamVec(TParams* parent, u16 keycode, const char* name, JGeometry::TVec3 defaultValue) - : TParamT >(parent, code, name, defaultValue) + : TParamT >(parent, keycode, name, defaultValue) { } }; diff --git a/include/gpMarDirector.hpp b/include/gpMarDirector.hpp index 9b635b82..121ea7bd 100644 --- a/include/gpMarDirector.hpp +++ b/include/gpMarDirector.hpp @@ -3,6 +3,8 @@ #include "GC2D/GCConsole2.hpp" +// Very barebones +// TODO: Add functions extern class TMarDirector { public: char pad_000[0x58]; diff --git a/src/JSystem/J3D/J3DGraphAnimator/J3DModel.cpp b/src/JSystem/J3D/J3DGraphAnimator/J3DModel.cpp index c451a3be..0ed08d37 100644 --- a/src/JSystem/J3D/J3DGraphAnimator/J3DModel.cpp +++ b/src/JSystem/J3D/J3DGraphAnimator/J3DModel.cpp @@ -473,16 +473,16 @@ J3DModel::~J3DModel() { } void J3DModel::initialize() { - unkC = nullptr; - unk8 = 0; - mModelData = nullptr; - mDeformData = 0; - mSkinDeform = nullptr; - mBaseScale.x = 1.0; - mBaseScale.y = 1.0; - mBaseScale.z = 1.0; + unkC = nullptr; + unk8 = 0; + mModelData = nullptr; + mDeformData = 0; + mSkinDeform = nullptr; + unk14.x = 1.0; + unk14.y = 1.0; + unk14.z = 1.0; - MTXIdentity(mBaseMtx); + MTXIdentity(unk20); mScaleFlagArr = nullptr; mEvlpScaleFlagArr = nullptr; @@ -688,7 +688,7 @@ void J3DModel::update() // TODO: missing unknown virtual calls j3dSys.setCurrentMtxCalc(mModelData->unk14); - mModelData->unk14->init(mBaseScale, mBaseMtx); + mModelData->unk14->init(unk14, unk20); j3dSys.setTexture(mModelData->getTexture()); mModelData->unk14->recursiveCalc(mModelData->mRootNode); @@ -727,7 +727,7 @@ void J3DModel::calc() // TODO: missing unknown virtual calls j3dSys.setCurrentMtxCalc(mModelData->unk14); - mModelData->unk14->init(mBaseScale, mBaseMtx); + mModelData->unk14->init(unk14, unk20); j3dSys.setTexture(mModelData->getTexture()); mModelData->unk14->recursiveCalc(mModelData->mRootNode); diff --git a/src/Map/MapMirror.cpp b/src/Map/MapMirror.cpp index 2b116856..be117801 100644 --- a/src/Map/MapMirror.cpp +++ b/src/Map/MapMirror.cpp @@ -91,7 +91,7 @@ static u8 getVertexFormat(const J3DModelData* model_data, GXAttr attr) void TMirrorModel::setPlane() { - MtxPtr mtx = unk4->unk4->mBaseMtx; + MtxPtr mtx = unk4->unk4->unk20; MTXMultVec(mtx, &unkC, &unkC); MTXMultVecSR(mtx, &unk18, &unk18); VECNormalize(&unk18, &unk18); diff --git a/src/Player/WaterGun.cpp b/src/Player/WaterGun.cpp index 40ee4d1f..2c44fcca 100644 --- a/src/Player/WaterGun.cpp +++ b/src/Player/WaterGun.cpp @@ -123,7 +123,7 @@ static bool WaterGunDivingCtrlL(J3DNode* node, BOOL param_2) // This looks very weird to me, probably because of some inline? // I could imagine some s32 getNozzleSpeedY() and // s16 localXXX = -getNozzleSpeedY(); - s32 nozzleSpeedY = gpMarioForCallBack->mWaterGun->mNozzleSpeedY; + s32 nozzleSpeedY = gpMarioForCallBack->mWaterGun->unk1CC8; s16 neg = -nozzleSpeedY; Mtx mtx; // Unused stack space @@ -140,7 +140,7 @@ static bool WaterGunDivingCtrlR(J3DNode* node, BOOL param_2) // This looks very weird to me, probably because of some inline? // I could imagine some s32 getNozzleSpeedY() and // s16 localXXX = -getNozzleSpeedY(); - s32 nozzleSpeedY = gpMarioForCallBack->mWaterGun->mNozzleSpeedZ; + s32 nozzleSpeedY = gpMarioForCallBack->mWaterGun->unk1CCC; s16 neg = -nozzleSpeedY; Mtx mtx; // Unused stack space @@ -155,18 +155,18 @@ static bool WaterGunDivingCtrlR(J3DNode* node, BOOL param_2) void TWaterGun::init() { - mFlags = 0; - mNozzleList[Spray] = &mNozzleDeform; - mNozzleList[Rocket] = &mNozzleRocket; - mNozzleList[Underwater] = &mNozzleUnderWater; - mNozzleList[Yoshi] = &mNozzleYoshiDeform; - mNozzleList[Hover] = &mNozzleHover; - mNozzleList[Turbo] = &mNozzleTurbo; - mCurrentNozzle = Spray; - mSecondNozzle = Hover; - mNozzleRocket.mSoundID = 0x81b; - mNozzleTurbo.mSoundID = 0x814; - mNozzleDeform.mBomb.mSoundID = 0x813; + mFlags = 0; + mNozzleList[Spray] = &mNozzleDeform; + mNozzleList[Rocket] = &mNozzleRocket; + mNozzleList[Underwater] = &mNozzleUnderWater; + mNozzleList[Yoshi] = &mNozzleYoshiDeform; + mNozzleList[Hover] = &mNozzleHover; + mNozzleList[Turbo] = &mNozzleTurbo; + mCurrentNozzle = Spray; + mSecondNozzle = Hover; + mNozzleRocket.unk38C = 0x81b; + mNozzleTurbo.unk38C = 0x814; + mNozzleDeform.mBomb.unk38C = 0x813; mCurrentWater = mNozzleList[mCurrentNozzle]->mEmitParams.mAmountMax.get(); mIsEmitWater = false; unk1C88 = 0.0f; @@ -177,7 +177,7 @@ void TWaterGun::init() unk1CF4 = 0.0049999999f; unk1CF8 = 0x168; unk1CFA = 0; - mFluddSwitchTween = 0.0f; + unk1CFC = 0.0f; unk1D00 = 0.0f; unk1D04 = 0; unk1D06 = -0x1800; @@ -185,9 +185,9 @@ void TWaterGun::init() // mEmitInfo = new TWaterEmitInfo; TODO - unk1D08 = 0; - mNozzleDeform.mBomb.mRumbleOnCharge = true; - mNozzleYoshiDeform.mBomb.mRumbleOnCharge = true; + unk1D08 = 0; + mNozzleDeform.mBomb.unk384 = true; + mNozzleYoshiDeform.mBomb.unk384 = true; mEmitPos[3].x = mMario->mPosition.x; mEmitPos[3].y = mMario->mPosition.y; @@ -197,9 +197,9 @@ void TWaterGun::init() unk1CC2 = 0; unk1CC4 = 0; - mNozzleSpeedY = 0.0f; - unk1CD0 = 0; - unk1CD2 = 0; + unk1CC8 = 0.0f; + unk1CD0 = 0; + unk1CD2 = 0; // This is definitely an inlined funciton. Creating a model seems quite // useful @@ -218,7 +218,7 @@ void TWaterGun::init() // Missing decompilation // PSMTXCopy( // mMario->mModelMario->unk8->mJointArray[mMario->mBindBoneIDArray[0]], - // mFluddModel->unk4->mBaseMtx); + // mFluddModel->unk4->unk20); mFluddModel->unk4->initialize(); @@ -227,57 +227,56 @@ void TWaterGun::init() // unk1CDC is TMultiMtxEffect, but confused from implementation atm - mCurFluddTransformIdx - = mFluddModel->unk4->mModelData->unkB0->getIndex("nozzle_center"); + unk1CD8 = mFluddModel->unk4->mModelData->unkB0->getIndex("nozzle_center"); for (int i = 0; i < 6; ++i) { if (!nozzleBmdData.getPath(i)) { - mNozzleList[i]->mActor = nullptr; + mNozzleList[i]->unk380 = nullptr; continue; } MActorAnmData* nozzleData = new MActorAnmData(); nozzleData->init(nozzleBmdData.getPath(i), nullptr); - mNozzleList[i]->mActor = new MActor(nozzleData); + mNozzleList[i]->unk380 = new MActor(nozzleData); void* nozzleModelData = JKRFileLoader::getGlbResource(nozzleBmdData.getBmdPath(i)); J3DModel* nozzleModel = new J3DModel( J3DModelLoaderDataBase::load(nozzleModelData, 0x10040000), 0, 1); - mNozzleList[i]->mActor->setModel(nozzleModel, 0); + mNozzleList[i]->unk380->setModel(nozzleModel, 0); // TODO: Figure out // ResTIMG* img = mFluddModel->unk4->mModelData->unkAC->getResTIMG(0); - // SMS_ChangeTextureAll(mNozzleList[i]->mActor->unk4->mModelData, + // SMS_ChangeTextureAll(mNozzleList[i]->unk380->unk4->mModelData, // "H_watergun_main_dummy", img); - mNozzleList[i]->mActor->initDL(); + mNozzleList[i]->unk380->initDL(); // Definitely inline potential if (nozzleBmdData.getFlags(i, 0) != 4) { s32 jointIdx - = mNozzleList[i]->mActor->unk4->mModelData->unkB0->getIndex( + = mNozzleList[i]->unk380->unk4->mModelData->unkB0->getIndex( "null_G_muzzle"); nozzleBmdData.setJointIndex(i, 0, jointIdx); } if (nozzleBmdData.getFlags(i, 1) != 4) { s32 jointIdx - = mNozzleList[i]->mActor->unk4->mModelData->unkB0->getIndex( + = mNozzleList[i]->unk380->unk4->mModelData->unkB0->getIndex( "null_G_muzzle2"); nozzleBmdData.setJointIndex(i, 1, jointIdx); } if (nozzleBmdData.getFlags(i, 2) != 4) { s32 jointIdx - = mNozzleList[i]->mActor->unk4->mModelData->unkB0->getIndex( + = mNozzleList[i]->unk380->unk4->mModelData->unkB0->getIndex( "null_G_muzzle3"); nozzleBmdData.setJointIndex(i, 2, jointIdx); } } s32 jointIdx - = mNozzleList[Spray]->mActor->unk4->mModelData->unkB0->getIndex( + = mNozzleList[Spray]->unk380->unk4->mModelData->unkB0->getIndex( "chn_muzzle_l"); // mNozzleList[Spray] - // ->mActor->unk4->mModelData->mJointNodePointer[jointIdx] + // ->unk380->unk4->mModelData->mJointNodePointer[jointIdx] // ->mCallBack = functionPtr; // 5 more of these @@ -381,15 +380,15 @@ MtxPtr TWaterGun::getEmitMtx(int jointIndex) volatile u32 unused2[24]; // TODO: A lot of stack space, possibly a lot of // inlined functions. MtxPtr result; - if (!this->mMario->onYoshi()) { - result = this->getYoshiMtx(); + if (!mMario->onYoshi()) { + result = getYoshiMtx(); } else { // This entire block is likely an inlined function. - u8 currentNozzle = this->mCurrentNozzle; + u8 currentNozzle = mCurrentNozzle; s8 flag = nozzleBmdData.getFlags(currentNozzle, jointIndex); if (flag < 3) { - return this->getCurrentNozzle()->mActor->unk4->getAnmMtx( - nozzleBmdData.getJointIndex(this->mCurrentNozzle, jointIndex)); + return getCurrentNozzle()->unk380->unk4->getAnmMtx( + nozzleBmdData.getJointIndex(mCurrentNozzle, jointIndex)); } else if (flag == 3) { return getYoshiMtx(); } @@ -400,7 +399,7 @@ MtxPtr TWaterGun::getEmitMtx(int jointIndex) MtxPtr TWaterGun::getNozzleMtx() { - return this->mFluddModel->unk4->getAnmMtx(this->mCurFluddTransformIdx); + return mFluddModel->unk4->getAnmMtx(unk1CD8); } void TWaterGun::initInLoadAfter() { } @@ -413,12 +412,12 @@ void TWaterGun::changeNozzle(TNozzleType nozzleType, bool animate) / mNozzleList[mCurrentNozzle]->mEmitParams.mAmountMax.get(); if (nozzleType == Spray) { if (animate) { - mFluddSwitchTween = 0.0f; + unk1CFC = 0.0f; } } else { mSecondNozzle = nozzleType; if (animate) { - mFluddSwitchTween = 1.0f; + unk1CFC = 1.0f; } } mCurrentNozzle = nozzleType; @@ -444,7 +443,7 @@ void TWaterGun::movement() if (kind == 1) { TNozzleTrigger* triggerNozzle = (TNozzleTrigger*)mNozzleList[mCurrentNozzle]; - if (triggerNozzle->mSprayState == TNozzleTrigger::ACTIVE) { + if (triggerNozzle->unk385 == TNozzleTrigger::ACTIVE) { canSpray = true; } else { canSpray = false; @@ -461,12 +460,10 @@ void TWaterGun::movement() unk1CC4 = 0; } - mNozzleSpeedY - += (unk1CC2 - mNozzleSpeedY) * mWatergunParams.mChangeSpeed.get(); - mNozzleSpeedZ - += (unk1CC4 - mNozzleSpeedZ) * mWatergunParams.mChangeSpeed.get(); + unk1CC8 += (unk1CC2 - unk1CC8) * mWatergunParams.mChangeSpeed.get(); + unk1CCC += (unk1CC4 - unk1CCC) * mWatergunParams.mChangeSpeed.get(); - TNozzleBase* currentNozzle = this->getCurrentNozzle(); + TNozzleBase* currentNozzle = getCurrentNozzle(); rotateProp(currentNozzle->unk378); @@ -500,9 +497,9 @@ void TWaterGun::movement() // Nozzle swapping if (unk1D00 != 0.0f) { - f32 unk = mFluddSwitchTween; - f32 sum = unk + unk1D00; - mFluddSwitchTween = sum; + f32 unk = unk1CFC; + f32 sum = unk + unk1D00; + unk1CFC = sum; if ((unk < 0.5f) && (0.5f <= sum)) { u8 curNozzle = mCurrentNozzle; s32 currentWater = mCurrentWater; @@ -515,7 +512,7 @@ void TWaterGun::movement() } mCurrentNozzle = secondNozzle; - currentNozzle = this->getCurrentNozzle(); + currentNozzle = getCurrentNozzle(); currentNozzle->init(); // TODO: 2 vtable entry if (secondNozzle == 3) { @@ -533,20 +530,20 @@ void TWaterGun::movement() mCurrentNozzle = 0; - currentNozzle = this->getCurrentNozzle(); + currentNozzle = getCurrentNozzle(); currentNozzle->init(); // TODO: 2 vtable entry mCurrentWater = waterPercentage * currentNozzle->mEmitParams.mAmountMax.get(); } - if (mFluddSwitchTween < 0.0) { - mFluddSwitchTween = 0.0f; - unk1D00 = 0.0f; + if (unk1CFC < 0.0) { + unk1CFC = 0.0f; + unk1D00 = 0.0f; } - if (1.0f < mFluddSwitchTween) { - mFluddSwitchTween = 1.0f; - unk1D00 = 0.0f; + if (1.0f < unk1CFC) { + unk1CFC = 1.0f; + unk1D00 = 0.0f; } } currentNozzle->animation(mCurrentNozzle); @@ -582,7 +579,7 @@ void TNozzleBase::emit(int param_1) { if (mFludd->mCurrentWater > 0 && unk378 != 0.0f) { TWaterEmitInfo* emitInfo = mFludd->mEmitInfo; - this->emitCommon(param_1, emitInfo); + emitCommon(param_1, emitInfo); unk37C = unk37C + mEmitParams.mNum.get(); s32 local37cInt = (s32)unk37C; @@ -679,7 +676,7 @@ void TWaterGun::setBaseTRMtx(Mtx mtx) MsMtxSetRotRPH(result, 0.0f, 0.0f, 0.005493164f * angle); PSMTXConcat(mtx, result, result); - PSMTXCopy(result, mFluddModel->unk4->mBaseMtx); + PSMTXCopy(result, mFluddModel->unk4->unk20); } // Not sure why this get's inlined aggressively @@ -689,21 +686,21 @@ TNozzleBase::TNozzleBase(const char* name, const char* prm, TWaterGun* fludd) , mFludd(fludd) { mEmitParams.load(mEmitParams.mPrmPath); - this->mAnimState = 2; - this->mGunAngle = 0; - this->unk372 = 0; - this->unk378 = 0.0f; - this->unk37C = 0.0f; + unk36C = 2; + unk36E = 0; + unk372 = 0; + unk378 = 0.0f; + unk37C = 0.0f; } #pragma dont_inline off void TNozzleBase::init() { - this->mAnimState = 2; - this->mGunAngle = 0; - this->unk372 = 0; - this->unk378 = 0.0f; - this->unk37C = 0.0f; + unk36C = 2; + unk36E = 0; + unk372 = 0; + unk378 = 0.0f; + unk37C = 0.0f; } void TNozzleBase::calcGunAngle(const TMarioControllerWork& work) @@ -712,14 +709,14 @@ void TNozzleBase::calcGunAngle(const TMarioControllerWork& work) if (mFludd->mMario == gpMarioAddress && (gpCamera->isLButtonCameraSpecifyMode(gpCamera->mMode) || gpCamera->isJetCoaster1stCamera())) { - mGunAngle = gpCamera->unkA4; + unk36E = gpCamera->unkA4; return; } s16 angle; if (mFludd->mMario->mAction == 0xC008220) { // TODO: Wrong reguster used, using r3 instead of r4 - angle = mGunAngle + angle = unk36E + (s16)(mFludd->mMario->mGamePad->mCompSPos[0].y * mEmitParams.mRButtonMult.get()); } else { @@ -734,8 +731,8 @@ void TNozzleBase::calcGunAngle(const TMarioControllerWork& work) angle = mEmitParams.mLAngleMax.get(); } - f32 diff = angle - mGunAngle; - mGunAngle += diff * mEmitParams.mLAngleChase.get(); + f32 diff = angle - unk36E; + unk36E += diff * mEmitParams.mLAngleChase.get(); } // TODO: This has a lot of inline functions, find them and update them @@ -746,35 +743,35 @@ void TNozzleBase::animation(int param_1) return; } - if (0.0f < this->mFludd->unk1D00) { - this->mAnimState = 4; + if (0.0f < mFludd->unk1D00) { + unk36C = 4; } - if (this->mFludd->unk1D00 < 0.0f) { - this->mAnimState = 3; + if (mFludd->unk1D00 < 0.0f) { + unk36C = 3; } - switch (this->mAnimState) { + switch (unk36C) { case 0: { - if (!this->mActor->checkCurBckFromIndex(4)) { - this->mActor->setBckFromIndex(4); + if (!unk380->checkCurBckFromIndex(4)) { + unk380->setBckFromIndex(4); } - J3DFrameCtrl* ctrl = this->mActor->getFrameCtrl(MActor::BCK); + J3DFrameCtrl* ctrl = unk380->getFrameCtrl(MActor::BCK); if (ctrl->mCurrentFrame <= (ctrl->mEndFrame - 0.1) && (ctrl->mFlags & 3) == 0) { return; } - this->mAnimState = 1; + unk36C = 1; break; } case 1: { - if (!this->mActor->checkCurBckFromIndex(2)) { - this->mActor->setBckFromIndex(2); + if (!unk380->checkCurBckFromIndex(2)) { + unk380->setBckFromIndex(2); } - TWaterGun* fludd = this->mFludd; + TWaterGun* fludd = mFludd; bool updateAnimation = false; if (fludd->mCurrentWater == 0) { updateAnimation = false; @@ -792,7 +789,7 @@ void TNozzleBase::animation(int param_1) if (nozzleKind == 1) { TNozzleTrigger* trigger = (TNozzleTrigger*)fludd->getCurrentNozzle(); - if (trigger->mSprayState == 1) { + if (trigger->unk385 == TNozzleTrigger::ACTIVE) { updateAnimation = true; } else { updateAnimation = false; @@ -811,15 +808,15 @@ void TNozzleBase::animation(int param_1) return; } - this->mAnimState = 2; + unk36C = 2; break; } case 2: { - if (!this->mActor->checkCurBckFromIndex(3)) { - this->mActor->setBckFromIndex(3); + if (!unk380->checkCurBckFromIndex(3)) { + unk380->setBckFromIndex(3); } - TWaterGun* fludd = this->mFludd; + TWaterGun* fludd = mFludd; bool updateAnimation = false; if (fludd->mCurrentWater == 0) { updateAnimation = false; @@ -837,7 +834,7 @@ void TNozzleBase::animation(int param_1) if (nozzleKind == 1) { TNozzleTrigger* trigger = (TNozzleTrigger*)fludd->getCurrentNozzle(); - if (trigger->mSprayState == 1) { + if (trigger->unk385 == TNozzleTrigger::ACTIVE) { updateAnimation = true; } else { updateAnimation = false; @@ -853,38 +850,38 @@ void TNozzleBase::animation(int param_1) } if (updateAnimation) { - this->mAnimState = 0; + unk36C = 0; } break; } case 3: { - J3DFrameCtrl* ctrl = this->mActor->getFrameCtrl(MActor::BCK); - if (!this->mActor->checkCurBckFromIndex(1)) { - this->mActor->setBckFromIndex(1); + J3DFrameCtrl* ctrl = unk380->getFrameCtrl(MActor::BCK); + if (!unk380->checkCurBckFromIndex(1)) { + unk380->setBckFromIndex(1); } // Use external tween value - ctrl->mCurrentFrame = this->mFludd->mFluddSwitchTween * ctrl->mEndFrame; + ctrl->mCurrentFrame = mFludd->unk1CFC * ctrl->mEndFrame; ctrl->mSpeed = 0.0f; break; } case 4: { - J3DFrameCtrl* ctrl = this->mActor->getFrameCtrl(MActor::BCK); - if (!this->mActor->checkCurBckFromIndex(0)) { - this->mActor->setBckFromIndex(0); + J3DFrameCtrl* ctrl = unk380->getFrameCtrl(MActor::BCK); + if (!unk380->checkCurBckFromIndex(0)) { + unk380->setBckFromIndex(0); } // Use external tween value - ctrl->mCurrentFrame = this->mFludd->mFluddSwitchTween * ctrl->mEndFrame; + ctrl->mCurrentFrame = mFludd->unk1CFC * ctrl->mEndFrame; ctrl->mSpeed = 0.0f; - if (this->mFludd->mFluddSwitchTween < 1.0f) { + if (mFludd->unk1CFC < 1.0f) { return; } - this->mAnimState = 0; + unk36C = 0; break; } } @@ -892,11 +889,11 @@ void TNozzleBase::animation(int param_1) void TNozzleTrigger::init() { - this->mRumbleOnCharge = false; - this->mSprayState = 0; - mAnimState = 0; - mSprayQuarterFramesLeft = 0; - mTriggerFill = 0.0f; + unk384 = false; + unk385 = 0; + unk36C = 0; + unk386 = 0; + unk388 = 0.0f; } void TNozzleBase::movement(const TMarioControllerWork& controllerWork) @@ -904,7 +901,7 @@ void TNozzleBase::movement(const TMarioControllerWork& controllerWork) // TODO: Missing stack space volatile u32 unused2[2]; - if (this->mFludd->mCurrentWater <= 0) { + if (mFludd->mCurrentWater <= 0) { return; } s32 var1 = 256.0f * controllerWork.mAnalogL * 150.0f; @@ -929,29 +926,27 @@ void TWaterGun::perform(u32 flags, JDrama::TGraphics* graphics) // volatile u32 unused2[24]; if ((flags & 0x1) != 0) { - if ((this->mFlags & 0x10) != 0) { - this->mCurrentWater = 0; + if ((mFlags & 0x10) != 0) { + mCurrentWater = 0; } - this->movement(); + movement(); } if ((flags & 0x2) != 0) { - this->calcAnimation(graphics); + calcAnimation(graphics); } - this->mFluddModel->perform(flags, graphics); + mFluddModel->perform(flags, graphics); if ((flags & 0x2) != 0) { - MActor* p2 = this->getCurrentNozzle()->mActor; + MActor* p2 = getCurrentNozzle()->unk380; if (p2 != nullptr) { - PSMTXCopy(this->getModel()->getAnmMtx(this->mCurFluddTransformIdx), - p2->unk4->mBaseMtx); + PSMTXCopy(getModel()->getAnmMtx(unk1CD8), p2->unk4->unk20); } for (s32 index = 0; - index < nozzleBmdData.getEmitterCount(this->mCurrentNozzle); - index++) { - MtxPtr p1 = this->getEmitMtx(index); + index < nozzleBmdData.getEmitterCount(mCurrentNozzle); index++) { + MtxPtr p1 = getEmitMtx(index); if (p1 != nullptr) { mEmitPos[index].x = p1[0][3]; mEmitPos[index].y = p1[1][3]; @@ -960,8 +955,8 @@ void TWaterGun::perform(u32 flags, JDrama::TGraphics* graphics) } } - if (this->getCurrentNozzle()->mActor) { - this->getCurrentNozzle()->mActor->perform(flags, graphics); + if (getCurrentNozzle()->unk380) { + getCurrentNozzle()->unk380->perform(flags, graphics); } } @@ -973,24 +968,22 @@ TNozzleBase* TWaterGun::getCurrentNozzle() const void TWaterGun::setAmountToRate(f32 rate) { // volatile u32 unused2[7]; // TODO: possibly inlined function - if (this->mCurrentNozzle == 3) { - TNozzleBase* currentNozzle = this->getCurrentNozzle(); - s32 amountMax = currentNozzle->mEmitParams.mAmountMax.get(); - this->mCurrentWater = amountMax; + if (mCurrentNozzle == 3) { + TNozzleBase* currentNozzle = getCurrentNozzle(); + s32 amountMax = currentNozzle->mEmitParams.mAmountMax.get(); + mCurrentWater = amountMax; } else { - TNozzleBase* currentNozzle = this->getCurrentNozzle(); - this->mCurrentWater - = rate * currentNozzle->mEmitParams.mAmountMax.get(); + TNozzleBase* currentNozzle = getCurrentNozzle(); + mCurrentWater = rate * currentNozzle->mEmitParams.mAmountMax.get(); } } bool TWaterGun::isPressureOn() { // volatile u32 unused2[6]; - if (this->getCurrentNozzle()->getNozzleKind() == 1) { - TNozzleTrigger* triggerNozzle - = (TNozzleTrigger*)this->getCurrentNozzle(); - if (triggerNozzle->mTriggerFill > 0.0f) { + if (getCurrentNozzle()->getNozzleKind() == 1) { + TNozzleTrigger* triggerNozzle = (TNozzleTrigger*)getCurrentNozzle(); + if (triggerNozzle->unk388 > 0.0f) { return true; } } @@ -1001,10 +994,9 @@ f32 TWaterGun::getPressure() { // TODO: Missing stack space // volatile u32 unused2[5]; - if (this->getCurrentNozzle()->getNozzleKind() == 1) { - TNozzleTrigger* triggerNozzle - = (TNozzleTrigger*)this->getCurrentNozzle(); - return triggerNozzle->mTriggerFill; + if (getCurrentNozzle()->getNozzleKind() == 1) { + TNozzleTrigger* triggerNozzle = (TNozzleTrigger*)getCurrentNozzle(); + return triggerNozzle->unk388; } return 0.0f; } @@ -1014,8 +1006,8 @@ f32 TWaterGun::getPressureMax() // TODO: Missing stack space // volatile u32 unused2[6]; - if (this->getCurrentNozzle()->getNozzleKind() == 1) { - return this->getCurrentNozzle()->mEmitParams.mInsidePressureMax.get(); + if (getCurrentNozzle()->getNozzleKind() == 1) { + return getCurrentNozzle()->mEmitParams.mInsidePressureMax.get(); } return 0.0f; @@ -1098,15 +1090,15 @@ void TWaterGun::emit() } if (!mMario->onYoshi()) { - if (this->unk1CEC > 0.0f) { + if (unk1CEC > 0.0f) { return; } } // TODO: Probably an enum // TODO: Probably inline function? - if (this->hasFlag(0x4)) { - this->mFlags &= ~0x4; + if (hasFlag(0x4)) { + mFlags &= ~0x4; return; } @@ -1118,21 +1110,25 @@ void TWaterGun::emit() if (mCurrentWater > 0) { switch (currentNozzleType) { case Spray: { - playSprayNozzleSound(0x24, getCurrentNozzle()->unk374); + JGeometry::TVec3* emitPos = &mEmitPos[0]; + playSoundWithInfo(0x24, emitPos, 0, getCurrentNozzle()->unk374); } case Yoshi: case Turbo: { - playSprayNozzleSound(0x0, getCurrentNozzle()->unk378); + JGeometry::TVec3* emitPos = &mEmitPos[0]; + playSoundWithInfo(0x0, emitPos, 0, getCurrentNozzle()->unk378); break; } case Underwater: { - playSound2(0x18); + JGeometry::TVec3* emitPos = &mEmitPos[0]; + trySound(0x18, emitPos); } break; case Rocket: break; case Hover: if (mIsEmitWater) { - playSound2(0x18); + JGeometry::TVec3* emitPos = &mEmitPos[0]; + trySound(0x18, emitPos); } break; } @@ -1142,12 +1138,12 @@ bool TWaterGun::suck() { // TODO: Missing stack space // volatile u32 unused1[7]; - if (this->isYoshiNozzle()) { + if (isYoshiNozzle()) { return false; } else { - s32 suckRate = this->getSuckRate(); + s32 suckRate = getSuckRate(); if (suckRate > 0) { - this->incWater(suckRate); + incWater(suckRate); return true; } } @@ -1156,13 +1152,13 @@ bool TWaterGun::suck() bool TWaterGun::damage() { - if (this->hasWater()) { - TNozzleBase* nozzle = this->getCurrentNozzle(); + if (hasWater()) { + TNozzleBase* nozzle = getCurrentNozzle(); - this->mCurrentWater -= nozzle->mEmitParams.mDamageLoss.value; + mCurrentWater -= nozzle->mEmitParams.mDamageLoss.value; - if (this->mCurrentWater < 0) { - this->mCurrentWater = 0; + if (mCurrentWater < 0) { + mCurrentWater = 0; } return true; } @@ -1171,18 +1167,19 @@ bool TWaterGun::damage() void TWaterGun::changeBackup() { - // volatile u32 unused2[5]; // TODO: Missing stack space - if (this->mFluddSwitchTween == 0.0f) { + // TODO: Missing stack space + // volatile u32 unused2[5]; + if (unk1CFC == 0.0f) { if (gpMSound->gateCheck(0x812)) { MSoundSESystem::MSoundSE::startSoundSystemSE(0x812, 0, nullptr, 0); } - this->unk1D00 = mWatergunParams.mChangeSpeed.get(); + unk1D00 = mWatergunParams.mChangeSpeed.get(); } - if (this->mFluddSwitchTween == 1.0f) { + if (unk1CFC == 1.0f) { if (gpMSound->gateCheck(0x811)) { MSoundSESystem::MSoundSE::startSoundSystemSE(0x811, 0, nullptr, 0); } - this->unk1D00 = -mWatergunParams.mChangeSpeed.get(); + unk1D00 = -mWatergunParams.mChangeSpeed.get(); } } diff --git a/src/Strategic/liveactor.cpp b/src/Strategic/liveactor.cpp index 6660378e..1eb4426f 100644 --- a/src/Strategic/liveactor.cpp +++ b/src/Strategic/liveactor.cpp @@ -431,7 +431,7 @@ MtxPtr TLiveActor::getTakingMtx() if (!mMActor) return nullptr; - return mMActor->unk4->mBaseMtx; + return mMActor->unk4->unk20; } void TLiveActor::initAnmSound() diff --git a/src/System/Params.cpp b/src/System/Params.cpp index a5323bb2..4cca84c2 100644 --- a/src/System/Params.cpp +++ b/src/System/Params.cpp @@ -53,7 +53,7 @@ void TParams::init() void TParams::load(JSUMemoryInputStream& stream) { - if (this->mHead != nullptr) { + if (mHead != nullptr) { s32 length = stream.readS32(); for (int i = 0; i < length; i++) { u16 keyCode = stream.read16b(); @@ -61,7 +61,7 @@ void TParams::load(JSUMemoryInputStream& stream) stream.readString(buffer, 0x50); TBaseParam* param; - for (param = this->mHead; param != nullptr; param = param->next) { + for (param = mHead; param != nullptr; param = param->next) { if (keyCode == param->keyCode && !strcmp(buffer, param->name)) { param->load(stream); break; diff --git a/src/System/TargetArrow.cpp b/src/System/TargetArrow.cpp index a766d7f6..8327283f 100644 --- a/src/System/TargetArrow.cpp +++ b/src/System/TargetArrow.cpp @@ -33,7 +33,7 @@ void TTargetArrow::setPos(const JGeometry::TVec3& pos) if (!unk10) return; - MtxPtr mat = unk10->getModel()->mBaseMtx; + MtxPtr mat = unk10->getModel()->unk20; mat[0][3] = pos.x; mat[1][3] = pos.y; mat[2][3] = pos.z; From b634f733c2555727dfc4c69fdd4fb20e016adb7d Mon Sep 17 00:00:00 2001 From: theAzack9 Date: Thu, 29 Jan 2026 19:21:25 +0100 Subject: [PATCH 6/9] Fix merge conflicts --- include/Player/MarioMain.hpp | 15 +++++++-------- src/Player/WaterGun.cpp | 14 ++++++++------ 2 files changed, 15 insertions(+), 14 deletions(-) diff --git a/include/Player/MarioMain.hpp b/include/Player/MarioMain.hpp index 39fdf8dc..25bdf730 100644 --- a/include/Player/MarioMain.hpp +++ b/include/Player/MarioMain.hpp @@ -1099,15 +1099,15 @@ class TMario : public TTakeActor, public TDrawSyncCallback { TBGCheckData* getGroundPlane() const { return mGroundPlane; } // Fabricated - bool hasAttribute(u32 attribute) const + bool checkFlag(u32 attribute) const { - bool hasAttribute; - if ((mAttributes & attribute) != 0) { - hasAttribute = true; + bool condition; + if ((unk118 & attribute) != 0) { + condition = true; } else { - hasAttribute = false; + condition = false; } - return hasAttribute; + return condition; } // Fabricated @@ -1162,7 +1162,7 @@ class TMario : public TTakeActor, public TDrawSyncCallback { /* 0x108 */ u32 unk108[4]; - /* 0x118 */ u32 mAttributes; + /* 0x118 */ u32 unk118; /* 0x11C */ u32 unk11C; @@ -1288,7 +1288,6 @@ class TMario : public TTakeActor, public TDrawSyncCallback { }; extern TMario* gpMarioOriginal; -extern TMario* gpMarioAddress; extern TMario* gpMarioForCallBack; #endif diff --git a/src/Player/WaterGun.cpp b/src/Player/WaterGun.cpp index a7cb2ccb..b2c40b7d 100644 --- a/src/Player/WaterGun.cpp +++ b/src/Player/WaterGun.cpp @@ -14,6 +14,8 @@ #include #include +extern size_t gpMarioAddress; + // Define the global variable in .data section TNozzleBmdData nozzleBmdData = { { { 0, // _00 @@ -325,8 +327,8 @@ void TWaterGun::calcAnimation(JDrama::TGraphics* graphics) if (unk1CEC == 0.0f) { if (mMario->fabricatedActionInline()) { mFluddModel->setBck("wg_fepmp"); - } else if (mMario->hasAttribute(ATTR_IS_SHALLOW_WATER - | ATTR_IS_WATER)) { + } else if (mMario->checkFlag(ATTR_IS_SHALLOW_WATER + | ATTR_IS_WATER)) { mFluddModel->setBck("wg_swpmp"); } else { // TODO: Cast would be weird here, probably an inlined @@ -703,7 +705,7 @@ void TNozzleBase::init() void TNozzleBase::calcGunAngle(const TMarioControllerWork& work) { // volatile u32 unused1[17]; - if (mFludd->mMario == gpMarioAddress + if ((size_t)mFludd->mMario == gpMarioAddress && (gpCamera->isLButtonCameraSpecifyMode(gpCamera->mMode) || gpCamera->isJetCoaster1stCamera())) { unk36E = gpCamera->unkA4; @@ -953,7 +955,7 @@ void TNozzleTrigger::movement(const TMarioControllerWork& controllerWork) } else { canSpray = false; } - if ((mario->mAttributes & 0x30000) == 0 + if ((mario->unk118 & 0x30000) == 0 && mFludd->mCurrentWater < mEmitParams.mAmountMax.get()) { canSpray = false; } @@ -1198,8 +1200,8 @@ void TWaterGun::emit() // volatile u32 unused1[25]; // TODO: Another possible inline to check if emit is possible - if (!mMario->hasAttribute(ATTR_HAS_HELMET_FLW_CAMERA) - && mMario->hasAttribute(ATTR_IS_SHALLOW_WATER | ATTR_IS_WATER)) { + if (!mMario->checkFlag(ATTR_HAS_HELMET_FLW_CAMERA) + && mMario->checkFlag(ATTR_IS_SHALLOW_WATER | ATTR_IS_WATER)) { // I can imagine this also being an inline function that checks // if the emit point is below the water height, but i will leave // it for now. TODO. From aa5122bd3a0e91e414a6114e3a240b1de1cf380d Mon Sep 17 00:00:00 2001 From: theAzack9 Date: Thu, 29 Jan 2026 19:27:28 +0100 Subject: [PATCH 7/9] Fix formatting --- include/Player/MarioMain.hpp | 2 +- include/Player/NozzleBase.hpp | 2 +- include/Player/Watergun.hpp | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/include/Player/MarioMain.hpp b/include/Player/MarioMain.hpp index 25bdf730..9d29b3f5 100644 --- a/include/Player/MarioMain.hpp +++ b/include/Player/MarioMain.hpp @@ -17,7 +17,7 @@ class J3DAnmTransform; struct TBGWallCheckRecord; // TODO: where should this be? -enum E_SIDEWALK_TYPE { }; +enum E_SIDEWALK_TYPE {}; // TODO: Not quite sure how to structure this // Please change or comment if you have a better idea :) diff --git a/include/Player/NozzleBase.hpp b/include/Player/NozzleBase.hpp index 8c9187a3..9a039a1f 100644 --- a/include/Player/NozzleBase.hpp +++ b/include/Player/NozzleBase.hpp @@ -126,6 +126,6 @@ class TNozzleBase { /* 0x378 */ f32 unk378; /* 0x37C */ f32 unk37C; /* 0x380 */ MActor* unk380; // MActor -}; // 0x384 +}; #endif diff --git a/include/Player/Watergun.hpp b/include/Player/Watergun.hpp index 831990fe..a655268d 100644 --- a/include/Player/Watergun.hpp +++ b/include/Player/Watergun.hpp @@ -21,7 +21,7 @@ class TWaterGunParams : public TParams { , PARAM_INIT(mNozzleAngleYSpeedMax, 0x2000) , PARAM_INIT(mHoverRotMax, 0x2000) , PARAM_INIT(mHoverSmooth, 0.05f) - , PARAM_INIT(mChangeSpeed, 0.1f) { }; + , PARAM_INIT(mChangeSpeed, 0.1f) {}; TParamRT mRocketHeight; TParamRT mHoverHeight; TParamRT mLAngleNormal; From 6cc06bb033da2eaec7d44529030b1edb71b5cdd2 Mon Sep 17 00:00:00 2001 From: theAzack9 Date: Fri, 30 Jan 2026 09:52:32 +0100 Subject: [PATCH 8/9] Cleanup after PR --- include/M3DUtil/MActor.hpp | 9 ++- include/Player/MarioMain.hpp | 50 ++++++-------- include/Player/NozzleDeform.hpp | 2 +- include/Player/NozzleTrigger.hpp | 1 - include/Player/Watergun.hpp | 4 +- include/gpMarDirector.hpp | 25 ------- src/Player/WaterGun.cpp | 115 +++++++++++++++++++++---------- 7 files changed, 110 insertions(+), 96 deletions(-) delete mode 100644 include/gpMarDirector.hpp diff --git a/include/M3DUtil/MActor.hpp b/include/M3DUtil/MActor.hpp index 09b58bfd..4bdd0606 100644 --- a/include/M3DUtil/MActor.hpp +++ b/include/M3DUtil/MActor.hpp @@ -22,7 +22,14 @@ class MActorAnmBlk; class MActor { public: - enum AnimationType { BCK, BLK, BPK, BTP, BTK, BRK }; + enum ANM_TYPE { + ANM_TYPE_BCK, + ANM_TYPE_BLK, + ANM_TYPE_BPK, + ANM_TYPE_BTP, + ANM_TYPE_BTK, + ANM_TYPE_BRK + }; MActor(MActorAnmData*); diff --git a/include/Player/MarioMain.hpp b/include/Player/MarioMain.hpp index 9d29b3f5..dbefd5ea 100644 --- a/include/Player/MarioMain.hpp +++ b/include/Player/MarioMain.hpp @@ -17,24 +17,24 @@ class J3DAnmTransform; struct TBGWallCheckRecord; // TODO: where should this be? -enum E_SIDEWALK_TYPE {}; - -// TODO: Not quite sure how to structure this -// Please change or comment if you have a better idea :) -#define ATTR_IS_ABOVE_SEWER_FLOOR 0x1 -#define ATTR_IS_VISIBLE 0x2 -#define ATTR_IS_NPC_TALKING 0x8 -#define ATTR_IS_RECENT_LEFT_WATER 0x10 -#define ATTR_IS_GAME_OVER 0x400 -#define ATTR_IS_GROUND_POUND_SIT_UP 0x800 -#define ATTR_HAS_HELMET_FLW_CAMERA 0x1000 -#define ATTR_HAS_HELMET 0x2000 -#define ATTR_IS_FLUDD_EMITTING 0x4000 -#define ATTR_HAS_FLUDD 0x8000 -#define ATTR_IS_SHALLOW_WATER 0x10000 -#define ATTR_IS_WATER 0x20000 -#define ATTR_HAS_SHIRT 0x100000 -#define ATTR_IS_PERFORMING 0x200000 +enum E_SIDEWALK_TYPE { }; + +enum E_MARIO_FLAG { + MARIO_FLAG_ABOVE_SEWER_FLOOR = (1 << 0), + MARIO_FLAG_VISIBLE = (1 << 1), + MARIO_FLAG_NPC_TALKING = (1 << 3), + MARIO_FLAG_RECENTLY_LEFT_WATER = (1 << 4), + MARIO_FLAG_GAME_OVER = (1 << 10), + MARIO_FLAG_GROUND_POUND_SIT_UP = (1 << 11), + MARIO_FLAG_HELMET_FLW_CAMERA = (1 << 12), + MARIO_FLAG_HELMET = (1 << 13), + MARIO_FLAG_FLUDD_EMITTING = (1 << 14), + MARIO_FLAG_HAS_FLUDD = (1 << 15), + MARIO_FLAG_IN_SHALLOW_WATER = (1 << 16), + MARIO_FLAG_IN_WATER = (1 << 17), + MARIO_FLAG_HAS_SHIRT = (1 << 20), + MARIO_FLAG_IS_PERFORMING = (1 << 21), +}; struct TRidingInfo { const TLiveActor* unk0; @@ -1101,13 +1101,7 @@ class TMario : public TTakeActor, public TDrawSyncCallback { // Fabricated bool checkFlag(u32 attribute) const { - bool condition; - if ((unk118 & attribute) != 0) { - condition = true; - } else { - condition = false; - } - return condition; + return unk118 & attribute ? true : false; } // Fabricated @@ -1180,18 +1174,18 @@ class TMario : public TTakeActor, public TDrawSyncCallback { /* 0x38A */ char unk38A[0x5A]; - /* 0x3E4 */ TWaterGun* mWaterGun; // TWaterGun + /* 0x3E4 */ TWaterGun* mWaterGun; /* 0x3E8 */ u32 unk3E8; /* 0x3EC */ u32 unk3EC; - /* 0x3F0 */ TYoshi* mYoshi; // TYoshi 0x3F0 + /* 0x3F0 */ TYoshi* mYoshi; /* 0x3F4 */ char unk3F4[0x0FC]; /* 0x4F0 */ JGeometry::TVec3 unk4F0; - /* 0x4FC */ TMarioGamePad* mGamePad; // TMarioGamePad + /* 0x4FC */ TMarioGamePad* mGamePad; /* 0x500 */ char unk500[0x74]; diff --git a/include/Player/NozzleDeform.hpp b/include/Player/NozzleDeform.hpp index adb47978..607176fc 100644 --- a/include/Player/NozzleDeform.hpp +++ b/include/Player/NozzleDeform.hpp @@ -12,7 +12,7 @@ class TNozzleDeform : public TNozzleBase { init(); } - virtual s32 getNozzleKind() const { return 3; } /* override */ + virtual s32 getNozzleKind() const { return 3; } virtual void movement(const TMarioControllerWork&); virtual void emit(int); virtual void animation(int); diff --git a/include/Player/NozzleTrigger.hpp b/include/Player/NozzleTrigger.hpp index 96876b7a..456b6272 100644 --- a/include/Player/NozzleTrigger.hpp +++ b/include/Player/NozzleTrigger.hpp @@ -6,7 +6,6 @@ class TNozzleTrigger : public TNozzleBase { public: - // Add constructor TNozzleTrigger(const char* name, const char* prm, TWaterGun* fludd) : TNozzleBase(name, prm, fludd) { diff --git a/include/Player/Watergun.hpp b/include/Player/Watergun.hpp index a655268d..afd52e78 100644 --- a/include/Player/Watergun.hpp +++ b/include/Player/Watergun.hpp @@ -21,7 +21,7 @@ class TWaterGunParams : public TParams { , PARAM_INIT(mNozzleAngleYSpeedMax, 0x2000) , PARAM_INIT(mHoverRotMax, 0x2000) , PARAM_INIT(mHoverSmooth, 0.05f) - , PARAM_INIT(mChangeSpeed, 0.1f) {}; + , PARAM_INIT(mChangeSpeed, 0.1f) { }; TParamRT mRocketHeight; TParamRT mHoverHeight; TParamRT mLAngleNormal; @@ -76,7 +76,7 @@ class TNozzleBmdData { NozzleData mNozzles[6]; }; -// Define the global variable in .data section + extern TNozzleBmdData nozzleBmdData; class TWaterGun { diff --git a/include/gpMarDirector.hpp b/include/gpMarDirector.hpp deleted file mode 100644 index 121ea7bd..00000000 --- a/include/gpMarDirector.hpp +++ /dev/null @@ -1,25 +0,0 @@ -#ifndef GPMARDIRECTOR_H -#define GPMARDIRECTOR_H - -#include "GC2D/GCConsole2.hpp" - -// Very barebones -// TODO: Add functions -extern class TMarDirector { -public: - char pad_000[0x58]; - s32 frameIndex; - char pad_001[0x14]; - int _070; - TGCConsole2* console; - int _078; - u8 map; - u8 _07D; - u8 _07E; - u8 _07F; - u32 _080[0x29]; - u8 mGameState; - -}* gpMarDirector; - -#endif diff --git a/src/Player/WaterGun.cpp b/src/Player/WaterGun.cpp index b2c40b7d..4751df4c 100644 --- a/src/Player/WaterGun.cpp +++ b/src/Player/WaterGun.cpp @@ -6,7 +6,7 @@ #include #include -#include +#include #include @@ -16,56 +16,94 @@ extern size_t gpMarioAddress; -// Define the global variable in .data section -TNozzleBmdData nozzleBmdData - = { { { 0, // _00 +TNozzleBmdData nozzleBmdData = { + { + { + 0, // _00 0, // _04 nullptr, // mHelmetPath "/mario/watergun2/normal_wg", // mPath "/mario/watergun2/normal_wg/normal_wg.bmd", // mBmdPath 1, // mNumEmitters 2, // _15 - { { 1, 0 }, { 4, 0 }, { 4, 0 } } }, - { 0, // _00 + { + { 1, 0 }, + { 4, 0 }, + { 4, 0 }, + }, + }, + { + 0, // _00 0, // _04 nullptr, // mHelmetPath "/mario/watergun2/rocket_wg", // mPath "/mario/watergun2/rocket_wg/rocket_wg.bmd", // mBmdPath 1, // mNumEmitters 2, // _15 - { { 2, 1 }, { 4, 0 }, { 4, 0 } } }, - { 0, // _00 + { + { 2, 1 }, + { 4, 0 }, + { 4, 0 }, + }, + }, + { + 0, // _00 0, // _04 "/mario/bmd/wg_hel_diver.bmd", // mHelmetPath "/mario/watergun2/hover_wg", // mPath "/mario/watergun2/hover_wg/hover_wg.bmd", // mBmdPath 2, // mNumEmitters 0xc, // _15 - { { 1, 0 }, { 1, 0 }, { 4, 0 } } }, - { 0, // _00 + { + { 1, 0 }, + { 1, 0 }, + { 4, 0 }, + }, + }, + { + 0, // _00 0, // _04 nullptr, // mHelmetPath "/mario/watergun2/dummy_wg", // mPath "/mario/watergun2/dummy_wg/dummy_wg.bmd", // mBmdPath 1, // mNumEmitters 2, // _15 - { { 3, 0 }, { 4, 0 }, { 4, 0 } } }, - { 0, // _00 + { + { 3, 0 }, + { 4, 0 }, + { 4, 0 }, + }, + }, + { + 0, // _00 0, // _04 nullptr, // mHelmetPath "/mario/watergun2/hover_wg", // mPath "/mario/watergun2/hover_wg/hover_wg.bmd", // mBmdPath 2, // mNumEmitters 0xc, // _15 - { { 1, 0 }, { 1, 0 }, { 4, 0 } } }, - { 0, // _00 + { + { 1, 0 }, + { 1, 0 }, + { 4, 0 }, + }, + }, + { + 0, // _00 0, // _04 nullptr, // mHelmetPath "/mario/watergun2/back_wg", // mPath "/mario/watergun2/back_wg/back_wg.bmd", // mBmdPath 1, // mNumEmitters 2, // _15 - { { 1, 0 }, { 4, 0 }, { 4, 0 } } } } }; + { + { 1, 0 }, + { 4, 0 }, + { 4, 0 }, + }, + }, + }, +}; TWaterGun::TWaterGun(TMario* mario) : mNozzleDeform("normal_wg", "/Mario/WaterGun/NozzleDeform.prm", this) @@ -96,11 +134,11 @@ static bool NozzleCtrl(J3DNode* node, BOOL param_2) // Unused stack space // volatile u32 unused2[6]; MsMtxSetRotRPH(mtx, 0.0f, 0.0f, 0.005493164f * gunAngle); - PSMTXConcat(J3DSys::mCurrentMtx, mtx, J3DSys::mCurrentMtx); + MTXConcat(J3DSys::mCurrentMtx, mtx, J3DSys::mCurrentMtx); } } } - return 1; + return true; } static bool RotateCtrl(J3DNode* node, BOOL param_2) @@ -111,9 +149,9 @@ static bool RotateCtrl(J3DNode* node, BOOL param_2) // Unused stack space // volatile u32 unused2[7]; MsMtxSetRotRPH(mtx, 0.005493164f * local1cd0, 0.0f, 0.0f); - PSMTXConcat(J3DSys::mCurrentMtx, mtx, J3DSys::mCurrentMtx); + MTXConcat(J3DSys::mCurrentMtx, mtx, J3DSys::mCurrentMtx); } - return 1; + return true; } static bool WaterGunDivingCtrlL(J3DNode* node, BOOL param_2) @@ -128,9 +166,9 @@ static bool WaterGunDivingCtrlL(J3DNode* node, BOOL param_2) // Unused stack space // volatile u32 unused2[7]; MsMtxSetRotRPH(mtx, 0.0f, 0.0f, 0.005493164f * neg); - PSMTXConcat(J3DSys::mCurrentMtx, mtx, J3DSys::mCurrentMtx); + MTXConcat(J3DSys::mCurrentMtx, mtx, J3DSys::mCurrentMtx); } - return 1; + return true; } static bool WaterGunDivingCtrlR(J3DNode* node, BOOL param_2) @@ -145,9 +183,9 @@ static bool WaterGunDivingCtrlR(J3DNode* node, BOOL param_2) // Unused stack space // volatile u32 unused2[7]; MsMtxSetRotRPH(mtx, 0.0f, 0.0f, 0.005493164f * neg); - PSMTXConcat(J3DSys::mCurrentMtx, mtx, J3DSys::mCurrentMtx); + MTXConcat(J3DSys::mCurrentMtx, mtx, J3DSys::mCurrentMtx); } - return 1; + return true; } // TODO: Nozzle deform @@ -215,7 +253,7 @@ void TWaterGun::init() // Requires M3UModelMario at 0x3a8 in TMario // Missing decompilation - // PSMTXCopy( + // MTXCopy( // mMario->mModelMario->unk8->mJointArray[mMario->mBindBoneIDArray[0]], // mFluddModel->unk4->unk20); @@ -279,7 +317,7 @@ void TWaterGun::init() // ->mCallBack = functionPtr; // 5 more of these - // PSMTXCopy that requires M3UModelMario at 0x3a8 in TMario + // MTXCopy that requires M3UModelMario at 0x3a8 in TMario unk1D10 = new TMirrorActor("水鉄砲in鏡"); unk1D10->init(mFluddModel->unk4, 4); @@ -304,7 +342,7 @@ void TWaterGun::calcAnimation(JDrama::TGraphics* graphics) volatile u32 unused2[12]; gpMarioForCallBack = mMario; - J3DFrameCtrl* frameCtrl = mFluddModel->getFrameCtrl(MActor::BCK); + J3DFrameCtrl* frameCtrl = mFluddModel->getFrameCtrl(MActor::ANM_TYPE_BCK); if (mMario == nullptr) { return; } @@ -327,8 +365,8 @@ void TWaterGun::calcAnimation(JDrama::TGraphics* graphics) if (unk1CEC == 0.0f) { if (mMario->fabricatedActionInline()) { mFluddModel->setBck("wg_fepmp"); - } else if (mMario->checkFlag(ATTR_IS_SHALLOW_WATER - | ATTR_IS_WATER)) { + } else if (mMario->checkFlag(MARIO_FLAG_IN_SHALLOW_WATER + | MARIO_FLAG_IN_WATER)) { mFluddModel->setBck("wg_swpmp"); } else { // TODO: Cast would be weird here, probably an inlined @@ -674,8 +712,8 @@ void TWaterGun::setBaseTRMtx(Mtx mtx) Vec unused2; MsMtxSetRotRPH(result, 0.0f, 0.0f, 0.005493164f * angle); - PSMTXConcat(mtx, result, result); - PSMTXCopy(result, mFluddModel->unk4->unk20); + MTXConcat(mtx, result, result); + MTXCopy(result, mFluddModel->unk4->unk20); } // Not sure why this get's inlined aggressively @@ -756,7 +794,7 @@ void TNozzleBase::animation(int param_1) if (!unk380->checkCurBckFromIndex(4)) { unk380->setBckFromIndex(4); } - J3DFrameCtrl* ctrl = unk380->getFrameCtrl(MActor::BCK); + J3DFrameCtrl* ctrl = unk380->getFrameCtrl(MActor::ANM_TYPE_BCK); if (ctrl->mCurrentFrame <= (ctrl->mEndFrame - 0.1) && (ctrl->mFlags & 3) == 0) { return; @@ -775,7 +813,7 @@ void TNozzleBase::animation(int param_1) if (fludd->mCurrentWater == 0) { updateAnimation = false; } else { - u8 gameState = gpMarDirector->mGameState; + u8 gameState = gpMarDirector->unk124; if (gameState != 3 && gameState != 4) { updateAnimation = true; if (gameState != 1 && gameState != 2) { @@ -820,7 +858,7 @@ void TNozzleBase::animation(int param_1) if (fludd->mCurrentWater == 0) { updateAnimation = false; } else { - u8 gameState = gpMarDirector->mGameState; + u8 gameState = gpMarDirector->unk124; if (gameState != 3 && gameState != 4) { updateAnimation = true; if (gameState != 1 && gameState != 2) { @@ -856,7 +894,7 @@ void TNozzleBase::animation(int param_1) case 3: { - J3DFrameCtrl* ctrl = unk380->getFrameCtrl(MActor::BCK); + J3DFrameCtrl* ctrl = unk380->getFrameCtrl(MActor::ANM_TYPE_BCK); if (!unk380->checkCurBckFromIndex(1)) { unk380->setBckFromIndex(1); } @@ -868,7 +906,7 @@ void TNozzleBase::animation(int param_1) } case 4: { - J3DFrameCtrl* ctrl = unk380->getFrameCtrl(MActor::BCK); + J3DFrameCtrl* ctrl = unk380->getFrameCtrl(MActor::ANM_TYPE_BCK); if (!unk380->checkCurBckFromIndex(0)) { unk380->setBckFromIndex(0); } @@ -1065,7 +1103,7 @@ void TWaterGun::perform(u32 flags, JDrama::TGraphics* graphics) if ((flags & 0x2) != 0) { MActor* p2 = getCurrentNozzle()->unk380; if (p2 != nullptr) { - PSMTXCopy(getModel()->getAnmMtx(unk1CD8), p2->unk4->unk20); + MTXCopy(getModel()->getAnmMtx(unk1CD8), p2->unk4->unk20); } for (s32 index = 0; @@ -1200,8 +1238,9 @@ void TWaterGun::emit() // volatile u32 unused1[25]; // TODO: Another possible inline to check if emit is possible - if (!mMario->checkFlag(ATTR_HAS_HELMET_FLW_CAMERA) - && mMario->checkFlag(ATTR_IS_SHALLOW_WATER | ATTR_IS_WATER)) { + if (!mMario->checkFlag(MARIO_FLAG_HELMET_FLW_CAMERA) + && mMario->checkFlag(MARIO_FLAG_IN_SHALLOW_WATER + | MARIO_FLAG_IN_WATER)) { // I can imagine this also being an inline function that checks // if the emit point is below the water height, but i will leave // it for now. TODO. From cdc29ced161dbc6c7282fff68b2f12dd9e0caf4e Mon Sep 17 00:00:00 2001 From: theAzack9 Date: Fri, 30 Jan 2026 09:54:05 +0100 Subject: [PATCH 9/9] Fix whitespaces --- include/Player/MarioMain.hpp | 2 +- include/Player/Watergun.hpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/Player/MarioMain.hpp b/include/Player/MarioMain.hpp index dbefd5ea..001bfac5 100644 --- a/include/Player/MarioMain.hpp +++ b/include/Player/MarioMain.hpp @@ -17,7 +17,7 @@ class J3DAnmTransform; struct TBGWallCheckRecord; // TODO: where should this be? -enum E_SIDEWALK_TYPE { }; +enum E_SIDEWALK_TYPE {}; enum E_MARIO_FLAG { MARIO_FLAG_ABOVE_SEWER_FLOOR = (1 << 0), diff --git a/include/Player/Watergun.hpp b/include/Player/Watergun.hpp index afd52e78..1667118b 100644 --- a/include/Player/Watergun.hpp +++ b/include/Player/Watergun.hpp @@ -21,7 +21,7 @@ class TWaterGunParams : public TParams { , PARAM_INIT(mNozzleAngleYSpeedMax, 0x2000) , PARAM_INIT(mHoverRotMax, 0x2000) , PARAM_INIT(mHoverSmooth, 0.05f) - , PARAM_INIT(mChangeSpeed, 0.1f) { }; + , PARAM_INIT(mChangeSpeed, 0.1f) {}; TParamRT mRocketHeight; TParamRT mHoverHeight; TParamRT mLAngleNormal;