Finish basic scene debug

include/Sports2/Cmn/Sp2CmnConst.h

@@ -48,8 +48,8 @@ enum ESeq {
     ESeq_Bwl_100 = 3, //!< Bowling (100-Pin Game)
     ESeq_Bwl_Wal = 4, //!< Bowling (Spin Control)
 
-    ESeq_Can = 7,    //!< Canoeing (Speed Challenge)
-    ESeq_Can_Vs = 8, //!< Canoeing (VS)
+    ESeq_Can = 8,    //!< Canoeing (Speed Challenge)
+    ESeq_Can_Vs = 7, //!< Canoeing (VS)
 
     ESeq_Png_Ret = 2, //!< Table Tennis (Return Challenge)
     ESeq_Png = 5,     //!< Table Tennis (Match)

include/Sports2/Cmn/Sp2CmnStaticMem.h

@@ -3,25 +3,45 @@
 #include <Pack/RPSystem.h>
 #include <Sports2/Sp2Types.h>
 
+#include <egg/core.h>
+
 namespace Sp2 {
 namespace Cmn {
 
-class StaticMem {
+enum EPlayStyle { EPlayStyle_Team, EPlayStyle_Solo };
+enum EPlayTeam { EPlayTeam_Blue, EPlayTeam_Red };
+
+/**
+ * @brief Static memory region
+ * @details Used for passing data between scenes
+ */
+class StaticMem /* : EGG::Singleton */ {
     RP_SINGLETON_DECL(StaticMem);
 
 public:
     u32 getVariable(u32 index, bool local = false);
     void setVariable(u32 index, u32 value, bool local = false);
 
-    u32 getSceneSeq() const {
+    s32 getSceneSeq() const {
         return mSequenceNo;
     }
-    void setSceneSeq(u32 seq);
+    void setSceneSeq(s32 seq) {
+        mSequenceNo = seq;
+    }
 
     u32 getSceneGroup() const {
         return mGroupNo;
     }
-    void setSceneGroup(u32 group);
+    void setSceneGroup(u32 group) {
+        mGroupNo = group;
+    }
+
+    u32 getStageNo() const {
+        return mStageNo;
+    }
+    void setStageNo(u32 stage) {
+        mStageNo = stage;
+    }
 
     RPSysScene::ETime getIslandTime() const {
         return mIslandTime;
@@ -32,10 +52,14 @@ class StaticMem {
 
 private:
     char _04[0x14 - 0x4];
-    u32 mGroupNo;    // at 0x14
-    u32 mSequenceNo; // at 0x18
-    char _1C[0x380 - 0x1C];
+    s32 mGroupNo;            // at 0x14
+    u32 mSequenceNo;         // at 0x18
+    u32 mStageNo;            // at 0x1C
+    EPlayStyle mPlayStyle;   // at 0x20
+    EPlayTeam mPlayTeams[4]; // at 0x24
+    char _34[0x380 - 0x34];
     RPSysScene::ETime mIslandTime; // at 0x380
+    // . . .
 };
 
 } // namespace Cmn

lib/libkiwi/debug/kiwiDebugOption.cpp

@@ -27,15 +27,15 @@ void DebugOptionBase::SetEnabled(bool enable) {
 /**
  * @brief Constructor
  *
- * @param rPage Parent page
+ * @param rMenu Parent menu
  * @param rName Option name
  * @param min Minimum value (inclusive)
  * @param max Maximum value (inclusive)
  * @param initial Initial value (optional)
  */
-DebugIntOption::DebugIntOption(DebugPage& rPage, const String& rName, int min,
+DebugIntOption::DebugIntOption(DebugMenu& rMenu, const String& rName, int min,
                                int max, Optional<int> initial)
-    : DebugOptionBase(rPage, rName), mMin(min), mMax(max) {
+    : DebugOptionBase(rMenu, rName), mMin(min), mMax(max) {
 
     K_ASSERT(max >= min);
 
@@ -237,7 +237,7 @@ EDebugMenuResult DebugOpenPageOption::OpenPageProc(void* pArg) {
     K_ASSERT_PTR(pArg);
 
     DebugOpenPageOption* p = static_cast<DebugOpenPageOption*>(pArg);
-    p->GetPage().GetMenu().OpenPage(*p->mpOpenPage);
+    p->GetMenu().OpenPage(*p->mpOpenPage);
 
     return EDebugMenuResult_Select;
 }

lib/libkiwi/debug/kiwiDebugOption.h

@@ -35,22 +35,22 @@ class DebugOptionBase {
     /**
      * @brief Constructor
      *
-     * @param rPage Parent page
+     * @param rMenu Parent menu
      * @param rName Option name
      */
-    DebugOptionBase(DebugPage& rPage, const String& rName)
-        : mrPage(rPage), mIsEnabled(true), mName(rName) {}
+    DebugOptionBase(DebugMenu& rMenu, const String& rName)
+        : mrMenu(rMenu), mIsEnabled(true), mName(rName) {}
 
     /**
      * @brief Destructor
      */
     virtual ~DebugOptionBase() {}
 
     /**
-     * @brief Gets the options's parent menu page
+     * @brief Gets the option's parent menu
      */
-    DebugPage& GetPage() const {
-        return mrPage;
+    DebugMenu& GetMenu() const {
+        return mrMenu;
     }
 
     /**
@@ -130,8 +130,8 @@ class DebugOptionBase {
     virtual void UpdateString() {}
 
 protected:
-    //! Parent menu page
-    DebugPage& mrPage;
+    //! Parent menu
+    DebugMenu& mrMenu;
 
     //! Enable option
     bool mIsEnabled;
@@ -157,13 +157,13 @@ class DebugIntOption : public DebugOptionBase {
     /**
      * @brief Constructor
      *
-     * @param rPage Parent page
+     * @param rMenu Parent menu
      * @param rName Option name
      * @param min Minimum value (inclusive)
      * @param max Maximum value (inclusive)
      * @param initial Initial value (optional)
      */
-    DebugIntOption(DebugPage& rPage, const String& rName, int min, int max,
+    DebugIntOption(DebugMenu& rMenu, const String& rName, int min, int max,
                    Optional<int> initial = kiwi::nullopt);
 
     /**
@@ -272,12 +272,12 @@ class DebugBoolOption : public DebugIntOption {
     /**
      * @brief Constructor
      *
-     * @param rPage Parent page
+     * @param rMenu Parent menu
      * @param rName Option name
      * @param initial Initial value (optional)
      */
-    DebugBoolOption(DebugPage& rPage, const String& rName, bool initial = false)
-        : DebugIntOption(rPage, rName, static_cast<int>(false),
+    DebugBoolOption(DebugMenu& rMenu, const String& rName, bool initial = false)
+        : DebugIntOption(rMenu, rName, static_cast<int>(false),
                          static_cast<int>(true), static_cast<int>(initial)) {
 
         UpdateString();
@@ -312,17 +312,17 @@ class DebugEnumOption : public DebugIntOption {
     /**
      * @brief Constructor
      *
-     * @param rPage Parent page
+     * @param rMenu Parent menu
      * @param rName Option name
      * @param ppValues Enum value strings
      * @param min Minimum value (inclusive)
      * @param max Maximum value (inclusive)
      * @param initial Initial value (optional)
      */
-    DebugEnumOption(DebugPage& rPage, const String& rName,
+    DebugEnumOption(DebugMenu& rMenu, const String& rName,
                     const char** ppValues, int min, int max,
                     Optional<int> initial = kiwi::nullopt)
-        : DebugIntOption(rPage, rName, min, max, initial), mppValues(ppValues) {
+        : DebugIntOption(rMenu, rName, min, max, initial), mppValues(ppValues) {
 
         ASSERT(ppValues != nullptr);
 
@@ -375,14 +375,14 @@ class DebugProcOption : public DebugOptionBase {
     /**
      * @brief Constructor
      *
-     * @param rPage Parent page
+     * @param rMenu Parent menu
      * @param rName Option name
      * @param pCallback Select callback function
      * @param pCallbackArg Select callback user argument
      */
-    DebugProcOption(DebugPage& rPage, const String& rName,
+    DebugProcOption(DebugMenu& rMenu, const String& rName,
                     SelectCallback pCallback, void* pCallbackArg = nullptr)
-        : DebugOptionBase(rPage, rName),
+        : DebugOptionBase(rMenu, rName),
           mpCallback(pCallback),
           mpCallbackArg(pCallbackArg) {}
 
@@ -421,13 +421,13 @@ class DebugOpenPageOption : public DebugProcOption {
     /**
      * @brief Constructor
      *
-     * @param rPage Parent page
+     * @param rMenu Parent menu
      * @param rName Option name
      * @param rOpenPage Sub-page to open
      */
-    DebugOpenPageOption(DebugPage& rPage, const String& rName,
+    DebugOpenPageOption(DebugMenu& rMenu, const String& rName,
                         DebugPage& rOpenPage)
-        : DebugProcOption(rPage, rName, OpenPageProc, this) {
+        : DebugProcOption(rMenu, rName, OpenPageProc, this) {
 
         mpOpenPage = &rOpenPage;
     }

lib/libkiwi/util/kiwiStateMachine.h

@@ -3,6 +3,8 @@
 #include <libkiwi/debug/kiwiAssert.h>
 #include <libkiwi/k_types.h>
 
+#include <climits>
+
 /**
  * @brief Declares state calc/exit functions
  */
@@ -129,15 +131,17 @@ template <typename TActor, typename TStateReturn = void> class StateMachine {
             mPrevState = mState;
             mState = mNextState;
 
-            mDuration = 0;
+            mDuration = -1;
             mEntering = false;
         }
 
-        K_ASSERT(mpCalcFunctions[mState]);
-        TStateReturn result = (mpObject->*mpCalcFunctions[mState])();
+        // Prevent overflow
+        if (mDuration < INT_MAX) {
+            mDuration++;
+        }
 
-        mDuration++;
-        return result;
+        K_ASSERT(mpCalcFunctions[mState]);
+        return (mpObject->*mpCalcFunctions[mState])();
     }
 
 private:
@@ -146,15 +150,15 @@ template <typename TActor, typename TStateReturn = void> class StateMachine {
     s32 mState;    //!< Current state
     u32 mStateNum; //!< Number of possible states
 
-    u32 mDuration;  //!< Current state duration
+    s32 mDuration;  //!< Current state duration
     s32 mPrevState; //!< Previous state
     s32 mNextState; //!< Next state
 
     bool mEntering; //!< Whether to call the enter function
     bool mExiting;  //!< Whether to call the enter function
 
     StateFunc* mpCalcFunctions; //!< State update functions
-    StateFunc* mpExitFunctions; //!< State update functions
+    StateFunc* mpExitFunctions; //!< State exit functions
 };
 
 //! @}

src/core/CosmeticMgr.cpp

@@ -56,7 +56,7 @@ void CosmeticMgr::Debug() {
     }
 
     kiwi::Shuffle(mRandomBgmMapping, K_LENGTHOF(mRandomBgmMapping));
-    mRandomBgmFlag = true;
+    mRandomBgmFlag = false;
 }
 
 } // namespace AP

src/scene/DebugRootScene/RootPage.cpp

@@ -12,10 +12,21 @@ namespace DebugRoot {
  */
 RootPage::RootPage(kiwi::DebugMenu& rMenu)
     : kiwi::DebugPage(rMenu),
-      mSceneSelect(*this, "Scene Select", mSceneSelectPage),
-      mSceneSelectPage(rMenu) {
+      mSceneSelect(rMenu, "Scene Debug", mSceneSelectPage),
+      mSceneSelectPage(rMenu),
+      mItemDebug(rMenu, "Item Debug", *this),
+      mCheckDebug(rMenu, "Check Debug", *this),
+      mCosmeticDebug(rMenu, "Cosmetic Debug", *this) {
 
     mOptions.PushBack(&mSceneSelect);
+    mOptions.PushBack(&mItemDebug);
+    mOptions.PushBack(&mCheckDebug);
+    mOptions.PushBack(&mCosmeticDebug);
+
+    // TODO: Not yet implemented
+    mItemDebug.SetEnabled(false);
+    mCheckDebug.SetEnabled(false);
+    mCosmeticDebug.SetEnabled(false);
 }
 
 } // namespace DebugRoot

src/scene/DebugRootScene/RootPage.h

@@ -24,6 +24,18 @@ class RootPage : public kiwi::DebugPage {
     //! Debug scene select
     kiwi::DebugOpenPageOption mSceneSelect;
     SceneSelectPage mSceneSelectPage;
+
+    //! AP item debug
+    kiwi::DebugOpenPageOption mItemDebug;
+    // ItemDebugPage mItemDebugPage;
+
+    //! AP check debug
+    kiwi::DebugOpenPageOption mCheckDebug;
+    // ItemDebugPage mItemDebugPage;
+
+    //! AP cosmetic debug
+    kiwi::DebugOpenPageOption mCosmeticDebug;
+    // ItemDebugPage mItemDebugPage;
 };
 
 } // namespace DebugRoot

src/scene/DebugRootScene/SceneSelectPage.cpp

@@ -20,7 +20,7 @@ SceneSelectPage::SceneSelectPage(kiwi::DebugMenu& rMenu)
         ASSERT_PTR(pSceneName);
 
         kiwi::DebugProcOption* pOption =
-            new kiwi::DebugProcOption(*this, pSceneName, SelectProc, this);
+            new kiwi::DebugProcOption(rMenu, pSceneName, SelectProc, this);
 
         ASSERT_PTR(pOption);