From 79c026ec292267062dea1d6b312ffb71d13c81e5 Mon Sep 17 00:00:00 2001 From: SwareJonge <41187958+SwareJonge@users.noreply.github.com> Date: Fri, 10 Jan 2025 00:55:51 +0100 Subject: [PATCH] Match some TUs from Kaneshige --- configure.py | 12 +- include/JSystem/J3D/J3DSys.h | 1 + include/JSystem/JFramework/JFWDisplay.h | 8 +- include/JSystem/JGadget/std-list.h | 98 +++ include/JSystem/JGadget/std-memory.h | 33 + include/JSystem/JKernel/JKRHeap.h | 5 +- include/JSystem/JSupport/JSUList.h | 3 +- include/Kameda/Demo2D.h | 4 +- include/Kameda/J2DManager.h | 4 +- include/Kameda/PauseManager.h | 46 +- include/Kaneshige/Course/Course.h | 7 +- include/Kaneshige/Course/CrsData.h | 7 +- include/Kaneshige/Course/CrsGround.h | 41 +- include/Kaneshige/DemoTimeKeeper.h | 2 + include/Kaneshige/DrawBuffer.h | 55 ++ include/Kaneshige/ExModel.h | 6 +- include/Kaneshige/GhostScreen.h | 8 +- include/Kaneshige/KartChecker.h | 21 +- include/Kaneshige/KartDrawer.h | 17 + include/Kaneshige/KartLoader.h | 2 +- include/Kaneshige/LightMgr.h | 59 +- include/Kaneshige/Objects/GeoBombCar.h | 44 +- include/Kaneshige/Objects/GeoBus.h | 4 +- include/Kaneshige/Objects/GeoCannon.h | 4 +- include/Kaneshige/Objects/GeoCarShadow.h | 14 +- include/Kaneshige/Objects/GeoDkCloud.h | 4 +- include/Kaneshige/Objects/GeoHanaBody.h | 4 +- include/Kaneshige/Objects/GeoHanaCar.h | 4 +- include/Kaneshige/Objects/GeoKinoCar.h | 4 +- include/Kaneshige/Objects/GeoKuriCar.h | 6 +- include/Kaneshige/Objects/GeoRabbitMark.h | 121 ++-- include/Kaneshige/Objects/GeoShimmer.h | 43 ++ include/Kaneshige/Objects/GeoShine.h | 67 ++ include/Kaneshige/Objects/GeoStartLine.h | 2 - include/Kaneshige/Objects/GeoTruck.h | 4 +- include/Kaneshige/Objects/GeoVision.h | 63 ++ include/Kaneshige/Objects/GeoWater.h | 7 +- include/Kaneshige/RaceBGMPlayer.h | 24 +- include/Kaneshige/RaceDirector.h | 70 +- include/Kaneshige/RaceDrawer.h | 127 ++-- include/Kaneshige/RaceInfo.h | 8 +- include/Kaneshige/RaceLight.h | 2 + include/Kaneshige/RaceMgr.h | 12 +- include/Kawano/accessory.h | 8 +- include/Kawano/feeling.h | 56 ++ include/Osako/Award2D.h | 13 +- include/Osako/shadowMgr.h | 18 +- include/Sato/GeographyObj.h | 54 +- include/Sato/GeographyObjMgr.h | 21 +- include/Sato/ItemObj.h | 21 +- include/Sato/ItemObjMgr.h | 17 +- include/Sato/JPEffectMgr.h | 2 +- include/Sato/RivalBodyCtrl.h | 6 +- include/Sato/StateObserver.h | 10 +- include/Sato/stEffectMgr.h | 73 +- include/Sato/stMath.h | 1 + include/Shiraiwa/Balloon.h | 83 ++- include/Shiraiwa/JugemMain.h | 7 +- include/Shiraiwa/LensFlare.h | 101 +++ include/Shiraiwa/MapObjHanabi.h | 5 +- include/Shiraiwa/ZCaptureMgr.h | 68 ++ include/Yamamoto/kartCtrl.h | 12 +- include/kartEnums.h | 35 +- src/Kaneshige/GeoRabbitMark.cpp | 523 ++++++++++++++- src/Kaneshige/KartChecker.cpp | 6 +- src/Kaneshige/KartDrawer.cpp | 11 - src/Kaneshige/LightMgr.cpp | 145 ++++ src/Kaneshige/RaceDirector.cpp | 779 ++++++++++++++++++++++ src/Kaneshige/RaceDrawBuffer.cpp | 138 ++++ src/Kaneshige/RaceDrawer.cpp | 472 +++++++++++++ src/Kaneshige/RaceInfo.cpp | 6 +- src/Kaneshige/RaceMgr.cpp | 16 +- src/Kaneshige/RaceTime.cpp | 5 +- src/Sato/ObjUtility.cpp | 1 + src/Sato/StateObserver.cpp | 34 + 75 files changed, 3395 insertions(+), 429 deletions(-) create mode 100644 include/JSystem/JGadget/std-list.h create mode 100644 include/JSystem/JGadget/std-memory.h create mode 100644 include/Kaneshige/Objects/GeoShimmer.h create mode 100644 include/Kaneshige/Objects/GeoShine.h create mode 100644 include/Kaneshige/Objects/GeoVision.h create mode 100644 include/Kawano/feeling.h create mode 100644 include/Shiraiwa/LensFlare.h create mode 100644 include/Shiraiwa/ZCaptureMgr.h diff --git a/configure.py b/configure.py index a2e00c88..d155bc44 100755 --- a/configure.py +++ b/configure.py @@ -1104,13 +1104,13 @@ def MatchingFor(*versions): Object(Equivalent, "Kaneshige/RaceMgr.cpp"), Object(Matching, "Kaneshige/SysDebug.cpp"), Object(Matching, "Kaneshige/CrsArea.cpp"), - Object(NonMatching, "Kaneshige/LightMgr.cpp"), + Object(Matching, "Kaneshige/LightMgr.cpp"), Object(Matching, "Kaneshige/ScrnShot.cpp"), Object(Matching, "Kaneshige/GeoStartLine.cpp"), Object(Matching, "Kaneshige/CenterLine.cpp"), Object(Matching, "Kaneshige/RaceInfo.cpp"), Object(Matching, "Kaneshige/RaceLight.cpp"), - Object(NonMatching, "Kaneshige/RaceDrawBuffer.cpp"), + Object(Matching, "Kaneshige/RaceDrawBuffer.cpp"), Object(Matching, "Kaneshige/KartDrawer.cpp"), Object(Matching, "Kaneshige/TexLODControl.cpp"), Object(Matching, "Kaneshige/ShapePktControl.cpp"), @@ -1134,14 +1134,14 @@ def MatchingFor(*versions): Object(NonMatching, "Kaneshige/GeoVision.cpp"), Object(NonMatching, "Kaneshige/GeoSubWater.cpp"), Object(Matching, "Kaneshige/RaceBGMPlayer.cpp"), - Object(NonMatching, "Kaneshige/RaceDirector.cpp"), - Object(NonMatching, "Kaneshige/RaceDrawer.cpp"), + Object(Matching, "Kaneshige/RaceDirector.cpp"), + Object(Matching, "Kaneshige/RaceDrawer.cpp"), Object(NonMatching, "Kaneshige/GeoDkCloud.cpp"), Object(NonMatching, "Kaneshige/KartMotion.cpp"), Object(NonMatching, "Kaneshige/GeoKuribo.cpp"), Object(Matching, "Kaneshige/GeoAirJet.cpp"), Object(Matching, "Kaneshige/BlurScreen.cpp"), - Object(NonMatching, "Kaneshige/GeoRabbitMark.cpp"), + Object(Matching, "Kaneshige/GeoRabbitMark.cpp"), Object(Matching, "Kaneshige/KartMtx.cpp"), Object(Matching, "Kaneshige/DemoTimeKeeper.cpp"), Object(NonMatching, "Kaneshige/GeoKinojii.cpp"), @@ -1285,7 +1285,7 @@ def MatchingFor(*versions): Object(NonMatching, "Sato/stEfctRoad.cpp"), Object(NonMatching, "Sato/AnmController.cpp"), Object(Matching, "Sato/RivalKart.cpp"), - Object(NonMatching, "Sato/StateObserver.cpp"), + Object(Matching, "Sato/StateObserver.cpp"), Object(NonMatching, "Sato/NeckCtrl.cpp"), Object(NonMatching, "Sato/LumbarCtrl.cpp"), Object(NonMatching, "Sato/ArmCtrl.cpp"), diff --git a/include/JSystem/J3D/J3DSys.h b/include/JSystem/J3D/J3DSys.h index 1686af9b..6e1556e2 100644 --- a/include/JSystem/J3D/J3DSys.h +++ b/include/JSystem/J3D/J3DSys.h @@ -29,6 +29,7 @@ struct J3DSys void loadPosMtxIndx(int, u16) const; void loadNrmMtxIndx(int, u16) const; void ErrorReport(J3DErrType) const; + void setTexCacheRegion(GXTexCacheSize); void setDrawBuffer(J3DDrawBuffer *drawBuffer, int idx) { mDrawBuffer[idx] = drawBuffer; } void setDrawModeOpaTexEdge() { mDrawMode = 3; } diff --git a/include/JSystem/JFramework/JFWDisplay.h b/include/JSystem/JFramework/JFWDisplay.h index 439f0416..8bdcceaa 100644 --- a/include/JSystem/JFramework/JFWDisplay.h +++ b/include/JSystem/JFramework/JFWDisplay.h @@ -102,18 +102,18 @@ class JFWDisplay _38 = val; } - int startFadeOut(int duration) { + bool startFadeOut(int duration) { if (mFader != nullptr) { return mFader->startFadeOut(duration); } - return 1; + return true; } - int startFadeIn(int duration) { + bool startFadeIn(int duration) { if (mFader != nullptr) { return mFader->startFadeIn(duration); } - return 1; + return true; } void setTickRate(u32 rate) { diff --git a/include/JSystem/JGadget/std-list.h b/include/JSystem/JGadget/std-list.h new file mode 100644 index 00000000..3fb3fb07 --- /dev/null +++ b/include/JSystem/JGadget/std-list.h @@ -0,0 +1,98 @@ +#ifndef JSYSTEM_LIST_H +#define JSYSTEM_LIST_H + +#include "JSystem/JGadget/define.h" +#include "JSystem/JGadget/linklist.h" +#include "JSystem/JGadget/std-memory.h" +#include "types.h" + +// massive TODO, pls help me + +namespace JGadget { + +template > +struct TList { + struct TNode_ { + TNode_ *pPrev_; + TNode_ *pNext_; + }; + + class iterator { + public: + iterator() { this->p_ = nullptr; } + iterator(TNode_* node) { this->p_ = node; } + + iterator& operator++() { + this->p_ = this->p_->getNext(); + return *this; + } + + iterator& operator--() { + this->p_ = this->p_->getPrev(); + return *this; + } + + TNode_& operator*() const { + JGADGET_ASSERT(p_!=0); + return *this->p_; + } + + TNode_* operator->() const { return this->p_; } + + TNode_* p_; + }; + + class const_iterator { + public: + const_iterator(const TNode_* node) { this->p_ = node; } + const_iterator(iterator it) { this->p_ = it.p_; } + + const const_iterator& operator++() { + this->p_ = this->p_->getNext(); + return *this; + } + + const const_iterator& operator--() { + this->p_ = this->p_->getPrev(); + return *this; + } + + const TNode_* operator->() const { return this->p_; } + + const TNode_* p_; + }; + + TList(const TAllocator &allocator=0) { + oSize_ = 0; + Initialize_(); + } + + void Initialize_() { + oEnd_.pNext_ = &this->oNode_; + oEnd_.pPrev_ = &this->oNode_; + } + + void DestroyNode_(TNode_ *p) { + // probably doesn't match + JGADGET_ASSERT(p!=0); + JGADGET_ASSERT(p!=&oEnd_); + JGADGET_ASSERT(p->pNext_->pPrev_!=p); + JGADGET_ASSERT(p->pPrev_->pNext_!=p); + oAllocator_.destroy(p + 1); + oAllocator_.DeallocateRaw(p); + } + + iterator end() {return &this->oNode_; } + const_iterator end() const { return &this->oNode_; } + +private: + TAllocator oAllocator_; // 0 + u32 oSize_; // 4 + TNode_ oEnd_; // 8 +}; + +} + + + +#endif diff --git a/include/JSystem/JGadget/std-memory.h b/include/JSystem/JGadget/std-memory.h new file mode 100644 index 00000000..7493e7b7 --- /dev/null +++ b/include/JSystem/JGadget/std-memory.h @@ -0,0 +1,33 @@ +#ifndef STD_MEMORY_H +#define STD_MEMORY_H + +#include "JSystem/JUtility/JUTAssert.h" + +namespace JGadget { +template +struct TAllocator { + T* allocate(u32 count, void *param_2) { + return AllocateRaw(count * sizeof(T)); + } + + T* AllocateRaw(u32 size) { + return (T*)operator new(size); + } + + void deallocate(T* mem, u32 size) { + DeallocateRaw(mem); + } + + void DeallocateRaw(T* mem) { + delete mem; + } + + void destroy(T* p) { + JUT_ASSERT(p!=0); + } + + u8 mAllocator; // 00 +}; +} + +#endif /* STD_MEMORY_H */ diff --git a/include/JSystem/JKernel/JKRHeap.h b/include/JSystem/JKernel/JKRHeap.h index cb06e004..d8b9f53f 100644 --- a/include/JSystem/JKernel/JKRHeap.h +++ b/include/JSystem/JKernel/JKRHeap.h @@ -175,10 +175,7 @@ class JKRHeap : public JKRDisposer return mHeapTree.getParent()->getObject(); } - const JSUTree &getHeapTree() - { - return mHeapTree; - } + const JSUTree &getHeapTree() { return mHeapTree; } // Unused void checkMemoryFilled(u8 *, u32 size, u8); diff --git a/include/JSystem/JSupport/JSUList.h b/include/JSystem/JSupport/JSUList.h index c0758ae6..ddf67891 100644 --- a/include/JSystem/JSupport/JSUList.h +++ b/include/JSystem/JSupport/JSUList.h @@ -64,6 +64,7 @@ class JSUList : public JSUPtrList { } + void initiate() { JSUPtrList::initiate(); } bool append(JSULink *link) { return JSUPtrList::append((JSUPtrLink *)link); } bool prepend(JSULink *link) { return JSUPtrList::prepend((JSUPtrLink *)link); } bool insert(JSULink *before, JSULink *link) { return JSUPtrList::insert((JSUPtrLink *)before, (JSUPtrLink *)link); } @@ -218,4 +219,4 @@ class JSUTreeIterator JSUTree *mTree; }; -#endif /* JSULIST_H */ \ No newline at end of file +#endif /* JSULIST_H */ diff --git a/include/Kameda/Demo2D.h b/include/Kameda/Demo2D.h index 0056c1ad..1e19ff1a 100644 --- a/include/Kameda/Demo2D.h +++ b/include/Kameda/Demo2D.h @@ -5,7 +5,7 @@ class Demo2D { // Autogenerated - // Global +public: Demo2D(JKRHeap *); // 0x8018313c void init(); // 0x8018325c void draw(); // 0x801832d0 @@ -25,4 +25,4 @@ class Demo2D // Inline/Unused ~Demo2D(); }; // class Demo2D -#endif // DEMO2D_H \ No newline at end of file +#endif // DEMO2D_H diff --git a/include/Kameda/J2DManager.h b/include/Kameda/J2DManager.h index fbc2bb30..63ac3015 100644 --- a/include/Kameda/J2DManager.h +++ b/include/Kameda/J2DManager.h @@ -30,7 +30,7 @@ class J2DManager void setStatus2Kart(int, int); // 0x80131d98 void setUsisi(int, ECharID); // 0x80131f40 void startPreRace(); // 0x80132034 - void getPreRaceStatus(); // 0x80132058 + int getPreRaceStatus(); // 0x80132058 int getPreRaceWipeType(); // 0x80132064 void setRace2DDrawFlag(bool); // 0x80132070 void hideRace2D(); // 0x80132084 @@ -87,4 +87,4 @@ class J2DManager inline J2DManager *GETJ2DManager() { return J2DManager::getManager(); } -#endif \ No newline at end of file +#endif diff --git a/include/Kameda/PauseManager.h b/include/Kameda/PauseManager.h index 92706a3d..f650d21d 100644 --- a/include/Kameda/PauseManager.h +++ b/include/Kameda/PauseManager.h @@ -2,35 +2,49 @@ #define PAUSEMANAGER_H #include "JSystem/JKernel/JKRHeap.h" +#include "Osako/kartPad.h" #include "types.h" class PauseManager { public: - PauseManager(JKRHeap *); - static bool tstPause(); // 0x80135288; - void setExecFlag(bool flag) { - mExecFlag = flag; - } - void reset(); + PauseManager(JKRHeap *); // 0x801343d0 + void reset(); // 0x801345fc + void draw(); // 0x801346d0 + void exec(); // 0x801348f8 + static bool tstPause(); // 0x80135288 + void wipeOut(int); // 0x80135290 + static int getPauseChoice(); // 0x801352d0 - void enablePause() { - _14 = 0; - } + void setResultStartFlag(bool flag) {mResultStart = flag; } + void setGameOverFlag(bool flag) { mGameOver = flag; } + void setExecFlag(bool flag) { mExec = flag; } + void setPauseEndFlag(bool flag) { mPauseEnd = flag; } + + void enablePause() { _14 = 0; } static PauseManager *getManager() { return mThis; } - static PauseManager *mThis; private: - u8 _00[0x13]; - bool mExecFlag; + static PauseManager *mThis; // 0x80416298 + static bool mIsPause; // 0x8041629c + static int mPauseSelector; // 0x804162a0 + static int mPauseChoice; // 0x804162a4 + static int mPauseNextChoice; // 0x804162a8 + static KartGamePad *mPausePad; // 0x804162ac + + u8 _0[0xe]; + bool mResultStart; + bool _f; + bool mGameOver; + u8 _11[0x13 - 0x11]; + bool mExec; u32 _14; + bool mPauseEnd; u8 _18[0x3c - 0x18]; }; -inline PauseManager *GETPauseManager() { - return PauseManager::getManager(); -} +inline PauseManager *GETPauseManager() { return PauseManager::getManager(); } -#endif \ No newline at end of file +#endif diff --git a/include/Kaneshige/Course/Course.h b/include/Kaneshige/Course/Course.h index a2813c2b..b7443941 100644 --- a/include/Kaneshige/Course/Course.h +++ b/include/Kaneshige/Course/Course.h @@ -170,9 +170,9 @@ class Course void drawBase(u32, u32 *, s16, bool); // 0x8019d028 void drawSky(u32); // 0x8019d6ac void getStartLine(JGeometry::TVec3f *, JGeometry::TVec3f *); // 0x8019d7e8 - void getLightColor(JUtility::TColor *); // 0x8019d914 + void getLightColor(JUTColor *); // 0x8019d914 void getLightOffsetPosition(JGeometry::TVec3f *); // 0x8019d948 - void getAmbientColor(JUtility::TColor *); // 0x8019d97c + void getAmbientColor(JUTColor *); // 0x8019d97c u32 getCourseBGM(); // 0x8019d9b0 u32 getFinalLapBGM(); // 0x8019db78 void drawModelForDebug(u32); // 0x8019dc2c @@ -215,6 +215,7 @@ class Course bool isTexPatAnmEnable() const { return mTexPattern != nullptr; }; // 0x80199534 bool isShaking() const { return getCrsData()->isShaking(); } + void disableShaking() { mShakeEnabled = false; } int getAreaNumber() const { return mAreaNum; } Area *getArea(int no) const { return &mAreas[no]; } @@ -258,7 +259,7 @@ class Course f32 mFogEndZ; f32 mFogNearZ; f32 mFogFarZ; - JUtility::TColor mFogColor; + JUTColor mFogColor; ExModel mTexModel; J3DAnmTextureSRTKey *mTexSRTKey[3]; J3DAnmObjMaterial mTexSRTAnm[3]; diff --git a/include/Kaneshige/Course/CrsData.h b/include/Kaneshige/Course/CrsData.h index 22e21d59..4f71e0c5 100644 --- a/include/Kaneshige/Course/CrsData.h +++ b/include/Kaneshige/Course/CrsData.h @@ -181,7 +181,7 @@ class CrsData JGeometry::TVec3 zNorm; // 18 JGeometry::TVec3 yNorm; // 1e u16 objID; - s16 pathID; // 26 + u16 pathID; // 26 s16 _28; // s16 pointIdx; // 2a struct { @@ -240,6 +240,7 @@ class CrsData s16 getPathSpeed() const { return mPathSpeed; } s16 getPathID() const { return mPathID; } int getTime() const { return mTime; } + int getNextCameraID() const { return mNextID; } bool isStartCamera() const { return mID != 0; } @@ -308,6 +309,10 @@ class CrsData struct MGParam // Minigame Parameters { + s16 getRabbitWinSec() const { return rabbitWinSec; } + s16 getRabbitMinSec() const { return rabbitMinSec; } + s16 getRabbitDecSec() const { return rabbitDecSec; } + s16 rabbitWinSec; s16 rabbitMinSec; s16 rabbitDecSec; diff --git a/include/Kaneshige/Course/CrsGround.h b/include/Kaneshige/Course/CrsGround.h index 4b10ba7a..068d6080 100644 --- a/include/Kaneshige/Course/CrsGround.h +++ b/include/Kaneshige/Course/CrsGround.h @@ -11,6 +11,33 @@ class GeographyObj; // forward declaration class CrsGround { public: + enum EAttr + { + Attr_0, + Attr_1, + Attr_2, + Attr_3, + Attr_4, + Attr_5, + Attr_6, + Attr_7, + Attr_8, + Attr_9, + Attr_10, + Attr_11, + Attr_12, + Attr_13, + Attr_14, + Attr_15, + Attr_16, + Attr_255 = 0xff, + }; + + enum EMat + { + // TODO + }; + CrsGround(Course *course = nullptr); void reset(); // 0x801a1814 void search(const JGeometry::TVec3f &); // 0x801a18f0 @@ -48,17 +75,7 @@ class CrsGround void getVelocity(JGeometry::TVec3f *dest) const { dest->set(mVelocity); } int getMaterial() const { return mMaterial; } int getAttrIndex() const { return mAttrIdx; } - int getAttribute() const { return mAttribute; } - - enum EAttr - { - // TODO - }; - - enum EMat - { - // TODO - }; + EAttr getAttribute() const { return mAttribute; } static f32 getOverLevel() { return 50.0f; } @@ -73,7 +90,7 @@ class CrsGround JGeometry::TVec3f mNormal; JGeometry::TVec3f mVelocity; JGeometry::TVec3f _0x40; - int mAttribute; + EAttr mAttribute; int mAttrIdx; int mMaterial; f32 mHeight; diff --git a/include/Kaneshige/DemoTimeKeeper.h b/include/Kaneshige/DemoTimeKeeper.h index 0fb5d2d1..5413cec6 100644 --- a/include/Kaneshige/DemoTimeKeeper.h +++ b/include/Kaneshige/DemoTimeKeeper.h @@ -17,12 +17,14 @@ class DemoTimeKeeper virtual bool isPlayingEndingWinAnm() const { return false; }; // Inline + bool isDemoEnd() const { return mDemoEnd; } bool isDispInfo() { return mDispFlags != 0; } void updateCutTimer() { mCutTimer++; } // 0x801cf1ec s32 getCutTimer() const { return mCutTimer; } // 0x801cf234 u32 getCurCutName() const { return mCutName; } // 0x801cf23c void setDemoEnd() { mDemoEnd = true; } // 0x801cf514 s32 getCurCutTime() const { return mCurCutTime; } // 0x801cfc94 + u32 getDemoCameraTagName() const { return mCutName; } private: bool mStaffRoll; u16 mDispFlags; diff --git a/include/Kaneshige/DrawBuffer.h b/include/Kaneshige/DrawBuffer.h index f7a9ab68..565f785f 100644 --- a/include/Kaneshige/DrawBuffer.h +++ b/include/Kaneshige/DrawBuffer.h @@ -52,6 +52,61 @@ class DrawBuffer }; // Size 0x10 +class EffectDrawBuffer : public DrawBuffer { +public: + EffectDrawBuffer(u32 bufSize=4) : DrawBuffer(bufSize) {} + virtual void drawIn(u32); + virtual void update(); + virtual void viewCalc(u32); +}; + +class FeelDrawBuffer : public DrawBuffer { +public: + FeelDrawBuffer(u32 bufSize=4) : DrawBuffer(bufSize) {} + virtual void drawIn(u32); + virtual void update(); + virtual void viewCalc(u32); +}; + +class GeoDrawBuffer : public DrawBuffer { +public: + GeoDrawBuffer(u32 bufSize=4) : DrawBuffer(bufSize) {} + virtual void drawIn(u32); + virtual void update(); + virtual void viewCalc(u32); +}; + +class ShadowGeoDrawBuffer : public DrawBuffer { +public: + ShadowGeoDrawBuffer(u32 bufSize=4) : DrawBuffer(bufSize) {} + virtual void drawIn(u32); + virtual void update(); + virtual void viewCalc(u32); +}; + +class ItemDrawBuffer : public DrawBuffer { +public: + ItemDrawBuffer(u32 bufSize=4) : DrawBuffer(bufSize) { + mTargetKart = -1; + } + virtual void drawIn(u32); + virtual void update(); + virtual void viewCalc(u32); + + void setTargetKart(s16 kartNo) { mTargetKart = kartNo; } + +private: + s16 mTargetKart; +}; + +class JugemDrawBuffer : public DrawBuffer { +public: + JugemDrawBuffer(u32 bufSize=4) : DrawBuffer(bufSize) {} + virtual void drawIn(u32); + virtual void update(); + virtual void viewCalc(u32); +}; + class OsageDrawBuffer : public DrawBuffer { public: OsageDrawBuffer(u32 bufSize) : DrawBuffer(bufSize) {} diff --git a/include/Kaneshige/ExModel.h b/include/Kaneshige/ExModel.h index 97005e0e..624a1deb 100644 --- a/include/Kaneshige/ExModel.h +++ b/include/Kaneshige/ExModel.h @@ -59,8 +59,7 @@ class ExModel const Mtx &getBaseTRMtx() { return mBaseTRMtx; } void hide(u32 p1) { clipAll(p1, false); } void show(u32 p1) { clipAll(p1, true); } - static bool isMtxCombinationOn() { return sMtxCombinationOn; }; - static f32 getInvalidLODBias() { return sExModelInvalidLODBias; } + bool isAllShapePacketHidding(u32 viewNo) { return isAllShapePacketHidding(0, viewNo); } J3DModelData *getModelData() const { return mModelData[0]; } J3DModel *getModel() const { return mModel[0]; } void setSimpleTevReg(u32 id) { mSimpleTevReg |= (1 << id); } @@ -72,6 +71,9 @@ class ExModel return mModelData[level]; } + static bool isMtxCombinationOn() { return sMtxCombinationOn; }; + static f32 getInvalidLODBias() { return sExModelInvalidLODBias; } + static bool sClippingOn; // 0x80414610 static bool sMtxCombinationOn; // 0x80416398 static bool sDrawingOnlyUpdZMat; // 0x80416399 diff --git a/include/Kaneshige/GhostScreen.h b/include/Kaneshige/GhostScreen.h index 8db035be..bf3675ff 100644 --- a/include/Kaneshige/GhostScreen.h +++ b/include/Kaneshige/GhostScreen.h @@ -12,6 +12,12 @@ class GhostScreen void captureScene(); // 0x801d2bfc void captureGhost(); // 0x801d2c78 void draw(); // 0x801d2cc4 + + void show() { mIsHide = false; } + void hide() { mIsHide = true; } + + bool isHide() const { return mIsHide; } + private: u16 mStartX; u16 mStartY; @@ -23,4 +29,4 @@ class GhostScreen JUTTexture mGhostTex; }; -#endif // GHOSTSCREEN_H \ No newline at end of file +#endif // GHOSTSCREEN_H diff --git a/include/Kaneshige/KartChecker.h b/include/Kaneshige/KartChecker.h index b3e663e3..d909e0f1 100644 --- a/include/Kaneshige/KartChecker.h +++ b/include/Kaneshige/KartChecker.h @@ -1,6 +1,7 @@ #ifndef KARTCHECKER_H #define KARTCHECKER_H + #include "types.h" #include "JSystem/JGeometry.h" @@ -90,16 +91,17 @@ class KartChecker mRaceEnd = true; } - // might be a reference const RaceTime &getDeathTime() { return mDeathTime; }; - int getBalloonNumber() const { return mBalloonNum; }; - bool isRankAvailable() const { return mRank != 0; }; - int getBombPoint() const { return mBombPoint; }; const RaceTime &getMarkTime() { return mMarkTime; }; + + int getBalloonNumber() const { return mBalloonNum; }; + int getBombPoint() const { return mBombPoint; }; + int getRabbitTimer() const { return mRabbitWinFrame; } + int getGoalFrame() const { return mGoalFrame; }; f32 getTotalUnitDist() const { return mRaceProgression; }; f32 getLapUnitDist() const { return mLapProgression; } - // cmpw was signed right? - int getGoalFrame() const { return mGoalFrame; }; + bool isRankAvailable() const { return mRank != 0; }; + void setForceGoal(); @@ -116,9 +118,11 @@ class KartChecker void setBombCtrl() { mRaceFlags |= 4; } void setRabbitCtrl() { mRaceFlags |= 8; } void setDemoRank() { mRaceFlags |= 16; } + void stillRabbitTimer() { mBattleFlags |= 1; } + void fixMiniPoint() { mBattleFlags |= 2; } void setDead() { mBattleFlags |= 4; } void setRank(int rank) { mRank = rank; } - void stillRabbitTimer() { mBattleFlags |= 1; } + inline bool setPass(int index); // ??? function is weak yet in cpp file itself void clrRank() { mRank = 0; } void resumeRabbitTimer() { mBattleFlags &= 0xfffe; } @@ -212,7 +216,8 @@ class KartChecker static s16 sBombPointCrushOneself; - // private: // i'm not really sure how else KartChkUsrPage got access to this + friend class KartChkUsrPage; +private: u16 mRaceFlags; s16 mTargetKartNo; int mNumSectors; diff --git a/include/Kaneshige/KartDrawer.h b/include/Kaneshige/KartDrawer.h index d08f0431..1007da37 100644 --- a/include/Kaneshige/KartDrawer.h +++ b/include/Kaneshige/KartDrawer.h @@ -45,6 +45,13 @@ class KartDrawer STAGE_GHOST }; + void drawKartFirstStage(u32 viewNo) { drawKart(viewNo, STAGE_1); } + void drawDriverFirstStage(u32 viewNo) { drawDriver(viewNo, STAGE_1); } + void drawKartSecondStage(u32 viewNo) { drawKart(viewNo, STAGE_2); } + void drawDriverSecondStage(u32 viewNo) { drawDriver(viewNo, STAGE_2); } + void drawKartGhostStage(u32 viewNo) { drawKart(viewNo, STAGE_GHOST); } + void drawDriverGhostStage(u32 viewNo) { drawDriver(viewNo, STAGE_GHOST); } + KartDrawer(); // 0x801b8714 void reset(); // 0x801b8844 void create(int, int, u16, EGhostKind); // 0x801b88e8 @@ -70,10 +77,12 @@ class KartDrawer void setFrame(f32 rate); // void sForceLODLevel; // Inline + bool isSecondStage() const { return mStage == STAGE_2; } bool isAvailableTevAnmShock() { return mShockAnm.getAnmBase() != nullptr; } bool isFlashing() const { return mFlashState != 0; } bool isHide(u32 viewNo) const { return (mHiddenDrivers & 1 << viewNo) != 0; } void hide() { mHiddenDrivers = 0xffff; } + void setLight(u32 viewNo, RaceKartLight *kartLight) { @@ -82,6 +91,14 @@ class KartDrawer mKartLight[viewNo] = kartLight; } + RaceKartLight *getLight(u32 viewNo) { + JUT_MAX_ASSERT(viewNo, 4); + return mKartLight[viewNo]; + } + + void lodOff() { mEnableLOD = false; } + u8 getGhostAlpha() const { return mGhostAlpha; } + private: static s16 sFlashInterval; // 0x80414648 static u8 sGhostA; // 0x8041464a diff --git a/include/Kaneshige/KartLoader.h b/include/Kaneshige/KartLoader.h index 981011f8..8ba40340 100644 --- a/include/Kaneshige/KartLoader.h +++ b/include/Kaneshige/KartLoader.h @@ -66,7 +66,7 @@ class KartLoader } ExModel *getExModelOsage(int driver) { - JUT_MINMAX_ASSERT(0, 2, 6); // line 97 + JUT_MINMAX_ASSERT(0, driver, 2); // line 102 return mOsageModel[driver]; } diff --git a/include/Kaneshige/LightMgr.h b/include/Kaneshige/LightMgr.h index 92121ee7..78bcf354 100644 --- a/include/Kaneshige/LightMgr.h +++ b/include/Kaneshige/LightMgr.h @@ -4,11 +4,14 @@ #include "JSystem/JGeometry.h" #include "JSystem/JGeometry/Vec.h" #include "JSystem/JKernel/JKRDisposer.h" +#include "JSystem/JSupport/JSUList.h" #include "JSystem/JUtility/TColor.h" #include "dolphin/mtx.h" #include "types.h" -// TODO: everything +class RaceKartLight; +class RaceSceneLight; + class LightObj : public JKRDisposer { public: @@ -17,17 +20,23 @@ class LightObj : public JKRDisposer void init(const char *, u32); u32 getViewNo() const { return mViewNo; } + u32 getTagName() const { return mTagName; } void setTagName(u32 tagName) { mTagName = tagName; }; void setManualDraw() { mDrawFlags |= 1; } + bool tstManualDraw() { return mDrawFlags & 1; } + bool isAllView() const { return mViewNo == 0xffffffff; } + // 00 Vtable virtual ~LightObj(); virtual MtxPtr getEffectMtx() { return nullptr; } virtual void draw() {} - virtual void getColor(JUtility::TColor *) const {} + virtual void getColor(JUTColor *) const {} virtual void calc() {} virtual void setGXObj() {} + friend class LightMgr; + private: u32 mDrawFlags; // 18 u32 mViewNo; // 1C @@ -39,27 +48,27 @@ class LightObj : public JKRDisposer class LtObjAmbient : public LightObj { public: - LtObjAmbient(JUtility::TColor color) : LightObj("アンビエント", 0xffffffff) + LtObjAmbient(JUTColor color) : LightObj("アンビエント", 0xffffffff) { GXColor gxColor = color; mColor.set(gxColor); } - LtObjAmbient(const char *name, JUtility::TColor color) : LightObj(name, 0xffffffff) + LtObjAmbient(const char *name, JUTColor color) : LightObj(name, 0xffffffff) { GXColor gxColor = color; mColor.set(gxColor); } - virtual ~LtObjAmbient(); // overide - virtual void getColor(JUtility::TColor *) const; // overide - virtual void draw(); // overide + virtual ~LtObjAmbient() {} // overide + virtual void getColor(JUTColor *color) const { color->set(mColor); } // overide + virtual void draw(); // overide - void setColor(const JUtility::TColor &color) { + void setColor(const JUTColor &color) { mColor.set(color); } private: - JUtility::TColor mColor; + JUTColor mColor; }; // Size: 0x3c class LtObjDiffuse : public LightObj @@ -72,10 +81,10 @@ class LtObjDiffuse : public LightObj mLoadNo = 0; } - virtual ~LtObjDiffuse(); // overide - virtual void setGXObj(); // overide - virtual void draw(); // overide - virtual void getColor(JUtility::TColor *out) const { out->set((mColor)); } + //virtual ~LtObjDiffuse() {} // overide + virtual void setGXObj(); // overide + virtual void draw(); // overide + virtual void getColor(JUTColor *out) const { out->set(mColor); } // overide void load(GXLightID id); MtxPtr getViewMtx() const { return mViewMtx; } @@ -89,34 +98,40 @@ class LtObjDiffuse : public LightObj protected: JGeometry::TVec3f mPos; // 0x38 - JUtility::TColor mColor; // 0x44 + JUTColor mColor; // 0x44 MtxPtr mViewMtx; // 0x48 u16 mLoadNo; // 0x4c GXLightObj mLightObj; // 0x50 }; -class LightMgr +class LightMgr : JKRDisposer { // Autogenerated public: // Global LightMgr(); // 0x801b3ec0 void createCharColor(); // 0x801b3fb8 - static int createManager(); // 0x801b3fbc + static bool createManager(); // 0x801b3fbc void appendLight(LightObj *); // 0x801b400c void removeLight(LightObj *); // 0x801b4054 void draw(); // 0x801b409c void calc(); // 0x801b4278 - LightObj *searchLight(unsigned long); // 0x801b431c + LightObj *searchLight(u32); // 0x801b431c virtual ~LightMgr(); // 0x801b446c - static LightMgr *getManager() { return sLightManager; }; + // Inline/Unused + void reset(); + RaceSceneLight *searchRaceSceneLight(u32 viewNo); + RaceKartLight *searchRaceKartLight(u32 viewNo, int); + void setCurrentViewNo(u32 viewNo) { mCurViewNo = viewNo; } + + static LightMgr *getManager() { return sLightManager; }; private: static LightMgr *sLightManager; // 0x804163b8 - // Inline/Unused - // void reset(); - // void searchRaceSceneLight(unsigned long); - // void searchRaceKartLight(unsigned long, int); + + u32 mCurViewNo; // 18 + JSUList mLights; // 1C + LightMgr *mParent; // 28, guess }; // class LightMgr #endif diff --git a/include/Kaneshige/Objects/GeoBombCar.h b/include/Kaneshige/Objects/GeoBombCar.h index 2711f400..59cca9ab 100644 --- a/include/Kaneshige/Objects/GeoBombCar.h +++ b/include/Kaneshige/Objects/GeoBombCar.h @@ -6,26 +6,26 @@ class GeoBombCar : public GeoCar { // Autogenerated public: - GeoBombCar(const CrsData::SObject &); // 0x801c0914, overide - virtual void reset(); // 0x801c0ac0, overide - virtual void createModel(JKRSolidHeap *, u32); // 0x801c0b2c, overide - virtual void createColModel(J3DModelData *); // 0x801c0b94, overide - virtual TVec3f *getTirePosOffset(int); // 0x801c0be0, overide - virtual void loadAnimation(); // 0x801c0c70, overide - virtual void setCurrentViewNo(u32); // 0x801c0cc0, overide - virtual void update(); // 0x801c0d20, overide - virtual void simpleDraw(u32); // 0x801c0d64, overide - virtual void calc(); // 0x801c0db8, overide - virtual void hitKart(int); // 0x801c0f30, overide - virtual void hitItemBomb(); // 0x801c0f8c, overide - virtual void hitItemWanWan(); // 0x801c0fc0, overide - virtual void hitItemGTurtleBig(); // 0x801c0fe8, overide - virtual void hitItemGTurtle(); // 0x801c1008, overide - virtual void hitItemRTurtle(); // 0x801c1028, overide - virtual void hitItemFireBall(); // 0x801c1048, overide - virtual void hitItemYoshiEgg(); // 0x801c1068, overide - virtual void initCallBackDeath(); // 0x801c1088, overide - virtual void doCallBackDeath(); // 0x801c115c, overide + GeoBombCar(const CrsData::SObject &); // 0x801c0914, overide + virtual void reset(); // 0x801c0ac0, overide + virtual void createModel(JKRSolidHeap *, u32); // 0x801c0b2c, overide + virtual void createColModel(J3DModelData *); // 0x801c0b94, overide + virtual JGeometry::TVec3f *getTirePosOffset(int); // 0x801c0be0, overide + virtual void loadAnimation(); // 0x801c0c70, overide + virtual void setCurrentViewNo(u32); // 0x801c0cc0, overide + virtual void update(); // 0x801c0d20, overide + virtual void simpleDraw(u32); // 0x801c0d64, overide + virtual void calc(); // 0x801c0db8, overide + virtual void hitKart(int); // 0x801c0f30, overide + virtual void hitItemBomb(); // 0x801c0f8c, overide + virtual void hitItemWanWan(); // 0x801c0fc0, overide + virtual void hitItemGTurtleBig(); // 0x801c0fe8, overide + virtual void hitItemGTurtle(); // 0x801c1008, overide + virtual void hitItemRTurtle(); // 0x801c1028, overide + virtual void hitItemFireBall(); // 0x801c1048, overide + virtual void hitItemYoshiEgg(); // 0x801c1068, overide + virtual void initCallBackDeath(); // 0x801c1088, overide + virtual void doCallBackDeath(); // 0x801c115c, overide // Inline @@ -34,7 +34,7 @@ class GeoBombCar : public GeoCar // static u32 sCreateNum; virtual bool isBlast(){/* return _270;*/}; // 0x801c134c virtual ~GeoBombCar() {} // 0x801c12c8 - virtual char *getBmdFileName() { return "/Objects/Car_Bomb1.bmd"; } // 801c1338 + virtual const char *getBmdFileName() { return "/Objects/Car_Bomb1.bmd"; } // 801c1338 virtual u32 getSoundCarType() const { return 0; } // 0x801c1344 private: @@ -54,4 +54,4 @@ class GeoBombCar : public GeoCar // void JPABaseEmitter::playCreateParticle() // JPABaseEmitter.h; // 0x801c128c // void JPABaseEmitter::clearStatus(u32) // JPABaseEmitter.h; // 0x801c12b0 // void StateObserver::getStateCount() const // StateObserver.h; // 0x801c12c0 -#endif // GEOBOMBCAR_H \ No newline at end of file +#endif // GEOBOMBCAR_H diff --git a/include/Kaneshige/Objects/GeoBus.h b/include/Kaneshige/Objects/GeoBus.h index b7aa85c6..debf5339 100644 --- a/include/Kaneshige/Objects/GeoBus.h +++ b/include/Kaneshige/Objects/GeoBus.h @@ -16,7 +16,7 @@ class GeoBus : public GeoCar virtual void calc(); // 0x801bd840 virtual ~GeoBus() {} // 0x801bd8c0, overide - virtual char *getBmdFileName() { return "/Objects/Car_Bus1.bmd"; }; // 0x801bd93c, overide + virtual const char *getBmdFileName() { return "/Objects/Car_Bus1.bmd"; }; // 0x801bd93c, overide virtual u32 getMotorType() const { return 3; }; // 0x801bd948, overide private: static JGeometry::TVec3f sTireOfsTable[4]; // 0x80378a60 @@ -31,4 +31,4 @@ class GeoBus : public GeoCar // void GeographyObj::setObjFlagSimpleDraw() // GeographyObj.h; // 0x801bd520 // void GeographyObj::getAllBoundsNum() const // GeographyObj.h; // 0x801bd740 // void GeoCar::getShadowArea() // GeoCar.h; // 0x801bd8b8 -#endif // GEOBUS_H \ No newline at end of file +#endif // GEOBUS_H diff --git a/include/Kaneshige/Objects/GeoCannon.h b/include/Kaneshige/Objects/GeoCannon.h index 3b6a335c..1bc2a0e0 100644 --- a/include/Kaneshige/Objects/GeoCannon.h +++ b/include/Kaneshige/Objects/GeoCannon.h @@ -34,7 +34,7 @@ class GeoCannon : public GeographyObj, StateObserver /*__ptmf_scall(this, StateObserver::FindStateFunc(uVar2, sTable, 1));*/ } virtual ~GeoCannon() {} // 0x801c05d4 - virtual char *getBmdFileName() { return "/Objects/Cannon1.bmd"; } // 0x801c065c + virtual const char *getBmdFileName() { return "/Objects/Cannon1.bmd"; } // 0x801c065c virtual void initClassCreateNum() { sSupervisorCreateNum = 0; } // 0x801c0668 private: // void sTable; // 0x80396640 @@ -115,4 +115,4 @@ class GeoCannonSupervisor : public GeoObjSupervisor // void TAnmControlBase::frameProc() // TAnmControlBase.h; // 0x801c06f8 // void TAnmControlBase::doframe(unsigned char) // TAnmControlBase.h; // 0x801c071c // void AnmControlBase::tstFlgAnmStop() const // AnmControlBase.h; // 0x801c07c0 -#endif // GEOCANNON_H \ No newline at end of file +#endif // GEOCANNON_H diff --git a/include/Kaneshige/Objects/GeoCarShadow.h b/include/Kaneshige/Objects/GeoCarShadow.h index 61bc5b8e..84f1e55e 100644 --- a/include/Kaneshige/Objects/GeoCarShadow.h +++ b/include/Kaneshige/Objects/GeoCarShadow.h @@ -9,7 +9,7 @@ class GeoCarShadow : public GeographyObj GeoCarShadow(); // 0x801c3be4 GeoCarShadow(u32); // 0x801c3c84 virtual void reset(); // 0x801c3d10 - virtual char *getBmdFileName(); // 0x801c3d90 + virtual const char *getBmdFileName(); // 0x801c3d90 void setCarPose(const JGeometry::TVec3f &, const JGeometry::TVec3f &); // 0x801c3db8 // Inline virtual ~GeoCarShadow() {} // 0x801c3ec0 @@ -23,17 +23,17 @@ class GeoHanaBodyShadow : public GeoCarShadow public: GeoHanaBodyShadow(); virtual ~GeoHanaBodyShadow() {} // 0x801c3fd8 - virtual char *getBmdFileName() { return "/Objects/Car_Hana1BodyShadow.bmd"; } // 0x801c4030 + virtual const char *getBmdFileName() { return "/Objects/Car_Hana1BodyShadow.bmd"; } // 0x801c4030 private: // TODO -} +}; class GeoHanaShadow : public GeoCarShadow { public: GeoHanaShadow(); virtual ~GeoHanaShadow() {} // 0x801c4068 - virtual char *getBmdFileName() { return "/Objects/Car_Hana1Shadow.bmd"; } // 0x801c40c0 + virtual const char *getBmdFileName() { return "/Objects/Car_Hana1Shadow.bmd"; } // 0x801c40c0 private: // TODO }; @@ -43,7 +43,7 @@ class GeoBombShadow : public GeoCarShadow public: GeoBombShadow(); virtual ~GeoBombShadow() {} // 0x801c4130 - virtual char *getBmdFileName() { return "/Objects/Car_Bomb1Shadow.bmd"; } // 0x801c4188 + virtual const char *getBmdFileName() { return "/Objects/Car_Bomb1Shadow.bmd"; } // 0x801c4188 private: // TODO }; @@ -53,9 +53,9 @@ class GeoKinoShadow : public GeoCarShadow public: GeoKinoShadow(); virtual ~GeoKinoShadow(); // 0x801c40cc - virtual char *getBmdFileName() { return "/Objects/Car_Kinoko1Shadow.bmd"; } // 0x801c4124 + virtual const char *getBmdFileName() { return "/Objects/Car_Kinoko1Shadow.bmd"; } // 0x801c4124 private: // TODO }; -#endif // GEOCARSHADOW_H \ No newline at end of file +#endif // GEOCARSHADOW_H diff --git a/include/Kaneshige/Objects/GeoDkCloud.h b/include/Kaneshige/Objects/GeoDkCloud.h index 465cd068..990be69b 100644 --- a/include/Kaneshige/Objects/GeoDkCloud.h +++ b/include/Kaneshige/Objects/GeoDkCloud.h @@ -14,11 +14,11 @@ class GeoDkCloud : public GeographyObj virtual void calc(); // 0x801caa54 virtual void update(); // 0x801caaa8 virtual ~GeoDkCloud() {} // 0x801caac8 - virtual char *getBmdFileName() { return "/Objects/DonkyCloud.bmd"; } // 0x801cab30 + virtual const char *getBmdFileName() { return "/Objects/DonkyCloud.bmd"; } // 0x801cab30 private: static J3DAnmTextureSRTKey *sBtkAnm; // 0x80416498 // Unused // static u16 sCreateNum; // TODO }; // class GeoDkCloud -#endif // GEODKCLOUD_H \ No newline at end of file +#endif // GEODKCLOUD_H diff --git a/include/Kaneshige/Objects/GeoHanaBody.h b/include/Kaneshige/Objects/GeoHanaBody.h index b6b0c134..d13c404f 100644 --- a/include/Kaneshige/Objects/GeoHanaBody.h +++ b/include/Kaneshige/Objects/GeoHanaBody.h @@ -17,7 +17,7 @@ class GeoHanaBody : public GeoCar virtual void calc(); // 0x801c37e8 virtual JGeometry::TVec3f *getTirePosOffset(int tireNo); // 0x801c39b4 virtual ~GeoHanaBody() {} // 0x801c3a44 - virtual char *getBmdFileName() { return "/Objects/Car_Hana1Body.bmd"; } // 0x801c3ab4 + virtual const char *getBmdFileName() { return "/Objects/Car_Hana1Body.bmd"; } // 0x801c3ab4 virtual u16 getPathID(){/*return mHanaCar->getPathId();*/}; // 0x801c3ac0 // Inline/Unused @@ -35,4 +35,4 @@ class GeoHanaBody : public GeoCar // void GeoCar::getScale(JGeometry::TVec3 *) // GeoCar.h; // 0x801c37bc // void GeoCar::getDarkAnm() // GeoCar.h; // 0x801c3988 // void GeoHanaCar::getDriveVelocity() const // GeoHanaCar.h; // 0x801c3990 -#endif // GEOHANABODY_H \ No newline at end of file +#endif // GEOHANABODY_H diff --git a/include/Kaneshige/Objects/GeoHanaCar.h b/include/Kaneshige/Objects/GeoHanaCar.h index 62a605ce..d3eee720 100644 --- a/include/Kaneshige/Objects/GeoHanaCar.h +++ b/include/Kaneshige/Objects/GeoHanaCar.h @@ -17,7 +17,7 @@ class GeoHanaCar : public GeoCar virtual void calc(); // 0x801c30f4 virtual JGeometry::TVec3f *getTirePosOffset(int); // 0x801c3280 virtual ~GeoHanaCar() {} // 0x801c3310 - virtual char *getBmdFileName() { return "/Objects/Car_Hana1.bmd"; } // 0x801c3370 + virtual const char *getBmdFileName() { return "/Objects/Car_Hana1.bmd"; } // 0x801c3370 virtual u32 getSoundCarType() const { return 3; }; // 0x801c337c virtual void hitKart(int) {} // 0x801c3384 virtual void hitItemBomb() {} // 0x801c3388 @@ -33,4 +33,4 @@ class GeoHanaCar : public GeoCar // void GeoHanaBody::setParent(GeoHanaCar *, GeoCar *) // GeoHanaBody.h; // 0x801c2fc4 // void GeoCar::setCarID(short) // GeoCar.h; // 0x801c3008 // void GeoCar::getCarID() // GeoCar.h; // 0x801c3010 -#endif // GEOHANACAR_H \ No newline at end of file +#endif // GEOHANACAR_H diff --git a/include/Kaneshige/Objects/GeoKinoCar.h b/include/Kaneshige/Objects/GeoKinoCar.h index 3e1fbef2..caa87345 100644 --- a/include/Kaneshige/Objects/GeoKinoCar.h +++ b/include/Kaneshige/Objects/GeoKinoCar.h @@ -26,7 +26,7 @@ class GeoKinoCar : public GeoCar // void sCreateNum; // Inline virtual ~GeoKinoCar() {} // 0x801c1bc4 - virtual char *getBmdFileName() { return "/Objects/Car_Kinoko1.bmd"; } // 0x801c1c34 + virtual const char *getBmdFileName() { return "/Objects/Car_Kinoko1.bmd"; } // 0x801c1c34 private: static JGeometry::TVec3f sTireOfsTable[4]; // 0x80378ed8 static s16 sOccurLimitSpeed; // 0x804146a8 @@ -36,4 +36,4 @@ class GeoKinoCar : public GeoCar /// TODO }; // class GeoKinoCar // void ItemObj::getPos() const // ItemObj.h; // 0x801c1acc -#endif // GEOKINOCAR_H \ No newline at end of file +#endif // GEOKINOCAR_H diff --git a/include/Kaneshige/Objects/GeoKuriCar.h b/include/Kaneshige/Objects/GeoKuriCar.h index c5bd0389..145f948d 100644 --- a/include/Kaneshige/Objects/GeoKuriCar.h +++ b/include/Kaneshige/Objects/GeoKuriCar.h @@ -5,7 +5,7 @@ class GeoKuriCar : public GeoCar { // Autogenerated - // Global +public: GeoKuriCar(const CrsData::SObject &); // 0x801c1d34 virtual void reset(); // 0x801c1e98 virtual void createColModel(J3DModelData *); // 0x801c1ecc @@ -15,11 +15,11 @@ class GeoKuriCar : public GeoCar void doCallBackDeath(); // 0x801c2020 // Inline virtual ~GeoKuriCar() {} // 0x801c20a8 - virtual char *getBmdFileName() { return "/Objects/Car_Kuri1.bmd"; } // 0x801c2108 + virtual const char *getBmdFileName() { return "/Objects/Car_Kuri1.bmd"; } // 0x801c2108 virtual int getVibrationLimitSpeed() { return 0; } // 0x801c2114 private: static JGeometry::TVec3f sTireOfsTable[4]; // 0x80378f88 // TODO }; // class GeoKuriCar // void GeoCar::clrCarCollision() // GeoCar.h; // 0x801c2010 -#endif // GEOKURICAR_H \ No newline at end of file +#endif // GEOKURICAR_H diff --git a/include/Kaneshige/Objects/GeoRabbitMark.h b/include/Kaneshige/Objects/GeoRabbitMark.h index 4040cd51..cf10f375 100644 --- a/include/Kaneshige/Objects/GeoRabbitMark.h +++ b/include/Kaneshige/Objects/GeoRabbitMark.h @@ -1,18 +1,30 @@ #ifndef GEORABBITMARK_H #define GEORABBITMARK_H +#include "JSystem/JGeometry/Vec.h" #include "types.h" #include "Sato/GeographyObj.h" #include "Sato/StateObserver.h" +class GeoShine; class GeoRabbitMark; class GeoRabbitMarkSupervisor : public GeoObjSupervisor, JKRDisposer { public: - void release(); + GeoRabbitMarkSupervisor(); + virtual ~GeoRabbitMarkSupervisor(); + virtual void reset(); + virtual void calc(); + void entry(GeoRabbitMark *); int getRabbitKartNo(); + void release(); + void getMarkPosition(JGeometry::TVec3f *); + void changeOwner(int); + void startWinnerEffect(); + void setWinnerPosition(); + s16 getWinFrame() const // not sure if this returns int or short, int makes more sense to me but this is kaneshige { return mWinTime * 60; @@ -23,67 +35,92 @@ class GeoRabbitMarkSupervisor : public GeoObjSupervisor, JKRDisposer return mWinTime; } - void changeOwner(int ownerNum); /* { - mRabbitMark->equip(ownerNum); - }*/ - - void startWinnerEffect(); - private: - GeoRabbitMark *mRabbitMark; + GeoRabbitMark *mMark; s16 mWinTime; + s16 mMinTime; + s16 mDecTime; }; class GeoRabbitMark : public GeographyObj, StateObserver { public: - GeoRabbitMark(const CrsData::SObject &); // 0x801cd788 - void reset(); // 0x801cd8dc - void resetPose(bool); // 0x801cda04 - void createColModel(J3DModelData *); // 0x801cdb70 - void doKartColCallBack(int); // 0x801cdb98 - void equip(int); // 0x801cdc24 - void calc(); // 0x801cdc7c - void release(); // 0x801cdd74 - void startFastRot(); // 0x801cddbc + GeoRabbitMark(const CrsData::SObject &); // 0x801cd788 + + virtual void reset(); // 0x801cd8dc + void resetPose(bool); // 0x801cda04 + virtual void createColModel(J3DModelData *); // 0x801cdb70 + virtual void doKartColCallBack(int); // 0x801cdb98 + void equip(int); // 0x801cdc24 + virtual void calc(); // 0x801cdc7c + void release(); // 0x801cdd74 + void startFastRot(); // 0x801cddbc void startWinnerEffect(); // 0x801cde10 void setWinnerPosition(); // 0x801cde70 void initFuncWait(); // 0x801ce0fc void doFuncWait(); // 0x801ce108 - void isRidingBossPakkun(); // 0x801ce244 - void getEquipOfsY(); // 0x801ce2b8 + bool isRidingBossPakkun(); // 0x801ce244 + f32 getEquipOfsY(); // 0x801ce2b8 void initFuncEquip(); // 0x801ce35c void doFuncEquip(); // 0x801ce4fc void initFuncRelease(); // 0x801ce63c void doFuncRelease(); // 0x801ce6cc - void isResetGndAttr(CrsGround::EAttr); // 0x801ce8c4 + bool isResetGndAttr(CrsGround::EAttr); // 0x801ce8c4 void setBoundSE(); // 0x801ce904 + virtual void InitExec(); + virtual void MoveExec(); + virtual void initClassCreateNum() { sSupervisorCreateNum = 0; } + //virtual ~GeoRabbitMark() {} + + static const s16 cNonOwner = -1; // was this an enum? + + bool isNonOwner() const { return mOwnerNo == cNonOwner; } + virtual GeoRabbitMarkSupervisor *getSupervisor() { return sSupervisor; } static GeoRabbitMarkSupervisor *getSupervisor() { return sSupervisor; } + + friend class GeoRabbitMarkSupervisor; +private: + static StateFuncSet sTable[3]; // 0x803979d8 + static f32 sFootLength; // 0x80414728 + static f32 sEquipOfsY1; // 0x8041472c + static f32 sEquipOfsYPakkun1; // 0x80414730 + static f32 sEquipOfsY2; // 0x80414734 + static f32 sEquipOfsYPakkun2; // 0x80414738 + static f32 sEquipOfsY34; // 0x8041473c + static f32 sEquipOfsYPakkun34; // 0x80414740 + static f32 sGravity; // 0x80414744 + static f32 sReflectK; // 0x80414748 + static f32 sNormalScale; // 0x8041474c + static f32 sEquipScale; // 0x80414750 + static f32 sEqpSprMinLength; // 0x80414754 + static f32 sEqpSpringK; // 0x80414758 + static f32 sEqpAirRegist; // 0x8041475c + static f32 sEqpChaseRate; // 0x80414760 + static f32 sRelV0; // 0x80414764 + static f32 sRelGravity; // 0x80414768 + static f32 sRelReflectK; // 0x8041476c + static u16 sSupervisorCreateNum; // 0x804164b8 + static GeoRabbitMarkSupervisor *sSupervisor; // 0x804164bc + private: - // void sTable; // 0x803979d8 - static f32 sFootLength; // 0x80414728 - static f32 sEquipOfsY1; // 0x8041472c - static f32 sEquipOfsYPakkun1; // 0x80414730 - static f32 sEquipOfsY2; // 0x80414734 - static f32 sEquipOfsYPakkun2; // 0x80414738 - static f32 sEquipOfsY34; // 0x8041473c - static f32 sEquipOfsYPakkun34; // 0x80414740 - static f32 sGravity; // 0x80414744 - static f32 sReflectK; // 0x80414748 - static f32 sNormalScale; // 0x8041474c - static f32 sEquipScale; // 0x80414750 - static f32 sEqpSprMinLength; // 0x80414754 - static f32 sEqpSpringK; // 0x80414758 - static f32 sEqpAirRegist; // 0x8041475c - static f32 sEqpChaseRate; // 0x80414760 - static f32 sRelV0; // 0x80414764 - static f32 sRelGravity; // 0x80414768 - static f32 sRelReflectK; // 0x8041476c - static u16 sSupervisorCreateNum; // 0x804164b8 - static GeoRabbitMarkSupervisor *sSupervisor; // 0x804164bc - // TODO + GeoShine *mShines[4]; + bool mIsDemoMode; + JGeometry::TVec3f mLfDir; + JGeometry::TVec3f mUpDir; + JGeometry::TVec3f mFrDir; + JGeometry::TVec3f mEqpSpr; + f32 mEqpSprLength; + f32 _1a0; + f32 mMarkScale; + s16 mState; // 1 = resetting, 0 is initialized + s16 _1aa; + s16 mPrevOwnerNo; + s16 mOwnerNo; + s16 _1b0; + JGeometry::TVec3f mWinnerPos; + s16 _1c0; }; #endif diff --git a/include/Kaneshige/Objects/GeoShimmer.h b/include/Kaneshige/Objects/GeoShimmer.h new file mode 100644 index 00000000..18acc6b3 --- /dev/null +++ b/include/Kaneshige/Objects/GeoShimmer.h @@ -0,0 +1,43 @@ +#ifndef GEOSHIMMER_H +#define GEOSHIMMER_H + +#include "JSystem/JKernel/JKRDisposer.h" +#include "types.h" + +#include "Sato/GeographyObj.h" + +class GeoShimmer; + +class GeoShimmerSupervisor : public GeoObjSupervisor, JKRDisposer { +public: + GeoShimmerSupervisor(); + void reset(); + void calc(); + void entry(GeoShimmer *); + void drawScreen(); + virtual ~GeoShimmerSupervisor() {} +}; + +class GeoShimmer : public GeographyObj { // Autogenerated +public: + GeoShimmer(const CrsData::SObject &); // 0x801d4434 + void setCrsOfsZ0(); // 0x801d4798 + void setCrsOfsZ1(); // 0x801d47c8 + void reset(); // 0x801d47f8 + void createColModel(J3DModelData *); // 0x801d483c + void calc(); // 0x801d4840 + void drawScreen(); // 0x801d493c + + // Inline + bool isShimmer() const; // 0x801d4784 + virtual ~GeoShimmer() {} + virtual GeoShimmerSupervisor *getSupervisor() { return sSupervisor; } + static GeoShimmerSupervisor *getSupervisor() { return sSupervisor; } + + friend class GeoShimmerSupervisor; +private: + static GeoShimmerSupervisor *sSupervisor; // 0x80416588 + static u16 sCreateNum; // UNUSED +}; // class GeoShimmer + +#endif // GEOSHIMMER_H diff --git a/include/Kaneshige/Objects/GeoShine.h b/include/Kaneshige/Objects/GeoShine.h new file mode 100644 index 00000000..647cbb0d --- /dev/null +++ b/include/Kaneshige/Objects/GeoShine.h @@ -0,0 +1,67 @@ +#ifndef GEOSHINE_H +#define GEOSHINE_H + +#include "JSystem/JGeometry/Vec.h" +#include "Sato/GeographyObj.h" + +class GeoRabbitMark; + +class GeoShine : public GeographyObj { // Autogenerated +public: + GeoShine(); // 0x801d50fc + void reset(); // 0x801d5190 + void calcShadowModel(); // 0x801d53d4 + const char *getShadowBmdFileName(); // 0x801d559c + void loadAnimation(); // 0x801d55bc + void createColModel(J3DModelData *); // 0x801d55c0 + void createModel(JKRSolidHeap *, u32); // 0x801d55e8 + void simpleDraw(u32); // 0x801d55ec + void calc(); // 0x801d5618 + void move(); // 0x801d561c + void startFastRot(); // 0x801d5a84 + + // Inline + virtual ~GeoShine() {} // 0x801d5aac + const char *getBmdFileName() { return "/Objects/MiniGame_shine.bmd"; } // 0x801d5b04 + + void setMark(GeoRabbitMark *mark) { mMark = mark; } + void setConsoleNo(u32 no) { mConsoleNo = no; } + void enableWinEffect() { mWinEffectOn = true; } + +private: + static const char *sNormalEmitterName[3]; // 0x803980b8 + static const f32 sShadowScale; // 0x803fc288 + static const char *sWinnerEmitterName[2]; // 0x804147a8 + static f32 sScalingNearZ; // 0x804147b0 + static f32 sScalingFarZ; // 0x804147b4 + static f32 sMaxScale; // 0x804147b8 + static f32 sRotAnmMaxVel; // 0x804147bc + static f32 sRotAnmVelNormal; // 0x804147c0 + static f32 sRotAnmFastV0; // 0x804147c4 + static f32 sRotAnmResist; // 0x804147c8 + + GeoRabbitMark *mMark; + u32 mConsoleNo; + JGeometry::TVec3f _154; + JGeometry::TVec3f _160; + JGeometry::TVec3f _16c; + JGeometry::TVec3f _178; + JGeometry::TVec3f _184; + JGeometry::TVec3f _190; + u8 _19c[0x1a4 - 0x19c]; + bool mWinEffectOn; + u8 _1a5[0x1b0 - 0x1a5]; +}; // class GeoShine + +// Inline Functions called in TU +// void ViewCtrlModel::setVisible(unsigned long) // ViewCtrlModel.h; // 0x801d5344 +// void ViewCtrlModel::clrVisibleAll() // ViewCtrlModel.h; // 0x801d535c +// void ViewCtrlModel::setDetailFlg() // ViewCtrlModel.h; // 0x801d536c +// void GeoRabbitMark::getPosition(JGeometry::TVec3 *) // GeoRabbitMark.h; // 0x801d53a8 +// void ViewCtrlModel::isInvisibleAll() // ViewCtrlModel.h; // 0x801d5588 +// void JPABaseEmitter::setGlobalScale(const JGeometry::TVec3 &) // JPABaseEmitter.h; // 0x801d59dc +// void GeoRabbitMark::getFootLength() const // GeoRabbitMark.h; // 0x801d5a2c +// void GeoRabbitMark::getMarkScale() const // GeoRabbitMark.h; // 0x801d5a44 +// void GeoRabbitMark::getFootPosition(JGeometry::TVec3 *) // GeoRabbitMark.h; // 0x801d5a4c + +#endif // GEOSHINE_H diff --git a/include/Kaneshige/Objects/GeoStartLine.h b/include/Kaneshige/Objects/GeoStartLine.h index 6ea26a93..fe782f7c 100644 --- a/include/Kaneshige/Objects/GeoStartLine.h +++ b/include/Kaneshige/Objects/GeoStartLine.h @@ -12,8 +12,6 @@ class GeoStartLine : public GeographyObj virtual void createColModel(J3DModelData *); // 0x801b4ba0 virtual const char *getBmdFileName(); // 0x801b4ba4 virtual void calc(); // 0x801b4bcc -private: - // TODO }; #endif diff --git a/include/Kaneshige/Objects/GeoTruck.h b/include/Kaneshige/Objects/GeoTruck.h index 306cd0a9..f09004af 100644 --- a/include/Kaneshige/Objects/GeoTruck.h +++ b/include/Kaneshige/Objects/GeoTruck.h @@ -16,7 +16,7 @@ class GeoTruck : public GeoCar virtual void calc(); // 0x801bdfb4 virtual ~GeoTruck(); // 0x801be024 virtual u32 getMotorType() const { return 3; } // 0x801be0a0, overide - virtual char *getBmdFileName() { return "/Objects/Car_Truck1.bmd"; } // 0x801be0a8, overide + virtual const char *getBmdFileName() { return "/Objects/Car_Truck1.bmd"; } // 0x801be0a8, overide virtual u32 getSoundCarType() const { return 1; } // 0x801be0b4, overide private: @@ -29,4 +29,4 @@ class GeoTruck : public GeoCar }; // class GeoTruck -#endif // GEOTRUCK_H \ No newline at end of file +#endif // GEOTRUCK_H diff --git a/include/Kaneshige/Objects/GeoVision.h b/include/Kaneshige/Objects/GeoVision.h new file mode 100644 index 00000000..daf117b4 --- /dev/null +++ b/include/Kaneshige/Objects/GeoVision.h @@ -0,0 +1,63 @@ +#ifndef GEOVISION_H +#define GEOVISION_H + +#include "JSystem/JGeometry/Vec.h" +#include "JSystem/JUtility/JUTTexture.h" +#include "types.h" + +#include "Sato/GeographyObj.h" +#include "Sato/StateObserver.h" + +class GeoVision; + +class GeoVisionSupervisor : public GeoObjSupervisor, JKRDisposer { +public: + GeoVisionSupervisor(); + void reset(); + void calc(); + void entry(GeoVision *); + void capture(); + + virtual ~GeoVisionSupervisor() {} + JUTTexture *getCaptureTexture() { return mCaptureTex; } + bool isCaptureEnable() { return mCaptureTex != nullptr; } + + // Unused + //void cCaptureWidth; + //void cCaptureHeight; +private: // TODO + JUTTexture *mCaptureTex; +}; + +class GeoVision : public GeographyObj, StateObserver { // Autogenerated +public: + GeoVision(const CrsData::SObject &); // 0x801c5e1c + void reset(); // 0x801c5f6c + void createModel(JKRSolidHeap *, u32); // 0x801c6070 + void calc(); // 0x801c6324 + void initFuncWait(); // 0x801c64d0 + void doFuncWait(); // 0x801c64d4 + + // Unused + //void sMonTime; + //void sCreateNum; + + // Inline + static GeoVisionSupervisor *getGeoVisionSupervisor() { return sSupervisor; } + void InitExec() { Observer_FindAndInit(GeoVision, 1); } + void MoveExec() { Observer_FindAndExec(GeoVision, 1); } + virtual ~GeoVision() {} + virtual const char * getBmdFileName() { return "/Objects/Wl_Screen1.bmd"; } + virtual GeoVisionSupervisor *getSupervisor() { return sSupervisor; } + void initClassCreateNum() { sSupervisorCreateNum = 0; } + + friend class GeoVisionSupervisor; +private: + static StateFuncSet sTable[1]; // 0x80397180 + static u16 sSupervisorCreateNum; // 0x80416470 + static GeoVisionSupervisor *sSupervisor; // 0x80416474 + + // TODO +}; // class GeoVision + +#endif // GEOVISION_H diff --git a/include/Kaneshige/Objects/GeoWater.h b/include/Kaneshige/Objects/GeoWater.h index 2091a75f..39d76cb6 100644 --- a/include/Kaneshige/Objects/GeoWater.h +++ b/include/Kaneshige/Objects/GeoWater.h @@ -29,7 +29,7 @@ class GeoWater : public GeographyObj, StateObserver { /*__ptmf_scall(this, FindStateFunc(getState()), &sTable, 1);*/ } // 0x801c4c3c virtual ~GeoWater() {} // 0x801c4e94 - virtual char *getBmdFileName() { return "/Objects/sea1_spc.bmd"; } // 0x801c4f1c + virtual const char *getBmdFileName() { return "/Objects/sea1_spc.bmd"; } // 0x801c4f1c virtual void initClassCreateNum() { sSupervisorCreateNum = 0; } // 0x801c4f28 private: // void sTable; // 0x80396f88 @@ -76,9 +76,8 @@ class GeoWaterUp2 : public GeoSubWater virtual void createModel(JKRSolidHeap *, u32); virtual void simpleDraw(u32); virtual void calc(); - virtual void simpleDraw(u32); virtual ~GeoWaterUp2() {} // 0x801c6b10 - virtual char *getBmdFileName() { return "/Objects/sea2_tex.bmd"; } // 0x801c6bdc + virtual const char *getBmdFileName() { return "/Objects/sea2_tex.bmd"; } // 0x801c6bdc private: // TODO }; @@ -137,4 +136,4 @@ class GeoWaterDown : public GeoSubWater // void JSULink::JSULink(GeoWater *) // JSULink.h; // 0x801c4750 // void GeographyObj::clrObjFlagLODBias() // GeographyObj.h; // 0x801c49a4 -#endif // GEOWATER_H \ No newline at end of file +#endif // GEOWATER_H diff --git a/include/Kaneshige/RaceBGMPlayer.h b/include/Kaneshige/RaceBGMPlayer.h index 2815c81f..eb43faa4 100644 --- a/include/Kaneshige/RaceBGMPlayer.h +++ b/include/Kaneshige/RaceBGMPlayer.h @@ -17,15 +17,19 @@ class RaceBGMPlayer // Inline/Unused // void stop(); // Inline - void stopCrsDemo() { mFlags |= 4; } // 0x801c6e54 - bool isMiniGameEnd() const { return mFlags & 16; } // 0x801c7288 - bool isLastTime() const { return mFlags & 8; } // 0x801c7294 - bool isExecPrepare() const { return mFlags & 32; } // 0x801c72a0 - bool isPlay() const { return mFlags & 2; } // 0x801c72ac - void execPrepare() { mFlags |= 32; } // 0x801c72b8 - bool isPrepare() const { return mFlags & 1; }; // 0x801c72c8 - bool isCrsDemoEnd() const { return mFlags & 4; } // 0x801c72d4 - + void prepare() { mFlags |= 1; } + void play() { mFlags |= 2; } + void stopCrsDemo() { mFlags |= 4; } + void setMiniGameEnd() {mFlags |= 0x10; } + void execPrepare() { mFlags |= 0x20; } + + bool isPrepare() const { return mFlags & 1; } + bool isPlay() const { return mFlags & 2; } + bool isCrsDemoEnd() const { return mFlags & 4; } + bool isLastTime() const { return mFlags & 8; } + bool isMiniGameEnd() const { return mFlags & 0x10; } + bool isExecPrepare() const { return mFlags & 0x20; } + void setLowestKartNo(int kartNo) { if (mLowestKartNo < 0) @@ -49,4 +53,4 @@ class RaceBGMPlayer }; // class RaceBGMPlayer // void RaceMgr::isRaceModeVs() const // RaceMgr.h; // 0x801c6f2c // void RaceMgr::isRaceModeTA() const // RaceMgr.h; // 0x801c6f58 -#endif // RACEBGMPLAYER_H \ No newline at end of file +#endif // RACEBGMPLAYER_H diff --git a/include/Kaneshige/RaceDirector.h b/include/Kaneshige/RaceDirector.h index dd5e8cfc..e6d87337 100644 --- a/include/Kaneshige/RaceDirector.h +++ b/include/Kaneshige/RaceDirector.h @@ -8,10 +8,45 @@ class RaceDirector { public: + enum ERace2DMode { + Race2DMode_0, + Race2DMode_1, + }; + + static u8 sForceStopFrame; + static s16 sForceWaitDemoTime; + static s16 sRace2DDelayTime; + static const int cFadeOutTime; + // Global RaceDirector(bool, DemoTimeKeeper *, int); // 0x801c752c - void calc(); - bool checkRaceEnd(); + void reset(); // 0x801c7680 + void resetCommon(); // 0x801c76d0 + void appearRace2D(ERace2DMode); // 0x801c775c + void calc(); // 0x801c77bc + void doCrsDemo(); // 0x801c78d4 + void doNoCrsDemo(); // 0x801c7968 + void checkCrsDemoEvent(); // 0x801c79b0 + void checkCrsDemoEventHanabi(s16); // 0x801c7afc + void doReset(); // 0x801c7b74 + void doWait(); // 0x801c7b80 + void doSafety(); // 0x801c7bb4 + void doRunning(bool); // 0x801c7c14 + s16 checkZoomWinConsoleNo(); // 0x801c8008 + bool isAllGoalAnmEnd(); // 0x801c8108 + void doEnding(); // 0x801c81a8 + void setEndingPhaseZoomConsole(); // 0x801c8608 + void checkPauseChoice(); // 0x801c865c + bool isExitWaitDemo(); // 0x801c8808 + void setPhaseWait(ERacePhase phase, bool fadeAudio, bool fadeVideo, int fadeOutTime=cFadeOutTime); // 0x801c88a8 + bool checkRaceEnd(); // 0x801c8a24 + bool checkRaceEndForRace(); // 0x801c8afc + bool checkRaceEndForBalloonBattle(); // 0x801c8c10 + bool checkRaceEndForBombBattle(); // 0x801c8c84 + bool checkRaceEndForEscapeBattle(); // 0x801c8cf8 + int requestDemoCameraID() const; // 0x801c8d60 + bool isPlayingDemoWinnerAnm() const; // 0x801c8dac + u32 getDemoCameraTagName() const; // 0x801c8df8 bool isFrameRenewal() const { #ifdef DEBUG bool ret = false; @@ -23,24 +58,37 @@ class RaceDirector return mFrameRenewal; #endif } - ERacePhase getRacePhase() const { return mRacePhase; }; bool isRaceEnd() const { return mIsRaceEnd; }; + bool isZoomWinConsole() const { return mZoomWinCnsNo >= 0; } + ERacePhase getRacePhase() const { return mRacePhase; }; + int getWaitDemoResult() const { return mWaitDemoResult; } - const RaceTime & getMiniGameTime() { return mMinigameTime; } - void reset(); + const RaceTime &getMiniGameTime() { return mMinigameTime; } - static u8 sForceStopFrame; private: - u8 _00[0xc]; + DemoTimeKeeper *mTimeKeeper; + ERace2DMode mRace2DMode; + s16 mRace2DDelayTime; ERacePhase mRacePhase; - u8 _10[0x1c - 0x10]; + ERacePhase _10; + int mRunningState; + int mWaitDemoTimer; int mWaitDemoResult; - u8 _20[0x28 - 0x20]; + int mWaitTimer; + int mFadeOutTime; bool mFrameRenewal; u8 _29; bool mIsRaceEnd; - u8 _2B[0x44 - 0x2B]; + s16 mZoomWinCnsNo; + int mRaceRunState; + int mEndingState; + bool mPlayingWinAnm; + bool mMovingToStart; + bool _3a; + s16 _3c; + s16 _3e; + int mMiniGameFrame; RaceTime mMinigameTime; }; // Size 0x48 -#endif \ No newline at end of file +#endif diff --git a/include/Kaneshige/RaceDrawer.h b/include/Kaneshige/RaceDrawer.h index 330f4580..3e3a5f4b 100644 --- a/include/Kaneshige/RaceDrawer.h +++ b/include/Kaneshige/RaceDrawer.h @@ -1,11 +1,16 @@ #ifndef RACEDRAWER_H #define RACEDRAWER_H +#include "JSystem/J2D/J2DGrafContext.h" #include "JSystem/JUtility/TColor.h" #include "Kaneshige/Blurscreen.h" #include "Kaneshige/DrawBuffer.h" #include "Kaneshige/KartDrawer.h" +#include "Kaneshige/GhostScreen.h" #include "Kaneshige/MaskScreen.h" +#include "Osako/shadowScr.h" +#include "Shiraiwa/ZCaptureMgr.h" +#include "kartEnums.h" #include "types.h" class RaceDrawer @@ -18,30 +23,31 @@ class RaceDrawer void drawSceneFirstStage(u32); // 0x801c9698 void drawMidScene(); // 0x801c9dfc void drawSceneSecondStage(u32); // 0x801c9f0c - void drawPreScene(); // 0x801ca29c + bool drawPreScene(); // 0x801ca29c void drawPostScene(); // 0x801ca32c void drawGhost(); // 0x801ca4b8 void showAllGhost(); // 0x801ca680 static u8 sBlurA0; // 0x80414700 static u8 sBlurDefaultDecrease; // 0x80414701 - static float sBlurAddY; // 0x80414704 - static float sBlurAddX; // 0x80416488 - static JUtility::TColor sBlurDefaultColor; // 0x8041648c - static int sForceGhostKind; // 0x80416490 + static f32 sBlurAddY; // 0x80414704 + static f32 sBlurAddX; // 0x80416488 + static JUTColor sBlurDefaultColor; // 0x8041648c + static EGhostKind sForceGhostKind; // 0x80416490 + // Inline - void isGhostActive() const; // 0x801c9650 - void isDrawJugem() const; // 0x801c9cdc - void isDrawGeoObj() const; // 0x801c9ce8 - void isDrawItem() const; // 0x801c9cf4 - void isDrawDriver() const; // 0x801c9d24 - void isDrawKart() const; // 0x801c9d54 - void isDrawCrs() const; // 0x801c9dd0 - void isDrawSky() const; // 0x801c9ddc - void isDrawGhostScene() const; // 0x801c9ef8 - void isDrawCup() const; // 0x801ca268 - void isBlurActive() const; // 0x801ca31c - MaskScreen *getMaskScreen(); // 0x801ca490 - void isMaskActive() const; // 0x801ca4a0 + bool isDrawSky() const { return mDrawFlags & 0x1; } + bool isDrawCrs() const { return mDrawFlags & 0x2; } + bool isDrawGeoObj() const { return mDrawFlags & 0x4; } + bool isDrawCup() const { return mDrawFlags & 0x8; } + bool isDrawKart() const { return mDrawFlags & 0x10; } + bool isDrawDriver() const { return mDrawFlags & 0x20; } + bool isDrawJugem() const { return mDrawFlags & 0x40; } + bool isDrawItem() const { return mDrawFlags & 0x80; } + bool isDrawGhostScene() const { return mDrawFlags & 0x8000; } + + bool isGhostActive() const { return mGhostScreen != nullptr; } + bool isBlurActive() const { return mBlurScreen != nullptr; } + bool isMaskActive() const { return mMaskScreen != nullptr; } void setBlurDecrease(u8 a) { mBlurDecrease = a; } void setBlurColor(const JUTColor &color) { mBlurColor.set(color); } @@ -52,79 +58,40 @@ class RaceDrawer return kartNo >= 0 ? mItmDrawBufs[kartNo] : mItmDrawBuf; // the day Kaneshige discovered ternaries } - KartDrawer * getKartDrawer(int kartNo) { + KartDrawer *getKartDrawer(int kartNo) { #line 172 JUT_MINMAX_ASSERT(0, kartNo, mKartNum); return &mKartDrawer[kartNo]; } - - BlurScreen *getBlurScreen() { - return mBlurScreen; - } - // TODO: own class types - DrawBuffer *getEffectDrawBuffer() { - return mEfctDrawBuf; - } - DrawBuffer *getFeelDrawBuffer() { - return mFeelDrawBuf; - } - DrawBuffer *getJugemDrawBuffer() { - return mJugemDrawBuf; - } - DrawBuffer *getGeoDrawBuffer() { - return mGeoDrawBuf; - } - DrawBuffer *getShadowGeoDrawBuffer() { - return mShdwDrawBuf; - } + BlurScreen *getBlurScreen() { return mBlurScreen; } + EffectDrawBuffer *getEffectDrawBuffer() {return mEfctDrawBuf; } + FeelDrawBuffer *getFeelDrawBuffer() { return mFeelDrawBuf; } + JugemDrawBuffer *getJugemDrawBuffer() { return mJugemDrawBuf; } + GeoDrawBuffer *getGeoDrawBuffer() { return mGeoDrawBuf; } + ShadowGeoDrawBuffer *getShadowGeoDrawBuffer() { return mShdwDrawBuf; } + MaskScreen *getMaskScreen() { return mMaskScreen; } private: - u8 _0[6]; - DrawBuffer *mShdwDrawBuf; - DrawBuffer *mGeoDrawBuf; - DrawBuffer *mItmDrawBufs[8]; - DrawBuffer *mItmDrawBuf; - DrawBuffer *mEfctDrawBuf; - DrawBuffer *mJugemDrawBuf; - DrawBuffer *mFeelDrawBuf; + J2DOrthoGraph *mOrtho; + s16 _4; + u16 mDrawFlags; + ShadowGeoDrawBuffer *mShdwDrawBuf; + GeoDrawBuffer *mGeoDrawBuf; + ItemDrawBuffer *mItmDrawBufs[8]; + ItemDrawBuffer *mItmDrawBuf; + EffectDrawBuffer *mEfctDrawBuf; + JugemDrawBuffer *mJugemDrawBuf; + FeelDrawBuffer *mFeelDrawBuf; int mKartNum; KartDrawer *mKartDrawer; // double array? BlurScreen *mBlurScreen; - u8 _4c[0x5c - 0x4c]; + GhostScreen *mGhostScreen; + ShadowScreen *mShadowScreen; + ZCaptureMgr *mCaptureMgr; + MaskScreen *mMaskScreen; u8 mBlurDecrease; - u8 _5d[0x60 - 0x5d]; JUTColor mBlurColor; // Size: 0x64 }; // class RaceDrawer -// void KartDrawer::lodOff() // KartDrawer.h; // 0x801c92f8 -// EGhostKind KartInfo::getGhostKind() // KartInfo.h; // 0x801c9304 -// virtual KartDrawer::~KartDrawer() // KartDrawer.h; // 0x801c930c -// void FeelDrawBuffer::FeelDrawBuffer(u32) // FeelDrawBuffer.h; // 0x801c93bc -// void JugemDrawBuffer::JugemDrawBuffer(u32) // JugemDrawBuffer.h; // 0x801c93f8 -// void EffectDrawBuffer::EffectDrawBuffer(u32) // EffectDrawBuffer.h; // 0x801c9434 -// void ItemDrawBuffer::setTargetKart(short) // ItemDrawBuffer.h; // 0x801c9470 -// void ItemDrawBuffer::ItemDrawBuffer(u32) // ItemDrawBuffer.h; // 0x801c9478 -// void GeoDrawBuffer::GeoDrawBuffer(u32) // GeoDrawBuffer.h; // 0x801c94bc -// void ShadowGeoDrawBuffer::ShadowGeoDrawBuffer(u32) // ShadowGeoDrawBuffer.h; // 0x801c94f8 -// void GhostScreen::hide() // GhostScreen.h; // 0x801c9644 -// void Course::drawHigh(u32) // Course.h; // 0x801c9cb0 -// void KartDrawer::drawDriverFirstStage(u32) // KartDrawer.h; // 0x801c9d00 -// void KartDrawer::drawKartFirstStage(u32) // KartDrawer.h; // 0x801c9d30 -// void ShadowManager::drawShadowVolume(u32, ShadowModel::ShadowKind) // ShadowManager.h; // 0x801c9d60 -// void Course::drawNormal(u32) // Course.h; // 0x801c9da4 -// void LightMgr::setCurrentViewNo(u32) // LightMgr.h; // 0x801c9de8 -// void RaceSceneLight::getSceneLightTagName(u32) // RaceSceneLight.h; // 0x801c9df0 -// void GhostScreen::isHide() const // GhostScreen.h; // 0x801c9f04 -// void KartDrawer::drawDriverSecondStage(u32) // KartDrawer.h; // 0x801ca220 -// void KartDrawer::drawKartSecondStage(u32) // KartDrawer.h; // 0x801ca244 -// void RaceCupLight::getTagName(u32) // RaceCupLight.h; // 0x801ca274 -// void TLensFlare::getSupervisor() // TLensFlare.h; // 0x801ca280 -// void KartDrawer::isSecondStage() const // KartDrawer.h; // 0x801ca288 -// void RaceMgr::getAward2D() // RaceMgr.h; // 0x801ca488 -// void RaceMgr::getStaffRoll2D() // RaceMgr.h; // 0x801ca498 -// void GeoShimmer::getSupervisor() // GeoShimmer.h; // 0x801ca4b0 -// void KartDrawer::drawDriverGhostStage(u32) // KartDrawer.h; // 0x801ca630 -// void KartDrawer::drawKartGhostStage(u32) // KartDrawer.h; // 0x801ca654 -// void KartDrawer::getGhostAlpha() const // KartDrawer.h; // 0x801ca678 -// void GhostScreen::show() // GhostScreen.h; // 0x801ca6bc + #endif // RACEDRAWER_H diff --git a/include/Kaneshige/RaceInfo.h b/include/Kaneshige/RaceInfo.h index c1678611..f21c5c05 100644 --- a/include/Kaneshige/RaceInfo.h +++ b/include/Kaneshige/RaceInfo.h @@ -1,6 +1,7 @@ #ifndef RACEINFO_H #define RACEINFO_H +#include "kartEnums.h" #include "types.h" #include "Kaneshige/KartInfo.h" @@ -44,8 +45,10 @@ class RaceInfo int getPlayerKartNumber() const { return mPlayerNum; } int getConsoleNumber() const { return mConsoleNum; } int getStatusNumber() const { return mStatusNum; } - ERaceMode getRaceMode() const { return mRaceMode; } + int getGpStageNo() const { return mGpStageNo; } int getItemSlotType() const { return mItemSlotType; } + ERaceMode getRaceMode() const { return mRaceMode; } + ERacePhase getDemoNextPhase() const { return mDemoNextPhase; } ERaceLevel getRaceLevel() const { return mRaceLevel; } ERaceGpCup getGpCup() const { return mGpCup; } @@ -54,6 +57,7 @@ class RaceInfo bool isTrueEnding() const { return mIsTrueEnding; } bool isMirror() const { return mIsMirror; } bool isWaitDemo() const {return mDemoType != 0; } + bool isLastWaitDemo() const { return mDemoType == 2; } bool isDriverLODOn() const { return (mLOD & 2); }; bool isHiddingConsole(u32 viewNo) const { return (mHidingConsoles & 1 << viewNo) != 0; } void setAwardKartNo(int kartNo) { mAwardKartNo = kartNo; } @@ -110,7 +114,7 @@ class RaceInfo s16 mTargetKarts[4]; // 114 bool mIsDemoKart[4]; // 11C s16 mAwardKartNo; // 120 - int mDemoNextPhase; // 124 + ERacePhase mDemoNextPhase; // 124 s16 mRank[8]; // 128, stores what rank you finished at previous race, basically the same as startPosIndex RaceTime mFinishTime[8]; // 138 RaceTime mLapTimes[8][10]; // 158 diff --git a/include/Kaneshige/RaceLight.h b/include/Kaneshige/RaceLight.h index 05ac9c11..4448db9c 100644 --- a/include/Kaneshige/RaceLight.h +++ b/include/Kaneshige/RaceLight.h @@ -23,6 +23,7 @@ class RaceSceneLight : public LtObjDiffuse void getUpDirection(JGeometry::TVec3f *out) { out->set(mUpDir); } void getLfDirection(JGeometry::TVec3f *out) { out->set(mLfDir); } + static u32 getSceneLightTagName(u32 viewNo) { return 0x53434e30 + viewNo; } // SCN0 private: KartCam *mTargetCam; JGeometry::TVec3f mOffsetPos; @@ -80,6 +81,7 @@ class RaceCupLight : public LtObjDiffuse virtual void draw(); // overide virtual void calc(); // overide + static u32 getTagName(u32 viewNo) { return 0x43555030 + viewNo; } // CUP0 private: RaceSceneLight *mSceneLight; LtObjAmbient mAmbient; diff --git a/include/Kaneshige/RaceMgr.h b/include/Kaneshige/RaceMgr.h index d6f31de5..1f99ee5c 100644 --- a/include/Kaneshige/RaceMgr.h +++ b/include/Kaneshige/RaceMgr.h @@ -55,6 +55,7 @@ class RaceMgr : public JKRDisposer void clearZBuffer(); bool isZoom(); // Inline + int getTargetNo() const { return mTargetNo; } void setDraw() { mFlags |= 1; } void setConsoleNo(int cnsNo) { mCnsNo = cnsNo; } void clrDraw() { mFlags &= ~1; } @@ -63,10 +64,11 @@ class RaceMgr : public JKRDisposer void setJugemZClr() { mFlags |= 8; } bool isNoStat() const { return mFlags & 4; } bool isValid() const { return mCnsNo >= 0; } + bool isDemo() const { return mIsDemo; } private: int mCnsNo; - bool _04; + bool mIsDemo; int mTargetNo; u16 mFlags; }; @@ -135,11 +137,14 @@ class RaceMgr : public JKRDisposer bool isMirror() const { return mRaceInfo->isMirror(); } bool isTinyProcess() const { return mRaceInfo->isTinyProcess(); } bool isWaitDemoMode() const { return mRaceInfo->isWaitDemo(); } + bool isLastWaitDemo() const { return mRaceInfo->isLastWaitDemo(); } int getKartNumber() const { return mRaceInfo->getKartNumber(); } int getAwardKartNo() const { return mRaceInfo->getAwardKartNo(); } int getConsoleNumber() const { return mRaceInfo->getConsoleNumber(); } int getItemSlotType() const { return mRaceInfo->getItemSlotType(); } int getStatusNumber() const { return mRaceInfo->getStatusNumber(); } + int getGPStageNo() const { return mRaceInfo->getGpStageNo(); } + ERacePhase getDemoNextPhase() const { return mRaceInfo->getDemoNextPhase(); } ERaceLevel getRaceLevel() const { return mRaceInfo->getRaceLevel(); } ERaceGpCup getRaceGpCup() const { return mRaceInfo->getGpCup(); } // why did this not use a getter? @@ -223,9 +228,10 @@ class RaceMgr : public JKRDisposer return mBestTotalTimes[recID]; } -private: +public: RaceDirector *mRaceDirector; RaceDrawer *mRaceDrawer; +private: u16 mAreaLight; u8 _0x22; // raceNum? u8 _0x23; // probably padding @@ -235,9 +241,11 @@ class RaceMgr : public JKRDisposer s16 mTotalLapNumber; s32 _0x30; bool mAbleStart; +public: RaceInfo *mRaceInfo; RaceBGMPlayer *mRaceBGMPlayer; Console *mConsole; +private: Course *mCourse; KartChecker *mKartChecker[8]; KartLoader *mKartLoader[8]; diff --git a/include/Kawano/accessory.h b/include/Kawano/accessory.h index c9925bff..f846d0c8 100644 --- a/include/Kawano/accessory.h +++ b/include/Kawano/accessory.h @@ -1,12 +1,16 @@ #ifndef ACCESSORY_H #define ACCESSORY_H +#include "types.h" + class AccessoryMgr { - public: +public: void update(); + void setCurrentViewNo(u32 viewNo); + void simpleDraw(u32 viewNo); static AccessoryMgr *ptr(); static AccessoryMgr *mspAccessoryMgr; }; -#endif \ No newline at end of file +#endif diff --git a/include/Kawano/feeling.h b/include/Kawano/feeling.h new file mode 100644 index 00000000..ae43014f --- /dev/null +++ b/include/Kawano/feeling.h @@ -0,0 +1,56 @@ +#ifndef FEELING_H +#define FEELING_H + +#include "JSystem/JKernel/JKRHeap.h" + +#include "Kawano/driver.h" + +#include "types.h" + +class Feeling { // Autogenerated +public: + Feeling(DriverModel *); + void update(int); + void *getBtpFrame(); + // Inline/Unused + void reset(); + void updateOffset(int); + void updateState(); + void createModel(JKRSolidHeap *, u32, u32); + void setCurrentViewNo(u32); + + static const char *mscpaFeelingAnmFileName[2]; +}; // class feeling + +class FeelingOne { +public: + void updateF(); + // Inline/Unused + FeelingOne(Feeling *, int); + void *getAnmFile(int); + void reset(); + void createModelF(int, JKRSolidHeap *, u32, u32); +}; + +class FeelingMgr { +public: + FeelingMgr(); + ~FeelingMgr(); + static FeelingMgr *ptr(); + void *getBrkFile(int); + void *getBtpFile(); + void init(DriverModel *); + void createModelData(int); + void update(); + void createModel(DriverModel *, JKRSolidHeap *, u32, u32); + void setCurrentViewNo(u32); + void *getJ3DModelDataPtr(int); + + static const u8 mscTevStage[60]; // TODO: correct type + static const char *mscpaFeelingBmdFileName[2]; + static const char *mscpaFeelingBrkFileName[2]; + static const char *mscpaFeelingBtpFileName[1]; + static FeelingMgr *mspFeelingMgr; +}; + +#endif // FEELING_H diff --git a/include/Osako/Award2D.h b/include/Osako/Award2D.h index dc8bc70e..34c91fe3 100644 --- a/include/Osako/Award2D.h +++ b/include/Osako/Award2D.h @@ -6,13 +6,15 @@ class Award2D { public: - Award2D(JKRHeap *); - void calc(); - void still() { - _10 = 0; - } + Award2D(JKRHeap *); // 0x8020f884 + void calc(); // 0x80210f48 + void draw(); // 0x80211254 class OKButton { + void calcAnm(); // 0x802112cc + void zoomIn(); // 0x802113d8 + void zoomOut(); // 0x802113f4 + private: int _0; s16 _4; s16 _6; @@ -21,6 +23,7 @@ class Award2D { f32 _10; }; + void still() { _10 = 0; } void start() { _10 = 1; } bool isFinish() { return _10 == 6; } diff --git a/include/Osako/shadowMgr.h b/include/Osako/shadowMgr.h index 3b5544ad..91305ac1 100644 --- a/include/Osako/shadowMgr.h +++ b/include/Osako/shadowMgr.h @@ -2,7 +2,7 @@ #define SHADOWMGR_H #include "JSystem/JUtility/TColor.h" -#include "JSystem/JGadget/linklist.h" +#include "JSystem/JGadget/std-list.h" #include "Osako/shadowModel.h" #include "types.h" @@ -10,9 +10,11 @@ class ShadowManager { public: ShadowManager(); - void getShadowModelList(ShadowModel::ShadowKind); + typedef JGadget::TList List; + + List &getShadowModelList(ShadowModel::ShadowKind); void regist(ShadowModel *); - //void draw(u32, JGadget::TList> &); + void draw(u32, List &modelList); void calc(); void viewCalc(u32); void setDstAlpha(); @@ -25,7 +27,7 @@ class ShadowManager { void setMirror(bool mirror) { mIsMirror = mirror; } - void setShadowColor(JUtility::TColor & color) { + void setShadowColor(JUTColor & color) { mShadowColor = color; } void setShadowDepth(u8 depth) { @@ -36,6 +38,10 @@ class ShadowManager { mDepthMode = depth; } + void drawShadowVolume(u32 viewNo, ShadowModel::ShadowKind shadowKind) { + draw(viewNo, getShadowModelList(shadowKind)); + } + int getDstAlpha() { if (mDepthMode == 1) { return 0xff - (mDepth[1] & 0xfc); @@ -47,7 +53,7 @@ class ShadowManager { //private: u8 _00[0x58]; - JUtility::TColor mShadowColor; + JUTColor mShadowColor; u8 mDepth[2]; u8 mDepthMode; u8 _5f; @@ -55,4 +61,4 @@ class ShadowManager { u8 _61[3]; // i thought operator new always gets aligned by 4? }; // Size: 0x64 -#endif // SHADOWMGR_H \ No newline at end of file +#endif // SHADOWMGR_H diff --git a/include/Sato/GeographyObj.h b/include/Sato/GeographyObj.h index 1275b209..acfe2605 100644 --- a/include/Sato/GeographyObj.h +++ b/include/Sato/GeographyObj.h @@ -10,6 +10,7 @@ #include "Osako/shadowModel.h" #include "Sato/AnmController.h" #include "Sato/ItemObj.h" +#include "Sato/stMath.h" // TODO: Remove Forward declarations class ObjColBase; // ObjCollision.h @@ -35,9 +36,9 @@ class GeoObjSupervisor // Vtable 0x0 virtual ~GeoObjSupervisor() {} // 0x801ba3b4 - virtual void load() {} // 0x801bcfa4 - virtual void reset() = 0; // 0x0 + virtual void reset() = 0; // 0x0 virtual void calc() = 0; // 0x0 + virtual void load() {} // 0x801bcfa4 virtual void thunderDownAll() {} // 0x801bcfa8 virtual void createModel(JKRSolidHeap *, u32); @@ -76,7 +77,7 @@ class GeographyObj void createMultiBoundsCylinder(u8, J3DModelData *, f32, f32); // 0x8022a934 void createBoundsCube(J3DModelData *); // 0x8022aa04 void setColObjPos(const JGeometry::TVec3f &, u8); // 0x8022ab20 - u32 getGeoRnd(); // 0x8022ac14 + stRandom *getGeoRnd(); // 0x8022ac14 void moveShadowModel(); // 0x8022ac38 void createSoundMgr(); // 0x8022acec f32 getColScaleRadius(); // 0x8022ad44 @@ -106,13 +107,20 @@ class GeographyObj template static T *ExNew(CrsData::SObject &object) { return new T(object); } + GameAudio::ObjectSoundMgr *getSoundMgr() { return mSoundMgr; } + void getPosition(JGeometry::TVec3f *pos) const { *pos = mPos; } void clrObjFlagCheckItemHitting() { mGeoObjFlag &= ~2; } + void clrObjFlagHidding() { mGeoObjFlag &= ~0x20; } void clrAllCheckKartHitFlag() { mKartHitFlags = 0; } + + void setObjFlagCheckItemHitting() { mGeoObjFlag |= 2; } void setObjFlagHidding() { mGeoObjFlag |= 0x20; } + void setObjFlagSimpleDraw() { mObjFlag |= 1; } void setObjFlagMainResource() { mObjFlag |= 2; } void setAllCheckKartHitFlag() { mKartHitFlags = 0xffffffff; } bool tstObjFlagSimpleDraw() const { return mObjFlag & 1; } + bool tstIsHitKartFlg(int kartNo) const { return mKartHitFlags == kartNo; } u32 getKind() const { return mKind; } ItemColReaction &getItemReaction() { return mReaction; } @@ -160,25 +168,27 @@ class GeographyObj virtual void initClassCreateNum() { } // 78 virtual void setModelMatrixAndScale(); // 7C protected: - JGeometry::TVec3f mPos; // 04 - JGeometry::TPos3f mRotMtx; // 10 - JGeometry::TVec3f mScale; // 40 - JGeometry::TVec3f mVel; // 4C - int _58; // 58, some sort of ID - ExModel mModel; // 5C - CrsData::SObject *mObjData; // E8 - u32 mGeoObjFlag; // EC - u32 mKartHitFlags; // F0 - u8 _f4[0xfc - 0xf4]; // - JSULink mLink; // FC - int mKind; // 10C - u8 _110[0x114 - 0x110]; // - ItemObj *mColItemObj; // 114 - u8 _118[0x11c - 0x118]; // - u16 mObjFlag; // 11C - AnmController *mAnmCtrl; // 120 - ItemColReaction mReaction; // 124 - u8 _134[0x14c - 0x134]; // + JGeometry::TVec3f mPos; // 04 + JGeometry::TPos3f mRotMtx; // 10 + JGeometry::TVec3f mScale; // 40 + JGeometry::TVec3f mVel; // 4C + int _58; // 58, some sort of ID + ExModel mModel; // 5C + CrsData::SObject *mObjData; // E8 + u32 mGeoObjFlag; // EC + u32 mKartHitFlags; // F0 + u8 _f4[0xfc - 0xf4]; // + JSULink mLink; // FC + int mKind; // 10C + u8 _110[0x114 - 0x110]; // + ItemObj *mColItemObj; // 114 + u8 _118[0x11c - 0x118]; // + u16 mObjFlag; // 11C + AnmController *mAnmCtrl; // 120 + ItemColReaction mReaction; // 124 + u8 _134[0x144 - 0x134]; // + GameAudio::ObjectSoundMgr *mSoundMgr; // 144 + u8 _148[0x14c - 0x148]; // }; // Size: 0x14c class TMapObjHioNode : public GeographyObj diff --git a/include/Sato/GeographyObjMgr.h b/include/Sato/GeographyObjMgr.h index c19d489d..f454e1a6 100644 --- a/include/Sato/GeographyObjMgr.h +++ b/include/Sato/GeographyObjMgr.h @@ -14,10 +14,29 @@ class GeographyObjManager : JKRDisposer void calc(); void createModel(JKRSolidHeap *, u32); void reset(const CrsData &); - + void drawGXObj(u32 cameraNo); + void drawPrim(u32 cameraNo); + + void update(); + void drawSimpleModel(u32 cameraNo); + void setCurrentViewNo(u32 cameraNo); + void viewCalc(u32 cameraNo); + + void update_groundObj(); + void drawSimpleModel_groundObj(u32 cameraNo); + void setCurrentViewNo_groundObj(u32 cameraNo); + void viewCalc_groundObj(u32 cameraNo); + + void update_foreground(); + void drawSimpleModel_foreground(u32 cameraNo); + void setCurrentViewNo_foreground(u32 cameraNo); + void viewCalc_foreground(u32 cameraNo); + TJugem *getJugem(int camera_index) const; TBalloonManager *getBalloonMgr(int kart_index) const; + GeographyObj *createSubObj(u32 id); + f32 getKartHitDepthNormalObj(int kart_index) const { return mHitDepth[kart_index]; } static void createMgr(const CrsData &crsData) { gMgr = new GeographyObjManager(crsData); } static GeographyObjManager *getGeographyObjManager() { return gMgr; } diff --git a/include/Sato/ItemObj.h b/include/Sato/ItemObj.h index 82ba92af..08b1c78d 100644 --- a/include/Sato/ItemObj.h +++ b/include/Sato/ItemObj.h @@ -4,6 +4,7 @@ #include #include "Inagaki/SoundMgr.h" #include "Kaneshige/Course/CrsGround.h" +#include "Kaneshige/DarkAnmMgr.h" #include "Osako/shadowModel.h" #include "Sato/ObjCollision.h" #include "Sato/stMath.h" @@ -237,6 +238,15 @@ class ItemObj } return ret; } + bool IsState1or5() const { return (mState != 1 && mState != 5); } + bool IsState1or5AndSameOwner(int owner) const { + bool ret = false; + if (owner == mOwnerNum) { + if ((mState != 1 && mState != 5)) + ret = true; + } + return ret; + } bool tst_80() const { return _12c & 0x80; } @@ -272,6 +282,14 @@ class ItemObj void setSuccessionParent(ItemObjSuc *parent) { mSuccessionParent = parent;} // private: + void setLightMask() { + GXLightID lightId = GX_LIGHT0; + if ((mState == 1 || mState == 5)) + lightId = GX_LIGHT1; + ExModel::setLightMask(mModel.getModelData(), lightId); + } + void setTevColor() { mAnmPlayer->setTevColor(&mModel); } + typedef void (ItemObj::*StateFunc)(); JGeometry::TVec3f mPos; // 04 @@ -329,7 +347,8 @@ class ItemObj JGeometry::TVec3f mNormal; // 250 u8 _25c[0x280 - 0x25c]; // GameAudio::ObjectSoundMgr *mSoundMgr; // 280 - u8 _284[0x28c - 0x284]; // + DarkAnmPlayer *mAnmPlayer; // 284 + u8 _288[0x28c - 0x288]; // int mDirectHitKartNo; // 28c u8 _290[0x298 - 0x290]; // u8 mColorID; // 298 diff --git a/include/Sato/ItemObjMgr.h b/include/Sato/ItemObjMgr.h index fd53983f..15d09360 100644 --- a/include/Sato/ItemObjMgr.h +++ b/include/Sato/ItemObjMgr.h @@ -143,6 +143,9 @@ class ItemObjMgr : public SysDbUsrPage enum eDrawSimplModelItemType { + ItemType_0, + ItemType_1, + ItemType_2 }; struct SLAN_DebugKartPadData @@ -305,20 +308,20 @@ class ItemObjMgr : public SysDbUsrPage ItemObj *equipItem(u32); void appendItemSuccession(ItemObj *, u32, u8); void createItemByKartStockingItemList(); - void isEnableDeleteItem(ItemObj *); - void IsItemAvailable(int); + bool isEnableDeleteItem(ItemObj *); + bool IsItemAvailable(int); bool tstKartEquipItemTrigger(int, u8); int getStockItem(int); void loadModelData(ItemObj *); void loadShadowModelData(); void changeItemHoldCharacter(); - void IsAbleToCreateItem(int); - void getNowStockingKindNum(int, u32); + bool IsAbleToCreateItem(int); + int getNowStockingKindNum(int, u32); void cancelRollingSlot(int); bool IsAvailableRollingSlotDriver(int, u8); static int getMaxHoldMiniBombNum(); void getNowEnableSlotDriver(u8 *, int); - void getConvertSucItemKind(u32); + static u32 getConvertSucItemKind(u32); void getMaxItemMoveNum(); void setMaxItemMoveNum(const u8 &); void entryMiniGameList(ItemObj *); @@ -352,6 +355,8 @@ class ItemObjMgr : public SysDbUsrPage return 0; } + bool isThunderDisabled() const { return mThunderDisableTimer != 0; } + // private: u8 _28[0x2c - 0x28]; // KartHitList mHitList[8]; // 2c @@ -373,7 +378,7 @@ class ItemObjMgr : public SysDbUsrPage JSUList _73c[16]; // JSUList _7fc; // bool mObjectsCreated; // 808 - int mThunderDisableTimer; // 80c + u32 mThunderDisableTimer; // 80c ItemObj::ItemHandOffsetData *mpHandOffsetData; // 810 J3DModelData *mpMdlData; // 814 ShadowModel *mpShadowMdl[2]; // 818, 81c diff --git a/include/Sato/JPEffectMgr.h b/include/Sato/JPEffectMgr.h index e3f965dc..8b19cafa 100644 --- a/include/Sato/JPEffectMgr.h +++ b/include/Sato/JPEffectMgr.h @@ -34,7 +34,7 @@ class JPEffectMgr void draw_thunder(int); // 0x80230ae0 void draw_for2D(); // 0x80230bf0 void draw_forBefore2D(); // 0x80230cc0 - void draw_forBefore2D(u8); // 0x80230d90 + void draw_forBefore2D(const u8); // 0x80230d90 void createSnowEmt(); // 0x80230f30 void createAwardDemoEmt(const bool); // 0x80231084 void createRainbowEmt(); // 0x80231130 diff --git a/include/Sato/RivalBodyCtrl.h b/include/Sato/RivalBodyCtrl.h index 2736d462..54c77132 100644 --- a/include/Sato/RivalBodyCtrl.h +++ b/include/Sato/RivalBodyCtrl.h @@ -60,7 +60,7 @@ class RivalBodyCtrl : public RivalCtrlBase, JKRDisposer // void sLowestComKartIndex; // 0x80415044 // void sCrsStdDistRatio; // 0x80415048 // void sEngineBParamPtr; // 0x80416d20 - // void sCommonFlgs; // 0x80416d24 + static u32 sCommonFlgs; // 0x80416d24 // void sCheckTopDistRatio; // 0x80416d28 // void getNthCLPoint(CLPoint *, short); @@ -81,6 +81,8 @@ class RivalBodyCtrl : public RivalCtrlBase, JKRDisposer // void findRivalDistanceFrontAngle(float, float); // void findRivalDistanceRearAngle(float, float); + static bool isPlayerFirst() { return (sCommonFlgs & 2) != 0; } + u8 _20[0xc8 - 0x20]; }; // Size: 0xc8 @@ -113,4 +115,4 @@ class RivalAward2ndBodyCtrl : public RivalAwardBodyCtrl virtual ~RivalAward2ndBodyCtrl() {} // 0x80284440 }; -#endif // RIVALBODYCTRL_H \ No newline at end of file +#endif // RIVALBODYCTRL_H diff --git a/include/Sato/StateObserver.h b/include/Sato/StateObserver.h index 23007394..5f31f4e1 100644 --- a/include/Sato/StateObserver.h +++ b/include/Sato/StateObserver.h @@ -20,9 +20,9 @@ class StateObserver StateObserver(); // 0x802714b0 void ExecuteState(); // 0x80271518 void ResetState(); // 0x80271570 - + void changeState(); void setState(u16); - u16 getState() const { return mState; } + u16 getState() const { return mPrevState; } // Vtable virtual ~StateObserver(); @@ -52,9 +52,9 @@ class StateObserver } private: - u16 _4; // confusion, this one gets set by the setter, _06 for the getter - u16 mState; // 6 - u32 _8; // + u16 mState; // 4 + u16 mPrevState; // 6 + u32 mTimeExecuted; // 8 }; template diff --git a/include/Sato/stEffectMgr.h b/include/Sato/stEffectMgr.h index ce18ccaf..ae45c28e 100644 --- a/include/Sato/stEffectMgr.h +++ b/include/Sato/stEffectMgr.h @@ -2,19 +2,74 @@ #define STEFFECTMGR_H #include "JSystem/JKernel/JKRHeap.h" +#include "JSystem/JGeometry/Vec.h" #include "types.h" -struct stEffectMgr -{ - stEffectMgr(); - void init(); - void createModel(JKRSolidHeap *, u32); - void calc(); - void reset(); +struct CrsGround; +struct stEmitterCallBack; +struct stGndAttrDataIndex; +struct stGndAttrParam; +struct stTireEfctStatusSet; +struct stTireEffectStatus; + +struct stEffectMgr { + stEffectMgr(); // 0x802360d4 + void createEmitterAndParticles(); // 0x8023647c + void createKartExhaustMtx(); // 0x8023677c + void model_init(); // 0x80236964 + void createModel(JKRSolidHeap *, u32); // 0x80236c78 + void init(); // 0x80236c98 + void initCallBackPtr(stEmitterCallBack *, s16, s16); // 0x80237664 + void reset(); // 0x80237670 + void calc(); // 0x80237ab8 + void calcGndAttrEffect(); // 0x80237b98 + void calcGndCenterEffect(int, bool); // 0x80237cf8 + void calcGndTireEffect(int, bool, stTireEfctStatusSet *); // 0x80237ea4 + void calcDriftSparkEfct(int, u8, stTireEffectStatus *, u32); // 0x802382cc + void calcSideGEfct(int, int, stTireEffectStatus *, bool); // 0x80238398 + void calcSpinTurnEfct(int, int, stTireEffectStatus *, bool); // 0x80238538 + void calcDriftEfct(int, int, stTireEffectStatus *, bool); // 0x8023864c + void createDriftEfct(int, int, stTireEffectStatus *, int); // 0x80238788 + void calcGndCharEffect(int, bool); // 0x80238864 + void calcWaterAttrEffect(int); // 0x80238b00 + void findParamPtrTire(int, CrsGround *, stTireEffectStatus *, u8); // 0x80238ebc + void findParamPtrCenter(int, CrsGround *, stTireEffectStatus *, u8); // 0x802394bc + void findParamPtrChar(int, CrsGround *, stTireEffectStatus *, u8); // 0x80239ad8 + void findParamPtrCommon(int); // 0x80239fc4 + void chkAvailablePtrList(int, int); // 0x8023a060 + void calcAttrRoad(int, int, stTireEffectStatus *, u8); // 0x8023a1d8 + void calcAttrRoadCenter(int, stTireEffectStatus *, u8); // 0x8023a49c + void calcAttrRoadCharCenter(int, stTireEffectStatus *, u8); // 0x8023a5e0 + void calcAttrWeedCharCenter(int, stTireEffectStatus *, u8); // 0x8023a6e8 + void setDriftStatus(int, int, stTireEffectStatus *); // 0x8023a7f0 + void draw(u32); // 0x8023a910 + void update(); // 0x8023a930 + void viewCalc(u32); // 0x8023a934 + void setCurrentViewNo(u32); // 0x8023a938 + void getWaterTrack(int); // 0x8023a93c + void getKartExhaustMtxL(int); // 0x8023a9d4 + void getKartExhaustMtxR(int); // 0x8023aa6c + void getEfctCarSpeed(int) const; // 0x8023ab04 + void getExhaustAccelCounter(int); // 0x8023abb4 + void getExhaustPosDir(JGeometry::TVec3f *, JGeometry::TVec3f *, int, u8); // 0x8023ac64 + void createEmitter(stEmitterCallBack *, u16); // 0x8023adb8 + void createKartCommonEmitter(int, stEmitterCallBack *, u16, bool); // 0x8023ae88 + void createKinokoDashEmt(int); // 0x8023b05c + void tstUseMufllerL(int); // 0x8023b294 + void tstUseMufllerR(int); // 0x8023b328 + void setExhaustStopFlg(int, bool); // 0x8023b3bc + void tstIsAvailableDistance(int) const; // 0x8023b4f0 + void resetIndex(); // 0x8023b584 + void loadCourseParam(u32); // 0x8023b834 + void setIndexToList_Common(u8, const stGndAttrParam &); // 0x8023bc04 + void setIndexToList_StdGnd(u8, const stGndAttrParam &, stGndAttrDataIndex &); // 0x8023bccc + void getEmitterPtr(char *); // 0x8023bd74 + void getBtiPtr(char *); // 0x8023bdc0 + void getSnpName(u32); // 0x8023be0c static void createMgr() { mMgr = new stEffectMgr(); } static stEffectMgr *getMgr() { return mMgr; } - static stEffectMgr *mMgr; + static stEffectMgr *mMgr; // 0x80416b40 u8 _00[0x1398]; }; @@ -22,4 +77,4 @@ struct stEffectMgr inline void CreateStEfctMgr() { stEffectMgr::createMgr(); } inline stEffectMgr *GetStEfctMgr() { return stEffectMgr::getMgr(); } -#endif \ No newline at end of file +#endif diff --git a/include/Sato/stMath.h b/include/Sato/stMath.h index d1992b85..325464a4 100644 --- a/include/Sato/stMath.h +++ b/include/Sato/stMath.h @@ -56,6 +56,7 @@ struct stRandom : public JMath::TRandom_fast_ static void createAllRandom(); static void deleteAllRandom(); + u32 getRandom() { return get(); } u32 getRandomMax(u32 max); void getArbitUnitVec(JGeometry::TVec3f &, f32, f32); void getArbitUnitVecSimple(JGeometry::TVec3f &, f32); diff --git a/include/Shiraiwa/Balloon.h b/include/Shiraiwa/Balloon.h index a9b11396..3f4ae8f1 100644 --- a/include/Shiraiwa/Balloon.h +++ b/include/Shiraiwa/Balloon.h @@ -2,13 +2,27 @@ #define BALLOON_H #include "JSystem/JGeometry.h" +#include "JSystem/JGeometry/Matrix.h" #include "JSystem/JKernel/JKRHeap.h" +#include "Kaneshige/RaceMgr.h" +#include "Sato/GeographyObj.h" #include "types.h" class J3DAnmObjMaterial; +class TBalloonSupervisor : public GeoObjSupervisor +{ +public: + ~TBalloonSupervisor(); + void drawString(u32); + void drawBalloon(u32); + + // void reset() // TBalloonSupervisor.h; // 0x802c0d7c + // void calc() // TBalloonSupervisor.h; // 0x802c0d88 +}; + // Inherited from GeographyObj -class TBalloon +class TBalloon : public GeographyObj { // Autogenerated public: // Global @@ -46,9 +60,9 @@ class TBalloon // void show(); // void hide(); // void drawString(u32); - // void drawNode(float, const JGeometry::TVec3 &, const JGeometry::TVec3 &, u32, unsigned char); - // void drawCrevicePyramid(const JGeometry::TVec3 &, const JGeometry::TVec3 &, const JGeometry::TVec3 &, unsigned char); - // void drawPrism(const JGeometry::TVec3 &, const JGeometry::TVec3 &, const JGeometry::TVec3 &, const JGeometry::TVec3 &, const JGeometry::TVec3 &, unsigned char); + // void drawNode(float, const JGeometry::TVec3f &, const JGeometry::TVec3f &, u32, u8); + // void drawCrevicePyramid(const JGeometry::TVec3f &, const JGeometry::TVec3f &, const JGeometry::TVec3f &, u8); + // void drawPrism(const JGeometry::TVec3f &, const JGeometry::TVec3f &, const JGeometry::TVec3f &, const JGeometry::TVec3f &, const JGeometry::TVec3f &, u8); // void sWidth; // void sRabbitScaleSize; // void sAlphaJudgeNode; @@ -60,30 +74,32 @@ class TBalloon virtual const char *getBmdFileName() {return "/Objects/MiniGame_Balloon.bmd"; } // 0x802c0e4c }; // class Balloon -class TBalloonString +class TBalloonString : public TMapObjHioNode, JKRDisposer { public: TBalloonString(); - virtual ~TBalloonString(); // TBalloonString.h; // 0x802c02a8 + virtual ~TBalloonString() {} void init(); void setColor(u32); void unlock(u32); void setMainViewNo(char); void reset(); - // void setCharID(const EKartWeight &, const ECharID &, const ECharID &); + void setCharID(const EKartWeight &, const ECharID &, const ECharID &); void resetNodeLength(); - // void setPosition(const JGeometry::TVec3 &, const JGeometry::TPosition3>> &); + void setPosition(const JGeometry::TVec3f &, const JGeometry::TPos3f); void calc(); void die(); void shake(); void drawBalloon(u32); - void getUpDir(JGeometry::TVec3 *); - void getPoint(JGeometry::TVec3 *); - void getPointDir(JGeometry::TVec3 *); + void getUpDir(JGeometry::TVec3f *); + void getPoint(JGeometry::TVec3f *); + void getPointDir(JGeometry::TVec3f *); void setParameters(); - static TBalloonString * getSupervisor() { return sSupervisor; } - + virtual TBalloonSupervisor *getSupervisor() { return sSupervisor; } +#ifdef __MWERKS__ + static TBalloonSupervisor *getSupervisor() { return sSupervisor; } +#endif // void sOffset; // void sTotalLength; // void sAdjustRatio; @@ -97,14 +113,14 @@ class TBalloonString // void sBreakOffset; // void sBreakUpVel; // void sShakePow; - static TBalloonString * sSupervisor; + static TBalloonSupervisor *sSupervisor; }; -class TBalloonManager +class TBalloonManager : public TMapObjHioNode { public: TBalloonManager(); - void init(unsigned char, char, unsigned char); + void init(u8, char, u8); void reset(); void calc(); void killBalloon(TBalloonString *); @@ -114,30 +130,31 @@ class TBalloonManager void setBalloon(TBalloonString *); void removeBalloon(); - // static void TBalloonString::sTotalLength; - // static void TBalloonManager::sPullDirX; - // static void TBalloonManager::sPullDirY; - // static void TBalloonManager::sPullDirZ; + // static void sTotalLength; + // static void sPullDirX; + // static void sPullDirY; + // static void sPullDirZ; // Inline/Unused - // void TBalloonManager(const CrsData::SObject &); + TBalloonManager(const CrsData::SObject &); // void isEscape(); // void drawBalloon(u32); // void getSpareBalloon(); - // virtual ~TBalloonManager() // TBalloonManager.h; // 0x802c0e58 - // void createColModel(J3DModelData *) // TBalloonManager.h; // 0x802c0ee8 -}; + virtual ~TBalloonManager() { } + virtual void createColModel(J3DModelData *) { } -class TBalloonSupervisor -{ -public: - ~TBalloonSupervisor(); - void drawString(u32); - void drawBalloon(u32); + void changeWinningPos() { + if (RCMGetKartChecker(mKartIdx)->getRank() == 1) { + mIsWinning = true; + } + } - // void reset() // TBalloonSupervisor.h; // 0x802c0d7c - // void calc() // TBalloonSupervisor.h; // 0x802c0d88 + u8 _14c[0x16e - 0x14c]; + u8 mKartIdx; // 16e + u8 _16f; + bool mIsWinning; // 170 }; -#endif // BALLOON_H \ No newline at end of file + +#endif // BALLOON_H diff --git a/include/Shiraiwa/JugemMain.h b/include/Shiraiwa/JugemMain.h index 0200ae2f..11f5324e 100644 --- a/include/Shiraiwa/JugemMain.h +++ b/include/Shiraiwa/JugemMain.h @@ -40,11 +40,14 @@ class TJugem : public TMapObjHioNode, public StateObserver mIsAbleStart = true; setState(0); }; + bool isAllShapePacketHidding(u32 viewNo) { return mModel.isAllShapePacketHidding(viewNo); } bool isAbleStart(); /* { return mIsAbleStart; }*/ bool isCallThree() { return !mSignal ? false : mSignal->isCallThree(); } bool isDemoOut() { return isDemoMode() && mAnmPlayer.getCurAnmNumber() == 2; } const JGeometry::TVec3f &getPosition() const { return mPos; } + u8 getKartNum() { return mKartNum; } + void setHearPtr(TJugemHeadHear *hear) { setJugemHeadItem(hear, 0); } void setSignalPtr(TJugemRodSignal *signal) { mSignal = signal; } void setVoidRodPtr(TJugemVoidRod *rod) { @@ -67,7 +70,9 @@ class TJugem : public TMapObjHioNode, public StateObserver TAnmPlayer mAnmPlayer; // 178 u8 _18c[0x244 - 0x18c]; // u32 mDemoPattern; // 244 - u8 _248[0x250 - 0x248]; // + u8 _248; // + u8 mKartNum; // 249 + u8 _24a[0x250 - 0x24a]; // bool mIsAbleStart; // 250 u8 _251[0x26c - 0x251]; // TJugemRodSignal *mSignal; // 26c diff --git a/include/Shiraiwa/LensFlare.h b/include/Shiraiwa/LensFlare.h new file mode 100644 index 00000000..a9c8519e --- /dev/null +++ b/include/Shiraiwa/LensFlare.h @@ -0,0 +1,101 @@ +#ifndef LENSFLARE_H +#define LENSFLARE_H + +#include "JSystem/JUtility/TColor.h" +#include "types.h" + +#include "Sato/GeographyObj.h" + +// TODO +class TLensFlare; + +class TLensFlareSupervisor : public GeoObjSupervisor { +public: + TLensFlareSupervisor() {} + ~TLensFlareSupervisor(); + void entry(TLensFlare *); + void getBufferZ(u32); + void draw(u32); + void setupGX(); + void load(); + + // Inline + void reset() { } + void calc() { } + + static const char *fileName[4]; +}; + +class TLensFlare : public TMapObjHioNode, JKRDisposer { // Autogenerated +public: + TLensFlare(const CrsData::SObject &); // 0x802b0558 + void reset(); // 0x802b0758 + void calc(); // 0x802b086c + void draw(u32); // 0x802b08c8 + + // Inline/Unused + void getBufferZ(u32); + + // Inline + virtual ~TLensFlare() {} + virtual TLensFlareSupervisor *getSupervisor() { return sSupervisor; } + static TLensFlareSupervisor *getSupervisor() { return sSupervisor; } +private: + static TLensFlareSupervisor *sSupervisor; // 0x80416f48 +}; // class LensFlare + + +class TLensFlareScrn { +public: + void calc(bool, f32); + void frameIn(); + void frameOut(); + + // Inline/Unused + TLensFlareScrn(); + ~TLensFlareScrn(); + void init(u32, const JUTColor &, u8, u8); + void draw(); + void setupGX(); + + static u8 sAlphaAccel; + static u8 sAlphaDecel; + static u8 sAlphaMax; + static u8 sAlphaMin; +}; + +class TFlareLine { +public: + class TFlare { + + }; + + // void __defctor() // TFlareLine.h; // 0x802b0678 + ~TFlareLine(); + void reset(u8, u8, u8, u8, u8); + void resetFlares(); + void calc(const JGeometry::TVec3f &); + void isInside(const JGeometry::TVec2f &); + void setPosition(const JGeometry::TVec2f &, const JGeometry::TVec2f &); + void draw(); + void drawFixCenter(TFlare &); + + // Inline/Unused + TFlareLine(u32); + void setTexture(ResTIMG **, int); + void getBufferZ(); + f32 getAspectRate(); + + static f32 sScale; + static f32 sFlareInterval; + static f32 sOutRadius; + static u8 sAlpha; + static u8 sAlphaAccel; + static u8 sAlphaDecel; + static f32 sScrnScaleRange; + // void sFlareInfo; + static JUTColor sColor; + //void cNumFlare; +}; + +#endif // LENSFLARE_H diff --git a/include/Shiraiwa/MapObjHanabi.h b/include/Shiraiwa/MapObjHanabi.h index 51b495cb..5995c638 100644 --- a/include/Shiraiwa/MapObjHanabi.h +++ b/include/Shiraiwa/MapObjHanabi.h @@ -16,7 +16,7 @@ class THanabiSupervisor : public GeoObjSupervisor { ~THanabiSupervisor(); void entry(TMapObjHanabi *); void fire(s16); - void getFireFrame(s16); + s16 getFireFrame(s16); void reset() {} // 0x802cdda0 void calc() {} // 0x802cdda4 @@ -31,11 +31,14 @@ class TMapObjHanabi : public TMapObjHioNode, JKRDisposer { // Autogenerated void reset(); // 0x802cdafc void calc(); // 0x802cdb4c + + virtual THanabiSupervisor *getSupervisor() { return sSupervisor; } // ??? GeographyObj::getSupervisor() is a virtual function which this class inherits from (via TMapObjHioNode) // and thus this overrides the function in the vtable // but is this even valid in C++? static THanabiSupervisor *getSupervisor() { return sSupervisor; } + static THanabiSupervisor *sSupervisor; // 0x80417110 }; // class MapObjHanabi diff --git a/include/Shiraiwa/ZCaptureMgr.h b/include/Shiraiwa/ZCaptureMgr.h new file mode 100644 index 00000000..d15e9805 --- /dev/null +++ b/include/Shiraiwa/ZCaptureMgr.h @@ -0,0 +1,68 @@ +#ifndef ZCAPTUREMGR_H +#define ZCAPTUREMGR_H + +#include "types.h" + +class ZCaptureScreen { +public: + ZCaptureScreen(); + virtual ~ZCaptureScreen(); + void reset(); + void captureAll(); + void capture(u32); + void setPosition(u32, s16, s16); + void getZValue(u32) const; + + class ZCaptureNode { + public: + ZCaptureNode(); + virtual ~ZCaptureNode(); + void reset(); + void setPosition(s16, s16); + void capture(); + void getZValue(); + private: + s16 mPosX; + s16 mPosY; + u8 *_8; + bool mPosSet; + }; + +private: + ZCaptureNode *mNodes[11]; +}; + +class ZCaptureMgr { // Autogenerated +public: + ZCaptureMgr(u32); // 0x802d7940 + virtual ~ZCaptureMgr(); // 0x802d79cc + void reset(); // 0x802d7a68 + void capture(u32); // 0x802d7abc + void captureDone(); // 0x802d7b58 + void setPosition(u32, u32, s16, s16); // 0x802d7b78 + void getZValue(u32, u32); // 0x802d7c1c + + class ZCaptureScreen { + public: + // Inline/Unused + void setActive(u32); + void setInactive(u32); + void isActive(u32); + + //void scCaptureSizeX; + //void scCaptureSizeY; + //void scBufferSize; + }; + // Inline/Unused + void captureAll(); + void setActive(u32); + void setInactive(u32); + bool isActive(u32); + +private: + ZCaptureScreen *mScreens; + u32 mNumViews; +}; // class ZCaptureMgr + + +#endif // ZCAPTUREMGR_H diff --git a/include/Yamamoto/kartCtrl.h b/include/Yamamoto/kartCtrl.h index 430c90df..9de04663 100644 --- a/include/Yamamoto/kartCtrl.h +++ b/include/Yamamoto/kartCtrl.h @@ -82,14 +82,14 @@ class KartCtrl : public KartMat // WHAT THE HELL ARE YOU DOING void GetTireAngle(int); void GetTandemDir(int); void GetWaterHeight(int); - void CheckJugemuSignal(); + bool CheckJugemuSignal(); GameAudio::KartSoundMgr *GetKartSoundMgr(int idx); /*{ return getKartSound(idx)->mKartSoundMgr; }*/ f32 GetKartBodyOffset(int); void MakeChangePossible(int); bool CheckTandemItmGet(int); bool CheckTandemItmRollingGet(int); void SetObjectPos(int, JGeometry::TVec3f); - void CheckThunderBolt(int); + bool CheckThunderBolt(int); void GetTireRadius(int); void IsBurn(int); void IsWallReact(int); @@ -97,17 +97,17 @@ class KartCtrl : public KartMat // WHAT THE HELL ARE YOU DOING int GetDriftCnt(int); bool IsMiniGame(); bool IsMiniGameEnd(); - void CheckWinner(); + bool CheckWinner(); void GetKartEffctVel(int, JGeometry::TVec3f *); bool CheckChange(int); - void CheckMatchless(int); - void CheckReverse(int); + bool CheckMatchless(int); + bool CheckReverse(int); f32 GetKartScale(int); RivalKart *getKartEnemy(int); CLPoint *GetKartCenterPtr(int); void EnemyInit(int); void EnemyResetInit(int); - void CheckZoomWinConsole(); + bool CheckZoomWinConsole(); void SetUpMiniTurbo(int, u8); // Inline/Unused // void SetPadKeyClear(KartGamePad *); diff --git a/include/kartEnums.h b/include/kartEnums.h index 628b43c7..c749c96c 100644 --- a/include/kartEnums.h +++ b/include/kartEnums.h @@ -181,21 +181,26 @@ enum ERaceMode enum ERacePhase { // idk how many phases there are - PHASE_CRS_DEMO = 1, - PHASE_2 = 2, - PHASE_3 = 3, - PHASE_4 = 4, - PHASE_5 = 5, - PHASE_6 = 6, - PHASE_7 = 7, - PHASE_8 = 8, - PHASE_9 = 9, - PHASE_10 = 10, - PHASE_11 = 11, - PHASE_12 = 12, - PHASE_13 = 13, - PHASE_14 = 14, - PHASE_15 = 15, + PHASE_0, + PHASE_CRS_DEMO, + PHASE_NO_CRS_DEMO, + PHASE_3, + PHASE_4, + PHASE_5, + PHASE_6, + PHASE_7, + PHASE_8, + PHASE_9, + PHASE_10, + PHASE_11, + PHASE_12, + PHASE_13, + PHASE_14, + PHASE_15, + PHASE_SAFETY, + PHASE_RUNNING, + PHASE_WAIT, + PHASE_ENDING, }; #endif diff --git a/src/Kaneshige/GeoRabbitMark.cpp b/src/Kaneshige/GeoRabbitMark.cpp index 1e7b5ead..44780fda 100644 --- a/src/Kaneshige/GeoRabbitMark.cpp +++ b/src/Kaneshige/GeoRabbitMark.cpp @@ -1,4 +1,523 @@ -/*#include "Kaneshige/GeoRabbitMark.h" +#include "Kaneshige/Objects/GeoRabbitMark.h" +#include "JSystem/JGeometry/Vec.h" +#include "JSystem/JUtility/JUTAssert.h" +#include "Kaneshige/Course/CrsGround.h" +#include "Kaneshige/Objects/GeoShine.h" +#include "Kaneshige/Course/CrsData.h" +#include "Kaneshige/RaceMgr.h" +#include "Sato/GeographyObj.h" +#include "Sato/GeographyObjMgr.h" +#include "Sato/ObjUtility.h" +#include "Sato/StateObserver.h" +#include "Yamamoto/kartCtrl.h" +#include "kartEnums.h" +#include "types.h" + +StateObserver::StateFuncSet GeoRabbitMark::sTable[3] = { + {0, &GeoRabbitMark::initFuncWait, &GeoRabbitMark::doFuncWait, }, + {1, &GeoRabbitMark::initFuncEquip, &GeoRabbitMark::doFuncEquip}, + {2, &GeoRabbitMark::initFuncRelease, &GeoRabbitMark::doFuncRelease} +}; u16 GeoRabbitMark::sSupervisorCreateNum; -GeoRabbitMark * GeoRabbitMark::sSupervisor;*/ \ No newline at end of file +GeoRabbitMarkSupervisor *GeoRabbitMark::sSupervisor; + +GeoRabbitMarkSupervisor::GeoRabbitMarkSupervisor() { + reset(); +} + +GeoRabbitMarkSupervisor::~GeoRabbitMarkSupervisor() { + GeoRabbitMark::sSupervisor = nullptr; +} + +f32 GeoRabbitMark::sFootLength = 200.0f; +f32 GeoRabbitMark::sEquipOfsY1 = 480.0f; +f32 GeoRabbitMark::sEquipOfsYPakkun1 = 550.0f; +f32 GeoRabbitMark::sEquipOfsY2 = 430.0f; +f32 GeoRabbitMark::sEquipOfsYPakkun2 = 530.0f; +f32 GeoRabbitMark::sEquipOfsY34 = 460.0f; +f32 GeoRabbitMark::sEquipOfsYPakkun34 = 550.0f; +f32 GeoRabbitMark::sGravity = 0.3f; +f32 GeoRabbitMark::sReflectK = 0.5f; +f32 GeoRabbitMark::sNormalScale = 0.6f; +f32 GeoRabbitMark::sEquipScale = 0.45f; +f32 GeoRabbitMark::sEqpSprMinLength = 250.0f; +f32 GeoRabbitMark::sEqpSpringK = 0.25f; +f32 GeoRabbitMark::sEqpAirRegist = 0.15f; +f32 GeoRabbitMark::sEqpChaseRate = 0.3f; +f32 GeoRabbitMark::sRelV0 = 30.0f; +f32 GeoRabbitMark::sRelGravity = 2.0f; +f32 GeoRabbitMark::sRelReflectK = 0.55f; + +void GeoRabbitMarkSupervisor::reset() { + CrsData *crsData = RCMGetCourse()->getCrsData(); + CrsData::MGParam *param = crsData->getMGParam(RaceMgr::getManager()->getKartNumber()); + mWinTime = param->getRabbitWinSec(); + mMinTime = param->getRabbitMinSec(); + mDecTime = param->getRabbitDecSec(); +} + +void GeoRabbitMarkSupervisor::calc() {} + +void GeoRabbitMarkSupervisor::entry(GeoRabbitMark *mark) { + mMark = mark; +} + +int GeoRabbitMarkSupervisor::getRabbitKartNo() { + return mMark->mOwnerNo; +} + +void GeoRabbitMarkSupervisor::release() { + mMark->release(); + + mWinTime -= mDecTime; + if (mWinTime < mMinTime) + mWinTime = mMinTime; +} + +void GeoRabbitMarkSupervisor::getMarkPosition(JGeometry::TVec3f *out) { + out->set(mMark->mPos); +} + +void GeoRabbitMarkSupervisor::changeOwner(int ownerNum) { + mMark->equip(ownerNum); +} + +void GeoRabbitMarkSupervisor::startWinnerEffect() { + mMark->startWinnerEffect(); +} + +void GeoRabbitMarkSupervisor::setWinnerPosition() { + mMark->setWinnerPosition(); +} + +GeoRabbitMark::GeoRabbitMark(const CrsData::SObject &object) : GeographyObj(object) { + if (sSupervisor == nullptr) { + sSupervisor = new GeoRabbitMarkSupervisor(); + sSupervisorCreateNum = 1; + } + + createSoundMgr(); + + for (u32 i = 0; i < 4; i++) { + if (i < RaceMgr::getManager()->getConsoleNumber()) { + mShines[i] = (GeoShine*)GetGeoObjMgr()->createSubObj(0x26b4); + mShines[i]->setMark(this); + mShines[i]->setConsoleNo(i); + } + else { + mShines[i] = nullptr; + } + } + + mState = 1; + reset(); + mState = 0; + sSupervisor->entry(this); +} + +void GeoRabbitMark::reset() { + resetObject(); + _58 = 0; + setObjFlagMainResource(); + setAllCheckKartHitFlag(); + setObjFlagCheckItemHitting(); + setObjFlagSimpleDraw(); + clrObjFlagHidding(); + ResetState(); + + mIsDemoMode = false; + if (RaceMgr::getManager()->isCrsDemoMode()) { + mIsDemoMode = true; + } + mEqpSpr.zero(); + mEqpSprLength = 0.0f; + _1a0 = 0.0f; + mMarkScale = sNormalScale; + _1aa = 0; + mPrevOwnerNo = cNonOwner; + mOwnerNo = cNonOwner; + _1b0 = 0; + mWinnerPos.zero(); + _1c0 = 0; + +#line 476 + JUT_ASSERT_MSG(mObjData->pathID != 0xffff, "UNLINK PATH") + bool initialized = false; + if (mState == 0) + initialized = true; + resetPose(initialized); +} + +void GeoRabbitMark::resetPose(bool initialized) { + mVel.zero(); + if (initialized) { + CrsData::PathData *pathData = RaceMgr::getManager()->getCourse()->getCrsData()->getPathData(mObjData->pathID); + u16 pointId = getGeoRnd()->getRandom() % pathData->pointCount; + CrsData::PointData *pointData = RaceMgr::getManager()->getCourse()->getCrsData()->getPointData(mObjData->pathID, pointId); + mPos.set(pointData->pos); + } + else { + mPos.set(mObjData->position); + } + + mLfDir.set(mObjData->zNorm); + mLfDir.scale(0.0001f); + mUpDir.set(mObjData->yNorm); + mUpDir.scale(0.0001f); + mFrDir.cross(mUpDir, mLfDir); + mFrDir.normalize(); + +} + +void GeoRabbitMark::createColModel(J3DModelData *mdlData) { + createBoundsSphere(225.0f, 1.0f); +} + +void GeoRabbitMark::doKartColCallBack(const int kartNo) { + if(!tstIsHitKartFlg(kartNo)) + return; + + bool canEquip = false; + if (isNonOwner() && !GetKartCtrl()->CheckMatchless(kartNo)) { + canEquip = true; + } + + if (canEquip) { + equip(kartNo); + } +} + +void GeoRabbitMark::equip(int kartNo) { + mOwnerNo = kartNo; + mPrevOwnerNo = cNonOwner; + _1aa = 0; + setState(1); + clrAllCheckKartHitFlag(); + clrObjFlagCheckItemHitting(); +} + +void GeoRabbitMark::calc() { + if (_1aa > 0) { + _1aa--; + } + else { + mPrevOwnerNo = cNonOwner; + } + + ExecuteState(); + + if (_1c0 != 0) { + mMarkScale = 0.35f; + } + else if (getState() == 1) { + mMarkScale = sEquipScale; + } + else { + mMarkScale = sNormalScale; + } + + + mFrDir.cross(mUpDir, mLfDir); + mFrDir.normalize(); + mUpDir.cross(mLfDir, mFrDir); + mRotMtx.setXYZDir(mFrDir, mUpDir, mLfDir); + + for (u32 i = 0; i < 4; i++) { + if (mShines[i]) { + mShines[i]->move(); + } + } +} + +void GeoRabbitMark::release() { + if (getState() == 1) { + setState(2); + } +} + +void GeoRabbitMark::startFastRot() { + for(u32 i = 0; i < 4; i++) { + if (mShines[i]) { + mShines[i]->startFastRot(); + } + } +} + +void GeoRabbitMark::startWinnerEffect() { + for(u32 i = 0; i < 4; i++) { + if (mShines[i]) { + mShines[i]->enableWinEffect(); + } + } +} + +void GeoRabbitMark::setWinnerPosition() { + if (RaceMgr::getManager()->getConsoleNumber() <= 1) { + if (isRidingBossPakkun()) { + mWinnerPos.set(-100.0f, -250.0f, 60.0f); + } + else { + mWinnerPos.set(-100.0f, -160.0f, 60.0f); + } + } + else if (RaceMgr::getManager()->getConsoleNumber() <= 2) { + if (isRidingBossPakkun()) { + mWinnerPos.set(-100.0f, -230.0f, 60.0f); + } + else { + mWinnerPos.set(-100.0f, -110.0f, 60.0f); + } + } + else { + if (isRidingBossPakkun()) { + mWinnerPos.set(-100.0f, -250.0f, 60.0f); + } + else { + mWinnerPos.set(-100.0f, -140.0f, 60.0f); + } + } + + startFastRot(); + _1c0 = 1; +} + +void GeoRabbitMark::InitExec() { + Observer_FindAndInit(GeoRabbitMark, 3); +} + +void GeoRabbitMark::MoveExec() { + Observer_FindAndExec(GeoRabbitMark, 3); +} + +void GeoRabbitMark::initFuncWait() { + _1b0 = 0; +} + +void GeoRabbitMark::doFuncWait() { + JGeometry::TVec3f v; + v.scaleAdd(-sFootLength, mUpDir, mPos); + + if (!mIsDemoMode) { + mVel.y -= sGravity; + } + + v.add(mVel); + + CrsGround ground; + ground.search(v); + if (v.y < ground.getHeight()) { + v.y = ground.getHeight(); + mVel.y *= -sReflectK; + if (_1b0 < 5) { + _1b0++; + } + setBoundSE(); + } + + mPos.scaleAdd(sFootLength, mUpDir, v); + + if(isResetGndAttr(ground.getAttribute())) { + resetPose(true); + } + else if (ground.getWaterHeight() >= mPos.y) { + resetPose(true); + } +} + +bool GeoRabbitMark::isRidingBossPakkun() { + bool ret = false; + if (mOwnerNo != cNonOwner) { + KartInfo *kartInfo = RaceMgr::getManager()->getKartInfo(mOwnerNo); + for (int i = 0; i < 2; i++) { + if (kartInfo->getDriverCharID(i) == PETEY) { + ret = true; + break; + } + } + } + return ret; +} + +f32 GeoRabbitMark::getEquipOfsY() { + if (RaceMgr::getManager()->getConsoleNumber() <= 1) { + if (isRidingBossPakkun()) { + return sEquipOfsYPakkun1; + } + else { + return sEquipOfsY1; + } + } + else if (RaceMgr::getManager()->getConsoleNumber() <= 2) { + if (isRidingBossPakkun()) { + return sEquipOfsYPakkun2; + } + else { + return sEquipOfsY2; + } + } + else if (isRidingBossPakkun()) { + return sEquipOfsYPakkun34; + } + else { + return sEquipOfsY34; + } +} + +void GeoRabbitMark::initFuncEquip() { +#line 996 + JUT_ASSERT(mOwnerNo != cNonOwner); + + JGeometry::TVec3f kartPos; + ObjUtility::getKartPos(mOwnerNo, &kartPos); + ObjUtility::getKartYdir(mOwnerNo, &mUpDir); + + kartPos.scaleAdd(getEquipOfsY(), mUpDir, kartPos); + mEqpSpr.sub(mPos, kartPos); + mEqpSprLength = mEqpSpr.length(); + + if (mEqpSprLength < sEqpSprMinLength) { + mEqpSprLength = sEqpSprMinLength; + } + + mEqpSpr.normalize(); + + JGeometry::TVec3f upDir(0.0f, 1.0f, 0.0f); + if (upDir.dot(mEqpSpr) < 0.3f) { + if (mEqpSpr.y > 0.0f){ + mEqpSpr.set(0.0f,1.0f, 0.0f); + } + else { + mEqpSpr.set(0.0f,-1.0f, 0.0f); + } + } + mEqpSpr.normalize(); + + _1a0 = 0.0f; + startFastRot(); + getSoundMgr()->setSe(0x40042); +} + +void GeoRabbitMark::doFuncEquip() { + JGeometry::TVec3f kartPos; + ObjUtility::getKartPos(mOwnerNo, &kartPos); + + JGeometry::TVec3f kartYDir; + ObjUtility::getKartYdir(mOwnerNo, &kartYDir); + + mUpDir.scaleAdd(sEqpChaseRate, kartYDir, mUpDir); + mUpDir.normalize(); + kartPos.scaleAdd(getEquipOfsY(), mUpDir, kartPos); + + JGeometry::TVec3f kartZDir; + ObjUtility::getKartZdir(mOwnerNo, &kartZDir); + + JGeometry::TVec3f kartXDir; + ObjUtility::getKartXdir(mOwnerNo, &kartXDir); + + kartPos.scaleAdd(mWinnerPos.x, kartXDir, kartPos); + kartPos.scaleAdd(mWinnerPos.y, mUpDir, kartPos); + kartPos.scaleAdd(mWinnerPos.z, kartZDir, kartPos); + + _1a0 *= (1.0f - sEqpAirRegist); + f32 springK = -sEqpSpringK * mEqpSprLength; + _1a0 += springK; + mEqpSprLength += _1a0; + mPos.scaleAdd(mEqpSprLength, mEqpSpr, kartPos); +} + +void GeoRabbitMark::initFuncRelease() { + mPrevOwnerNo = mOwnerNo; + _1aa = 120; + mOwnerNo = -1; + _1b0 = 0; + + mUpDir.set(0.0f, 1.0f, 0.0f); + mVel.set(0.0f, sRelV0, 0.0f); + getSoundMgr()->setSe(0x40043); +} + +void GeoRabbitMark::doFuncRelease() { + JGeometry::TVec3f v; + v.scaleAdd(-sFootLength, mUpDir, mPos); + + CrsArea area; + area.searchRoof(v); + mVel.y -= sRelGravity; + + v.add(mVel); + if (area.isInside()) { + JGeometry::TVec3f v2; + v2.scaleAdd(sFootLength, mUpDir, v); + + JGeometry::TVec3f roofPos; + area.getRoofPosition(&roofPos); + + if (v2.y >= roofPos.y) { + v2.y = roofPos.y; + if (mVel.y > 0.0f) { + mVel.y = 0.0f; + } + v.scaleAdd(-sFootLength, mUpDir, v2); + } + } + + CrsGround ground; + ground.search(v); + if (v.y <= ground.getHeight()) { + v.y = ground.getHeight(); + mVel.y *= -sRelReflectK; + _1b0++; + + setAllCheckKartHitFlag(); + setObjFlagCheckItemHitting(); + setBoundSE(); + + if(isResetGndAttr(ground.getAttribute())) { + resetPose(true); + v.scaleAdd(-sFootLength, mUpDir, mPos); + } + if (mVel.y <= 1.0f || _1b0 >= 5) { + mVel.y = 0.0f; + setState(0); + } + } + + mPos.scaleAdd(sFootLength, mUpDir, v); + +} + +bool GeoRabbitMark::isResetGndAttr(CrsGround::EAttr attr) { + bool ret = false; + switch (attr) { + case CrsGround::Attr_5: + case CrsGround::Attr_10: + case CrsGround::Attr_14: + case CrsGround::Attr_15: + case CrsGround::Attr_255: + ret = true; + break; + } + return ret; +} + +void GeoRabbitMark::setBoundSE() { + if (mVel.y >= 1.0f) { + switch (_1b0) { + case 1: { + getSoundMgr()->setSe(0x40070); + break; + } + case 2: { + getSoundMgr()->setSe(0x40071); + break; + } + case 3: { + getSoundMgr()->setSe(0x40072); + break; + } + } + } +} + +#include "JSystem/JAudio/JASFakeMatch2.h" diff --git a/src/Kaneshige/KartChecker.cpp b/src/Kaneshige/KartChecker.cpp index caeec7e0..3ec695af 100644 --- a/src/Kaneshige/KartChecker.cpp +++ b/src/Kaneshige/KartChecker.cpp @@ -908,7 +908,7 @@ void KartChecker::setBombEvent(KartChecker::EBombEvent bombEvent, ItemObj *itemO ownerNum = itemObj->getOwnerNum(); switch (bombEvent) { - case EVENT_1: + case EVENT_1: { int increment = sBombPointCrushOneself; if (ownerNum != mTargetKartNo) increment = sBombPointAttacked; @@ -929,10 +929,12 @@ void KartChecker::setBombEvent(KartChecker::EBombEvent bombEvent, ItemObj *itemO incYourBombPoint(ownerNum, mTargetKartNo, increment); } break; - case EVENT_3: + } + case EVENT_3: { incMyBombPoint(-1, -1); break; } + } } } diff --git a/src/Kaneshige/KartDrawer.cpp b/src/Kaneshige/KartDrawer.cpp index c3e0e074..94405dae 100644 --- a/src/Kaneshige/KartDrawer.cpp +++ b/src/Kaneshige/KartDrawer.cpp @@ -146,17 +146,6 @@ void KartDrawer::create(int kartNo, int numCams, u16 numLevels, EGhostKind ghost } -//void OsageDrawBuffer::setTargetKart(short) {} - -//void OsageDrawBuffer::OsageDrawBuffer(u32) {} - - -//void DrawBuffer::create(u32) {} - -//void KartDrawer::DriverDB::~DriverDB() {} - -//void KartDrawer::DriverDB::DriverDB() {} - void KartDrawer::setAnimation() { KartLoader *kartLoader = RaceMgr::getManager()->getKartLoader(mKartNo); diff --git a/src/Kaneshige/LightMgr.cpp b/src/Kaneshige/LightMgr.cpp index e69de29b..e37927fb 100644 --- a/src/Kaneshige/LightMgr.cpp +++ b/src/Kaneshige/LightMgr.cpp @@ -0,0 +1,145 @@ +#include "Kaneshige/LightMgr.h" +#include "JSystem/JGeometry/Vec.h" +#include "JSystem/JSupport/JSUList.h" +#include "JSystem/JUtility/JUTAssert.h" +#include "Kaneshige/KartDrawer.h" +#include "Kaneshige/RaceLight.h" +#include "Kaneshige/RaceMgr.h" +#include "Yamamoto/kartCtrl.h" +#include "dolphin/gx/GXEnum.h" +#include "dolphin/gx/GXLighting.h" +#include "dolphin/gx/GXStruct.h" +#include "dolphin/mtx.h" +#include "types.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +LightMgr *LightMgr::sLightManager; + +LightObj::LightObj(const char *name) : mLink(this) { + init(name, 0xffffffff); +} + +LightObj::LightObj(const char *name, u32 viewNo) : mLink(this) { + init(name, viewNo); +} + +LightObj::~LightObj() { + if (LightMgr::getManager()) { + LightMgr::getManager()->removeLight(this); + } +} + +void LightObj::init(const char *name, u32 viewNo) { + mDrawFlags = 0; + mViewNo = viewNo; + mTagName = 0; + _34 = 0; +} + +void LtObjDiffuse::setGXObj() { +#line 242 + JUT_ASSERT(mViewMtx != 0); + + JGeometry::TVec3f lightPos; + + PSMTXMultVec(mViewMtx, &mPos, &lightPos); + + GXLightObj *lt_obj = &mLightObj; + GXInitLightPos(lt_obj, lightPos.x, lightPos.y, lightPos.z); + GXInitLightAttn(lt_obj, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f); + GXInitLightColor(lt_obj, mColor); +} + +void LtObjDiffuse::draw() { + GXLoadLightObjImm(&mLightObj, (GXLightID)(1 << mLoadNo)); +} + +void LtObjDiffuse::load(GXLightID light) { + GXLoadLightObjImm(&mLightObj, light); +} + +void LtObjAmbient::draw() { + GXSetChanAmbColor(GX_COLOR0A0, mColor); + GXSetChanAmbColor(GX_COLOR1A1, mColor); +} + +LightMgr::LightMgr() { + mCurViewNo = 0; + mLights.initiate(); + mParent = nullptr; +} + +void LightMgr::createCharColor() {} + +bool LightMgr::createManager() { + if (sLightManager == nullptr) { + sLightManager = new LightMgr(); + sLightManager->createCharColor(); + } + return false; +} + +void LightMgr::reset() {} + +void LightMgr::appendLight(LightObj *obj) { + mLights.append(&obj->mLink); +} + +void LightMgr::removeLight(LightObj *obj) { + mLights.remove(&obj->mLink); +} + +void LightMgr::draw() { + for (JSUListIterator it(mLights.getFirst()); it != mLights.getEnd(); it++) { + if (it->tstManualDraw()) + continue; + + if (it->isAllView()) { + it->draw(); + } + else if (mCurViewNo == it->getViewNo()) { + it->draw(); + } + } +} + +void LightMgr::calc() { + for (JSUListIterator it(mLights.getFirst()); it != mLights.getEnd(); it++) { + it->calc(); + it->setGXObj(); + } +} + +LightObj *LightMgr::searchLight(u32 tagName) { + LightObj *ret = nullptr; + if (tagName != 0) { + for (JSUListIterator it(mLights.getFirst()); it != mLights.getEnd(); it++) { + if (tagName == it->getTagName()) { + ret = it.getObject(); + break; + } + } + } + + return ret; +} + +RaceSceneLight *LightMgr::searchRaceSceneLight(u32 viewNo) { + // UNUSED, should call another unused function + // getTagName__14RaceSceneLightFUl +} + +RaceKartLight *LightMgr::searchRaceKartLight(u32 viewNo, int kartNo) { + // UNUSED + return RaceMgr::getManager()->getKartDrawer(kartNo)->getLight(viewNo); +} + +LightMgr::~LightMgr() { + for (JSUListIterator it(mLights.getFirst()); it != mLights.getEnd(); it++) { + mLights.remove(&it->mLink); + } + if (mParent) + delete mParent; + sLightManager = nullptr; +} diff --git a/src/Kaneshige/RaceDirector.cpp b/src/Kaneshige/RaceDirector.cpp index e69de29b..9ee7a580 100644 --- a/src/Kaneshige/RaceDirector.cpp +++ b/src/Kaneshige/RaceDirector.cpp @@ -0,0 +1,779 @@ +#include "Kaneshige/RaceDirector.h" +#include "Inagaki/GameAudioMain.h" +#include "JSystem/JUtility/TColor.h" +#include "Kameda/J2DManager.h" +#include "Kameda/PauseManager.h" +#include "Kaneshige/KartChecker.h" +#include "Kaneshige/Objects/GeoRabbitMark.h" +#include "Kaneshige/RaceMgr.h" +#include "Osako/kartPad.h" +#include "Osako/system.h" +#include "Sato/GeographyObjMgr.h" +#include "Sato/JPEffectMgr.h" +#include "Shiraiwa/MapObjHanabi.h" +#include "kartEnums.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" + +#ifdef DEBUG +u8 RaceDirector::sForceStopFrame; +s16 RaceDirector::sForceWaitDemoTime; +#endif + +s16 RaceDirector::sRace2DDelayTime = 30; +const int RaceDirector::cFadeOutTime = 35; + +RaceDirector::RaceDirector(bool waitForDemo, DemoTimeKeeper *demoTimeKeeper, int numConsoles) { + mTimeKeeper = demoTimeKeeper; + mRace2DMode = Race2DMode_0; + mRace2DDelayTime = sRace2DDelayTime; + + if (numConsoles >= 3) { + mRace2DMode = Race2DMode_1; + } + + if (waitForDemo) { + mRacePhase = PHASE_CRS_DEMO; + } + else if (RaceMgr::getManager()->isWaitDemoMode()) { + mRacePhase = PHASE_RUNNING; + } + else { + mRacePhase = PHASE_NO_CRS_DEMO; + } + + resetCommon(); + if (RaceMgr::getManager()->isStaffRoll()) { + GameAudioParameters::setDemoMode(2); + } + else { + GameAudioParameters::setDemoMode(1); + } + GameAudioParameters::setMirrorSwitch(RaceMgr::getManager()->isMirror()); + + bool isStartFade = true; + if (mTimeKeeper) { + isStartFade = mTimeKeeper->isStartFadeIn(); + } + if (isStartFade) { + SYSTEM_StartFadeIn(15); + } +} + +void RaceDirector::reset() { + mRacePhase = PHASE_3; + resetCommon(); + if (mTimeKeeper) { + mTimeKeeper->reset(); + } +} + +void RaceDirector::resetCommon() { + mRunningState = 0; + mRace2DDelayTime = sRace2DDelayTime; + mWaitDemoTimer = 0; + mWaitDemoResult = 0; + mWaitTimer = 0; + mFadeOutTime = cFadeOutTime; + mFrameRenewal = true; + _29 = 0; + mIsRaceEnd = false; + mZoomWinCnsNo = -1; + _10 = PHASE_0; + mRaceRunState = 0; + mEndingState = 0; + mPlayingWinAnm = false; + mMovingToStart = false; + _3a = false; + _3c = -1; + _3e = 0; + mMiniGameFrame = 0; + mMinigameTime.setFrame(mMiniGameFrame); +} + +void RaceDirector::appearRace2D(ERace2DMode race2dMode) { + if (!RaceMgr::getManager()->isReplayMode() && mRace2DMode == race2dMode) { + GETJ2DManager()->setRace2DDrawFlag(true); + } +} + +void RaceDirector::calc() { + bool raceEnd = false; + if (mRacePhase == PHASE_RUNNING ) { + raceEnd = checkRaceEnd(); + if (raceEnd) { + PauseManager::getManager()->setPauseEndFlag(true); + } + } + PauseManager::getManager()->exec(); + if (!PauseManager::tstPause()) { + mFrameRenewal = true; + } + else { + mFrameRenewal = false; + } + + if (mTimeKeeper) { + mTimeKeeper->calc(); + } + + switch (mRacePhase) { + case PHASE_CRS_DEMO: { + doCrsDemo(); + break; + case PHASE_NO_CRS_DEMO: { + doNoCrsDemo(); + break; + } + case PHASE_3: + case PHASE_4: + case PHASE_5: { + doReset(); + break; + } + case PHASE_RUNNING: + doRunning(raceEnd); + break; + case PHASE_ENDING: + doEnding(); + break; + case PHASE_WAIT: + doWait(); + break; + case PHASE_SAFETY: + doSafety(); + break; + } + } +} + +void RaceDirector::doCrsDemo() { + if (!RaceMgr::getManager()->isLANMode()) { + checkCrsDemoEvent(); + } + mWaitTimer++; + switch (GETJ2DManager()->getPreRaceStatus()) { + case 1: { + RaceMgr::getManager()->mRaceBGMPlayer->stopCrsDemo(); + break; + } + case 2: { + mRacePhase = PHASE_3; + GameAudioParameters::setDemoMode(0); + mWaitTimer = 0; + break; + } + } +} + +void RaceDirector::doNoCrsDemo() { + mRacePhase = PHASE_3; + RaceMgr::getManager()->mRaceBGMPlayer->stopCrsDemo(); + + if (GameAudioParameters::getDemoMode() != 2) { + GameAudioParameters::setDemoMode(0); + } +} + +void RaceDirector::checkCrsDemoEvent() { + s16 startId = RCMGetCamera(0)->GetDemoCam()->mStartId; + if (startId != _3c) { + _3c = startId; + _3e = 0; + } + + CrsData::Camera *camData =RCMGetCourse()->getCrsData()->getCameraData(startId); + if (RaceMgr::getManager()->isRaceModeGp()) { + if (RaceMgr::getManager()->getGPStageNo() == 0) { + if (camData && camData->getNextCameraID() < 0 && _3e == 0) { + GetJPAMgr()->createCupStartDemoEmt(); + } + + for (s16 i = 1; i <= 8; i++) { + checkCrsDemoEventHanabi(i); + } + } + } + + _3e++; +} + +void RaceDirector::checkCrsDemoEventHanabi(s16 idx) { + s16 fireFrame = -1; + if (TMapObjHanabi::getSupervisor()) { + fireFrame = TMapObjHanabi::getSupervisor()->getFireFrame(idx); + } + + if (fireFrame >= 0 && mWaitTimer == fireFrame) { + TMapObjHanabi::getSupervisor()->fire(idx); + } +} + +void RaceDirector::doReset() { + mRacePhase = PHASE_RUNNING; +} + +void RaceDirector::doWait() { + mWaitTimer++; + if (mWaitTimer > mFadeOutTime) { + mRacePhase = PHASE_SAFETY; + mWaitTimer = 0; + mFrameRenewal = false; + } +} + +void RaceDirector::doSafety() { + mWaitTimer++; + if (mWaitTimer <= 10) { + return; + } + + if (_10 == PHASE_0) { + mRacePhase = PHASE_6; + } + else { + mRacePhase = _10; + } + mWaitTimer = 0; + RaceMgr::getManager()->setRaceResult(); +} + +void RaceDirector::doRunning(bool raceEnd) { + if (RaceMgr::getManager()->isRaceModeMiniGame()) { + if (RaceMgr::getManager()->getRaceMode() == ESCAPE_BATTLE) { + int time = GeoRabbitMark::getSupervisor()->getWinFrame(); + for (int i = 0; i < RaceMgr::getManager()->getKartNumber(); i++) { + KartChecker *kartChecker = RaceMgr::getManager()->getKartChecker(i); + if (kartChecker->isRabbit()) { + time = kartChecker->getRabbitTimer(); + } + } + mMinigameTime.setFrame(time); + } + + } + + if (mRace2DDelayTime > 0) { + mRace2DDelayTime--; + if (mRace2DDelayTime == 0) { + appearRace2D(Race2DMode_1); + mRace2DDelayTime = -1; + } + } + + switch (mRaceRunState) { + case 0: { + if (RaceMgr::getManager()->isJugemCountStart()) { + mRaceRunState = 1; + RaceMgr::getManager()->mRaceBGMPlayer->prepare(); + appearRace2D(Race2DMode_0); + } + break; + } + case 1: { + if (RaceMgr::getManager()->isAbleStart()) { + mRaceRunState = 2; + RaceMgr::getManager()->mRaceBGMPlayer->play(); + RaceMgr::getManager()->mRaceDrawer->showAllGhost(); + } + break; + } + case 2: + break; + } + checkPauseChoice(); + + switch (mRunningState) { + case 5: { + mRacePhase = PHASE_5; + mRunningState = 0; + break; + } + case 4: { + mRacePhase = PHASE_4; + GetGameAudioMain()->fadeOutAll(cFadeOutTime); + mRunningState = 0; + break; + } + case 6: { + setPhaseWait(PHASE_6, true, true); + mRunningState = 0; + break; + } + } + + if (RaceMgr::getManager()->isWaitDemoMode()) { + if (isExitWaitDemo()) { + bool fadeAudio = false; + if (!RaceMgr::getManager()->isLastWaitDemo()) { + if (mWaitDemoResult == 2) { + fadeAudio = true; + } + } + else { + fadeAudio = false; + mWaitDemoResult = 1; + } + setPhaseWait(PHASE_6, fadeAudio, true); + } + } + else if (RaceMgr::getManager()->isAwardDemoMode() || RaceMgr::getManager()->isStaffRoll()) { + if (mTimeKeeper->isDemoEnd()) { + setPhaseWait(RaceMgr::getManager()->getDemoNextPhase(), true, true, 90); + GetGameAudioMain()->changeSection(0); + } + } + + if (raceEnd) { + mIsRaceEnd = true; + + if (!RaceMgr::getManager()->isReplayMode()) { + mRacePhase = PHASE_ENDING; + mEndingState = 1; + mWaitTimer = 0; + } + + for (int i = 0; i < RaceMgr::getManager()->getKartNumber(); i++) { + KartChecker *kartChecker = RCMGetKartChecker(i); + kartChecker->fixMiniPoint(); + if (kartChecker->getRank() != 1) { + kartChecker->setDead(); + } + } + if (RaceMgr::getManager()->isRaceModeMiniGame()) { + RCMGetCourse()->disableShaking(); + } + } +} + +s16 RaceDirector::checkZoomWinConsoleNo() { + s16 ret = RaceMgr::getManager()->getConsoleNumber() - 1; + + int maxKartIdx = RaceMgr::getManager()->getKartNumber() - 1; + for (s16 i = 0; i < RaceMgr::getManager()->getConsoleNumber(); i++) { + RaceMgr::Console *console = &RaceMgr::getManager()->mConsole[i]; + if (!console->isDemo()) { + bool winningPlayer = false; + s16 cnsTarget = console->getTargetNo(); + KartChecker *kartChecker = RCMGetKartChecker(cnsTarget); + if (kartChecker->getRank() < maxKartIdx) { + winningPlayer = true; + } + else { + + if (maxKartIdx == kartChecker->getRank() && i < ret) { + winningPlayer = true; + } + } + + if (winningPlayer) { + ret = i; + maxKartIdx = kartChecker->getRank(); + } + + } + } + return ret; +} + +bool RaceDirector::isAllGoalAnmEnd() { + bool ret = true; + + for (int i = 0; i < RaceMgr::getManager()->getConsoleNumber(); i++) { + RaceMgr::Console *console = &RaceMgr::getManager()->mConsole[i]; + if (!console->isDemo()) { + int cnsTarget = console->getTargetNo(); + KartChecker *kartChecker = RCMGetKartChecker(cnsTarget); + if (kartChecker->isGoal() && !J2DManager::getManager()->isGoalAnmEnd(i)) { + ret = false; + break; + } + } + } + return ret; +} + +void RaceDirector::doEnding() { + int oldEndState = mEndingState; + switch (mEndingState) { + case 1: { + if (!RaceMgr::getManager()->isRaceModeMiniGame()) { + mEndingState = 2; + } + else { + mEndingState = 5; + } + mWaitTimer = 0; + break; + } + case 2: { + bool endRace = false; + if (RaceMgr::getManager()->isLANMode()) { + mWaitTimer++; + if (mWaitTimer >= 300) { + endRace = true; + GETPauseManager()->setGameOverFlag(true); + } + } + else { + endRace = isAllGoalAnmEnd(); + } + + if (endRace) { + J2DManager::getManager()->hideRace2D(); + mEndingState = 3; + } + break; + } + case 3: { + if (J2DManager::getManager()->isHideRace2D()) { + if (RaceMgr::getManager()->isLANMode()) { + for (int i = 0; i < RaceMgr::getManager()->getKartNumber(); i++) { + if (RCMGetKartChecker(i)->getRank() == 1) { + J2DManager::getManager()->startLANResultAnm(i); + J2DManager::getManager()->startLANNumResultAnm(); + break; + } + } + } + setEndingPhaseZoomConsole(); + } + break; + } + case 4: { + bool isWinConsole = true; + if (isZoomWinConsole() && RaceMgr::getManager()->getConsoleNumber() > 1) { + isWinConsole = GetKartCtrl()->CheckZoomWinConsole(); + } + if (isWinConsole) { + mWaitTimer++; + } + int waitTimeEnd = 60; + if (RaceMgr::getManager()->isLANMode()) { + waitTimeEnd = 180; + } + if (mWaitTimer >= waitTimeEnd) { + mEndingState = 7; + mWaitTimer = 0; + PauseManager::getManager()->setResultStartFlag(true); + } + + break; + } + case 5: { + if (mWaitTimer == 0) { + mPlayingWinAnm = true; + } + else if (mWaitTimer >= 30) { + mEndingState = 6; + mWaitTimer = 0; + } + if (mEndingState == oldEndState) { + mWaitTimer++; + } + break; + } + case 6: { + int waitTimeEnd = 110; + if (RaceMgr::getManager()->isLANMode()) { + waitTimeEnd = 270; // whoa mkw mt charge value + } + + if (mWaitTimer == 0) { + for (int i = 0; i < RaceMgr::getManager()->getKartNumber(); i++) { + if (RCMGetKartChecker(i)->getRank() == 1) { + GETJ2DManager()->startWinnerAnm(i); + } + } + RaceMgr::getManager()->mRaceBGMPlayer->setMiniGameEnd(); + } + else if (mWaitTimer == 70) { + J2DManager::getManager()->hideRace2D(); + } + else if (mWaitTimer == 90) { + mMovingToStart = true; + _3a = true; + for (int i = 0; i < RaceMgr::getManager()->getKartNumber(); i++) { + if (GetGeoObjMgr()->getBalloonMgr(i)) { + GetGeoObjMgr()->getBalloonMgr(i)->changeWinningPos(); + } + } + + if (GeoRabbitMark::getSupervisor()) { + GeoRabbitMark::getSupervisor()->setWinnerPosition(); + } + + if (RaceMgr::getManager()->isLANMode()) { + for (int i = 0; i < RaceMgr::getManager()->getKartNumber(); i++) { + if (RCMGetKartChecker(i)->getRank() == 1) { + J2DManager::getManager()->startLANResultAnm(i); + J2DManager::getManager()->startLANNumResultAnm(); + break; + } + } + } + } + else if (mWaitTimer >= waitTimeEnd) { + setEndingPhaseZoomConsole(); + if (RaceMgr::getManager()->isLANMode()) { + GETPauseManager()->setGameOverFlag(true); + } + } + if (mEndingState == oldEndState) { + mWaitTimer++; + } + break; + } + case 7: { + checkPauseChoice(); + break; + } + + } +} + +void RaceDirector::setEndingPhaseZoomConsole() { + mEndingState = 4; + mWaitTimer = 0; + if (!RaceMgr::getManager()->isLANMode()) { + mZoomWinCnsNo = checkZoomWinConsoleNo(); + } +} + +void RaceDirector::checkPauseChoice() { + switch(PauseManager::getPauseChoice()) { + case 1: + mRacePhase = PHASE_4; + break; + case 7: + mRacePhase = PHASE_5; + break; + case 4: { + setPhaseWait(PHASE_7, true, true); + break; + } + + case 2: + setPhaseWait(PHASE_8, true, true); + break; + case 3: + setPhaseWait(PHASE_14, true, true); + break; + case 6: + setPhaseWait(PHASE_15, true, true); + break; + case 9: + setPhaseWait(PHASE_10, true, true); + break; + case 5: + setPhaseWait(PHASE_11, true, true); + break; + case 11: + setPhaseWait(PHASE_11, true, true); + GetGameAudioMain()->changeSection(2); + break; + case 12: { + bool fadeAudio = true; + if (GetGameAudioMain()->getPlayingStreamID() == 0x2000022) + fadeAudio = false; + setPhaseWait(PHASE_11, fadeAudio, true); + GetGameAudioMain()->changeSection(2); + break; + } + case 8: + setPhaseWait(PHASE_6,true, false); + break; + case 10: + setPhaseWait(PHASE_13, true, true); + break; + } +} + +bool RaceDirector::isExitWaitDemo() { + u32 waitTimeFrames = 1800; + if (sForceWaitDemoTime != 0) { + waitTimeFrames = sForceWaitDemoTime * 60u; + } + + bool skip = false; + mWaitDemoTimer++; + if (mWaitDemoTimer >= 60u) { + if (gGamePad1P.testTrigger(KartGamePad::A | KartGamePad::START)) { + skip = true; + mWaitDemoResult = 1; + } + } + + if (!skip && mWaitDemoTimer >= waitTimeFrames) { + skip = true; + mWaitDemoResult = 2; + } + return skip; +} + +void RaceDirector::setPhaseWait(ERacePhase phase, bool fadeAudio, bool fadeVideo, int fadeOutTime) { + mRacePhase = PHASE_WAIT; + _10 = phase; + mWaitTimer = 0; + mFadeOutTime = fadeOutTime; + + JUTColor fadeColor(0x00, 0x00, 0x00, 0xff); + SYSTEM_GetFader()->setColor(fadeColor); + + if (fadeVideo) { + SYSTEM_StartFadeOut(mFadeOutTime); + } + else { + PauseManager::getManager()->wipeOut(mFadeOutTime); + } + + if (fadeAudio) { + GetGameAudioMain()->fadeOutAll(mFadeOutTime); + } + + switch (phase) { + case PHASE_9: + case PHASE_11: + break; + case PHASE_6: + case PHASE_7: + case PHASE_8: + case PHASE_10: + case PHASE_13: + case PHASE_14: + case PHASE_15: { + GetGameAudioMain()->changeSection(0); + break; + } + } +} + +bool RaceDirector::checkRaceEnd() { + bool ret = false; + + if (!RaceMgr::getManager()->isWaitDemoMode()) { + switch(RaceMgr::getManager()->getRaceMode()) { + case BALLOON_BATTLE: { + ret = checkRaceEndForBalloonBattle(); + break; + } + case ROBBERY_BATTLE: { + if (mMiniGameFrame <= 0) { + ret = true; + } + break; + } + case BOMB_BATTLE: { + ret = checkRaceEndForBombBattle(); + break; + } + case ESCAPE_BATTLE: { + ret = checkRaceEndForEscapeBattle(); + break; + } + case TIME_ATTACK: { + if (RaceMgr::getManager()->getKartChecker(0)->isGoal()) { + ret = true; + } + break; + } + case AWARD_DEMO: { + break; + } + default: { + ret = checkRaceEndForRace(); + break; + } + } + } + return ret; +} + +bool RaceDirector::checkRaceEndForRace() { + bool ret = true; + + if (RaceMgr::getManager()->getKartInfo(0)->isPlayerKart() && RaceMgr::getManager()->mRaceInfo->getPlayerKartNumber() != RaceMgr::getManager()->getKartNumber() || RaceMgr::getManager()->getKartNumber() == 1) { + int playersNotFinished = 0; + for (int i = 0; i < RaceMgr::getManager()->getKartNumber(); i++) { + KartInfo *kartInfo = RaceMgr::getManager()->getKartInfo(i); + KartChecker *kartChecker = RaceMgr::getManager()->getKartChecker(i); + if (kartInfo->isPlayerKart() && !kartChecker->isGoal()) { + playersNotFinished++; + } + } + + if (playersNotFinished > 0) { + ret = false; + } + } + + else if (RaceMgr::getManager()->getGoalKartNumber() < RaceMgr::getManager()->getKartNumber() - 1) { + ret = false; + } + + return ret; +} + +bool RaceDirector::checkRaceEndForBalloonBattle() { + bool ret = false; + int balloonNum = 0; + for (int i = 0; i < RaceMgr::getManager()->getKartNumber(); i++) { + if (RaceMgr::getManager()->getKartChecker(i)->getBalloonNumber() > 0) { + balloonNum++; + } + } + + if (balloonNum <= 1) + ret = true; + return ret; +} + +bool RaceDirector::checkRaceEndForBombBattle() { + bool ret = false; + int bombPoints = 0; + for (int i = 0; i < RaceMgr::getManager()->getKartNumber(); i++) { + if (RaceMgr::getManager()->getKartChecker(i)->isBombPointFull()) { + bombPoints++; + } + } + + if (bombPoints > 0) + ret = true; + return ret; +} + +bool RaceDirector::checkRaceEndForEscapeBattle() { + bool ret = false; + + for (int i = 0; i < RaceMgr::getManager()->getKartNumber(); i++) { + if (RaceMgr::getManager()->getKartChecker(i)->isRabbitWinner()) { + ret = true; + break; + } + } + return ret; +} + +int RaceDirector::requestDemoCameraID() const { + int ret = -1; + if (mTimeKeeper) { + ret = mTimeKeeper->requestDemoCameraID(); + } + return ret; +} + +bool RaceDirector::isPlayingDemoWinnerAnm() const { + bool ret = false; + if (mTimeKeeper) { + ret = mTimeKeeper->isPlayingEndingWinAnm(); + } + return ret; +} + +u32 RaceDirector::getDemoCameraTagName() const { + u32 ret = 0; + if (mTimeKeeper) { + ret = mTimeKeeper->getDemoCameraTagName(); + } + return ret; +} diff --git a/src/Kaneshige/RaceDrawBuffer.cpp b/src/Kaneshige/RaceDrawBuffer.cpp index e69de29b..d86ee26f 100644 --- a/src/Kaneshige/RaceDrawBuffer.cpp +++ b/src/Kaneshige/RaceDrawBuffer.cpp @@ -0,0 +1,138 @@ +#include "Kaneshige/DrawBuffer.h" + +#include "JSystem/JAudio/JASFakeMatch2.h" +#include "Kaneshige/KartLoader.h" +#include "Kaneshige/RaceMgr.h" +#include "Kawano/feeling.h" +#include "Sato/GeographyObjMgr.h" +#include "Sato/ItemObjMgr.h" +#include "Sato/J3DEffectMgr.h" +#include "Sato/stEffectMgr.h" + + +void ShadowGeoDrawBuffer::drawIn(u32 viewNo) { + GetGeoObjMgr()->setCurrentViewNo_groundObj(viewNo); +} + +void ShadowGeoDrawBuffer::update() { + DrawBuffer::update(); + GetGeoObjMgr()->update_groundObj(); + DrawBuffer::lock(); +} + +void ShadowGeoDrawBuffer::viewCalc(u32 viewNo) { + GetGeoObjMgr()->viewCalc_groundObj(viewNo); +} + +void GeoDrawBuffer::drawIn(u32 viewNo) { + GetGeoObjMgr()->setCurrentViewNo(viewNo); +} + +void GeoDrawBuffer::update() { + DrawBuffer::update(); + GetGeoObjMgr()->update(); + DrawBuffer::lock(); +} + +void GeoDrawBuffer::viewCalc(u32 viewNo) { + GetGeoObjMgr()->viewCalc(viewNo); +} + +void JugemDrawBuffer::drawIn(u32 viewNo) { + GetGeoObjMgr()->setCurrentViewNo_foreground(viewNo); + int kartNum = GetGeoObjMgr()->getJugem(viewNo)->getKartNum(); + RaceMgr::getManager()->getKartDrawer(kartNum)->getLight(viewNo)->draw(); + + if (GetGeoObjMgr()->getJugem(viewNo)->isAllShapePacketHidding(viewNo)) { + DrawBuffer::clrDraw(); + } +} + +void JugemDrawBuffer::update() { + DrawBuffer::update(); + GetGeoObjMgr()->update_foreground(); + DrawBuffer::lock(); +} + +void JugemDrawBuffer::viewCalc(u32 viewNo) { + GetGeoObjMgr()->viewCalc_foreground(viewNo); +} + +void ItemDrawBuffer::drawIn(u32 viewNo) { + if (mTargetKart == -1) { + GetItemObjMgr()->setCurrentViewNo(viewNo); + } +} + +void ItemDrawBuffer::update() { + DrawBuffer::update(); + ItemObjMgr::eDrawSimplModelItemType type = ItemObjMgr::ItemType_2; + if (RaceMgr::getManager()->isActiveAreaLight()) { + if (mTargetKart >= 0) { + type = ItemObjMgr::ItemType_1; + } + } + else { + type = ItemObjMgr::ItemType_0; + } + + GetItemObjMgr()->update(type, mTargetKart); +} + +void ItemDrawBuffer::viewCalc(u32 viewNo) { + if (mTargetKart == -1) { + GetItemObjMgr()->viewCalc(viewNo); + } +} + +void EffectDrawBuffer::drawIn(u32 viewNo) { + GetStEfctMgr()->setCurrentViewNo(viewNo); + GetJ3DEfctMgr()->setCurrentViewNo(viewNo); +} + +void EffectDrawBuffer::update() { + DrawBuffer::update(); + GetStEfctMgr()->update(); + GetJ3DEfctMgr()->update(); +} + +void EffectDrawBuffer::viewCalc(u32 viewNo) { + GetStEfctMgr()->viewCalc(viewNo); + GetJ3DEfctMgr()->viewCalc(viewNo); +} + +void FeelDrawBuffer::drawIn(u32 viewNo) { + FeelingMgr::ptr()->setCurrentViewNo(viewNo); +} + +void FeelDrawBuffer::update() { + DrawBuffer::update(); + FeelingMgr::ptr()->update(); + DrawBuffer::lock(); +} + +void FeelDrawBuffer::viewCalc(u32 viewNo) {} + +void OsageDrawBuffer::drawIn(u32 viewNo) { + KartLoader *kartLoader = RCMGetKartLoader(mTargetKart); + for (int i = 0; i < 2; i++) { + ExModel *osageMdl = kartLoader->getExModelOsage(i); + if (osageMdl) { + osageMdl->setCurrentViewNo(viewNo); + } + } +} + +void OsageDrawBuffer::update() { + DrawBuffer::update(); + KartLoader *kartLoader = RCMGetKartLoader(mTargetKart); + for (int i = 0; i < 2; i++) { + ExModel *osageMdl = kartLoader->getExModelOsage(i); + if (osageMdl) { + osageMdl->update(0); + } + } + DrawBuffer::lock(); +} + +void OsageDrawBuffer::viewCalc(u32 viewNo) {} diff --git a/src/Kaneshige/RaceDrawer.cpp b/src/Kaneshige/RaceDrawer.cpp index e69de29b..1e4bfc2d 100644 --- a/src/Kaneshige/RaceDrawer.cpp +++ b/src/Kaneshige/RaceDrawer.cpp @@ -0,0 +1,472 @@ +#include "Kaneshige/RaceDrawer.h" + +#include "Kameda/J2DManager.h" +#include "Kameda/PauseManager.h" +#include "Kaneshige/Blurscreen.h" +#include "Kaneshige/GhostScreen.h" +#include "Kaneshige/KartDrawer.h" +#include "Kaneshige/LightMgr.h" +#include "Kaneshige/MaskScreen.h" +#include "Kaneshige/RaceLight.h" +#include "Kaneshige/RaceMgr.h" +#include "Kaneshige/Objects/GeoShimmer.h" +#include "Kaneshige/Objects/GeoVision.h" +#include "Kawano/accessory.h" +#include "Osako/shadowMgr.h" +#include "Osako/shadowModel.h" +#include "Osako/shadowScr.h" +#include "Osako/system.h" +#include "Sato/GeographyObjMgr.h" +#include "Sato/ItemObjMgr.h" +#include "Sato/JPEffectMgr.h" +#include "Sato/EffectScreen.h" +#include "Sato/stEffectMgr.h" +#include "Shiraiwa/Balloon.h" +#include "Shiraiwa/LensFlare.h" +#include "Shiraiwa/MapObjAward.h" +#include "Shiraiwa/ZCaptureMgr.h" +#include "dolphin/gx/GXEnum.h" +#include "dolphin/gx/GXPixel.h" +#include "kartEnums.h" +#include "types.h" + +u8 RaceDrawer::sBlurA0 = 0x80; +u8 RaceDrawer::sBlurDefaultDecrease = 0xfa; // 250 +f32 RaceDrawer::sBlurAddY = -0.5f; +f32 RaceDrawer::sBlurAddX = 0.0f; +JUTColor RaceDrawer::sBlurDefaultColor(0xff,0xfa,0xff,0xff); +EGhostKind RaceDrawer::sForceGhostKind = KIND_0; + +#include "JSystem/JAudio/JASFakeMatch2.h" + +RaceDrawer::RaceDrawer(u16 numLevels, bool staffRoll) { + RaceMgr *rcm = RaceMgr::getManager(); // Kaneshige saving the RaceMgr instance? Am i dreaming?? + + mOrtho = new J2DOrthoGraph(System::getOrthoL(), System::getOrthoT(), System::getOrthoR(), System::getOrthoB(), -1000.0f, 1000.0f); + + _4 = -1; + mDrawFlags = 0xffff; + mShdwDrawBuf = new ShadowGeoDrawBuffer(); + mGeoDrawBuf = new GeoDrawBuffer(); + + for (int i = 0; i < 8; i++) { + if (i < rcm->getKartNumber()) { + mItmDrawBufs[i] = new ItemDrawBuffer(); + mItmDrawBufs[i]->setTargetKart(i); + } + else { + mItmDrawBufs[i] = nullptr; + } + } + + mItmDrawBuf = new ItemDrawBuffer(); + mEfctDrawBuf = new EffectDrawBuffer(); + mJugemDrawBuf = new JugemDrawBuffer(); + mFeelDrawBuf = new FeelDrawBuffer(); + + new DarkAnmMgr(); + mKartNum = rcm->getKartNumber(); + mKartDrawer = new KartDrawer[mKartNum]; + for (int i = 0; i < mKartNum; i++) { + EGhostKind ghostKind = rcm->getKartInfo(i)->getGhostKind(); + if (sForceGhostKind != KIND_0) { + ghostKind = sForceGhostKind; + } + + mKartDrawer[i].create(i, rcm->getCameraNumber(), numLevels, ghostKind); + + if (rcm->isCrsDemoMode()) { + mKartDrawer[i].lodOff(); + } + + } + + if (staffRoll) { + mBlurScreen = new BlurScreen(); + } + else { + mBlurScreen = nullptr; + } + + if (rcm->getRaceMode() == TIME_ATTACK) { + mGhostScreen = new GhostScreen(); + } + else { + mGhostScreen = nullptr; + } + + mShadowScreen = new ShadowScreen(); + mCaptureMgr = new ZCaptureMgr(RaceMgr::getManager()->getConsoleNumber()); // hey, you forgot to use the copy! + + if (staffRoll) { + mMaskScreen = new MaskScreen(); + } + else { + mMaskScreen = nullptr; + } + + mBlurDecrease = sBlurDefaultDecrease; + mBlurColor.set(sBlurDefaultColor); +} + +void RaceDrawer::reset() { + RaceMgr *rcm = RaceMgr::getManager(); // again?? + + mDrawFlags = 0xffff; + + mShdwDrawBuf->reset(); + mGeoDrawBuf->reset(); + + for (int i = 0; i < rcm->getKartNumber(); i++) { + mItmDrawBufs[i]->reset(); + } + + mItmDrawBuf->reset(); + mEfctDrawBuf->reset(); + mJugemDrawBuf->reset(); + mFeelDrawBuf->reset(); + + for (int i = 0; i < rcm->getKartNumber(); i++) { + mKartDrawer[i].reset(); + } + + if (isGhostActive()) { + mGhostScreen->reset(); + mGhostScreen->hide(); + } + mCaptureMgr->reset(); + + mBlurDecrease = sBlurDefaultDecrease; + mBlurColor.set(sBlurDefaultColor); +} + +void RaceDrawer::initJ3D() { + j3dSys.drawInit(); + j3dSys.setTexCacheRegion(GX_TEXCACHE_128K); +} + +void RaceDrawer::drawSceneFirstStage(u32 viewNo) { + RaceMgr *rcm = RaceMgr::getManager(); + u32 tagName = RaceSceneLight::getSceneLightTagName(viewNo); + RaceSceneLight *sceneLight = (RaceSceneLight*)LightMgr::getManager()->searchLight(tagName); + j3dSys.setViewMtx(rcm->getCamera(viewNo)->GetMtx()); + LightMgr::getManager()->setCurrentViewNo(viewNo); + LightMgr::getManager()->draw(); + KartCtrl::getKartCtrl()->DrawKartInit(viewNo); + initJ3D(); + + rcm->beginProcTime(0); + if (isDrawSky()) { + rcm->getCourse()->drawSky(viewNo); + } + rcm->endProcTime(0); + + rcm->beginProcTime(1); + if (isDrawCrs()) { + rcm->getCourse()->drawNormal(viewNo); + } + rcm->endProcTime(1); + + getShadowGeoDrawBuffer()->draw(viewNo); + GetGeoObjMgr()->drawSimpleModel_groundObj(viewNo); + + rcm->beginProcTime(13); + mCaptureMgr->capture(viewNo); + rcm->endProcTime(13); + + rcm->beginProcTime(3); + ShadowManager::ptr()->drawShadowVolume(viewNo, ShadowModel::cShadowKind_Kart); + rcm->endProcTime(3); + + rcm->beginProcTime(5); + if (isDrawKart()) { + for (int i = 0; i < rcm->getKartNumber(); i++) { + getKartDrawer(i)->drawKartFirstStage(viewNo); + } + } + + ShadowManager::ptr()->drawShadowVolume(viewNo, ShadowModel::cShadowKind_Geo); + + if (isDrawDriver()) { + for (int i = 0; i < rcm->getKartNumber(); i++) { + getKartDrawer(i)->drawDriverFirstStage(viewNo); + } + } + rcm->endProcTime(5); + + LightMgr::getManager()->searchLight(0x414d4249)->draw(); // AMBI + + rcm->beginProcTime(6); + ShadowManager::ptr()->drawShadowVolume(viewNo, ShadowModel::cShadowKind_2); + rcm->endProcTime(6); + + rcm->beginProcTime(7); + if (isDrawItem()) { + GXSetAlphaUpdate(GX_TRUE); + sceneLight->load(GX_LIGHT1); + getItemDrawBuffer(-1)->drawOpa(viewNo); + if (RaceMgr::getManager()->isActiveAreaLight()) { + for (int i = 0; i < rcm->getKartNumber(); i++) { + getKartDrawer(i)->getLight(viewNo)->draw(); + getItemDrawBuffer(i)->drawOpa(viewNo); + } + } + + GXSetAlphaUpdate(GX_FALSE); + if (RaceMgr::getManager()->isActiveAreaLight()) { + for (int i = 0; i < rcm->getKartNumber(); i++) { + getKartDrawer(i)->getLight(viewNo)->draw(); + getItemDrawBuffer(i)->drawXlu(viewNo); + } + } + + sceneLight->load(GX_LIGHT1); + getItemDrawBuffer(-1)->drawXlu(viewNo); + GXSetAlphaUpdate(GX_TRUE); + if (RaceMgr::getManager()->isActiveAreaLight()) { + for (int i = 0; i < rcm->getKartNumber(); i++) { + if (!rcm->getKartInfo(i)->isGhostKart()) { + LightObj *lightObj = getKartDrawer(i)->getLight(viewNo); + lightObj->draw(); + GetItemObjMgr()->drawSimpleModel(viewNo, ItemObjMgr::ItemType_1, i, lightObj); + } + } + } + + sceneLight->load(GX_LIGHT1); + LightMgr::getManager()->searchLight(0x414d4249)->draw(); //AMBI + if (RaceMgr::getManager()->isActiveAreaLight()) { + GetItemObjMgr()->drawSimpleModel(viewNo, ItemObjMgr::ItemType_2, -1, sceneLight); + } + else { + GetItemObjMgr()->drawSimpleModel(viewNo, ItemObjMgr::ItemType_0, -1, sceneLight); + } + } + rcm->endProcTime(7); + + rcm->beginProcTime(2); + if (isDrawGeoObj()) { + getGeoDrawBuffer()->drawOpa(viewNo); + GetGeoObjMgr()->drawSimpleModel(viewNo); + GXSetAlphaUpdate(GX_FALSE); + getGeoDrawBuffer()->drawXlu(viewNo); + + if (TBalloonString::getSupervisor()) { + TBalloonString::getSupervisor()->drawBalloon(viewNo); + } + GXSetAlphaUpdate(GX_TRUE); + } + rcm->endProcTime(2); + + if (isDrawJugem()) { + getJugemDrawBuffer()->drawOpa(viewNo); + } + + GXSetAlphaUpdate(GX_FALSE); + + if (isDrawJugem()) { + getJugemDrawBuffer()->drawXlu(viewNo); + } + + if (isDrawCrs()) { + rcm->getCourse()->drawHigh(viewNo); + } + + GXSetAlphaUpdate(GX_TRUE); + + ShadowManager::ptr()->drawShadowVolume(viewNo, ShadowModel::cShadowKind_SkyShip); + rcm->beginProcTime(8); + getEffectDrawBuffer()->draw(viewNo); + rcm->endProcTime(8); + + getFeelDrawBuffer()->draw(viewNo); + j3dSys.reinitGX(); + GetGeoObjMgr()->drawGXObj(viewNo); + GetGeoObjMgr()->drawPrim(viewNo); + GetItemObjMgr()->drawColModel(viewNo); + rcm->getCourse()->drawModelForDebug(viewNo); +} + +void RaceDrawer::drawMidScene() { + RaceMgr *rcm = RaceMgr::getManager(); + rcm->beginProcTime(10); + mShadowScreen->draw(); + rcm->endProcTime(10); + + if (isGhostActive() && !mGhostScreen->isHide() && isDrawGhostScene()) { + GXSetColorUpdate(GX_FALSE); + GXSetAlphaUpdate(GX_TRUE); + GXSetZMode(GX_TRUE, GX_LEQUAL, GX_FALSE); + mGhostScreen->captureScene(); + GXSetColorUpdate(GX_TRUE); + GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE); + drawGhost(); + j3dSys.reinitGX(); + GXSetAlphaUpdate(GX_FALSE); + mGhostScreen->captureGhost(); + mOrtho->setPort(); + mGhostScreen->draw(); + } +} + +void RaceDrawer::drawSceneSecondStage(u32 viewNo) { + RaceMgr *rcm = RaceMgr::getManager(); + bool isSecondStage = false; + + for (int i = 0; i < rcm->getKartNumber(); i++) { + if (getKartDrawer(i)->isSecondStage()) { + isSecondStage = true; + break; + } + } + GetEfctScreenMgr()->draw_demoScreen(viewNo); + KartCtrl::getKartCtrl()->DrawKartInit(viewNo); + + rcm->beginProcTime(9); + GetStEfctMgr()->draw(viewNo); + GetJPAMgr()->draw(viewNo); + rcm->endProcTime(9); + + if (!isSecondStage) { + j3dSys.setViewMtx(rcm->getCamera(viewNo)->GetMtx()); + LightMgr::getManager()->setCurrentViewNo(viewNo); + LightMgr::getManager()->draw(); + initJ3D(); + AccessoryMgr::ptr()->setCurrentViewNo(viewNo); + AccessoryMgr::ptr()->simpleDraw(viewNo); + j3dSys.reinitGX(); + } + + if (TLensFlare::getSupervisor()) { + TLensFlare::getSupervisor()->draw((u8)viewNo); + } + rcm->beginProcTime(11); + GetEfctScreenMgr()->draw_middle(viewNo); + GetEfctScreenMgr()->draw(viewNo); + rcm->endProcTime(11); + + bool secondStageOrAward = false; + bool awardMode = false; + if (RaceMgr::getManager()->isAwardDemoMode()) { + j3dSys.setViewMtx(rcm->getCamera(viewNo)->GetMtx()); + LightMgr::getManager()->searchLight(RaceCupLight::getTagName(viewNo))->draw(); + KartCtrl::getKartCtrl()->DrawKartInit(viewNo); + initJ3D(); + + if (isDrawCup()) { + TMapObjAwardCup::sSupervisor->draw(viewNo); + } + LightMgr::getManager()->searchLight(0x414d4249)->draw(); // AMBI + awardMode = true; + secondStageOrAward = true; + } + if (isSecondStage) { + if (!awardMode) { + j3dSys.setViewMtx(rcm->getCamera(viewNo)->GetMtx()); + LightMgr::getManager()->setCurrentViewNo(viewNo); + LightMgr::getManager()->draw(); + KartCtrl::getKartCtrl()->DrawKartInit(viewNo); + initJ3D(); + } + for (int i = 0; i < rcm->getKartNumber(); i++) { + getKartDrawer(i)->drawKartSecondStage(viewNo); + } + for (int i = 0; i < rcm->getKartNumber(); i++) { + getKartDrawer(i)->drawDriverSecondStage(viewNo); + } + secondStageOrAward = true; + } + if (secondStageOrAward) { + j3dSys.reinitGX(); + } + if (!secondStageOrAward) { + KartCtrl::getKartCtrl()->DrawKartInit(viewNo); + } + GetJPAMgr()->draw_thunder(viewNo); +} + +bool RaceDrawer::drawPreScene() { + if (isBlurActive()) { + drawSceneFirstStage(0); + mBlurScreen->captureScene(); + mBlurScreen->draw(mBlurColor, sBlurA0, mBlurDecrease, sBlurAddX, sBlurAddY); + mBlurScreen->captureBlur(); + } + GXSetAlphaUpdate(FALSE); + ShadowManager::ptr()->setDstAlpha(); + return false; +} + +void RaceDrawer::drawPostScene() { + if (GeoVision::getGeoVisionSupervisor()) { + GeoVision::getGeoVisionSupervisor()->capture(); + } + mOrtho->setPort(); + + if (GeoShimmer::getSupervisor()) { + GeoShimmer::getSupervisor()->drawScreen(); + } + + if (isMaskActive()) { + mMaskScreen->capture(); + } + mOrtho->setPort(); + + GetJPAMgr()->draw_forBefore2D(); + for (u8 i = 0; i < RaceMgr::getManager()->getCameraNumber(); i++) { + GetJPAMgr()->draw_forBefore2D(i); + } + + RaceMgr::getManager()->beginProcTime(12); + J2DManager::getManager()->draw(); + RaceMgr::getManager()->endProcTime(12); + + if (RaceMgr::getManager()->getStaffRoll2D()) { + RaceMgr::getManager()->getStaffRoll2D()->draw(); + } + + if (isMaskActive()) { + getMaskScreen()->draw(); + } + mOrtho->setPort(); + + GetJPAMgr()->draw_for2D(); + PauseManager::getManager()->draw(); + + if (RaceMgr::getManager()->getAward2D()) { + RaceMgr::getManager()->getAward2D()->draw(); + } +} + +void RaceDrawer::drawGhost() { + RaceMgr *rcm = RaceMgr::getManager(); + j3dSys.setViewMtx(rcm->getCamera(0)->GetMtx()); + LightMgr::getManager()->setCurrentViewNo(0); + LightMgr::getManager()->draw(); + + KartCtrl::getKartCtrl()->DrawKartInit(0); + initJ3D(); + + for (int i = 0; i < rcm->getKartNumber(); i++) { + GXSetDstAlpha(GX_TRUE, 0xff - getKartDrawer(i)->getGhostAlpha()); + getKartDrawer(i)->drawKartGhostStage(0); + getKartDrawer(i)->drawDriverGhostStage(0); + } + + for (int i = 0; i < rcm->getKartNumber(); i++) { + if (rcm->getKartInfo(i)->isGhostKart()) { + GXSetDstAlpha(GX_TRUE, 0xff - getKartDrawer(i)->getGhostAlpha()); + RaceKartLight *light = getKartDrawer(i)->getLight(0); + light->draw(); + GetItemObjMgr()->drawSimpleModel(0, ItemObjMgr::ItemType_1, i, light); + } + } + + GXSetDstAlpha(GX_TRUE, 0); +} + +void RaceDrawer::showAllGhost() { + if (isGhostActive()) { + mGhostScreen->show(); + } +} diff --git a/src/Kaneshige/RaceInfo.cpp b/src/Kaneshige/RaceInfo.cpp index 280d69a3..04ef7d2f 100644 --- a/src/Kaneshige/RaceInfo.cpp +++ b/src/Kaneshige/RaceInfo.cpp @@ -87,7 +87,7 @@ void RaceInfo::reset() } mAwardKartNo = -1; - mDemoNextPhase = 6; + mDemoNextPhase = PHASE_6; } void RaceInfo::setConsoleTarget(int cnsNo, int target, bool demo) @@ -276,14 +276,14 @@ void RaceInfo::setRaceLevel(ERaceLevel raceLvl) void RaceInfo::shuffleRandomSeed() { - JMath::TRandom_ rndm(mRandomSeed); + JMARandFast rndm(mRandomSeed); mRandomSeed = rndm.get(); // randomSeed = JMath::TRandom_(randomSeed).get(); } void RaceInfo::shuffleStartNo() { - JMath::TRandom_ rndm(mRandomSeed); + JMARandFast rndm(mRandomSeed); for (u32 i = 0; i < (u32)getKartNumber(); i++) { diff --git a/src/Kaneshige/RaceMgr.cpp b/src/Kaneshige/RaceMgr.cpp index ad4d9d0e..4f5eebab 100644 --- a/src/Kaneshige/RaceMgr.cpp +++ b/src/Kaneshige/RaceMgr.cpp @@ -156,7 +156,7 @@ RaceMgr::RaceMgr(RaceInfo *raceInfo) : mRaceInfo(nullptr), if (getProcLevel() <= 0) activeAreaLight(); - bool hasRacePhase = false; + bool waitForDemo = false; if (!isWaitDemoMode()) { switch (getRaceMode()) @@ -166,7 +166,7 @@ RaceMgr::RaceMgr(RaceInfo *raceInfo) : mRaceInfo(nullptr), case ROBBERY_BATTLE: case BOMB_BATTLE: case ESCAPE_BATTLE: - hasRacePhase = true; + waitForDemo = true; break; } } @@ -177,7 +177,7 @@ RaceMgr::RaceMgr(RaceInfo *raceInfo) : mRaceInfo(nullptr), else if (isStaffRoll()) timeKeeper = new StaffRollTimeKeeper(); - mRaceDirector = new RaceDirector(hasRacePhase, timeKeeper, getConsoleNumber()); + mRaceDirector = new RaceDirector(waitForDemo, timeKeeper, getConsoleNumber()); u16 numLevels = 1; if (mRaceInfo->isDriverLODOn()) @@ -1605,7 +1605,7 @@ RaceMgr::Console::Console() { mCnsNo = -1; mTargetNo = -1; - _04 = false; + mIsDemo = false; mFlags = 0; mFlags |= 8; } @@ -1615,7 +1615,7 @@ void RaceMgr::Console::changeTargetNo(int targetNo, bool p2) if (isValid()) { mTargetNo = targetNo; - _04 = p2; + mIsDemo = p2; RCMGetCamera(mCnsNo)->SetTargetNum(mTargetNo); if (!isNoStat()) J2DManager::getManager()->setStatus2Kart(mCnsNo, mTargetNo); @@ -1684,7 +1684,7 @@ void RaceUsrPage::draw() for (int i = 0; i < RaceMgr::getManager()->getKartNumber(); i++) { KartInfo *kartInfo = RaceMgr::getManager()->getKartInfo(i); - char *kind = nullptr; + const char *kind = nullptr; switch (kartInfo->getPlayerKind(0)) { case 0: @@ -1704,8 +1704,8 @@ void RaceUsrPage::draw() break; } KartGamePad *kartPad = kartInfo->getPad(0); - char *type = "NULL "; - char *port = "NULL "; + const char *type = "NULL "; + const char *port = "NULL "; if (kartPad) { diff --git a/src/Kaneshige/RaceTime.cpp b/src/Kaneshige/RaceTime.cpp index ac99c660..7c715bcd 100644 --- a/src/Kaneshige/RaceTime.cpp +++ b/src/Kaneshige/RaceTime.cpp @@ -1,6 +1,6 @@ #include "Kaneshige/RaceTime.h" -void RaceTime::get(int *minutes, int * seconds, int *miliseconds) const { +void RaceTime::get(int *minutes, int *seconds, int *miliseconds) const { int absTime = mTime; if (absTime < 0) { absTime = -absTime; @@ -12,5 +12,4 @@ void RaceTime::get(int *minutes, int * seconds, int *miliseconds) const { if (mTime < 0) *minutes = -*minutes; - -} \ No newline at end of file +} diff --git a/src/Sato/ObjUtility.cpp b/src/Sato/ObjUtility.cpp index e69de29b..5394f970 100644 --- a/src/Sato/ObjUtility.cpp +++ b/src/Sato/ObjUtility.cpp @@ -0,0 +1 @@ +#include "Sato/ObjUtility.h" diff --git a/src/Sato/StateObserver.cpp b/src/Sato/StateObserver.cpp index e69de29b..b7bef846 100644 --- a/src/Sato/StateObserver.cpp +++ b/src/Sato/StateObserver.cpp @@ -0,0 +1,34 @@ +#include "Sato/StateObserver.h" + +StateObserver::StateObserver() { + mState = 0; + mPrevState = 0; + mTimeExecuted = 0; +} + +StateObserver::~StateObserver() {} + +void StateObserver::ExecuteState() { + if (mState != 0xffff) { + changeState(); + } + MoveExec(); + mTimeExecuted++; +} + +void StateObserver::ResetState() { + mState = 0; + mPrevState = 0; + mTimeExecuted = 0; +} + +void StateObserver::setState(u16 state) { + mState = state; +} + +void StateObserver::changeState() { + mPrevState = mState; + mState = 0xffff; + mTimeExecuted = 0; + InitExec(); +}