Moved a couple of folders and wrote some code

Assets/Packages/FishNet/Runtime/Managing/Timing/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 142c456200062324b95ea95078a9c38f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Packages/FishNet/Runtime/Managing/Timing/Editor/TimeManagerEditor.cs

@@ -0,0 +1,79 @@
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEngine;
+
+namespace FishNet.Managing.Timing.Editing
+{
+
+
+    [CustomEditor(typeof(TimeManager), true)]
+    [CanEditMultipleObjects]
+    public class TimeManagerEditor : Editor
+    {
+        private SerializedProperty _updateOrder;
+        private SerializedProperty _timingType;
+        private SerializedProperty _tickRate;
+        private SerializedProperty _allowTickDropping;
+        private SerializedProperty _maximumFrameTicks;
+        private SerializedProperty _pingInterval;
+        private SerializedProperty _timingInterval;
+        private SerializedProperty _physicsMode;        
+
+        protected virtual void OnEnable()
+        {
+            _updateOrder = serializedObject.FindProperty("_updateOrder");
+            _timingType = serializedObject.FindProperty("_timingType");
+            _tickRate = serializedObject.FindProperty("_tickRate");
+            _allowTickDropping = serializedObject.FindProperty("_allowTickDropping");
+            _maximumFrameTicks = serializedObject.FindProperty("_maximumFrameTicks");
+            _pingInterval = serializedObject.FindProperty("_pingInterval");
+            _timingInterval = serializedObject.FindProperty("_timingInterval");
+            _physicsMode = serializedObject.FindProperty("_physicsMode");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            GUI.enabled = false;
+            EditorGUILayout.ObjectField("Script:", MonoScript.FromMonoBehaviour((TimeManager)target), typeof(TimeManager), false);
+            GUI.enabled = true;
+
+            //Timing.
+            EditorGUILayout.LabelField("Timing", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(_updateOrder);
+            EditorGUILayout.PropertyField(_timingType);
+            EditorGUILayout.PropertyField(_allowTickDropping);
+            if (_allowTickDropping.boolValue == true)
+            {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(_maximumFrameTicks);
+                EditorGUI.indentLevel--;
+            }
+            EditorGUILayout.PropertyField(_tickRate);
+            EditorGUILayout.PropertyField(_pingInterval);
+            EditorGUILayout.PropertyField(_timingInterval);            
+            EditorGUI.indentLevel--;
+            EditorGUILayout.Space();
+
+            //Physics.
+            EditorGUILayout.LabelField("Physics", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(_physicsMode);
+            if (_physicsMode.intValue != (int)FishNet.Managing.Timing.PhysicsMode.TimeManager)
+                EditorGUILayout.HelpBox("If you are using physics interactions be sure to change the PhysicsMode to TimeManager and implement physics within the TimeManager tick events.", MessageType.None);
+            EditorGUI.indentLevel--;
+
+            ////Prediction.
+            //EditorGUILayout.LabelField("Prediction", EditorStyles.boldLabel);
+            //EditorGUI.indentLevel++;
+            //EditorGUILayout.PropertyField(_maximumBufferedInputs);
+            //EditorGUI.indentLevel--;
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+
+}
+#endif

Assets/Packages/FishNet/Runtime/Managing/Timing/Editor/TimeManagerEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 12987a8c0302190489ecb55f6fbd494e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Packages/FishNet/Runtime/Managing/Timing/MovingAverage.cs

@@ -0,0 +1,81 @@
+using FishNet.Documenting;
+using System;
+using UnityEngine;
+
+namespace FishNet.Managing.Timing
+{
+
+    [APIExclude]
+    public class MovingAverage
+    {
+        #region Public.
+        /// <summary>
+        /// Average from samples favoring the most recent sample.
+        /// </summary>
+        public float Average { get; private set; }
+        #endregion
+
+        /// <summary>
+        /// Next index to write a sample to.
+        /// </summary>
+        private int _writeIndex;
+        /// <summary>
+        /// Collected samples.
+        /// </summary>
+        private float[] _samples;
+        /// <summary>
+        /// Number of samples written. Will be at most samples size.
+        /// </summary>
+        private int _writtenSamples;
+        /// <summary>
+        /// Samples accumulated over queue.
+        /// </summary>
+        private float _sampleAccumulator;
+
+        public MovingAverage(int sampleSize)
+        {
+            if (sampleSize < 0)
+                sampleSize = 0;
+            else if (sampleSize < 2)
+                NetworkManager.StaticLogWarning("Using a sampleSize of less than 2 will always return the most recent value as Average.");
+
+            _samples = new float[sampleSize];
+        }
+
+
+        /// <summary>
+        /// Computes a new windowed average each time a new sample arrives
+        /// </summary>
+        /// <param name="newSample"></param>
+        public void ComputeAverage(float newSample)
+        {
+            if (_samples.Length <= 1)
+            {
+                Average = newSample;
+                return;
+            }
+
+            _sampleAccumulator += newSample;
+            _samples[_writeIndex] = newSample;
+
+            //Increase writeIndex.
+            _writeIndex++;
+            _writtenSamples = Math.Max(_writtenSamples, _writeIndex);
+            if (_writeIndex >= _samples.Length)
+                _writeIndex = 0;
+
+            Average = _sampleAccumulator / _writtenSamples;
+
+            /* If samples are full then drop off
+            * the oldest sample. This will always be
+            * the one just after written. The entry isn't
+            * actually removed from the array but will
+            * be overwritten next sample. */
+            if (_writtenSamples >= _samples.Length)
+                _sampleAccumulator -= _samples[_writeIndex];
+
+        }
+    }
+
+
+}

Assets/Packages/FishNet/Runtime/Managing/Timing/MovingAverage.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 03d05f88778c5c744810e48f251f2d3b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Packages/FishNet/Runtime/Managing/Timing/PhysicsMode.cs

@@ -0,0 +1,23 @@
+namespace FishNet.Managing.Timing
+{
+    /// <summary>
+    /// How to simulate physics.
+    /// </summary>
+    public enum PhysicsMode
+    {
+        /// <summary>
+        /// Unity performs physics every FixedUpdate.
+        /// </summary>
+        Unity = 0,
+        /// <summary>
+        /// TimeManager performs physics each tick.
+        /// </summary>
+        TimeManager = 1,
+        /// <summary>
+        /// Physics will be disabled.
+        /// </summary>
+        Disabled = 2
+    }
+
+
+}

Assets/Packages/FishNet/Runtime/Managing/Timing/PhysicsMode.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 502e9f31bebd41f4f9088a19eae53735
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Packages/FishNet/Runtime/Managing/Timing/PreciseTick.cs

@@ -0,0 +1,47 @@
+using FishNet.Serializing;
+using FishNet.Utility.Extension;
+using System;
+using UnityEngine;
+
+namespace FishNet.Managing.Timing
+{
+
+    public struct PreciseTick
+    {
+        /// <summary>
+        /// The current tick.
+        /// </summary>
+        public uint Tick;
+        /// <summary>
+        /// Percentage into the next tick.
+        /// </summary>
+        public double Percent;
+
+        public PreciseTick(uint tick, double percent)
+        {
+            Tick = tick;
+            Percent = percent;
+        }
+    }
+
+    public static class PreciseTickSerializer
+    {
+        public static void WritePreciseTick(this Writer writer, PreciseTick value)
+        {
+            writer.WriteUInt32(value.Tick, AutoPackType.Unpacked);
+            /* No reason percent should exist beyond these values, but better to be safe.
+             * There is also no double clamp in Unity so... */
+            double percent = MathFN.ClampDouble(value.Percent, 0d, 1f);
+            byte percentByte = (byte)(percent * 100);
+            writer.WriteByte(percentByte);
+        }
+
+        public static PreciseTick ReadPreciseTick(this Reader reader)
+        {
+            uint tick = reader.ReadUInt32(AutoPackType.Unpacked);
+            byte percentByte = reader.ReadByte();
+            double percent = MathFN.ClampDouble((percentByte / 100f), 0d, 1d);
+            return new PreciseTick(tick, percent);
+        }
+    }
+}

Assets/Packages/FishNet/Runtime/Managing/Timing/PreciseTick.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a96dd6b21066a424199583b80746464f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Packages/FishNet/Runtime/Managing/Timing/TickRounding.cs

@@ -0,0 +1,23 @@
+namespace FishNet.Managing.Timing
+{
+    /// <summary>
+    /// How ticks are rounded when using time.
+    /// </summary>
+    public enum TickRounding
+    {
+        /// <summary>
+        /// Rounds up.
+        /// </summary>
+        RoundUp,
+        /// <summary>
+        /// Rounds down.
+        /// </summary>
+        RoundDown,
+        /// <summary>
+        /// Rounds to the nearest whole.
+        /// </summary>
+        RoundNearest
+    }
+
+
+}

Assets/Packages/FishNet/Runtime/Managing/Timing/TickRounding.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d12f8894fc7343b4bbe332464dc4bce5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Packages/FishNet/Runtime/Managing/Timing/TickType.cs

@@ -0,0 +1,10 @@
+namespace FishNet.Managing.Timing
+{
+    public enum TickType : byte
+    {
+        Tick = 0,
+        LocalTick = 1,
+        LastPacketTick = 2
+    }
+
+}

Assets/Packages/FishNet/Runtime/Managing/Timing/TickType.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 489fba8b0da3c9b4b9ff4e7a46804473
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Packages/FishNet/Runtime/Managing/Timing/TimeManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3fdaae44044276a49a52229c1597e33b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: bf9191e2e07d29749bca3a1ae44e4bc8, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: