Clean-up and fixed 60fps not spawning in weapons

Author: hyperbx

MarathonRecomp/api/Sonicteam/NamedActor.h

@@ -2,7 +2,7 @@
 
 #include <Marathon.inl>
 #include <Sonicteam/Actor.h>
-#include <api/stdx/string.h>
+#include <stdx/string.h>
 
 namespace Sonicteam
 {

MarathonRecomp/api/Sonicteam/NamedTask.h

@@ -2,7 +2,7 @@
 
 #include <Marathon.inl>
 #include <Sonicteam/SoX/Engine/Task.h>
-#include <api/stdx/string.h>
+#include <stdx/string.h>
 
 namespace Sonicteam
 {

MarathonRecomp/api/Sonicteam/SoX/Engine/Doc.h

@@ -2,6 +2,7 @@
 
 #include <Marathon.inl>
 #include <Sonicteam/SoX/Engine/DocMode.h>
+#include <Sonicteam/SoX/Engine/Task.h>
 
 namespace Sonicteam::SoX::Engine
 {

MarathonRecomp/api/Sonicteam/SoX/Engine/Task.h

@@ -2,38 +2,41 @@
 
 #include <Marathon.inl>
 #include <Sonicteam/SoX/Component.h>
-#include <Sonicteam/SoX/MessageReceiver.h>
 #include <Sonicteam/SoX/LinkNode.h>
+#include <Sonicteam/SoX/MessageReceiver.h>
 
 namespace Sonicteam::SoX::Engine
 {
     class Doc;
+
     class Task : public Component, public MessageReceiver
     {
     public:
-        be<uint32_t> m_flags; //used to store last pointer for itterate, sometimes
-        be<uint32_t> m_timestamp; //not always
-        xpointer<Task> m_pSiblingPrev;
-        xpointer<Task> m_pSiblingNext;
+        be<uint32_t> m_Flags;
+        be<uint32_t> m_Timestamp;
+        xpointer<Task> m_pPrevSibling;
+        xpointer<Task> m_pNextSibling;
         xpointer<Task> m_pDependency;
-        xpointer<Task> m_pDependents;
-        xpointer<Sonicteam::SoX::Engine::Doc> m_pDoc;
-        SoX::LinkNode<Task> m_lnTask;
+        xpointer<Task> m_pDependencies;
+        xpointer<Doc> m_pDoc;
+        LinkNode<Task> m_lnTask;
 
-        Task* GetFirstDependent() const 
+        Task* GetFirstDependency() const 
         {
-            if (!m_pDependents) return nullptr;
+            if (!m_pDependencies)
+                return nullptr;
 
-            Task* current = m_pDependents.get();
-            while (current->m_pSiblingPrev && current->m_pSiblingPrev != m_pDependents.get()) {
-                current = current->m_pSiblingPrev.get();
-            }
-            return current;
-        }
+            auto pCurrent = m_pDependencies.get();
 
-        Task* GetLastDependent() const {
-            return m_pDependents.get();
+            while (pCurrent->m_pPrevSibling && pCurrent->m_pPrevSibling != m_pDependencies.get())
+                pCurrent = pCurrent->m_pPrevSibling.get();
+
+            return pCurrent;
         }
 
+        Task* GetLastDependency() const
+        {
+            return m_pDependencies.get();
+        }
     };
 }

MarathonRecomp/api/Sonicteam/SoX/LinkNode.h

@@ -3,25 +3,25 @@
 namespace Sonicteam::SoX
 {
     template <typename T>
-    class LinkNodeTemplate
+    class ILinkNode
     {
     public:
         xpointer<T> m_pPrev;
         xpointer<T> m_pNext;
     };
 
     template <typename T>
-    class LinkNode : public LinkNodeTemplate<LinkNode<T>>
+    class LinkNode : public ILinkNode<LinkNode<T>>
     {
     public:
-        xpointer<LinkNode<T>> m_pThis;
+        xpointer<T> m_pThis;
     };
 
     template <typename T>
     class LinkRef
     {
     public:
         xpointer<T> m_pElement;
-        SoX::LinkNode<LinkRef> m_lnElement;
+        LinkNode<LinkRef> m_lnElement;
     };
-}
+}

MarathonRecomp/api/Sonicteam/SoX/Object.h

@@ -1,10 +1,22 @@
 #pragma once
 
+#include <Marathon.inl>
+
 namespace Sonicteam::SoX
 {
     class Object
     {
     public:
-        xpointer<void> m_pVftable;
+        struct Vftable
+        {
+            be<uint32_t> fpGetName;
+        };
+
+        xpointer<Vftable> m_pVftable;
+
+        const char* GetName() const
+        {
+            return GuestToHostFunction<const char*>(m_pVftable->fpGetName.get());
+        }
     };
 }

MarathonRecomp/api/Sonicteam/SoX/Physics/Havok/WorldHavok.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include <Marathon.inl>
-#include <Sonicteam/SoX/Physics/World.h>
 #include <hk330/hkpWorld.h>
+#include <Sonicteam/SoX/Physics/World.h>
 
 namespace Sonicteam::SoX::Physics::Havok
 {

MarathonRecomp/api/hk330/hkpCollidableCollidableFilter.h

@@ -9,8 +9,8 @@ namespace hk330
     public:
         struct Vftable
         {
-            be<uint32_t> ctor;
-            be<uint32_t> isCollisionEnabled; //(a,b)
+            be<uint32_t> fpCtor;
+            be<uint32_t> fpIsCollisionEnabled;
         };
 
         xpointer<Vftable> m_pVftable;

MarathonRecomp/api/hk330/hkpCollisionFilter.h

@@ -1,21 +1,21 @@
 #pragma once
 
 #include <Marathon.inl>
-#include <hk330/hkReferencedObject.h>
-#include <Sonicteam/SoX/Math/Vector.h>
-#include <hk330/hkpRigidBody.h>
 #include <hk330/hkArray.h>
 #include <hk330/hkpCollidableCollidableFilter.h>
 #include <hk330/hkpRayCollidableFilter.h>
-#include <hk330/hkpShapeCollectionFilter.h>
 #include <hk330/hkpRayShapeCollectionFilter.h>
+#include <hk330/hkpRigidBody.h>
+#include <hk330/hkpShapeCollectionFilter.h>
+#include <hk330/hkReferencedObject.h>
+#include <Sonicteam/SoX/Math/Vector.h>
 
 namespace hk330
 {
     class hkpCollisionFilter : public hkReferencedObject, public hkpCollidableCollidableFilter, public hkpShapeCollectionFilter, public hkpRayShapeCollectionFilter, public hkpRayCollidableFilter
     {
     public:
         be<uint32_t> m_FilterType;
-        MARATHON_INSERT_PADDING(0xC);
+        MARATHON_INSERT_PADDING(0x0C);
     };
 }

MarathonRecomp/api/hk330/hkpPhantom.h

@@ -1,14 +1,14 @@
 #pragma once
 
-#include <hk330/hkpWorldObject.h>
 #include <hk330/hkArray.h>
+#include <hk330/hkpWorldObject.h>
 
 namespace hk330
 {
     class hkpPhantom : public hkpWorldObject
     {
     public:
-        hkArray<void*> m_overlapListeners;
-        hkArray<void*> m_phantomListeners;
+        hkArray<xpointer<void>> m_overlapListeners;
+        hkArray<xpointer<void>> m_phantomListeners;
     };
 }