Added baseline for NetworkedVar Settings

Author: TwoTenPvP

MLAPI/Data/NetworkedVar.cs

@@ -1,9 +1,4 @@
-using MLAPI.Data;
-using MLAPI.NetworkingManagerComponents.Binary;
-using MLAPI.NetworkingManagerComponents.Core;
-using System;
-using System.Collections.Generic;
-using UnityEngine;
+using MLAPI.NetworkingManagerComponents.Binary;
 using MLAPI.MonoBehaviours.Core;
 
 namespace MLAPI.Data
@@ -13,6 +8,10 @@ namespace MLAPI.Data
     /// </summary>
     public class NetworkedVar<T> : INetworkedVar
     {
+        public bool IsDirty { get; set; }
+        public readonly NetworkedVarSettings<T> Settings = new NetworkedVarSettings<T>();
+        public float LastSyncedTime { get; internal set; }
+        
         public delegate void OnValueChangedByRemoteDelegate(T newValue);
         public OnValueChangedByRemoteDelegate OnValueChangedByRemote;
         private NetworkedBehaviour networkedBehaviour;
@@ -30,41 +29,93 @@ public T Value
             }
             set
             {
-                if (!EqualityComparer<T>.Default.Equals(InternalValue, value)) // Note: value types of T should implement IEquatable to avoid boxing by default comparer
+                if (Settings.SendOnChange)
                 {
-                    using (BitWriter writer = BitWriter.Get())
-                    {
-                        FieldTypeHelper.WriteFieldType(writer, value, InternalValue);
-                        InternalValue = value;
-                        networkedBehaviour.SendNetworkedVar(this, writer);
-                        MonoBehaviour.print("sending networked var to remote");
-                    }
+                    IsDirty = false;
+                    LastSyncedTime = NetworkingManager.singleton.NetworkTime;
+                    InternalValue = value;
+                    //TODO: Send
                 }
+                else
+                {
+                    InternalValue = value;
+                    IsDirty = true;
+                }
+            }
+        }
+
+        bool INetworkedVar.NeedsDirtySync()
+        {
+            if (!IsDirty && !Settings.SendOnChange && NetworkingManager.singleton.NetworkTime - LastSyncedTime >= Settings.SendDelay)
+            {
+                IsDirty = true;
             }
+            return IsDirty;
+        }
+
+        bool INetworkedVar.CanClientRead(uint clientId)
+        {
+            switch (Settings.ReadPermission)
+            {
+                case NetworkedVarPermission.Everyone:
+                    return true;
+                case NetworkedVarPermission.ServerOnly:
+                    return false;
+                case NetworkedVarPermission.OwnerOnly:
+                    return networkedBehaviour.OwnerClientId == clientId;
+                case NetworkedVarPermission.Custom:
+                {
+                    if (Settings.ReadPermissionCallback == null) return false;
+                    return Settings.ReadPermissionCallback(clientId);
+                }
+            }
+            return true;
+        }
+        
+        bool INetworkedVar.CanClientWrite(uint clientId)
+        {
+            switch (Settings.WritePermission)
+            {
+                case NetworkedVarPermission.Everyone:
+                    return true;
+                case NetworkedVarPermission.ServerOnly:
+                    return false;
+                case NetworkedVarPermission.OwnerOnly:
+                    return networkedBehaviour.OwnerClientId == clientId;
+                case NetworkedVarPermission.Custom:
+                {
+                    if (Settings.WritePermissionCallback == null) return false;
+                    return Settings.WritePermissionCallback(clientId);
+                }
+            }
+
+            return true;
         }
 
         void INetworkedVar.SetNetworkedBehaviour(NetworkedBehaviour behaviour)
         {
             networkedBehaviour = behaviour;
         }
 
