Reworked the internal event loop & Lag compensator

MLAPI/Data/FixedQueue.cs

@@ -0,0 +1,40 @@
+using System;
+
+namespace MLAPI.Data
+{
+    public class FixedQueue<T>
+    {
+        protected readonly T[] queue;
+        protected int queueCount = 0;
+        protected int queueStart;
+
+        public int Count { get => queueCount; }
+
+        public FixedQueue(int maxSize)
+        {
+            queue = new T[maxSize];
+            queueStart = 0;
+        }
+
+        public bool Enqueue(T t)
+        {
+            queue[(queueStart + queueCount) % queue.Length] = t;
+            if (++queueCount > queue.Length)
+            {
+                --queueCount;
+                return true;
+            }
+            return false;
+        }
+
+        public T Dequeue()
+        {
+            if (--queueCount == -1) throw new IndexOutOfRangeException("Cannot dequeue empty queue!");
+            T res = queue[queueStart];
+            queueStart = (queueStart + 1) % queue.Length;
+            return res;
+        }
+
+        public T ElementAt(int index) => queue[(queueStart + index) % queue.Length];
+    }
+}

MLAPI/Data/NetworkConfig.cs

@@ -104,7 +104,7 @@ namespace MLAPI.Data
         /// <summary>
         /// The amount of seconds to keep a lag compensation position history
         /// </summary>
-        public float SecondsHistory = 5;
+        public int SecondsHistory = 5;
         /// <summary>
         /// Wheter or not to make the library handle object spawning
         /// </summary>

MLAPI/MLAPI.csproj

@@ -74,6 +74,7 @@
     <Compile Include="Data\Channel.cs" />
     <Compile Include="Data\FieldType.cs" />
     <Compile Include="Attributes\SyncedVar.cs" />
+    <Compile Include="Data\FixedQueue.cs" />
     <Compile Include="Data\NetworkConfig.cs" />
     <Compile Include="Data\NetworkedPrefab.cs" />
     <Compile Include="Data\NetworkPool.cs" />

MLAPI/MonoBehaviours/Core/NetworkingManager.cs

@@ -212,9 +212,10 @@ namespace MLAPI.MonoBehaviours.Core
         private ConnectionConfig Init(bool server)
         {
             networkTime = 0f;
-            lastSendTickTime = 0;
+            lastSendTickTime = 0f;
-            lastEventTickTime = 0;
+            lastEventTickTime = 0f;
-            lastReceiveTickTime = 0;
+            lastReceiveTickTime = 0f;
+            eventOvershootCounter = 0f;
             pendingClients = new HashSet<uint>();
             connectedClients = new Dictionary<uint, NetworkedClient>();
             messageBuffer = new byte[NetworkConfig.MessageBufferSize];
@@ -679,6 +680,7 @@ namespace MLAPI.MonoBehaviours.Core
         private float lastReceiveTickTime;
         private float lastSendTickTime;
         private float lastEventTickTime;
+        private float eventOvershootCounter;
         private float lastTimeSyncTime;
         private void Update()
         {
@@ -781,12 +783,19 @@ namespace MLAPI.MonoBehaviours.Core
                     lastReceiveTickTime = NetworkTime;
                 }
 
-                if (isServer && ((NetworkTime - lastEventTickTime >= (1f / NetworkConfig.EventTickrate)) || NetworkConfig.EventTickrate <= 0))
+                if (isServer && ((NetworkTime - lastEventTickTime >= (1f / NetworkConfig.EventTickrate))))
                 {
+                    eventOvershootCounter += ((NetworkTime - lastEventTickTime) - (1f / NetworkConfig.EventTickrate));
                     LagCompensationManager.AddFrames();
                     NetworkedObject.InvokeSyncvarUpdate();
                     lastEventTickTime = NetworkTime;
                 }
+                else if (isServer && eventOvershootCounter >= ((1f / NetworkConfig.EventTickrate)))
+                {
+                    //We run this one to compensate for previous update overshoots.
+                    eventOvershootCounter -= (1f / NetworkConfig.EventTickrate);
+                    LagCompensationManager.AddFrames();
+                }
 
                 if (NetworkConfig.EnableTimeResync && NetworkTime - lastTimeSyncTime >= 30)
                 {

MLAPI/MonoBehaviours/Core/TrackedObject.cs

@@ -1,5 +1,6 @@
 using MLAPI.Data;
 using MLAPI.NetworkingManagerComponents.Core;
+using System;
 using System.Collections.Generic;
 using UnityEngine;
 
@@ -15,7 +16,7 @@ namespace MLAPI.MonoBehaviours.Core
     public class TrackedObject : MonoBehaviour
     {
         internal Dictionary<float, TrackedPointData> FrameData = new Dictionary<float, TrackedPointData>();
-        internal LinkedList<float> Framekeys = new LinkedList<float>();
+        internal FixedQueue<float> Framekeys;
         private Vector3 savedPosition;
         private Quaternion savedRotation;
 
@@ -37,38 +38,49 @@ namespace MLAPI.MonoBehaviours.Core
         {
             get
             {
-                if (Framekeys.First == null || Framekeys.Last == null)
+                if (Framekeys.Count < 2)
                     return 0;
-                float totalSpan = Framekeys.Last.Value - Framekeys.First.Value;
+                float totalSpan = Framekeys.ElementAt(Framekeys.Count - 1) - Framekeys.ElementAt(0);
                 return (totalSpan / Framekeys.Count) * 1000f;
             }
         }
 
+        public float TotalTimeHistory
+        {
+            get
+            {
+                return Framekeys.ElementAt(Framekeys.Count - 1) - Framekeys.ElementAt(0);
+            }
+        }
+
+        private int maxPoints
+        {
+            get
+            {
+                return (int)(NetworkingManager.singleton.NetworkConfig.SecondsHistory / (1f / NetworkingManager.singleton.NetworkConfig.EventTickrate));
+            }
+        }
+
         internal void ReverseTransform(float secondsAgo)
         {
             savedPosition = transform.position;
             savedRotation = transform.rotation;
+
             float currentTime = NetworkingManager.singleton.NetworkTime;
             float targetTime = currentTime - secondsAgo;
-            float previousTime = 0;
+
-            float nextTime = 0;
+            float previousTime = 0f;
-            LinkedListNode<float> node = Framekeys.First;
+            float nextTime = 0f;
-            float previousValue = 0f;
+            for (int i = 0; i < Framekeys.Count; i++)
-            while(node != null)
             {
-                if(previousValue <= targetTime && node.Value >= targetTime)
+                if (previousTime <= targetTime && Framekeys.ElementAt(i) >= targetTime)
                 {
-                    previousTime = previousValue;
+                    nextTime = Framekeys.ElementAt(i);
-                    nextTime = node.Value;
                     break;
                 }
                 else
-                {
+                    previousTime = Framekeys.ElementAt(i);
-                    previousValue = node.Value;
-                    node = node.Next;
-                }
             }
-
             float timeBetweenFrames = nextTime - previousTime;
             float timeAwayFromPrevious = currentTime - previousTime;
             float lerpProgress = timeAwayFromPrevious / timeBetweenFrames;
@@ -84,35 +96,27 @@ namespace MLAPI.MonoBehaviours.Core
 
         void Start()
         {
-            Framekeys.AddFirst(0);
+            Framekeys = new FixedQueue<float>(maxPoints);
+            Framekeys.Enqueue(0);
             LagCompensationManager.simulationObjects.Add(this);
         }
 
         void OnDestroy()
         {
-            Framekeys.Clear();
-            FrameData.Clear();
             LagCompensationManager.simulationObjects.Remove(this);
         }
 
         internal void AddFrame()
         {
-            float currentTime = NetworkingManager.singleton.NetworkTime;
+            if (Framekeys.Count == maxPoints)
-            LinkedListNode<float> node = Framekeys.First;
+                FrameData.Remove(Framekeys.Dequeue());
-            LinkedListNode<float> nextNode = node.Next;
+
-            while (node != null && currentTime - node.Value >= NetworkingManager.singleton.NetworkConfig.SecondsHistory)
-            {
-                nextNode = node.Next;
-                FrameData.Remove(node.Value);
-                Framekeys.RemoveFirst();
-                node = nextNode;
-            }
             FrameData.Add(NetworkingManager.singleton.NetworkTime, new TrackedPointData()
             {
                 position = transform.position,
                 rotation = transform.rotation
             });
-            Framekeys.AddLast(NetworkingManager.singleton.NetworkTime);
+            Framekeys.Enqueue(NetworkingManager.singleton.NetworkTime);
         }
     }
 }