diff --git a/include/Yamamoto/KartAnime.h b/include/Yamamoto/KartAnime.h index ee75157f..98d5c38b 100644 --- a/include/Yamamoto/KartAnime.h +++ b/include/Yamamoto/KartAnime.h @@ -39,7 +39,7 @@ class KartAnime bool IsBack(int); // 0x802fa298 bool IsGaol(int); // 0x802fa2fc bool IsAttack(int); // 0x802fa344 - void IsProhibition(int); // 0x802fa38c + bool IsProhibition(int); // 0x802fa38c void MakeThrowAnime(int, int, int); // 0x802fa408 void MakeBackAnime(int); // 0x802fa424 void MakeFrontAnime(int); // 0x802fa4b0 @@ -99,7 +99,7 @@ class KartAnime // void MakeDriverThrowAnime(int, int, int); // void MakeGetAnime(ItemObj *, int); // Inline - void IsChangeStart(); // 0x802f9bc4 + bool IsChangeStart() { return mFlags & 0x1; } // 0x802f9bc4 u8 _0[0x10]; // u64 mFlags; // 0x10, 0x14 diff --git a/include/Yamamoto/KartCheck.h b/include/Yamamoto/KartCheck.h index 9b3d7e10..05e4702c 100644 --- a/include/Yamamoto/KartCheck.h +++ b/include/Yamamoto/KartCheck.h @@ -9,14 +9,14 @@ class KartCheck KartCheck() {} void Init(int); - void CheckCrash(); - void CheckCheange(int); - void CheckSpecialDyn(); - void CheckSpecialDyn2(); - void CheckBodyHit(int, int); - void CheckAllClearKey(); - void CheckAllClearKeyT(); - void CheckPartsClearKey(int); + bool CheckCrash(); + bool CheckCheange(int); + bool CheckSpecialDyn(); + bool CheckSpecialDyn2(); + bool CheckBodyHit(int, int); + bool CheckAllClearKey(); + bool CheckAllClearKeyT(); + bool CheckPartsClearKey(int); bool CheckOnlyTandemPartsClearKey(int); bool CheckPlayer(); bool CheckDraw(u32, int); @@ -27,4 +27,4 @@ class KartCheck }; // 0x8 -#endif \ No newline at end of file +#endif diff --git a/include/Yamamoto/KartGame.h b/include/Yamamoto/KartGame.h index be0cc870..324af94d 100644 --- a/include/Yamamoto/KartGame.h +++ b/include/Yamamoto/KartGame.h @@ -10,6 +10,7 @@ class KartBody; class KartGame { public: + // In kartCtrlStrat.cpp void Init(int); void GetGorundTireNum(); void WatchEffectAcceleration(); @@ -60,6 +61,23 @@ class KartGame void DoActionMgr(); void DoActionCtrl(); void DoStatus(); + + // In kartChapter.cpp + void DoVisible(); + void DoWinCamera(); + void DoChapterOne(); + void DoChapterTwo(); + void DoChapterThree(); + void DoChapterFour(); + void DoChapterFive(); + void DoChapterSix(); + void DoChapterSeven(); + void DoChapterBalloon(); + void DoChapterBomEsc(); + void DoStaffRoll(); + void DoWaitBattleWin(); + void DoStartGoalCtl(); + // Inline/Unused // void DoParamChange(); // void DoJump(); @@ -80,4 +98,4 @@ class KartGame JGeometry::TVec3f _34; }; -#endif KARTGAME_H \ No newline at end of file +#endif KARTGAME_H diff --git a/include/Yamamoto/KartItem.h b/include/Yamamoto/KartItem.h index 8a1afeee..5786e28b 100644 --- a/include/Yamamoto/KartItem.h +++ b/include/Yamamoto/KartItem.h @@ -17,8 +17,8 @@ class KartItem void ReleseWanWan(); void CompulsionReleseWanWan(); void KillWanWan(); - void IsMyItem(); - void IsChanging(); + bool IsMyItem(); + bool IsChanging(); void DoTurtleReleaseDir(int, int); void DoBananaReleaseDir(); void DoTurtleReleaseDynamicDir(u32); @@ -47,4 +47,4 @@ class KartItem }; // 0xc -#endif // KARTITEMSTRAT_H \ No newline at end of file +#endif // KARTITEMSTRAT_H diff --git a/include/Yamamoto/KartThunder.h b/include/Yamamoto/KartThunder.h index b1d781f0..aaba0f59 100644 --- a/include/Yamamoto/KartThunder.h +++ b/include/Yamamoto/KartThunder.h @@ -11,8 +11,8 @@ class KartThunder KartThunder() {} void Init(int); // 0x80307ff4 - void DoReturn(); // 0x80308058 - void DoShake(); // 0x803080c4 + bool DoReturn(); // 0x80308058 + bool DoShake(); // 0x803080c4 void ClearThunder(); // 0x80308144 void MakeThunder(); // 0x803081d0 void DoThunderCrl(); // 0x80308364 @@ -31,4 +31,4 @@ class KartThunder f32 _10; }; // 14 -#endif // KARTTHUNDER_H \ No newline at end of file +#endif // KARTTHUNDER_H diff --git a/include/Yamamoto/kartBody.h b/include/Yamamoto/kartBody.h index aa725150..4b9e7be1 100644 --- a/include/Yamamoto/kartBody.h +++ b/include/Yamamoto/kartBody.h @@ -310,4 +310,4 @@ class KartBody u8 mMTState; }; -#endif \ No newline at end of file +#endif diff --git a/include/Yamamoto/kartCamera.h b/include/Yamamoto/kartCamera.h index bf1f274a..e38e81e8 100644 --- a/include/Yamamoto/kartCamera.h +++ b/include/Yamamoto/kartCamera.h @@ -43,7 +43,7 @@ class KartCam // void InitLaunchView(); // void InitLandView(); - JGeometry::TVec3f *SetTargetNum(u8); + void SetTargetNum(u8); void SetClipper(); void CheckClipper(); void MakeShaker(float); diff --git a/include/Yamamoto/kartCtrl.h b/include/Yamamoto/kartCtrl.h index 9de04663..a7cdf72d 100644 --- a/include/Yamamoto/kartCtrl.h +++ b/include/Yamamoto/kartCtrl.h @@ -71,17 +71,17 @@ class KartCtrl : public KartMat // WHAT THE HELL ARE YOU DOING u32 GetGameStatus(int); void SetTireDispRound(KartBody *, KartSus *, f32); void SetKartRpm(KartBody *, f32, f32); - void WhichDriver(int); + u8 WhichDriver(int); u8 WhichNowDriver(int); bool CheckCamera(int); int GetCameraNum(int); - void CheckItem(int); - void GetMaxSpeed(int); - void GetDownSlopeAcc(int); - void GetDownSlopeSpeed(int); - void GetTireAngle(int); - void GetTandemDir(int); - void GetWaterHeight(int); + bool CheckItem(int); + f32 GetMaxSpeed(int); + f32 GetDownSlopeAcc(int); + f32 GetDownSlopeSpeed(int); + f32 GetTireAngle(int); + f32 GetTandemDir(int); + f32 GetWaterHeight(int); bool CheckJugemuSignal(); GameAudio::KartSoundMgr *GetKartSoundMgr(int idx); /*{ return getKartSound(idx)->mKartSoundMgr; }*/ f32 GetKartBodyOffset(int); diff --git a/include/Yamamoto/kartSus.h b/include/Yamamoto/kartSus.h index 9ca0ac37..d17f07cc 100644 --- a/include/Yamamoto/kartSus.h +++ b/include/Yamamoto/kartSus.h @@ -12,6 +12,7 @@ class KartSus public: KartSus() { } + void InitTirePose(int); void InitSettingParam(int); void InitParam(int); void Init(int); @@ -25,6 +26,10 @@ class KartSus // Inlines KartBody *getKartBody() { return mBody; } + // Unused + void InitTestTirePose(int); + void WallReflection(JGeometry::TVec3 *, JGeometry::TVec3 *, float, float); + // TODO ExModel *mWheel; ExModel *mArm; @@ -62,4 +67,4 @@ class KartSus u8 _290[0x2cc - 0x290]; }; // _2cc -#endif \ No newline at end of file +#endif diff --git a/src/Yamamoto/KartAnime.cpp b/src/Yamamoto/KartAnime.cpp index e69de29b..350cccd2 100644 --- a/src/Yamamoto/KartAnime.cpp +++ b/src/Yamamoto/KartAnime.cpp @@ -0,0 +1,182 @@ +#include "Yamamoto/KartAnime.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// comments inside functions are inline functions being called in that function + +bool KartAnime::IsAppeal(int) {} + +bool KartAnime::IsThrow(int) {} + +bool KartAnime::IsMove(int) {} + +bool KartAnime::IsSuspend(int) { + // IsStart(); +} + +bool KartAnime::IsDamage(int) {} + +bool KartAnime::IsDamageL(int) {} + +bool KartAnime::IsDamageS(int) {} + +bool KartAnime::IsRide(int) {} + +bool KartAnime::IsNormalStart(int) {} + +bool KartAnime::IsBackStart(int) {} + +bool KartAnime::IsRun(int) {} + +bool KartAnime::IsDrift(int) {} + +bool KartAnime::IsDriftStart(int) {} + +bool KartAnime::IsDriftLeft(int) {} + +bool KartAnime::IsDriftRight(int) {} + +bool KartAnime::IsChange(int) {} + +bool KartAnime::IsRocket(int) {} + +bool KartAnime::IsJump(int) {} + +bool KartAnime::IsSit(int) {} + +bool KartAnime::IsBackAnime(int) {} + +bool KartAnime::IsFloatAnime(int) {} + +bool KartAnime::IsDangerAnime(int) {} + +bool KartAnime::IsDangerLoopAnime(int) {} + +bool KartAnime::IsDangerPlusAnime(int) {} + +bool KartAnime::IsGetItemAnime(int) {} + +bool KartAnime::IsBurnAnime(int) {} + +bool KartAnime::IsDrive(int) {} + +bool KartAnime::IsBack(int) {} + +bool KartAnime::IsGaol(int) {} + +bool KartAnime::IsAttack(int) {} + +bool KartAnime::IsProhibition(int) {} + +void KartAnime::MakeThrowAnime(int, int, int) {} + +void KartAnime::MakeBackAnime(int) {} + +void KartAnime::MakeFrontAnime(int) {} + +void KartAnime::Init() {} + +void KartAnime::DoGetAnime(int) { + //void ItemObj::clrTransferPartner() {} + //void ItemObj::tstTransferPartner() const {} +} + +void KartAnime::DoBackAnime(int) { + //void DriverModel::TurnBack() {} +} + +void KartAnime::DoFrontAnime(int) {} + +void KartAnime::DoChangeAnime(int) {} + +void KartAnime::DoDriveAnime(int) {} + +void KartAnime::DoStartRunStartAnime(int) {} + +void KartAnime::DoStartRunEndAnime(int) { + //void DriverModel::BacktoDWait() {} +} + +void KartAnime::DoDriverThrowAnime(int) {} + +void KartAnime::DoDriverDamageAnime(int) {} + +void KartAnime::DoDriverDriveAnime(int) {} + +void KartAnime::DoThrowAnime(int) {} + +void KartAnime::DoDriftAnime(int) {} + +void KartAnime::DoDriftEndAnime(int) {} + +void KartAnime::DoSlideAnime(int) {} + +void KartAnime::DoJumpAnime(int) {} + +void KartAnime::DoCrouchAnime(int) {} + +void KartAnime::DoStandAnime(int) {} + +void KartAnime::DoPushStartAnime(int) {} + +void KartAnime::DoNormalStartAnime(int) { + //void DriverModel::StartNormalStart() {} +} + +void KartAnime::DoRocketStartAnime(int) { + //void DriverModel::StartRocketStart() {} +} + +void KartAnime::DoFalseStartAnime(int) { + //void DriverModel::StartRocketStartFailure() {} +} + +void KartAnime::DoDamageStartAnime(int) {} + +void KartAnime::DoDamageEndAnime(int) {} + +void KartAnime::DoBigDamageStartAnime(int) {} + +void KartAnime::DoBigDamageEndAnime(int) {} + +void KartAnime::DoBurnStartAnime(int) {} + +void KartAnime::DoBurnEndAnime(int) {} + +void KartAnime::DoFloatStartAnime(int) {} + +void KartAnime::DoHangStartAnime(int) {} + +void KartAnime::DoGoalStartAnime(int) {} + +void KartAnime::DoStaffAnime(int) {} + +void KartAnime::DoHappyAnime(int) {} + +void KartAnime::DoWinAnime(int) {} + +void KartAnime::DoDefeatAnime(int) {} + +void KartAnime::DoFloatEndAnime(int) {} + +void KartAnime::DoSurpriseAnime(int) {} + +void KartAnime::DoSurpriseEndAnime(int) {} + +void KartAnime::DoHangJumpStartAnime(int) {} + +void KartAnime::DoHangJumpEndAnime(int) {} + +void KartAnime::DoAppealAnime(int) {} + +void KartAnime::DoStopAnime(int) { + //void DriverModel::SetFreeze() {} +} + +void KartAnime::DoReStopAnime(int) { + //void DriverModel::ResetFreeze() {} +} + +void KartAnime::DoCheck(int) {} + +void KartAnime::DoAnime(int) {} diff --git a/src/Yamamoto/KartApeendix.cpp b/src/Yamamoto/KartApeendix.cpp index 96213455..d5fe875e 100644 --- a/src/Yamamoto/KartApeendix.cpp +++ b/src/Yamamoto/KartApeendix.cpp @@ -7,4 +7,4 @@ void KartAppendix::Init(int idx) { { mModelWheel = mKartLoader->getExModelWheel(idx + 4); } -} \ No newline at end of file +} diff --git a/src/Yamamoto/KartCannon.cpp b/src/Yamamoto/KartCannon.cpp index e69de29b..32cec218 100644 --- a/src/Yamamoto/KartCannon.cpp +++ b/src/Yamamoto/KartCannon.cpp @@ -0,0 +1,48 @@ +#include "Yamamoto/KartCannon.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// comments inside functions are inline functions being called in that function + +void KartCannon::Init(int) {} + +void KartCannon::MakeCannon() { + // void GeoCannon::getSpec() const {} +} + +void KartCannon::DoKeep() {} + +void KartCannon::SetPose() { + // void GeoCannon::getShotDirection(JGeometry::TVec3 *) {} + // void GeoCannon::getShotPosition(JGeometry::TVec3 *) {} +} + +void KartCannon::DoCatch() {} + +void KartCannon::DoLaunch() {} + +void KartCannon::DoFlight() {} + +void KartCannon::DoTouchDown() {} + +void KartCannon::DoLanding() {} + +void KartCannon::DoCheckEnd() {} + +void KartCannon::DoRainbowLaunch() {} + +void KartCannon::DoRainbowFlight() {} + +void KartCannon::DoRainbowTouchDown() {} + +void KartCannon::DoRainbowLanding() {} + +void KartCannon::DoRainbowCheckEnd() {} + +void KartCannon::DoCannonCrl() {} + +void KartCannon::DoDonkyCannonCrl() {} + +void KartCannon::DoRainbowCannonCrl() {} + +void KartCannon::DoAfterCannonCrl() {} diff --git a/src/Yamamoto/KartChecker.cpp b/src/Yamamoto/KartChecker.cpp index e69de29b..218415b9 100644 --- a/src/Yamamoto/KartChecker.cpp +++ b/src/Yamamoto/KartChecker.cpp @@ -0,0 +1,35 @@ +#include "Yamamoto/KartCheck.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// comments inside functions are inline functions being called in that function + +void KartCheck::Init(int) {} + +bool KartCheck::CheckCrash() {} + +bool KartCheck::CheckCheange(int) {} + +bool KartCheck::CheckSpecialDyn() {} + +bool KartCheck::CheckSpecialDyn2() {} + +bool KartCheck::CheckBodyHit(int, int) {} + +bool KartCheck::CheckAllClearKey() {} + +bool KartCheck::CheckAllClearKeyT() { + // void KartBody::getScene() {} +} + +bool KartCheck::CheckPartsClearKey(int) {} + +bool KartCheck::CheckOnlyTandemPartsClearKey(int) {} + +bool KartCheck::CheckPlayer() {} + +bool KartCheck::CheckDraw(unsigned long, int) { + // void KartCam::GetTargetNum() {} +} + +bool KartCheck::CheckIndication() {} diff --git a/src/Yamamoto/KartCrash.cpp b/src/Yamamoto/KartCrash.cpp index e69de29b..7c965fcc 100644 --- a/src/Yamamoto/KartCrash.cpp +++ b/src/Yamamoto/KartCrash.cpp @@ -0,0 +1,71 @@ +#include "Yamamoto/KartCrash.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// comments inside functions are inline functions being called in that function + +void KartCrash::Init(int) {} + +void KartCrash::DoRabbitMark() {} + +void KartCrash::DoMatchlessTimer() { + // void KartDrawer::flashOff() {} + // void KartDrawer::flashOn() {} +} + +void KartCrash::CheckMatchlessTimer() {} + +void KartCrash::SetMatchlessTimer() {} + +void KartCrash::ClearMatchlessTimer() {} + +void KartCrash::DoDecBalloon() {} + +void KartCrash::DoPointBomb(ItemObj *) { + // void KartChecker::setBEHitBomb(ItemObj *) {} +} + +void KartCrash::DoDecPointBomb() { + // void KartChecker::setBEJugem() {} +} + +void KartCrash::SaveDir() {} + +void KartCrash::NonRescue() { + // void CrsArea::searchInvValley(const JGeometry::TVec3 &) {} +} + +void KartCrash::DoRollCrashCrl() {} + +void KartCrash::DoPitchCrashCrl() {} + +void KartCrash::MakeBombCrash(ItemObj *) {} + +void KartCrash::DoBombCrashCrl() {} + +void KartCrash::MakeKameCrash(ItemObj *) {} + +void KartCrash::MakeTornado() {} + +void KartCrash::DoTornadeCenter() {} + +void KartCrash::DotornadeCrashCrl() {} + +void KartCrash::MakeSpin(ItemObj *) {} + +void KartCrash::DoSpinCrashCrl() {} + +void KartCrash::MakeHalfSpin(ItemObj *) {} + +void KartCrash::DoHalfSpinCrashCrl() {} + +void KartCrash::MakeThunderSpin() {} + +void KartCrash::MakeBurn(ItemObj *) { + // void ItemFireBall::IsEfctTypeRed() const {} + // void ItemObj::getItemColorID() const {} +} + +void KartCrash::MakeFreezeCrash() {} + +void KartCrash::DoFreezeCrashCrl() {} diff --git a/src/Yamamoto/KartDemoCam.cpp b/src/Yamamoto/KartDemoCam.cpp index e69de29b..8bca8b5c 100644 --- a/src/Yamamoto/KartDemoCam.cpp +++ b/src/Yamamoto/KartDemoCam.cpp @@ -0,0 +1,161 @@ +#include "Yamamoto/KartDemoCam.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// comments inside functions are inline functions being called in that function + +void KartDemoCam::Init(KartCam *) {} + +void KartDemoCam::ChaseFovy(const CrsData::Camera *) { + // void KartCam::SetFovy(float) {} + // void CrsData::Camera::getFovy() const {} + // void CrsData::Camera::getFovy2() const {} +} + +void KartDemoCam::DoInitCol() {} + +void KartDemoCam::DoCol() {} + +void KartDemoCam::InitFixCam() { + // void CrsData::Camera::getPosition(JGeometry::TVec3 *) const {} +} + +void KartDemoCam::DoFixCam() {} + +void KartDemoCam::InitFixSearchCam() {} + +void KartDemoCam::DoFixSearchCam() {} + +void KartDemoCam::InitFixChaseCam() {} + +void KartDemoCam::DoFixChaseCam() {} + +void KartDemoCam::InitChaseCam() {} + +void KartDemoCam::DoChaseCam() {} + +void KartDemoCam::InitFixPathCam() { + // void CrsData::Camera::getPathID() const {} +} + +void KartDemoCam::DoFixPathCam() { + // void CrsData::Camera::getPathSpeed() const {} +} + +void KartDemoCam::InitChasePathCam() {} + +void KartDemoCam::DoChasePathCam() {} + +void KartDemoCam::InitFixSplCam() {} + +void KartDemoCam::DoFixSplCam() {} + +void KartDemoCam::InitChaseSplCam() {} + +void KartDemoCam::DoChaseSplCam() {} + +void KartDemoCam::InitFixPalaCam() { + // void CrsData::Camera::getTargetPos2(JGeometry::TVec3 *) const {} + // void CrsData::Camera::getTargetPos(JGeometry::TVec3 *) const {} +} + +void KartDemoCam::DoFixPalaCam() {} + +void KartDemoCam::InitDemoPathCam() {} + +void KartDemoCam::DoDemoPathCam() {} + +void KartDemoCam::InitDemoParallelView() {} + +void KartDemoCam::DemoParallelView() {} + +void KartDemoCam::InitDemoGoalView() {} + +void KartDemoCam::DemoGoalView() {} + +void KartDemoCam::MapView() {} + +void KartDemoCam::ObjectView() {} + +void KartDemoCam::DemoInitID() { + // void CrsData::Camera::getKind() const {} +} + +void KartDemoCam::InitID() {} + +void KartDemoCam::DoDemoView() {} + +void KartDemoCam::LiveViewChange() {} + +void KartDemoCam::DemoView() { + // void RaceMgr::requestDemoCameraID() const {} +} + +void KartDemoCam::DoPathEnd(JGeometry::TVec3 *, float *) {} + +void KartDemoCam::InitStartFixPathCam() {} + +void KartDemoCam::DoStartFixPathCam() {} + +void KartDemoCam::InitStartPathCam() {} + +void KartDemoCam::DoStartPathCam() {} + +void KartDemoCam::InitStartLookPathCam() {} + +void KartDemoCam::DoStartLookPathCam() {} + +void KartDemoCam::InitStartOnlyPathCam() {} + +void KartDemoCam::DoStartOnlyPathCam() {} + +void KartDemoCam::InitStartFixCam() {} + +void KartDemoCam::DoStartFixCam() {} + +void KartDemoCam::InitStartChasePathCam() {} + +void KartDemoCam::DoStartChasePathCam() {} + +void KartDemoCam::InitVsLastCam() {} + +void KartDemoCam::VsLastCam() {} + +void KartDemoCam::InitLastCam() { + // void TJugem::getPosition() const {} +} +void KartDemoCam::LastCam() {} + +void KartDemoCam::InitStartDemoCam() {} + +void KartDemoCam::StartDemoCam() {} + +void KartDemoCam::SetLastDemo() {} + +void KartDemoCam::SetRaceCam() {} + +void KartDemoCam::SetNextID() {} + +void KartDemoCam::DoExecution() {} + +u8 KartDemoCam::GetStartID() {} + +void KartDemoCam::InitStartID(bool) {} + +void KartDemoCam::StartDemoView() {} + +void KartDemoCam::InitStartMapCam() {} + +void KartDemoCam::StartMapCam() {} + +void KartDemoCam::SetMapNextID() {} + +void KartDemoCam::SetUpMapID() {} + +void KartDemoCam::InitStaffView() {} + +void KartDemoCam::StaffView() {} + +void KartDemoCam::SetStaffNextID() {} + +void KartDemoCam::SetUpStaffID() {} diff --git a/src/Yamamoto/KartDossin.cpp b/src/Yamamoto/KartDossin.cpp index e69de29b..6c76c691 100644 --- a/src/Yamamoto/KartDossin.cpp +++ b/src/Yamamoto/KartDossin.cpp @@ -0,0 +1,31 @@ +#include "Yamamoto/KartDossin.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// comments inside functions are inline functions being called in that function + +void KartDossin::Init(int) {} + +void KartDossin::DoDossinTimer() {} + +void KartDossin::MakeDossin(GeographyObj *) {} + +void KartDossin::DoDossin() { + // void GeographyObj::getVelocity(JGeometry::TVec3 *) const {} +} + +void KartDossin::DoKeep() {} + +void KartDossin::DoClear() {} + +void KartDossin::DoCheck() {} + +void KartDossin::DoReturn() {} + +void KartDossin::DoShake() {} + +void KartDossin::DoCheckEnd() {} + +void KartDossin::DoDossinCrl() {} + +void KartDossin::DoAfterDossinCrl() {} diff --git a/src/Yamamoto/KartFitParam.cpp b/src/Yamamoto/KartFitParam.cpp index e69de29b..cb8ef454 100644 --- a/src/Yamamoto/KartFitParam.cpp +++ b/src/Yamamoto/KartFitParam.cpp @@ -0,0 +1,87 @@ + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// marioluiziTireOp; +// biglTireOp; +// KuppaTireOp; +// peachTireOp; +// yossyTireOp; +// nokonokoTireOp; +// babyTireOp; +// warioTireOp; +// kuppajrTireOp; +// waluiziTireOp; +// pakknTireOp; +// didyTireOp; +// kinoTireOp; +// demolTireOp; +// TireOpData; +// normalArmOp; +// peachArmOp; +// kuppaArmOp; +// donkyArmOp; +// yossyArmOp; +// nokonokoArmOp; +// babyArmOp; +// warioArmOp; +// kuppajrArmOp; +// waluiziArmOp; +// pakknArmOp; +// didiyArmOp; +// kinopioArmOp; +// demoArmOp; +// ArmOpData; +// normalDumpOp; +// bigDumpOp; +// peachDumpOp; +// kuppaDumpOp; +// yossyDumpOp; +// nokonokoDumpOp; +// babyDumpOp; +// warioDumpOp; +// kuppajrDumpOp; +// waluiziDumpOp; +// pakknDumpOp; +// demoDumpOp; +// didyDumpOp; +// DumpOpData; +// marioBodyOp; +// bigBodyOp; +// peachBodyOp; +// nokonokoBodyOp; +// babyBodyOp; +// warioBodyOp; +// kuppaBodyOp; +// waluiziBodyOp; +// pakknBodyOp; +// didyBodyOp; +// kuppajrBodyOp; +// kinopioBodyOp; +// demoBodyOp; +// BodyOpData; +// CubeParamsData; +// marioCamOp; +// donkyCamOp; +// yossyCamOp; +// nokonokoCamOp; +// peachCamOp; +// babyCamOp; +// waruCamOp; +// kuppaCamOp; +// CameraOpData; +// RescueSeaDepth; +// floorDepth; +// floorThunderDepth; +// bridgeDepth; +// bridgeThunderDepth; +// tireOffsetPos; + +// Unused +// normalTireOp; +// minilTireOp; +// bigArmOp; +// miniArmOp; +// miniDumpOp; +// miniBodyOp; +// cubeNormalPos; +// cubeMiniPos; diff --git a/src/Yamamoto/KartItemStrat.cpp b/src/Yamamoto/KartItemStrat.cpp index e69de29b..8b188457 100644 --- a/src/Yamamoto/KartItemStrat.cpp +++ b/src/Yamamoto/KartItemStrat.cpp @@ -0,0 +1,55 @@ +#include "Yamamoto/KartItem.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// comments inside functions are inline functions being called in that function + +void KartItem::Init(int) {} + +void KartItem::DoRabbit() {} + +void KartItem::SetSucMashItem() {} + +void KartItem::CheckHitItem() {} + +void KartItem::FallStealItem(int, int) {} + +void KartItem::FallItem() {} + +void KartItem::FallAllItem() {} + +void KartItem::ReleseWanWan() {} + +void KartItem::CompulsionReleseWanWan() { + // void ItemWanWanObj::tstReverseThrow() const {} +} + +void KartItem::KillWanWan() {} + +bool KartItem::IsMyItem() { + // void ItemWanWanObj::IsEndPull() {} +} + +bool KartItem::IsChanging() {} + +void KartItem::DoTurtleReleaseDir(int, int) {} + +void KartItem::DoBananaReleaseDir() {} + +void KartItem::DoTurtleReleaseDynamicDir(unsigned long) {} + +void KartItem::DoBananaReleaseDynamicDir() {} + +void KartItem::TeamRobItm() {} + +void KartItem::SuspendItem() {} + +void KartItem::CheckOtherAnime() {} + +void KartItem::DoOtherAnime() {} + +void KartItem::DoTandemItemAnime() {} + +void KartItem::DoTandemItemRelease() {} + +void KartItem::DoItem() {} diff --git a/src/Yamamoto/KartRescue.cpp b/src/Yamamoto/KartRescue.cpp index e69de29b..8d7c7616 100644 --- a/src/Yamamoto/KartRescue.cpp +++ b/src/Yamamoto/KartRescue.cpp @@ -0,0 +1,52 @@ +#include "Yamamoto/KartRescue.h" +#include "Kameda/WipeManager.h" +#include "Kaneshige/Course/Course.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// comments inside functions are inline functions being called in that function + +void KartRescue::Init(int) {} + +void KartRescue::DoKeep() {} + +void KartRescue::GetJugemuStatus() { + // void CrsGround::operator= (const CrsGround &) {} implicit most likely + // void GeographyObj::getObjData() const {} +} + +void KartRescue::SetPose(unsigned char) {} + +void KartRescue::SetJugemuPose(int, KartBody *) {} + +void KartRescue::DoMove(KartBody *) {} + +void KartRescue::SetHookPos(KartBody *) {} + +void KartRescue::DoCatch() { + // void KartChecker::beginWarp(JugemPoint *) {} + // void KartCam::SetFlag(unsigned short) {} +} + +void KartRescue::DoTop() {} + +void KartRescue::DoDrop() {} + +void KartRescue::DoCheckEnd() { + // void KartCam::ClrFlag(unsigned short) {} +} + +void KartRescue::MakeRescue(GeographyObj *, unsigned char) {} + +void KartRescue::DoRescueCrl() { + // void KartChecker::endWarp() {} + // void RivalKart::getBodyCtrl() {} + // void JugemPoint::getCLPoint() {} + // void Course::isFreeze() {} + // void CrsData::isSnow() const {} + // void TMapObjAntLion::eat() {} + // void GETWipeManager() {} + // void WipeManager::getManager() {} +} + +void KartRescue::DoAfterRescueCrl() {} diff --git a/src/Yamamoto/KartThunder.cpp b/src/Yamamoto/KartThunder.cpp index e69de29b..766971b7 100644 --- a/src/Yamamoto/KartThunder.cpp +++ b/src/Yamamoto/KartThunder.cpp @@ -0,0 +1,15 @@ +#include "Yamamoto/KartThunder.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +void KartThunder::Init(int) {} + +bool KartThunder::DoReturn() {} + +bool KartThunder::DoShake() {} + +void KartThunder::ClearThunder() {} + +void KartThunder::MakeThunder() {} + +void KartThunder::DoThunderCrl() {} diff --git a/src/Yamamoto/KartTumble.cpp b/src/Yamamoto/KartTumble.cpp index e69de29b..2210813d 100644 --- a/src/Yamamoto/KartTumble.cpp +++ b/src/Yamamoto/KartTumble.cpp @@ -0,0 +1,31 @@ +#include "Yamamoto/KartTumble.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// comments inside functions are inline functions being called in that function + +void KartTumble::Init(int) {} + +void KartTumble::MakeWanWanTumble(ItemObj *) { + // void ItemObj::getPos(JGeometry::TVec3 *) {} +} + +void KartTumble::MakeKameTumble(ItemObj *) {} + +void KartTumble::MakeStarTumble() {} + +void KartTumble::MakeDashTumble() {} + +void KartTumble::DoTumble() {} + +void KartTumble::DoPakunTumble() {} + +void KartTumble::DoHanaTumble() {} + +void KartTumble::MakePoiHanaTumble() {} + +void KartTumble::DoShootCrashCrl() {} + +void KartTumble::DoTumbleCrl() {} + +void KartTumble::DoAfterTumbleCrl() {} diff --git a/src/Yamamoto/kartBody.cpp b/src/Yamamoto/kartBody.cpp index e69de29b..46f3b2fd 100644 --- a/src/Yamamoto/kartBody.cpp +++ b/src/Yamamoto/kartBody.cpp @@ -0,0 +1,136 @@ +#include "Yamamoto/kartBody.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// settingPtr2 +// settingMiniPtr2 + +// body settings + +// comments inside functions are inline functions being called in that function + +void KartBody::DegubBody(unsigned long) { + // void SysDebug::checkNaNVector(Vec *, unsigned long) {} + + //void SysDebug::checkNaNMatrix(float (*) [4], unsigned long) {} +} + +void KartBody::MakeMassBody(float, float, float, float) {} + +void KartBody::MakeRigidVertexBody(float, float, float, float) {} + +void KartBody::SetUpRigidBodyPose(JGeometry::TVec3 *, JGeometry::TVec3 *) { + //void std::atan2f(float, float) {} +} + +void KartBody::SetUpRigidBodyStartGridPose() { + // void JGeometry::TVec3::setNormal(const JGeometry::TVec3 &, const JGeometry::TVec3 &, const JGeometry::TVec3 &) {} + // void KartBody::getSus(int) {} +} + +void KartBody::DoForce(JGeometry::TVec3 *, JGeometry::TVec3 *) {} + +void KartBody::DoTq(JGeometry::TVec3 *, JGeometry::TVec3 *) {} + +void KartBody::DoForceOnly(KartBody *, JGeometry::TVec3 *, JGeometry::TVec3 *) {} + +void KartBody::DoForceOnly(JGeometry::TVec3 *, JGeometry::TVec3 *) {} + +void KartBody::DoGForce() { + // int KartBody::getTouchNum() {} +} + +void KartBody::CalcMovement(JGeometry::TVec3 *, JGeometry::TVec3 *, JGeometry::TVec3 *, JGeometry::TVec3 *) {} + +void KartBody::DoCalcWgVel() { + //void KartBody::getGame() {} + //void KartBody::getStrat() {} + //void KartThunder::getScale() {} + //void KartBody::getThunder() {} + //void JGeometry::TVec3::div(float, const JGeometry::TVec3 &) {} + //void JGeometry::TUtil::invert(float) {} +} + +void KartBody::DoPose() {} + +void KartBody::DoCalcMassMatrix(float (*) [4], float, JGeometry::TVec3 *, JGeometry::TVec3 *) {} + +void KartBody::WallFriction(JGeometry::TVec3 *, float, JGeometry::TVec3 *, JGeometry::TVec3 *, JGeometry::TVec3 *, float) {} + +void KartBody::GroundReflection(JGeometry::TVec3 *, JGeometry::TVec3 *, float, float, float) {} + +void KartBody::RigidReflectionAnime(KartBody *, KartBody *, float, float) { + // void KartCtrl::getKartSound(int) {} + // void KartCtrl::getKartAnime(int) {} + // void KartBody::getChecker() {} +} + +void KartBody::RigidReflectionPower(KartBody *, KartBody *, float *, float *) { + // void KartBody::getCrash() {} + // void KartBody::getTumble() {} + // void KartBody::getDamage() {} +} + +void KartBody::RigidReflection(KartBody *, KartBody *, JGeometry::TVec3 *, JGeometry::TVec3 *, float, float, float) { + // void JGeometry::TVec3::angle(const JGeometry::TVec3 &) const {} + // void JGeometry::TUtil::abs(float) {} + // void JGeometry::TUtil::atan2(float, float) {} + // void JMAAtan2Radian(float, float) {} + // void JMath::TAtanTable<1024, float>::atan2Radian(float, float) const {} +} + +void KartBody::ObjectReflection(JGeometry::TVec3 *) {} + +void KartBody::ObjectWallReflection(GeographyObj *) { + // void GeographyObjManager::getKartHitRefVecNormalObj(int) const {} + // void GeographyObjManager::getKartHitDepthNormalObj(int) const {} + // void GeographyObj::getPosition(JGeometry::TVec3 *) const {} +} + +void KartBody::StarReact(GeographyObj *) {} + +void KartBody::CheckObjectReflection() { + // void KartBody::getDossin() {} + // void GeographyObjManager::getKartReactHitObjectList(int) {} +} + +void KartBody::CheckRoofReflection() {} + +void KartBody::WallReflection(JGeometry::TVec3 *, float, float, float) {} + +void KartBody::GroundVertexReflection(int, CrsGround, JGeometry::TVec3 *, unsigned char *) {} + +void KartBody::WallVertexReflection(CrsGround, JGeometry::TVec3 *, unsigned char *, unsigned char *) {} + +void KartBody::CheckVertexReflection() { + // void CrsGround::CrsGround(const CrsGround &) {} + // void KartBody::CheckBodyHit(KartBody *, KartBody *) {} +} + +void KartBody::InitBodySetting() {} + +void KartBody::GetMiniGameCamData(int) { + // void RaceMgr::getCurrentManager() {} +} + +void KartBody::GetPakkunMiniGameCamData(int) {} + +void KartBody::GetPakkunGameCamData(int) {} + +void KartBody::InitCamSetting() { + // void RaceMgr::isSubScrExist() const {} +} + +void KartBody::InitBodyCamParam() {} + +void KartBody::InitBodyParam() { + //void KartInfo::getWeight() const {} + //void KartInfo::getDriverWeight(int) const {} + //void KartInfo::KartCharacter::getWeight() const {} +} + +void KartBody::Init(int) { + //void KartShadowModel::setScale(float, float) {} + //void KartLoader::getShadowModel() {} + //void CrsGround::getObject() const {} +} diff --git a/src/Yamamoto/kartBodyStrat.cpp b/src/Yamamoto/kartBodyStrat.cpp index e69de29b..49378afd 100644 --- a/src/Yamamoto/kartBodyStrat.cpp +++ b/src/Yamamoto/kartBodyStrat.cpp @@ -0,0 +1,121 @@ +#include "Yamamoto/KartStrat.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// comments inside functions are inline functions being called in that function + +void KartStrat::Init(int) {} + +void KartStrat::GetBodySpeed() {} + +void KartStrat::GetBodyRoll() { + // void KartShadowModel::setRoll(float) {} + // void std::atanf(float) {} +} + +void KartStrat::GetRoadBodyRoll() {} + +void KartStrat::GetBodyNorm() {} + +void KartStrat::DoEnemyMaxmZCrl(float) {} + +void KartStrat::DoMaxLevelZXVelCrl(float, float) {} + +void KartStrat::DoVelCrl(float) {} + +void KartStrat::DoWgCrl(float) {} + +void KartStrat::DoRotPose(JGeometry::TVec3, float) { + // void JGeometry::TVec3::operator* (float) const {} + // void JGeometry::TVec3::operator*= (float) {} +} + +void KartStrat::DoPoseCrl() {} + +void KartStrat::MovingSpinClear() {} + +void KartStrat::MovingHalfSpinClear() {} + +void KartStrat::MovingTornadeClear() {} + +void KartStrat::FreezeClear() {} + +void KartStrat::RollCrashClear() {} + +void KartStrat::AllGravyClear() {} + +void KartStrat::GravyClear() {} + +void KartStrat::LiftClear() {} + +void KartStrat::PitchClear() {} + +void KartStrat::DashClear() {} + +void KartStrat::OtherClear() {} + +void KartStrat::ShakeGround() {} + +void KartStrat::DoAdjustment() { + // void KartBody::getPipe() {} +} + +void KartStrat::DoWheelSpinCrl() {} + +void KartStrat::DoWallCrl() {} + +void KartStrat::DoYawLimit() {} + +void KartStrat::DoRollLimit() {} + +void KartStrat::DoLiftCrl() {} + +void KartStrat::DoLiftYawCrl() { + // void SysDebug::checkNaNVector(Vec *, char *) {} +} + +void KartStrat::DoRollLim(float, float) {} + +void KartStrat::DoPitchLim() {} + +void KartStrat::DoRollCrash() {} + +void KartStrat::DoTestPitchCrl() {} + +void KartStrat::DoDashCrl(float) {} + +void KartStrat::DoStarCrl(float) {} + +void KartStrat::DoAirCrl() {} + +void KartStrat::DoYawCrl() {} + +void KartStrat::DoSignalCrl() {} + +void KartStrat::DoSpeedCrl() {} + +void KartStrat::DoComSpeedCrl() {} + +void KartStrat::DoCutSlide() {} + +void KartStrat::DoCalcSpeed() {} + +void KartStrat::DoMotor(MotorManager::MotorType) { + // void KartBody::getHandle() {} +} + +void KartStrat::DoPowerMotor(float, unsigned char, unsigned char) {} + +void KartStrat::DashSpeedCtrl(float) {} + +void KartStrat::DashSpSpeedCtrl(float) {} + +void KartStrat::CompulsionDash(JGeometry::TVec3 *) {} + +void KartStrat::DoDash() { + // void KartCam::GetCameraMode() {} +} + +void KartStrat::DoStatusCrl() { + // void KartBody::getAnt() {} +} diff --git a/src/Yamamoto/kartCamStrat.cpp b/src/Yamamoto/kartCamStrat.cpp index e69de29b..68a06226 100644 --- a/src/Yamamoto/kartCamStrat.cpp +++ b/src/Yamamoto/kartCamStrat.cpp @@ -0,0 +1,105 @@ +#include "Yamamoto/kartCamera.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// Unused function calls set from TVec3f +// comments inside functions are inline functions being called in that function + +void KartCam::SetTargetNum(unsigned char) {} + +void KartCam::SetClipper() { + // void J3DUClipper::setFovy(float) {} + // void J3DUClipper::setFar(float) {} + // void J3DUClipper::setNear(float) {} + // void J3DUClipper::setAspect(float) {} +} + +void KartCam::CheckClipper() {} + +GrafPort::GrafPort(int, int, int, int, float, float, float) {} + +void GrafPort::setPort() {} + +void GrafPort::SetParam(float, float, float) {} + +void KartCam::MakeShaker(float) {} + +void KartCam::DoShaker(JGeometry::TVec3 *, JGeometry::TVec3) {} + +void KartCam::SetPtr() {} + +JGeometry::TVec3f *KartCam::GetCameraPos() {} + +JGeometry::TVec3f *KartCam::GetCameraLookPos() {} + +void KartCam::SetFovyData() {} + +void KartCam::First4ScreenPort(unsigned char) {} + +void KartCam::Second4ScreenPort(unsigned char) {} + +void KartCam::Third4ScreenPort(unsigned char) {} + +void KartCam::Fourth4ScreenPort(unsigned char) {} + +void KartCam::First2ScreenPort(unsigned char) {} + +void KartCam::Second2ScreenPort(unsigned char) {} + +void KartCam::SetVictoryScreenPort(unsigned char) { + // void RaceMgr::getZoomWinConsoleNo() const {} + // void RaceDirector::getZoomWinConsoleNo() const {} + // void RaceMgr::isZoomWinConsole() const {} +} + +void KartCam::DoMoveCamera(JGeometry::TVec3 *, JGeometry::TVec3 *) {} + +void KartCam::DoRoof(JGeometry::TVec3 *, CrsArea *) {} + +void KartCam::DoColCamera() {} + +void KartCam::DoSea(JGeometry::TVec3 *, CrsGround *) {} + +void KartCam::DoGround(JGeometry::TVec3 *, CrsGround *) {} + +void KartCam::GroundCheck(JGeometry::TVec3 *, JGeometry::TVec3 *, CrsArea *) {} + +void KartCam::OutViewCalc() {} + +void KartCam::InitOutView() {} + +void KartCam::DoChangFovy() {} + +void KartCam::DoLookChase() {} + +void KartCam::DoYRotation() {} + +void KartCam::DoXRotation() {} + +void KartCam::DoDist() {} + +void KartCam::DoCamPos(float, JGeometry::TVec3 *) {} + +void KartCam::OutView() {} + +void KartCam::InitRaceBackView() {} + +void KartCam::ParallelView() {} + +void KartCam::InitBackView() {} + +void KartCam::BackView() {} + +void KartCam::HangRescueView() {} + +void KartCam::InitDropRescueView() {} + +void KartCam::DropRescueView() {} + +void KartCam::LaunchView() {} + +void KartCam::LandView() {} + +void KartCam::InitPipeView() {} + +void KartCam::PipeView() {} diff --git a/src/Yamamoto/kartChapter.cpp b/src/Yamamoto/kartChapter.cpp index e69de29b..d33cfaea 100644 --- a/src/Yamamoto/kartChapter.cpp +++ b/src/Yamamoto/kartChapter.cpp @@ -0,0 +1,49 @@ +#include "Yamamoto/KartGame.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// comments inside functions are inline functions being called in that function + +void KartGame::DoVisible() {} + +void KartGame::DoWinCamera() {} + +void KartGame::DoChapterOne() {} + +void KartGame::DoChapterTwo() {} + +void KartGame::DoChapterThree() {} + +void KartGame::DoChapterFour() {} + +void KartGame::DoChapterFive() {} + +void KartGame::DoChapterSix() { + // void KartDrawer::fadeOutGhost() {} +} + +void KartGame::DoChapterSeven() {} + +void KartGame::DoChapterBalloon() { + // void WipeManager::killWipe(int) {} + // void WipeManager::startWipe(int) {} + // void WipeManager::stopWipe(int) {} + // void J2DManager::startLoserAnm(int) {} +} + +void KartGame::DoChapterBomEsc() { + // void RaceMgr::isMovingToStartPoint() const {} + // void RaceDirector::isMovingToStartPoint() const {} + // void RaceMgr::isPlayingWinnerAnm() const {} + // void RaceDirector::isPlayingWinnerAnm() const {} +} + +void KartGame::DoStaffRoll() { + // void KartChecker::clrDemoPoint() {} + // void RaceMgr::isPlayingDemoWinnerAnm() const {} + // void KartChecker::getDemoPoint() {} +} + +void KartGame::DoWaitBattleWin() {} + +void KartGame::DoStartGoalCtl() {} diff --git a/src/Yamamoto/kartCtrlInfo.cpp b/src/Yamamoto/kartCtrlInfo.cpp index e69de29b..89a299ee 100644 --- a/src/Yamamoto/kartCtrlInfo.cpp +++ b/src/Yamamoto/kartCtrlInfo.cpp @@ -0,0 +1,172 @@ +#include "Osako/kartPad.h" +#include "Yamamoto/kartCtrl.h" + +#include "Jsystem/JAudio/JASFakeMatch2.h" + +// comments inside functions are inline functions being called in that function + +void KartCtrl::SetPadClear(KartGamePad *) {} + +void KartCtrl::SetWanWanPadClear(KartGamePad *) {} + +void KartCtrl::SetGhostPadClear(KartGamePad *) {} + +void KartCtrl::PadAllClear(int) { + // void KartCtrl::getCoPad(int) {} + // void KartCtrl::getPad(int) {} +} + +void KartCtrl::DoContCtl(int) {} + +void KartCtrl::DoContCopy(int) {} + +void KartCtrl::DoContPaste(int) { +} + +f32 KartCtrl::GetItemStickY(int) {} +f32 KartCtrl::GetItemStickX(int) {} + +void KartCtrl::GetItemButton(int) {} + +void KartCtrl::DoLod() { + // void KartCam::GetClipperScale() {} + // void KartCam::GetLodLen() {} +} + +void KartCtrl::GetPortPtr(int) {} + +void KartCtrl::GetCamFovy(int) {} + +void KartCtrl::GetCamAspect(int) {} + +void KartCtrl::GetBodyGround(int) {} + +void KartCtrl::GetRRTireGround(int) {} + +void KartCtrl::GetRLTireGround(int) {} + +void KartCtrl::GetBodyPos(int, JGeometry::TVec3 *) {} + +void KartCtrl::GetBodyVel(int, JGeometry::TVec3 *) {} + +bool KartCtrl::GetLeftFTirePos(int, Vec *) {} + +bool KartCtrl::GetRightFTirePos(int, Vec *) {} + +void KartCtrl::GetLeftTirePos(int, Vec *) {} + +void KartCtrl::GetRightTirePos(int, Vec *) {} + +void KartCtrl::GetTirePos(int, int, Vec *) {} + +void KartCtrl::GeTireG(int) {} + +f32 KartCtrl::GetCarSpeed(int) {} + +f32 KartCtrl::GetCarRpm(int) {} + +f32 KartCtrl::GetKartRpm(int) {} + +KartGamePad *KartCtrl::GetDriveCont(int) {} + +KartGamePad *KartCtrl::GetCoDriveCont(int) {} + +u64 KartCtrl::GetCarStatus(int idx) { + return getKartBody(idx)->mCarStatus; +} + +u32 KartCtrl::GetGameStatus(int idx) { + return getKartBody(idx)->mGameStatus; +} + +void KartCtrl::SetTireDispRound(KartBody *, KartSus *, float) {} + +void KartCtrl::SetKartRpm(KartBody *, float, float) {} + +u8 KartCtrl::WhichDriver(int) {} + +u8 KartCtrl::WhichNowDriver(int) {} + +bool KartCtrl::CheckCamera(int) {} + +int KartCtrl::GetCameraNum(int) {} + +bool KartCtrl::CheckItem(int) {} + +f32 KartCtrl::GetMaxSpeed(int) {} + +f32 KartCtrl::GetDownSlopeAcc(int) {} + +f32 KartCtrl::GetDownSlopeSpeed(int) {} + +f32 KartCtrl::GetTireAngle(int) {} + +f32 KartCtrl::GetTandemDir(int) {} + +f32 KartCtrl::GetWaterHeight(int) {} + +bool KartCtrl::CheckJugemuSignal() {} + +GameAudio::KartSoundMgr *KartCtrl::GetKartSoundMgr(int) { + // void DriverModel::getGameAudioCharacterSoundMgr() {} +} + +f32 KartCtrl::GetKartBodyOffset(int) {} + +void KartCtrl::MakeChangePossible(int) {} + +bool KartCtrl::CheckTandemItmGet(int) {} + +bool KartCtrl::CheckTandemItmRollingGet(int) {} + +void KartCtrl::SetObjectPos(int, JGeometry::TVec3) {} + +bool KartCtrl::CheckThunderBolt(int) {} + +void KartCtrl::GetTireRadius(int) {} + +void KartCtrl::IsBurn(int) {} + +void KartCtrl::IsWallReact(int) {} + +void KartCtrl::HaveBalloon(int) {} + +int KartCtrl::GetDriftCnt(int) {} + +bool KartCtrl::IsMiniGame() {} + +bool KartCtrl::IsMiniGameEnd() {} + +bool KartCtrl::CheckWinner() {} + +void KartCtrl::GetKartEffctVel(int, JGeometry::TVec3 *) {} + +bool KartCtrl::CheckChange(int) {} + +bool KartCtrl::CheckMatchless(int) {} + +bool KartCtrl::CheckReverse(int) {} + +f32 KartCtrl::GetKartScale(int) {} + +RivalKart *KartCtrl::getKartEnemy(int) {} + +CLPoint *KartCtrl::GetKartCenterPtr(int) {} + +void KartCtrl::EnemyInit(int) {} + +void KartCtrl::EnemyResetInit(int) {} + +bool KartCtrl::CheckZoomWinConsole() {} + +void KartCtrl::SetUpMiniTurbo(int, unsigned char) {} + +void KartStrat::DoStepAccel() {} + +void KartStrat::DoStepSterr() {} + +void KartStrat::DoSterr() {} + +void KartStrat::DoAccel() {} + +bool KartCtrl::HaveRabbit() {} diff --git a/src/Yamamoto/kartCtrlStrat.cpp b/src/Yamamoto/kartCtrlStrat.cpp index e69de29b..2f5b745e 100644 --- a/src/Yamamoto/kartCtrlStrat.cpp +++ b/src/Yamamoto/kartCtrlStrat.cpp @@ -0,0 +1,119 @@ +#include "Yamamoto/KartGame.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// comments inside functions are inline functions being called in that function + +void KartGame::Init(int) {} + +void KartGame::GetGorundTireNum() {} + +void KartGame::WatchEffectAcceleration() {} + +void KartGame::WatchAcceleration() {} + +void KartGame::DoItmCancel() {} + +void KartGame::DoStopItm() {} + +void KartGame::DoChange() {} + +void KartGame::DoSlide() {} + +void KartGame::DoDriftTurboSterr() {} + +void KartGame::SetDriftTurboSterr() {} + +void KartGame::CheckDriftTurbo() { + // void JUTGamePad::getMainStickX() const {} +} + +void KartGame::DoWarmUpRoll() {} + +void KartGame::DoRollAnim() {} + +void KartGame::DoDriftClear() {} + +void KartGame::DoRoll() {} + +void KartGame::DoTestPitch() { + // void JUTGamePad::getMainStickY() const {} +} + +void KartGame::DoLiftTurbo() {} + +void KartGame::DoTurbo() {} + +void KartGame::DoRollThrow() {} + +void KartGame::DoRollOver() {} + +void KartGame::DoWanWan() { + // void ItemWanWanObj::getDifVel() const {} + // void ItemWanWanObj::getPullVec(JGeometry::TVec3 *) {} +} + +void KartGame::DoPushStart() {} + +void KartGame::DoBalance(float *, float) {} + +void KartGame::MakeClear() {} + +void KartGame::MakeBoardDash() {} + +void KartGame::MakeJumpDash() {} + +void KartGame::MakeSpJumpDash() {} + +void KartGame::MakeMashDash() {} + +void KartGame::MakeGoldenMashDash() {} + +void KartGame::MakeStartDash() {} + +void KartGame::MakeCrashDash() {} + +void KartGame::MakeWheelSpin() {} + +void KartGame::MakeJump() {} + +void KartGame::DoAirCheck() {} + +void KartGame::DoRearSlidePower() {} + +void KartGame::DoRearSlideBody() { + // void JGeometry::TVec3::div(float) {} +} + +void KartGame::DoCorner() {} + +void KartGame::FrameWork(float, KartSus *, KartSus *) {} + +void KartGame::DoBodyAction() {} + +void KartGame::DoElementForce() {} + +void KartGame::CheckBalloon() {} + +void KartGame::SetRank() {} + +void KartGame::RankWatchMan() {} + +void KartGame::ItemWatchMan(ItemObj *) {} + +void KartGame::AfterItemWatchMan() {} + +void KartGame::DoFlagCtrl() {} + +void KartGame::KeepWatch() {} + +void KartGame::DoActionMgr() { + // void KartBody::getStar() {} + // void ItemObjMgr::getKartHitList(int) {} +} + +void KartGame::DoActionCtrl() {} + +void KartGame::DoStatus() { + // void KartCtrl::DoAnime(int) {} +} diff --git a/src/Yamamoto/kartParams.cpp b/src/Yamamoto/kartParams.cpp index e69de29b..f8bc5854 100644 --- a/src/Yamamoto/kartParams.cpp +++ b/src/Yamamoto/kartParams.cpp @@ -0,0 +1,30 @@ +#include "JSystem/JAudio/JASFakeMatch2.h" + +// normalBody; +// bigBody; +// miniBody; +// warioBody; +// kuppaBody; +// kinoBody; +// peachBody; +// normalSus; +// malioSus; +// nokonokoSus; +// peachSus; +// kuppaSus; +// warioSus; +// babySus; +// didySus; +// kinopioSus; +// demoSus; +// normalTire; +// Jdata; +// BodyFullHeightData; +// BodyFullBumpData; +// SusPowerData; +// ThunderOffet; +// SusDushDive; +// SetEngineClassData; +// SusParamsData; +// TireParamsData; +// BodyParamsData; diff --git a/src/Yamamoto/kartSus.cpp b/src/Yamamoto/kartSus.cpp index e69de29b..5ffae8c6 100644 --- a/src/Yamamoto/kartSus.cpp +++ b/src/Yamamoto/kartSus.cpp @@ -0,0 +1,35 @@ +#include "Yamamoto/kartSus.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +// Called in Unused Function +// void KartSus::getKartBody() {} + +// comments inside functions are inline functions being called in that function + +void KartSus::InitTirePose(int) {} + +void KartSus::InitSettingParam(int) {} + +void KartSus::InitParam(int) {} + +void KartSus::Init(int) {} + +void KartSus::NormalInit(int) {} + +void KartSus::ResetInit(int) {} + +void KartSus::CircleFriction(JGeometry::TVec3 *, float) {} + +f32 KartSus::GetCornerForce() {} + +f32 KartSus::GetCircleFric() {} + +void KartSus::DoSusAction(int) { + // void KartBody::getCannon() {} + // void KartBody::getRescue() {} + // void Spline::setAll(const JGeometry::TVec3 *) {} + // void Spline::set(int, const JGeometry::TVec3 &) {} +} + +void KartSus::DoTireAction() {}