-        void INetworkedVar.HandleValueChangedByRemote(BitReader reader)
+        void INetworkedVar.SetFieldFromReader(BitReader reader)
         {
             // TODO TwoTen - Boxing sucks
             T newValue = (T)FieldTypeHelper.ReadFieldType(reader, typeof(T), (object)InternalValue);
-            if (!EqualityComparer<T>.Default.Equals(InternalValue, newValue)) // Note: value types of T should implement IEquatable to avoid boxing by default comparer
-                                                                              // Could allow a non default comparer to be specified by the user for this case?
-            {
-                InternalValue = newValue;
-                OnValueChangedByRemote(Value);
-            }
-            MonoBehaviour.print("value received from remote");
+        }
+        
+        void INetworkedVar.WriteFieldToWriter(BitWriter writer)
+        {
+            //TODO: Write field
         }
     }
 
     internal interface INetworkedVar
     {
-        void HandleValueChangedByRemote(BitReader reader);
+        bool NeedsDirtySync();
+        bool CanClientWrite(uint clientId);
+        bool CanClientRead(uint clientId);
+        void WriteFieldToWriter(BitWriter writer);
+        void SetFieldFromReader(BitReader reader);
         void SetNetworkedBehaviour(NetworkedBehaviour behaviour);
     }
 }

MLAPI/Data/NetworkedVarMeta.cs

@@ -0,0 +1,27 @@
+namespace MLAPI.Data
+{
+    public class NetworkedVarSettings<T>
+    {
+        public NetworkedVarPermission WritePermission = NetworkedVarPermission.ServerOnly;
+        public NetworkedVarPermission ReadPermission = NetworkedVarPermission.Everyone;
+        public NetworkedVarPermissionsDelegate WritePermissionCallback = null;
+        public NetworkedVarPermissionsDelegate ReadPermissionCallback = null;
+        public bool SendOnChange = false;
+        public float SendDelay = 0.1f;
+        
+        internal NetworkedVarSettings()
+        {
+            
+        }
+    }
+    
+    public delegate bool NetworkedVarPermissionsDelegate(uint clientId);
+
+    public enum NetworkedVarPermission
+    {
+        Everyone,
+        ServerOnly,
+        OwnerOnly,
+        Custom
+    }
+}

MLAPI/MLAPI.csproj

@@ -91,6 +91,7 @@
     <Compile Include="Data\Channel.cs" />
     <Compile Include="Data\AttributeMessageMode.cs" />
     <Compile Include="Data\NetworkedVar.cs" />
+    <Compile Include="Data\NetworkedVarMeta.cs" />
     <Compile Include="Data\Transports\ChannelType.cs" />
     <Compile Include="Data\FieldType.cs" />
     <Compile Include="Attributes\SyncedVar.cs" />

MLAPI/MonoBehaviours/Core/NetworkedBehaviour.cs

@@ -928,7 +928,6 @@ private bool SetDirtyness()
         #region NetworkedVar
 
         bool networkedVarInit = false;
-        const string networkedVarTypeName = "NetworkedVar`1";
         List<INetworkedVar> networkedVarFields = new List<INetworkedVar>();
         internal void NetworkedVarInit()
         {
@@ -940,7 +939,7 @@ internal void NetworkedVarInit()
             for (int i = 0; i < sortedFields.Length; i++)
             {
                 Type fieldType = sortedFields[i].FieldType;
-                if (fieldType.Name == networkedVarTypeName)
+                if (fieldType == typeof(NetworkedVar<>))
                 {
                     Type genericTypeDefinition = typeof(NetworkedVar<>);
                     Type genericType = genericTypeDefinition.MakeGenericType(fieldType.GetGenericArguments());
@@ -963,7 +962,7 @@ internal void HandleNetworkedVarChangedByRemote(BitReader reader)
                 return;
             }
 
-            networkedVarFields[index].HandleValueChangedByRemote(reader);
+            networkedVarFields[index].SetFieldFromReader(reader);
         }
 
         internal void SendNetworkedVar(INetworkedVar networkedVar, BitWriter varWriter)