Prototype components

MLAPI/Data/NetworkingConfiguration.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Net;
 using System.Security.Cryptography;
 using UnityEngine.Networking;
 

MLAPI/MLAPI.csproj

@@ -51,6 +51,7 @@
     <Compile Include="MonoBehaviours\Core\NetworkedObject.cs" />
     <Compile Include="Data\NetworkingConfiguration.cs" />
     <Compile Include="MonoBehaviours\Core\NetworkingManager.cs" />
+    <Compile Include="MonoBehaviours\Prototyping\NetworkedTransform.cs" />
     <Compile Include="NetworkingManagerComponents\MessageManager.cs" />
     <Compile Include="NetworkingManagerComponents\SpawnManager.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

MLAPI/MonoBehaviours/Core/NetworkingManager.cs

@@ -84,12 +84,14 @@ private ConnectionConfig Init(NetworkingConfiguration netConfig)
 
             //MLAPI channels and messageTypes
             NetworkConfig.Channels.Add("MLAPI_RELIABLE_FRAGMENTED", QosType.ReliableFragmented);
+            NetworkConfig.Channels.Add("MLAPI_POSITION_UPDATE", QosType.StateUpdate);
             MessageManager.messageTypes.Add("MLAPI_CONNECTION_REQUEST", 0);
             MessageManager.messageTypes.Add("MLAPI_CONNECTION_APPROVED", 1);
             MessageManager.messageTypes.Add("MLAPI_ADD_OBJECT", 2);
             MessageManager.messageTypes.Add("MLAPI_CLIENT_DISCONNECT", 3);
             MessageManager.messageTypes.Add("MLAPI_DESTROY_OBJECT", 4);
-
+            NetworkConfig.MessageTypes.Add("MLAPI_OnRecieveTransformFromClient");
+            NetworkConfig.MessageTypes.Add("MLAPI_OnRecieveTransformFromServer");
 
             HashSet<string> channelNames = new HashSet<string>();
             foreach (KeyValuePair<string, QosType> pair in NetworkConfig.Channels)

MLAPI/MonoBehaviours/Prototyping/NetworkedTransform.cs

