Finish CustomNetworkTransform

diff --git a/src/Impostor.Server/GameData/Objects/Components/InnerCustomNetworkTransform.cs b/src/Impostor.Server/GameData/Objects/Components/InnerCustomNetworkTransform.cs
index 013d666fd1c42f68949adf08cb4d11eefc207509..d3b5c051763f2afa3af03f9cc3b1beff74cf2ed5 100644 (file)
--- a/src/Impostor.Server/GameData/Objects/Components/InnerCustomNetworkTransform.cs
+++ b/src/Impostor.Server/GameData/Objects/Components/InnerCustomNetworkTransform.cs
@@ -1,7 +1,7 @@
-using System;
-using System.Numerics;
+using System.Numerics;
 using Impostor.Server.Net.Messages;
 using Impostor.Shared.Innersloth;
+using Microsoft.Extensions.Logging;
 
 namespace Impostor.Server.GameData.Objects.Components
 {
@@ -10,63 +10,104 @@ namespace Impostor.Server.GameData.Objects.Components
         private static readonly FloatRange XRange = new FloatRange(-40f, 40f);
         private static readonly FloatRange YRange = new FloatRange(-40f, 40f);
 
+        private readonly ILogger<InnerCustomNetworkTransform> _logger;
+
         private ushort _lastSequenceId;
         private Vector2 _targetSyncPosition;
         private Vector2 _targetSyncVelocity;
 
+        public InnerCustomNetworkTransform(ILogger<InnerCustomNetworkTransform> logger)
+        {
+            _logger = logger;
+        }
+
+        private static bool SidGreaterThan(ushort newSid, ushort prevSid)
+        {
+            var num = (ushort)(prevSid + (uint) short.MaxValue);
+
+            return (int) prevSid < (int) num
+                ? newSid > prevSid && newSid <= num
+                : newSid > prevSid || newSid <= num;
+        }
+
+        private static void WriteVector2(IMessageWriter writer, Vector2 vec)
+        {
+            writer.Write((ushort)(XRange.ReverseLerp(vec.X) * (double) ushort.MaxValue));
+            writer.Write((ushort)(YRange.ReverseLerp(vec.Y) * (double) ushort.MaxValue));
+        }
+
+        private static Vector2 ReadVector2(IMessageReader reader)
+        {
+            var v1 = reader.ReadUInt16() / (float) ushort.MaxValue;
+            var v2 = reader.ReadUInt16() / (float) ushort.MaxValue;
+
+            return new Vector2(XRange.Lerp(v1), YRange.Lerp(v2));
+        }
+
         public override void HandleRpc(byte callId, IMessageReader reader)
         {
-            throw new NotImplementedException();
+            if (callId == 0)
+            {
+                SnapTo(ReadVector2(reader), reader.ReadUInt16());
+            }
+            else
+            {
+                _logger.LogWarning("InnerCustomNetworkTransform: Unknown rpc call {0}", callId);
+            }
         }
 
         public override bool Serialize(IMessageWriter writer, bool initialState)
         {
-            throw new NotImplementedException();
+            if (initialState)
+            {
+                writer.Write(_lastSequenceId);
+                WriteVector2(writer, _targetSyncPosition);
+                WriteVector2(writer, _targetSyncVelocity);
+                return true;
+            }
+
+            // TODO: DirtyBits == 0 return false.
+            _lastSequenceId++;
+
+            writer.Write(_lastSequenceId);
+            WriteVector2(writer, _targetSyncPosition);
+            WriteVector2(writer, _targetSyncVelocity);
+            return true;
         }
 
         public override void Deserialize(IMessageReader reader, bool initialState)
         {
+            var sequenceId = reader.ReadUInt16();
+
             if (initialState)
             {
-                _lastSequenceId = reader.ReadUInt16();
+                _lastSequenceId = sequenceId;
                 _targetSyncPosition = ReadVector2(reader);
                 _targetSyncVelocity = ReadVector2(reader);
-
-                Console.WriteLine(_targetSyncPosition + " - " + _targetSyncVelocity);
             }
             else
             {
-                var newSid = reader.ReadUInt16();
-                if (!SidGreaterThan(newSid, _lastSequenceId))
+                if (!SidGreaterThan(sequenceId, _lastSequenceId))
                 {
                     return;
                 }
 
-                _lastSequenceId = newSid;
+                _lastSequenceId = sequenceId;
                 _targetSyncPosition = ReadVector2(reader);
                 _targetSyncVelocity = ReadVector2(reader);
-
-                // TODO: Snap / update position
-
-                Console.WriteLine(_targetSyncPosition + " - " + _targetSyncVelocity);
             }
         }
 
-        private static bool SidGreaterThan(ushort newSid, ushort prevSid)
+        private void SnapTo(Vector2 position, ushort minSid)
         {
-            var num = (ushort)(prevSid + (uint) short.MaxValue);
-
-            return (int) prevSid < (int) num
-                ? newSid > prevSid && newSid <= num
-                : newSid > prevSid || newSid <= num;
-        }
-
-        public static Vector2 ReadVector2(IMessageReader reader)
-        {
-            var v1 = (float) reader.ReadUInt16() / (float) ushort.MaxValue;
-            var v2 = (float) reader.ReadUInt16() / (float) ushort.MaxValue;
+            if (SidGreaterThan(minSid, _lastSequenceId))
+            {
+                return;
+            }
 
-            return new Vector2(XRange.Lerp(v1), YRange.Lerp(v2));
+            _lastSequenceId = minSid;
+            _targetSyncPosition = position;
+            _targetSyncVelocity = Vector2.Zero;
         }
     }
 }
