Implement DummyPole

STATUS.md

@@ -8,7 +8,7 @@ Test Case                                                 | Frames      |     |
 [`mg-ng-rta-1-40-273`](https://youtu.be/8-0Xetey5xY)      | 877 / 6422  | ❌ | Mushroom
 [`tf-rta-1-44-178`](https://youtu.be/2XWFuncJAGk)         | 743 / 6656  | ❌ | Moving road
 [`tf-ng-rta-1-49-039`](https://youtu.be/mqQa_1Cq1bw)      | 689 / 6947  | ❌ | Moving road
-[`mc-rta-0-46-553`](https://youtu.be/1F2xfHYrkXM)         | 686 / 3202  | ❌ | KMP
+[`mc-rta-0-46-553`](https://youtu.be/1F2xfHYrkXM)         | 1494 / 3202 | ❌ | KMP
 [`mc-ng-rta-1-20-357`](https://youtu.be/kG8PvG8K1ZA)      | 1222 / 4228 | ❌ | KMP
 [`cm-rta-0-25-145`](https://youtu.be/F_RUQVghmuA)         | 1919 / 1919 | ✔️ |
 [`cm-ng-rta-1-55-264`](https://youtu.be/XxKG3IYWduE)      | 651 / 7320  | ❌ | KMP

source/game/field/ObjectDirector.cc

@@ -80,7 +80,7 @@ size_t ObjectDirector::checkKartObjectCollision(Kart::KartObject *kartObj,
             obj->onObjectCollision(kartObj);
         }
 
-        m_collisionObjects[count] = obj;
+        m_collidingObjects[count] = obj;
         if (m_hitDepths[count].y < 0.0f) {
             m_hitDepths[count].y = 0.0f;
         }
@@ -95,6 +95,12 @@ const ObjectFlowTable &ObjectDirector::flowTable() const {
     return m_flowTable;
 }
 
+const ObjectBase *ObjectDirector::collidingObject(size_t idx) const {
+    ASSERT(idx < m_collidingObjects.size());
+
+    return m_collidingObjects[idx];
+}
+
 Kart::Reaction ObjectDirector::reaction(size_t idx) const {
     ASSERT(idx < m_reactions.size());
 
@@ -150,9 +156,13 @@ ObjectDirector::~ObjectDirector() {
 void ObjectDirector::createObjects() {
     const auto *courseMap = System::CourseMap::Instance();
     size_t objectCount = courseMap->getGeoObjCount();
-    m_objects.reserve(objectCount);
-    m_calcObjects.reserve(objectCount);
-    m_collisionObjects.reserve(objectCount);
+
+    // It's possible for the KMP to specify settings for objects that aren't tracked here
+    // MAX_UNIT_COUNT is the upper bound for tracked object count, so we reserve the minimum
+    size_t maxCount = std::min(objectCount, MAX_UNIT_COUNT);
+    m_objects.reserve(maxCount);
+    m_calcObjects.reserve(maxCount);
+    m_collisionObjects.reserve(maxCount);
 
     for (size_t i = 0; i < objectCount; ++i) {
         const auto *pObj = courseMap->getGeoObj(i);
@@ -181,6 +191,10 @@ ObjectBase *ObjectDirector::createObject(const System::MapdataGeoObj &params) {
         return new ObjectDokan(params);
     case ObjectId::OilSFC:
         return new ObjectOilSFC(params);
+    // Non-specified objects are stock collidable objects by default
+    // However, we need to specify an impl, so we don't use default
+    case ObjectId::DummyPole:
+        return new ObjectCollidable(params);
     default:
         return new ObjectNoImpl(params);
     }

source/game/field/ObjectDirector.hh

@@ -19,6 +19,7 @@ public:
             ObjectCollisionConvexHull *convexHull);
 
     const ObjectFlowTable &flowTable() const;
+    const ObjectBase *collidingObject(size_t idx) const;
     Kart::Reaction reaction(size_t idx) const;
     const EGG::Vector3f &hitDepth(size_t idx) const;
 
@@ -43,6 +44,8 @@ private:
 
     static constexpr size_t MAX_UNIT_COUNT = 0x100;
 
+    std::array<ObjectBase *, MAX_UNIT_COUNT>
+            m_collidingObjects; ///< Objects we are currently colliding with
     std::array<EGG::Vector3f, MAX_UNIT_COUNT> m_hitDepths;
     std::array<Kart::Reaction, MAX_UNIT_COUNT> m_reactions;
 

source/game/field/obj/ObjectId.hh

@@ -5,6 +5,7 @@
 namespace Field {
 
 enum class ObjectId {
+    DummyPole = 0x066,
     DokanSFC = 0x12e,
     OilSFC = 0x15d,
 };

source/game/kart/KartCollide.cc

@@ -32,6 +32,8 @@ void KartCollide::init() {
     m_suspBottomHeightSoftWall = 0.0f;
     m_someNonSoftWallTimer = 0;
     m_someSoftWallTimer = 0;
+    m_poleAngVelTimer = 0;
+    m_poleYaw = 0.0f;
     m_colPerpendicularity = 0.0f;
 }
 
@@ -461,6 +463,10 @@ void KartCollide::calcBoundingRadius() {
 
 /// @addr{0x80571F10}
 void KartCollide::calcObjectCollision() {
+    constexpr f32 COS_PI_OVER_4 = 0.707f;
+    constexpr s32 DUMMY_POLE_ANG_VEL_TIME = 3;
+    constexpr f32 DUMMY_POLE_ANG_VEL = 0.005f;
+
     m_totalReactionWallNrm = EGG::Vector3f::zero;
     m_surfaceFlags.resetBit(eSurfaceFlags::ObjectWall, eSurfaceFlags::ObjectWall3);
 
@@ -481,7 +487,33 @@ void KartCollide::calcObjectCollision() {
                 m_movement += hitDepth;
             }
         }
+
+        if (objectDirector->collidingObject(i)->id() == Field::ObjectId::DummyPole) {
+            EGG::Vector3f hitDirection = objectCollisionKart()->GetHitDirection(i);
+            const EGG::Vector3f &lastDir = move()->lastDir();
+
+            if (lastDir.dot(hitDirection) < -COS_PI_OVER_4) {
+                EGG::Vector3f angVel = hitDirection.cross(lastDir);
+                f32 sign = angVel.y > 0.0f ? -1.0f : 1.0f;
+
+                m_poleAngVelTimer = DUMMY_POLE_ANG_VEL_TIME;
+                m_poleYaw = DUMMY_POLE_ANG_VEL * sign;
+            }
+        }
     }
+
+    calcPoleTimer();
+}
+
+/// @addr{Inlined in 0x80571F10}
+void KartCollide::calcPoleTimer() {
+    if (m_poleAngVelTimer > 0 && (state()->isAccelerate() || state()->isBrake())) {
+        EGG::Vector3f angVel2 = dynamics()->angVel2();
+        angVel2.y += m_poleYaw;
+        dynamics()->setAngVel2(angVel2);
+    }
+
+    m_poleAngVelTimer = std::max(0, m_poleAngVelTimer - 1);
 }
 
 /// @stage All

source/game/kart/KartCollide.hh

@@ -83,6 +83,7 @@ public:
             Field::CourseColMgr::CollisionInfo *colInfo);
     void calcBoundingRadius();
     void calcObjectCollision();
+    void calcPoleTimer();
 
     void processWheel(CollisionData &collisionData, Hitbox &hitbox,
             Field::CourseColMgr::CollisionInfo *colInfo, Field::KCLTypeMask *maskOut);
@@ -154,6 +155,8 @@ private:
     u16 m_someSoftWallTimer;
     f32 m_suspBottomHeightNonSoftWall;
     u16 m_someNonSoftWallTimer;
+    s16 m_poleAngVelTimer;
+    f32 m_poleYaw;
     f32 m_colPerpendicularity;
 
     static std::array<ObjectCollisionHandler, 33> s_objectCollisionHandlers;