Add AIPathManager and related structs

Author: Bsquo

config/RMCP01/module/symbols.txt

@@ -11227,7 +11227,7 @@ __dt__Q25Enemy10struct_121Fv = .text:0x00224EFC; // type:function size:0x40
 vf_0x0C__Q25Enemy10struct_121Fv = .text:0x00224F3C; // type:function size:0x4
 vf_0x10__Q25Enemy10struct_121Fv = .text:0x00224F40; // type:function size:0x4
 avoidPow__Q25Enemy14AITrickHandlerFv = .text:0x00224F44; // type:function size:0x10
-isStartingAirborne__Q25Enemy14AITrickHandlerFv = .text:0x00224F54; // type:function size:0x40
+allowTricking__Q25Enemy14AITrickHandlerFv = .text:0x00224F54; // type:function size:0x40
 shouldTrick__Q25Enemy14AITrickHandlerFv = .text:0x00224F94; // type:function size:0xB0
 __ct__Q25Enemy14AITrickHandlerFPQ25Enemy6AIInfo = .text:0x00225044; // type:function size:0x14
 __dt__Q25Enemy14AITrickHandlerFv = .text:0x00225058; // type:function size:0x40

include/rk_types.h

@@ -3,7 +3,6 @@
 #include <stdint.h>
 #include <stddef.h>
 #include <macros.h>
-#include <rk_common.h>
 
 //! Describes an unknown 32 bit value
 typedef int unk32;

lib/egg/core/eggDisposer.hpp

@@ -14,15 +14,15 @@ class Heap;
 
 //! @brief Base class for garbage-collected objects.
 //!
-//! Scene-specific, heap-allocated resources in mkw are typically not explicitly
+//! Scene-specific, heap-allocated resources in Mario Kart Wii are typically not explicitly
 //! freed. This isn't a memory leak, though: when a Scene transitions, all
 //! memory allocated within it is returned in one block. However, in C++, the
 //! destructor of an object must be called when its lifetime
 //! expires--otherwise, we could leak second-order resources and introduce
 //! use-after-free bugs.
 //!
 //! Disposer solves this issue: when a heap is destroyed,