@@ -0,0 +1,165 @@
+using MLAPI;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+
+namespace MLAP
+{
+    public class NetworkedTransform : NetworkedBehaviour
+    {
+        [Range(0, 120)]
+        public int SendsPerSecond = 20;
+        [Tooltip("This assumes that the SendsPerSecond is synced across clients")]
+        public bool AssumeSyncedSends = true;
+        [Tooltip("This requires AssumeSyncedSends to be true")]
+        public bool InterpolatePosition = true;
+        [Tooltip("The transform will snap if the distance is greater than this distance")]
+        public float SnapDistance = 10f;
+        public bool InterpolateServer = true;
+        public float MinMeters = 0.15f;
+        public float MinDegrees = 1.5f;
+        private float timeForLerp;
+        private float lerpT;
+        private Vector3 lerpStartPos;
+        private Quaternion lerpStartRot;
+        private Vector3 lerpEndPos;
+        private Quaternion lerpEndRot;
+
+        private float lastSendTime;
+        private Vector3 lastSentPos;
+        private Quaternion lastSentRot;
+
+        private void OnValidate()
+        {
+            if (!AssumeSyncedSends && InterpolatePosition)
+                InterpolatePosition = false;
+            if (InterpolateServer && !InterpolatePosition)
+                InterpolateServer = false;
+            if (MinDegrees < 0)
+                MinDegrees = 0;
+            if (MinMeters < 0)
+                MinMeters = 0;
+        }
+
+
+        void Start()
+        {
+            if (isServer)
+            {
+                RegisterMessageHandler("MLAPI_OnRecieveTransformFromClient", OnRecieveTransformFromClient);
+            }
+            if (isClient)
+            {
+                RegisterMessageHandler("MLAPI_OnRecieveTransformFromServer", OnRecieveTransformFromServer);
+            }
+            if(AssumeSyncedSends)
+            {
+                timeForLerp = 1f / SendsPerSecond;
+            }
+        }
+
+        void Update()
+        {
+            if(isLocalPlayer)
+            {
+                if(Time.time - lastSendTime >= timeForLerp && (Vector3.Distance(transform.position, lastSentPos) > MinMeters || Quaternion.Angle(transform.rotation, lastSentRot) > MinDegrees))
+                {
+                    lastSendTime = Time.time;
+                    lastSentPos = transform.position;
+                    lastSentRot = transform.rotation;
+                    using (MemoryStream writeStream = new MemoryStream())
+                    {
+                        using (BinaryWriter writer = new BinaryWriter(writeStream))
+                        {
+                            writer.Write(transform.position.x);
+                            writer.Write(transform.position.y);
+                            writer.Write(transform.position.z);
+                            writer.Write(transform.rotation.x);
+                            writer.Write(transform.rotation.y);
+                            writer.Write(transform.rotation.z);
+                        }
+                        SendToServerTarget("MLAPI_OnRecieveTransformFromClient", "MLAPI_POSITION_UPDATE", writeStream.ToArray());
+                    }
+
+                }
+            }
+            else
+            {
+                if((isServer && InterpolateServer) || !isServer)
+                {
+                    lerpT += Time.deltaTime / timeForLerp;
+                    transform.position = Vector3.Lerp(lerpStartPos, lerpEndPos, lerpT);
+                    transform.rotation = Quaternion.Slerp(lerpStartRot, lerpEndRot, lerpT);
+                }
+            }
+        }
+
+        private void OnRecieveTransformFromServer(int clientId, byte[] data)
+        {
+            if (isServer)
+                return;
+            using (MemoryStream stream = new MemoryStream(data))
+            {
+                using (BinaryReader reader = new BinaryReader(stream))
+                {
+                    float xPos = reader.ReadSingle();
+                    float yPos = reader.ReadSingle();
+                    float zPos = reader.ReadSingle();
+                    float xRot = reader.ReadSingle();
+                    float yRot = reader.ReadSingle();
+                    float zRot = reader.ReadSingle();
+                    lerpStartPos = transform.position;
+                    lerpStartRot = transform.rotation;
+                    lerpEndPos = new Vector3(xPos, yPos, zRot);
+                    lerpEndRot = Quaternion.Euler(xRot, yRot, zRot);
+                    lerpT = 0;
+                }
+            }
+        }
+
+        private void OnRecieveTransformFromClient(int clientId, byte[] data)
+        {
+            using(MemoryStream readStream = new MemoryStream(data))
+            {
+                using(BinaryReader reader = new BinaryReader(readStream))
+                {
+                    float xPos = reader.ReadSingle();
+                    float yPos = reader.ReadSingle();
+                    float zPos = reader.ReadSingle();
+                    float xRot = reader.ReadSingle();
+                    float yRot = reader.ReadSingle();
+                    float zRot = reader.ReadSingle();
+                    if (InterpolateServer)
+                    {
+                        lerpStartPos = transform.position;
+                        lerpStartRot = transform.rotation;
+                        lerpEndPos = new Vector3(xPos, yPos, zRot);
+                        lerpEndRot = Quaternion.Euler(xRot, yRot, zRot);
+                        lerpT = 0;
+                    }
+                    else
+                    {
+                        transform.position = new Vector3(xPos, yPos, zPos);
+                        transform.rotation = Quaternion.Euler(new Vector3(xRot, yRot, zRot));
+                    }
+                    using (MemoryStream writeStream = new MemoryStream())
+                    {
+                        using(BinaryWriter writer = new BinaryWriter(writeStream))
+                        {
+                            writer.Write(xPos);
+                            writer.Write(yPos);
+                            writer.Write(zPos);
+                            writer.Write(xRot);
+                            writer.Write(yRot);
+                            writer.Write(zRot);
+                        }
+                        SendToNonLocalClientsTarget("MLAPI_OnRecieveTransformFromServer", "MLAPI_POSITION_UPDATE", writeStream.ToArray());
+                    }
+                }
+            }
+        }
+    }
+}