\ No newline at end of file

diff --git a/src/Impostor.Server/GameData/Objects/InnerPlayerControl.cs b/src/Impostor.Server/GameData/Objects/InnerPlayerControl.cs
index 91116702195acfd793789c8eca86e3855a04efa0..5da19a95ae017e356f103194594cc69089628b0c 100644 (file)
--- a/src/Impostor.Server/GameData/Objects/InnerPlayerControl.cs
+++ b/src/Impostor.Server/GameData/Objects/InnerPlayerControl.cs
@@ -2,6 +2,7 @@
 using Impostor.Server.GameData.Objects.Components;
 using Impostor.Server.Games;
 using Impostor.Server.Net.Messages;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Impostor.Server.GameData.Objects
 {
@@ -9,13 +10,13 @@ namespace Impostor.Server.GameData.Objects
     {
         private readonly IGame _game;
 
-        public InnerPlayerControl(IGame game)
+        public InnerPlayerControl(IGame game, IServiceProvider serviceProvider)
         {
             _game = game;
 
             Components.Add(this);
-            Components.Add(new InnerPlayerPhysics());
-            Components.Add(new InnerCustomNetworkTransform());
+            Components.Add(ActivatorUtilities.CreateInstance<InnerPlayerPhysics>(serviceProvider));
+            Components.Add(ActivatorUtilities.CreateInstance<InnerCustomNetworkTransform>(serviceProvider));
 
             PlayerId = byte.MaxValue;
         }

diff --git a/src/Impostor.Shared/Innersloth/FloatRange.cs b/src/Impostor.Shared/Innersloth/FloatRange.cs
index 23c3ed42725c8dd8dd640586f1a3b115f4ac39d3..fc68e2de7632617db5bdd7aa7ff547c93965cc84 100644 (file)
--- a/src/Impostor.Shared/Innersloth/FloatRange.cs
+++ b/src/Impostor.Shared/Innersloth/FloatRange.cs
@@ -13,6 +13,10 @@ namespace Impostor.Shared.Innersloth
             _max = max;
         }
 
-        public float Lerp(float v) => Mathf.Lerp(this._min, this._max, v);
+        public float Width => _max - _min;
+
+        public float Lerp(float v) => Mathf.Lerp(_min, _max, v);
+
+        public float ReverseLerp(float t) => Mathf.Clamp((t - _min) / Width, 0.0f, 1f);
     }
 }
\ No newline at end of file

diff --git a/src/Impostor.Shared/Unity/Mathf.cs b/src/Impostor.Shared/Unity/Mathf.cs
index bc6b51048bfecbdbe90137e36e8d11ffcc62ef9e..e608bbbd84f97452d5c2b74c93bfd2831eb88b92 100644 (file)
--- a/src/Impostor.Shared/Unity/Mathf.cs
+++ b/src/Impostor.Shared/Unity/Mathf.cs
@@ -2,6 +2,24 @@
 {
     public static class Mathf
     {
+        /// <summary>
+        ///   <para>Clamps the given value between the given minimum float and maximum float values.  Returns the given value if it is within the min and max range.</para>
+        /// </summary>
+        /// <param name="value">The floating point value to restrict inside the range defined by the min and max values.</param>
+        /// <param name="min">The minimum floating point value to compare against.</param>
+        /// <param name="max">The maximum floating point value to compare against.</param>
+        /// <returns>
+        ///   <para>The float result between the min and max values.</para>
+        /// </returns>
+        public static float Clamp(float value, float min, float max)
+        {
+            if ((double) value < (double) min)
+                value = min;
+            else if ((double) value > (double) max)
+                value = max;
+            return value;
+        }
+
         /// <summary>
         ///   <para>Clamps value between 0 and 1 and returns value.</para>
         /// </summary>