-//! the linked list of dispoers is traversed and each destructor is called
+//! the linked list of disposers is traversed and each destructor is called
 //! in-order.
 //!
 class Disposer : private NonCopyable {

src/enemy/AIManager.hpp

@@ -4,10 +4,16 @@
 #include "AIRank.hpp"
 #include "AISpeed.hpp"
 #include <egg/core/eggDisposer.hpp>
+#include <rk_common.h>
 
 namespace Enemy {
 
-    class AIManager: public EGG::Disposer {
+    class AIManagerEx {
+        public:
+            virtual ~AIManagerEx();
+    };
+
+    class AIManager: public AIManagerEx, public EGG::Disposer {
         public:
             static AIManager* createInstance();
             static void destroyInstance();
@@ -17,6 +23,9 @@ namespace Enemy {
             inline AIRankManager* getRankManager() { return mpRankManager; }
 
         private:
+            AIManager();
+            virtual ~AIManager();
+
             static AIManager* spInstance;
 
             s32 mPlayerCount;
@@ -26,9 +35,6 @@ namespace Enemy {
             AI* mpCpuPlayers[MAX_PLAYER_COUNT];
             AI* mpRealPlayers[MAX_PLAYER_COUNT];
             AIRankManager* mpRankManager;
-
-            AIManager();
-            virtual ~AIManager();
     };
 
 }

src/enemy/AIPath.hpp

@@ -1,9 +1,12 @@
 #pragma once
 
-#include <rk_types.h>
+#include <egg/math/eggVector.hpp>
+#include <rk_common.h>
 
 namespace Enemy {
 
+    struct AIPathManager;
+
     struct PointParam {
         virtual ~PointParam();
         virtual bool shouldEnterRouteIfHasMushroom();
@@ -30,8 +33,25 @@ namespace Enemy {
         f32 field_0x10;
     };
 
-    struct AIPathPoint {
-        u8 field_0x00[0x44];
+    struct AIPathPointInfo {
+        AIPathPointInfo();
+        virtual ~AIPathPointInfo();
+
+        AIPathManager* mpPathManager;
+        s8 mStartingPoint;
+        s8 mPointIdxLog[5];  // List of the last 5 enemy points that have been traversed
+        s32 field_0x10;
+        EGG::Vector3f mTargetTrans;
+        f32 field_0x20;
+        f32 field_0x24;
+        f32 offsetRate;
+        f32 field_0x2C;
+        s32 mPlayerIdx;
+    };
+
+    struct AIPathPoint: public AIPathPointInfo {
+        void* mpBattleSearcher;
+        EGG::Vector3f field_0x38;
     };
 
     struct AIPathHandler {
@@ -40,10 +60,10 @@ namespace Enemy {
         bool isSwitchingPath();
 
         bool mbIsSwitchingPath;
-        PointParam* field_0x08;
-        PointParam* field_0x0C;
-        PointParam* field_0x10;
-        AIPathPoint* field_0x14;
+        PointParam* mpPrevPointParam;
+        PointParam* mpCurrPointParam;
+        PointParam* mpNextPointParam;
+        AIPathPoint* mpPathPoint;
         s32 field_0x18;
         bool field_0x1C;
         bool field_0x20;
@@ -58,4 +78,40 @@ namespace Enemy {
         f32 field_0x3C;
     };
 
+    struct AIPathManager {
+        AIPathManager();
+        virtual ~AIPathManager();
+
+        AIPathHandler* mpPlayers[MAX_PLAYER_COUNT];
+        u32 mPlayerCount;
+    };
+
+    struct GoNextInfo {
+        bool field_0x00;
+        EGG::Vector3f field_0x04;
+        u8 field_0x10;
+        u8 field_0x11;
+        s32 field_0x14;
+        u32 field_0x18;
+        bool field_0x1C;
+        bool field_0x1D;
+        bool mbInBullet;
+        s32 mNextSearchMode;
+        bool field_0x24;
+        f32 field_0x28;
+
+        enum eSearchMode {
+            GO_TO_RANDOM_POINT         = 0,
+            GO_TO_RANDOM_POINT_2       = 2,
+            GO_TO_ITEM_POINT_HIGHEST   = 3,
+            GO_TO_ITEM_POINT_LOWEST    = 4,
+            GO_TO_FRIEND_POINT_HIGHEST = 5,
+            GO_TO_RIVAL_POINT_HIGHEST  = 6,
+            GO_TO_FRIEND_POINT_LOWEST  = 7,
+            GO_TO_COIN_POINT_HIGHEST   = 8,
+            GO_TO_NEAREST_TARGET       = 9,
+            GO_TO_FARTHEST_TARGET      = 10
+        };
+    };
+
 }

src/enemy/AITrickHandler.cpp

@@ -5,6 +5,7 @@
 #include "AIProbability.hpp"
 #include "AIControl.hpp"
 #include "kart/KartState.hpp"
+#include <rk_common.h>
 
 namespace Enemy {
 
@@ -22,9 +23,13 @@ void AITrickHandler::avoidPow() {
     mpInfo->mpInput->setTrick(System::KPadRaceInputState::UP_TRICK);
 }
 
-bool AITrickHandler::isStartingAirborne() {
+bool AITrickHandler::allowTricking() {
     Kart::KartState* state = mpInfo->mpAI->kartState();
 
+    /**
+     * Ensure that CPUs can only request tricking when they are in the air and 
+     * not when they're on a jump pad or mushroom trampoline, or while hit with an object.
+     */
     if (state->on(Kart::KART_FLAG_AIR_START) && !state->on(Kart::KART_FLAG_JUMPPAD) && !state->on(Kart::KART_FLAG_HIT_ITEM_OR_OBJ)) {
         return true;
     }
@@ -35,7 +40,7 @@ bool AITrickHandler::isStartingAirborne() {
 bool AITrickHandler::shouldTrick() {
     AIProbabilityBase* probability = mpInfo->mpAI->mpEngine->mpControl->getAIProbability();
 
-    if (isStartingAirborne() && probability->getTrick()) {
+    if (allowTricking() && probability->getTrick()) {
         return true;
     }
 
@@ -58,12 +63,12 @@ void AITrickHandler::update() {
     if (shouldTrick()) {
         System::KPadRaceInputState* input = mpInfo->mpInput;
 
-        const int kartTricks[2] = {
+        const System::KPadRaceInputState::eTrick kartTricks[2] = {
             System::KPadRaceInputState::UP_TRICK,
             System::KPadRaceInputState::DOWN_TRICK
         };
 
-        int rand = AIManager::getInstance()->getRandU32(ARRAY_COUNT(kartTricks));
+        u32 rand = AIManager::getInstance()->getRandU32(ARRAY_COUNT(kartTricks));
         input->setTrick(kartTricks[rand]);
     }
 }
@@ -99,11 +104,11 @@ void AITrickHandlerBike::calcWheelie() {
 
         System::KPadRaceInputState* input = mpInfo->mpInput;
 
-        if (pathHandler->field_0x0C->shouldWheelie() && probability->getWheelie() && !disableWheelie) {
+        if (pathHandler->mpCurrPointParam->shouldWheelie() && probability->getWheelie() && !disableWheelie) {
             mbPerformWheelie = true;
         }
 
-        if (pathHandler->field_0x0C->shouldEndWheelie()) {
+        if (pathHandler->mpCurrPointParam->shouldEndWheelie()) {
             mbPerformWheelie = false;
             input->setTrick(System::KPadRaceInputState::DOWN_TRICK);
         }
@@ -118,14 +123,14 @@ void AITrickHandlerBike::update() {
     if (shouldTrick()) {
         System::KPadRaceInputState* input = mpInfo->mpInput;
 
-        const int bikeTricks[4] = {
+        const System::KPadRaceInputState::eTrick bikeTricks[4] = {
             System::KPadRaceInputState::UP_TRICK,
             System::KPadRaceInputState::DOWN_TRICK,
             System::KPadRaceInputState::LEFT_TRICK,
             System::KPadRaceInputState::RIGHT_TRICK,
         };
 
-        int rand = AIManager::getInstance()->getRandU32(ARRAY_COUNT(bikeTricks));
+        u32 rand = AIManager::getInstance()->getRandU32(ARRAY_COUNT(bikeTricks));
         input->setTrick(bikeTricks[rand]);
     }
 }

src/enemy/AITrickHandler.hpp

@@ -21,7 +21,7 @@ namespace Enemy {
         virtual void disableWheelie();
         virtual void update();
         void avoidPow();
-        bool isStartingAirborne();
+        bool allowTricking();
         bool shouldTrick();
 
         AIInfo* mpInfo;

src/system/KPadController.cpp

@@ -84,16 +84,16 @@ void KPadUIInputState::setStickY(u8 y) {
   mStick.y = rawStickToFloat(y);
 }
 
-void KPadRaceInputState::setTrick(int trick) {
+void KPadRaceInputState::setTrick(eTrick trick) {
   mTrickRaw = trick;
-  int actualTrick = trick;
+  eTrick actualTrick = trick;
   if (KPadDirector::spInstance->mIsMirror) {
     switch (trick) {
-    case 3:
-      actualTrick = 4;
+    case LEFT_TRICK:
+      actualTrick = RIGHT_TRICK;
       break;
-    case 4:
-      actualTrick = 3;
+    case RIGHT_TRICK:
+      actualTrick = LEFT_TRICK;
       break;
     default:
       break;

src/system/KPadController.hpp

@@ -36,7 +36,7 @@ struct KPadRaceInputState {
   void setStickXMirrored(u8 x);
   void setStickXUnmirrored(u8 x);
   void setStickY(u8 y);
-  void setTrick(int trick);
+  void setTrick(eTrick trick);
 
   u16 mButtons;                                   // [this+0x04]
   u16 mButtonsRaw;                                // [this+0x06]

src/system/KPadDirector.hpp

@@ -2,6 +2,8 @@
 
 #include <rk_types.h>
 
+#include <rk_common.h>
+
 #include <decomp.h>
 
 #include <rvl/pad/pad.h>