Fix Seagull, classes count their own instances --> cleanup

9 files changed, 155 insertions, 115 deletions

diff --git a/src/engine/objects/BombKart.cpp b/src/engine/objects/BombKart.cpp
index 42506f826..c33b4b107 100644
--- a/src/engine/objects/BombKart.cpp
+++ b/src/engine/objects/BombKart.cpp
@@ -26,8 +26,10 @@ extern "C" {
 extern s8 gPlayerCount;
 }
 
-OBombKart::OBombKart(Vec3f pos, TrackWaypoint* waypoint, uint16_t waypointIndex, uint16_t state, f32 unk_3C) {
+size_t OBombKart::_count = 0;
 
+OBombKart::OBombKart(Vec3f pos, TrackWaypoint* waypoint, uint16_t waypointIndex, uint16_t state, f32 unk_3C) {
+    _idx = _count;
     Vec3f _pos = {0, 0, 0};
 
     if (waypoint) { // Spawn kart on waypoint
@@ -68,6 +70,8 @@ OBombKart::OBombKart(Vec3f pos, TrackWaypoint* waypoint, uint16_t waypointIndex,
     WheelPos[3][1] = _pos[1];
     WheelPos[3][2] = _pos[2];
     check_bounding_collision(&_Collision, 2.0f, _pos[0], _pos[1], _pos[2]);
+
+    _count++;
 }
 
 void OBombKart::Spawn() {
@@ -334,9 +338,7 @@ void OBombKart::Draw(s32 cameraId) {
     }
 
     if (GetCourse() == GetPodiumCeremony()) {
-        // This isn't functionally equivallent.
-        // Technicaly it should be if (kart[0].WaypointIndex < 16)
-        if (WaypointIndex < 16) {
+        if ((_idx == 0) && (WaypointIndex < 16)) {
             return;
         } else {
             cameraId = PLAYER_FOUR;
diff --git a/src/engine/objects/BombKart.h b/src/engine/objects/BombKart.h
index 4500e41c2..7ceba7ecb 100644
--- a/src/engine/objects/BombKart.h
+++ b/src/engine/objects/BombKart.h
@@ -5,6 +5,8 @@
 #include <vector>
 #include "engine/Matrix.h"
 
+#include "World.h"
+
 extern "C" {
 #include "macros.h"
 #include "main.h"
@@ -53,16 +55,26 @@ public:
     // Set waypoint to NULL if using a spawn position and not a waypoint.
     explicit OBombKart(Vec3f pos, TrackWaypoint* waypoint, uint16_t waypointIndex, uint16_t state, f32 unk_3C);
 
+    ~OBombKart() {
+        _count--;
+    }
+
+    static size_t GetCount() {
+        return _count;
+    }
+
     void Spawn();
     void BeginPlay();
     void Tick();
-    void Draw(s32 playerId);
+    void Draw(s32 cameraId);
     void DrawBattle(s32 cameraId);
     void Collision(s32 playerId, Player* player);
     void SomeRender(Vec3f arg1);
     void LoadMtx();
     void Waypoint(s32 screenId);
 private:
+    static size_t _count;
+    s32 _idx;
     Player* FindTarget();
     void Chase(Player*, Vec3f pos);
 
diff --git a/src/engine/objects/Hedgehog.h b/src/engine/objects/Hedgehog.h
index dab8cf15a..2057d894d 100644
--- a/src/engine/objects/Hedgehog.h
+++ b/src/engine/objects/Hedgehog.h
@@ -4,7 +4,7 @@
 #include <vector>
 #include "Object.h"
 
-#include "World.h"
+#include "engine/World.h"
 
 extern "C" {
 #include "macros.h"
diff --git a/src/engine/objects/Penguin.cpp b/src/engine/objects/Penguin.cpp
index c126174a1..c690e1ef2 100644
--- a/src/engine/objects/Penguin.cpp
+++ b/src/engine/objects/Penguin.cpp
@@ -33,16 +33,19 @@ extern "C" {
 extern s8 gPlayerCount;
 }
 
-OPenguin::OPenguin(s32 i, Vec3f pos, u16 direction, PenguinType type, Behaviour behaviour) {
-    if (i >= 32) {
+size_t OPenguin::_count = 0;
+
+OPenguin::OPenguin(Vec3f pos, u16 direction, PenguinType type, Behaviour behaviour) {
+    _idx = _count;
+    _type = type;
+    _bhv = behaviour;
+
+    if (_idx >= 32) {
         printf("MAX penguin REACHED (32), skipping\n");
         return;
     }
-    _idx = i;
-    _type = type;
-    _bhv = behaviour;
 
-    s32 objectIndex = indexObjectList1[i];
+    s32 objectIndex = indexObjectList1[_idx];
     init_object(objectIndex, 0);
 
     Object *object = &gObjectList[objectIndex];
@@ -73,6 +76,7 @@ OPenguin::OPenguin(s32 i, Vec3f pos, u16 direction, PenguinType type, Behaviour
             break;
     }
 
+    _count++;
 }
 
 void OPenguin::Tick(void) {
diff --git a/src/engine/objects/Penguin.h b/src/engine/objects/Penguin.h
index 0e9c36f49..63c2207c1 100644
--- a/src/engine/objects/Penguin.h
+++ b/src/engine/objects/Penguin.h
@@ -2,6 +2,8 @@
 
 #include <libultraship.h>
 #include <vector>
+#include "engine/World.h"
+#include "engine/objects/Object.h"
 
 extern "C" {
 #include "macros.h"
@@ -13,7 +15,7 @@ extern "C" {
 #include "course_offsets.h"
 }
 
-class OPenguin {
+class OPenguin : public OObject {
 public:
     enum PenguinType : uint32_t {
         CHICK,
@@ -36,10 +38,19 @@ public:
     f32 Diameter = 0.0f; // Waddle in a circle around the spawn point at this diameter.
     uint16_t MirrorModeAngleOffset;
 
-    explicit OPenguin(s32 i, Vec3f pos, u16 direction, PenguinType type, Behaviour behaviour);
+    explicit OPenguin(Vec3f pos, u16 direction, PenguinType type, Behaviour behaviour);
 
-    void Tick();
-    void Draw(s32 playerId);
+    ~OPenguin() {
+        _count--;
+    }
+
+    static size_t GetCount() {
+        return _count;
+    }
+
+
+    virtual void Tick() override;
+    virtual void Draw(s32 cameraId) override;
 private:
     void Behaviours(s32 objectIndex, s32 arg1);
     void EmperorPenguin(s32 objectIndex);
@@ -51,7 +62,7 @@ private:
     void OtherPenguin(s32 objectIndex);
     void InitOtherPenguin(s32 objectIndex);
 
-
+    static size_t _count;
     s32 _idx;
     PenguinType _type;
     Behaviour _bhv;
diff --git a/src/engine/objects/Seagull.cpp b/src/engine/objects/Seagull.cpp
index 5f0b12a7e..cced70348 100644
--- a/src/engine/objects/Seagull.cpp
+++ b/src/engine/objects/Seagull.cpp
@@ -1,8 +1,8 @@
 #include <libultraship.h>
 #include <libultra/gbi.h>
 #include "Seagull.h"
-#include "engine/Actor.h"
 #include <vector>
+#include "World.h"
 
 #include "port/Game.h"
 
@@ -29,9 +29,14 @@ extern SplineData D_800E6280;
 
 SplineData* D_800E633C[] = { &D_800E6034, &D_800E60F0, &D_800E61B4, &D_800E6280 };
 
-OSeagull::OSeagull(s32 i, Vec3f pos) {
-    size_t objectId;
-    _idx = i;
+size_t OSeagull::_count = 0;
+
+OSeagull::OSeagull(Vec3f pos) {
+    size_t objectIndex;
+    _idx = _count;
+    _pos[0] = pos[0];
+    _pos[1] = pos[1];
+    _pos[2] = pos[2];
 
     s16 randZ;
     s16 randX;
@@ -40,60 +45,48 @@ OSeagull::OSeagull(s32 i, Vec3f pos) {
     randY = random_int(20);
     randZ = random_int(200) + -100.0;
 
-    SpawnPos[0] = pos[0] + randX;
-    SpawnPos[1] = pos[1] + randY;
-    SpawnPos[2] = pos[2] + randZ;
-
     //for (i = 0; i < NUM_SEAGULLS; i++) {
 
 
-    //objectId = indexObjectList2[i];
-    //init_object(objectId, 0);
+    objectIndex = indexObjectList2[_idx];
+    init_object(objectIndex, 0);
 
 
-    //set_obj_origin_pos(objectId, pos[0], pos[1], pos[2]);
-        //if (i < (NUM_SEAGULLS / 2)) {
-    //gObjectList[objectId].unk_0D5 = 0;
-        //} else {
-        //    gObjectList[objectId].unk_0D5 = 1;
-        //}
-    //}
-}
+    set_obj_origin_pos(objectIndex, pos[0], pos[1], pos[2]);
+    if (_idx < (NUM_SEAGULLS / 2)) {
+        gObjectList[objectIndex].unk_0D5 = 0;
+    } else {
+        gObjectList[objectIndex].unk_0D5 = 1;
+    }
 
-bool OSeagull::IsMod() { return true; }
+    _count++;
+}
 
 void OSeagull::Tick() {
     Object* object;
-    UNUSED s32* var_s4;
-    s32 temp_s0;
+    s32 objectIndex = indexObjectList2[_idx];
 
-    //for (var_s3 = 0; var_s3 < NUM_SEAGULLS; var_s3++) {
-        //temp_s0 = indexObjectList2[_idx];
-
-        //object = &gObjectList[temp_s0];
-        if (_state == 0) {
+        object = &gObjectList[objectIndex];
+        if (object->state == 0) {
             return;
         }
 
-        OSeagull::func_80082714(temp_s0, _idx);
-        OSeagull::func_8008275C(temp_s0);
-        if (_toggle) {
-            _toggle = false;
+        OSeagull::func_80082714(objectIndex, _idx);
+        OSeagull::func_8008275C(objectIndex);
+        if (func_80072320(objectIndex, 2) != 0) {
+            func_800722CC(objectIndex, 2);
             if (D_80165A90 != 0) {
                 D_80165A90 = 0;
                 D_80183E40[0] = 0.0f;
                 D_80183E40[1] = 0.0f;
                 D_80183E40[2] = 0.0f;
                 if (gGamestate != CREDITS_SEQUENCE) {
-                    func_800C98B8(Pos, D_80183E40, SOUND_ARG_LOAD(0x19, 0x01, 0x70, 0x43));
+                    func_800C98B8(object->pos, D_80183E40, SOUND_ARG_LOAD(0x19, 0x01, 0x70, 0x43));
                 } else {
-                    //temp_s0 = indexObjectList2[1];
-                    //! @todo confirm this is equivallent to indexObjectList2[1];
-                    if (_idx == 1) {
-                        if (gCutsceneShotTimer <= 150) {
-                            //object = &gObjectList[temp_s0];
-                            func_800C98B8(Pos, D_80183E40, SOUND_ARG_LOAD(0x19, 0x01, 0x70, 0x43));
-                        }
+                    objectIndex = indexObjectList2[1];
+                    if (gCutsceneShotTimer <= 150) {
+                        object = &gObjectList[objectIndex];
+                        func_800C98B8(object->pos, D_80183E40, SOUND_ARG_LOAD(0x19, 0x01, 0x70, 0x43));
                     }
                 }
             }
@@ -114,19 +107,16 @@ void OSeagull::Tick() {
     D_80165908 = 0;
 }
 
-void OSeagull::Draw(Camera* camera) { // render_object_seagulls
-    s32 var_s1;
-    //for (i = 0; i < NUM_SEAGULLS; i++) {
-        var_s1 = indexObjectList2[_idx];
-        //! @todo: Quick hack to let seagull work in actor system. Should be cameraId not camera->playerId
-        //if (func_8008A364(var_s1, camera->playerId, 0x5555U, 0x000005DC) < 0x9C401 && CVarGetInteger("gNoCulling", 0) == 0) {
-            D_80165908 = 1;
-            _toggle = true;
-        //}
-        //if (is_obj_flag_status_active(var_s1, VISIBLE) != 0) {
-            OSeagull::func_800552BC(var_s1);
-        //}
-    //}
+void OSeagull::Draw(s32 cameraId) { // render_object_seagulls
+    s32 objectIndex = indexObjectList2[_idx];
+
+    if (func_8008A364(objectIndex, cameraId, 0x5555U, 0x000005DC) < 0x9C401 && CVarGetInteger("gNoCulling", 0) == 0) {
+        D_80165908 = 1;
+        _toggle = true;
+    }
+    if (is_obj_flag_status_active(objectIndex, VISIBLE) != 0) {
+        OSeagull::func_800552BC(objectIndex);
+    }
 }
 
 void OSeagull::func_800552BC(s32 objectIndex) {
@@ -155,11 +145,11 @@ void OSeagull::func_8008275C(s32 objectIndex) {
         case 2:
             func_8008B78C(objectIndex);
             vec3f_copy(gObjectList[objectIndex].unk_01C, gObjectList[objectIndex].pos);
-            func_8000D940(SpawnPos, (s16*) &gObjectList[objectIndex].unk_0C6,
+            func_8000D940(gObjectList[objectIndex].origin_pos, (s16*) &gObjectList[objectIndex].unk_0C6,
                           gObjectList[objectIndex].unk_034, 0.0f, 0);
-            Offset[0] *= 2.0;
-            Offset[1] *= 2.5;
-            Offset[2] *= 2.0;
+            gObjectList[objectIndex].offset[0] *= 2.0;
+            gObjectList[objectIndex].offset[1] *= 2.5;
+            gObjectList[objectIndex].offset[2] *= 2.0;
             object_calculate_new_pos_offset(objectIndex);
             gObjectList[objectIndex].direction_angle[1] =
                 get_angle_between_two_vectors(gObjectList[objectIndex].unk_01C, gObjectList[objectIndex].pos);
@@ -169,31 +159,26 @@ void OSeagull::func_8008275C(s32 objectIndex) {
 }
 
 void OSeagull::func_8008241C(s32 objectIndex, s32 arg1) {
-    UNUSED s16 stackPadding0;
+    s16 randZ;
+    s16 randX;
+    s16 randY;
 
     gObjectList[objectIndex].unk_0D8 = 1;
     gObjectList[objectIndex].model = (Gfx*) d_course_koopa_troopa_beach_unk4;
     gObjectList[objectIndex].vertex = (Vtx*) d_course_koopa_troopa_beach_unk_data5;
     gObjectList[objectIndex].sizeScaling = 0.2f;
     gObjectList[objectIndex].unk_0DD = 1;
-    // if (gGamestate == CREDITS_SEQUENCE) {
-    //     set_obj_origin_pos(objectIndex, randX + -360.0, randY + 60.0, randZ + -1300.0);
-    // } else if (gObjectList[objectIndex].unk_0D5 != 0) {
-    //     set_obj_origin_pos(objectIndex, (randX + 328.0) * xOrientation, randY + 20.0, randZ + 2541.0);
-    // } else {
-    //     set_obj_origin_pos(objectIndex, (randX + -985.0) * xOrientation, randY + 15.0, randZ + 1200.0);
-    // }
+    randX = random_int(0x00C8) + -100.0;
+    randY = random_int(0x0014);
+    randZ = random_int(0x00C8) + -100.0;
+
+    set_obj_origin_pos(objectIndex, (randX + _pos[0]) * xOrientation, randY + _pos[1], randZ + _pos[2]);
     set_obj_direction_angle(objectIndex, 0U, 0U, 0U);
     gObjectList[objectIndex].unk_034 = 1.0f;
     func_80086EF0(objectIndex);
-    //gObjectList[objectIndex].spline = D_800E633C[arg1 % 4];
-    spline = D_800E633C[arg1 % 4];
-    //set_object_flag(objectIndex, 0x800);
-    //object_next_state(objectIndex);
-    _status |= 0x800;
-    _timer = 0;
-    _status &= ~0x2000;
-    _state++;
+    gObjectList[objectIndex].spline = D_800E633C[arg1 % 4];
+    set_object_flag(objectIndex, 0x00000800);
+    object_next_state(objectIndex);
 }
 
 
diff --git a/src/engine/objects/Seagull.h b/src/engine/objects/Seagull.h
index 528da0708..d575e3721 100644
--- a/src/engine/objects/Seagull.h
+++ b/src/engine/objects/Seagull.h
@@ -2,7 +2,9 @@
 
 #include <libultraship.h>
 #include <vector>
-#include "engine/Actor.h"
+#include "Object.h"
+
+#include "engine/World.h"
 
 extern "C" {
 #include "macros.h"
@@ -11,34 +13,34 @@ extern "C" {
 #include "waypoints.h"
 #include "common_structs.h"
 #include "objects.h"
-#include "course_offsets.h"
-#include "some_data.h"
+#include "camera.h"
 }
 
 
-class OSeagull : public AActor {
+class OSeagull : public OObject {
 public:
-    enum Behaviour : uint16_t {
-    };
+    explicit OSeagull(Vec3f pos);
 
-public:
-    explicit OSeagull(s32 i, Vec3f pos);
+    ~OSeagull() {
+        _count--;
+    }
+
+    static size_t GetCount() {
+        return _count;
+    }
 
     virtual void Tick() override;
-    virtual void Draw(Camera*) override;
+    virtual void Draw(s32 cameraId) override;
+
     void func_800552BC(s32 objectIndex);
 
     void func_8008275C(s32 objectIndex);
     void func_8008241C(s32 objectIndex, s32 arg1);
     void func_80082714(s32 objectIndex, s32 arg1);
-    virtual bool IsMod() override;
-    Vec3f Offset;
-    Vec3f SpawnPos;
 private:
+    Vec3f _pos;
+    static size_t _count;
     s32 _idx;
-    s32 _state;
-    s32 _timer;
-    s32 _status;
     bool _toggle;
 
     SplineData *spline;
diff --git a/src/engine/objects/Thwomp.cpp b/src/engine/objects/Thwomp.cpp
index 87d670cfd..afa12b03b 100644
--- a/src/engine/objects/Thwomp.cpp
+++ b/src/engine/objects/Thwomp.cpp
@@ -44,16 +44,19 @@ f32 D_800E594C[][2] = {
 
 s16 D_800E597C[] = { 0x0000, 0x0000, 0x4000, 0x8000, 0x8000, 0xc000 };
 
-OThwomp::OThwomp(s32 i, s16 x, s16 z, s16 direction, f32 scale, s16 behaviour, s16 primAlpha, u16 boundingBoxSize) {
-    if (i >= 32) {
-        printf("MAX THWOMPS REACHED (32), skipping\n");
-        return;
-    }
-    _idx = i;
+size_t OThwomp::_count = 0;
+
+OThwomp::OThwomp(s16 x, s16 z, s16 direction, f32 scale, s16 behaviour, s16 primAlpha, u16 boundingBoxSize) {
+    _idx = _count;
     _faceDirection = direction;
     _boundingBoxSize = boundingBoxSize;
     State = (States)behaviour;
-    s32 objectId = indexObjectList1[i];
+    
+    if (_idx >= 32) {
+        printf("MAX THWOMPS REACHED (32), skipping\n");
+        return;
+    }
+    s32 objectId = indexObjectList1[_idx];
     init_object(objectId, 0);
     gObjectList[objectId].origin_pos[0] = x * xOrientation;
     gObjectList[objectId].origin_pos[2] = z;
@@ -66,9 +69,11 @@ OThwomp::OThwomp(s32 i, s16 x, s16 z, s16 direction, f32 scale, s16 behaviour, s
     }
 
     gObjectList[objectId].sizeScaling = scale;
+
+    _count++;
 }
 
-void OThwomp::Tick() { // func_80081210
+void OThwomp::Tick60fps() { // func_80081210
     Player* player;
     s32 objectIndex;
     s32 var_s2_3;
@@ -80,6 +85,13 @@ void OThwomp::Tick() { // func_80081210
 
     OThwomp::func_8007F8D8();
 
+    // Tick lights only one time. This gets applied to every thwomp.
+    // Running this more than once per frame will result in the lights moving at a high rate of speed.
+    if (_idx == 0) {
+        D_80165834[0] += 0x100;
+        D_80165834[1] += 0x200;
+    }
+
     objectIndex = indexObjectList1[_idx];
     if (gObjectList[objectIndex].state != 0) {
         switch (State) {
diff --git a/src/engine/objects/Thwomp.h b/src/engine/objects/Thwomp.h
index f64318e4d..22c674bb5 100644
--- a/src/engine/objects/Thwomp.h
+++ b/src/engine/objects/Thwomp.h
@@ -3,6 +3,9 @@
 #include <libultraship.h>
 #include <vector>
 
+#include "engine/World.h"
+#include "engine/objects/Object.h"
+
 extern "C" {
 #include "macros.h"
 #include "main.h"
@@ -27,7 +30,7 @@ extern "C" {
  * @arg primAlpha unknown
  * @arg boundingBoxSize optional. The size of the bounding box for the thwomp. Default value is 12
  */
-class OThwomp {
+class OThwomp : public OObject {
 private:
     enum States : uint16_t {
         DISABLED,
@@ -42,12 +45,20 @@ private:
 public:
     States State = States::DISABLED;
 
-    explicit OThwomp(s32 i, s16 x, s16 z, s16 direction, f32 scale, s16 behaviour, s16 primAlpha, u16 boundingBoxSize);
+    explicit OThwomp(s16 x, s16 z, s16 direction, f32 scale, s16 behaviour, s16 primAlpha, u16 boundingBoxSize = 7);
+
+    ~OThwomp() {
+        _count--;
+    }
+
+    static size_t GetCount() {
+        return _count;
+    }
 
-    void Tick();
+    virtual void Tick60fps() override;
+    virtual void Draw(s32 cameraId) override;
     void SetVisibility(s32 objectIndex);
     void func_80080B28(s32 objectIndex, s32 playerId);
-    void Draw(s32 playerId);
     void DrawModel(s32);
     void TranslateThwompLights();
     void ThwompLights(s32 objectIndex);
@@ -100,6 +111,7 @@ public:
 
     void func_8007E63C(s32 objectIndex);
 private:
+    static size_t _count;
     s32 _idx;
     s16 _faceDirection;
     //! @todo Write this better. This effects the squish size and the bounding box size.