Added more XML documentation and updated API reference

Author: TwoTenPvP

MLAPI/Attributes/SyncedVar.cs

@@ -12,10 +12,5 @@ public class SyncedVar : Attribute
         /// The method name to invoke when the SyncVar get's updated.
         /// </summary>
         public string hook;
-
-        public SyncedVar()
-        {
-            
-        }
     }
 }

MLAPI/MonoBehaviours/Core/NetworkedBehaviour.cs

@@ -118,27 +118,39 @@ private void OnEnable()
         }
 
         internal bool networkedStartInvoked = false;
+        /// <summary>
+        /// Gets called when message handlers are ready to be registered and the networking is setup
+        /// </summary>
         public virtual void NetworkStart()
         {
 
         }
-
+        /// <summary>
+        /// Gets called when the local client gains ownership of this object
+        /// </summary>
         public virtual void OnGainedOwnership()
         {
 
         }
-
+        /// <summary>
+        /// Gets called when we loose ownership of this object
+        /// </summary>
         public virtual void OnLostOwnership()
         {
 
         }
-
-        protected void RegisterMessageHandler(string name, Action<int, byte[]> action)
+        /// <summary>
+        /// Registers a message handler
+        /// </summary>
+        /// <param name="name">The MessageType to register</param>
+        /// <param name="action">The callback to get invoked whenever a message is received</param>
+        /// <returns>HandlerId for the messageHandler that can be used to deregister the messageHandler</returns>
+        protected int RegisterMessageHandler(string name, Action<int, byte[]> action)
         {
             if (!MessageManager.messageTypes.ContainsKey(name))
             {
                 Debug.LogWarning("MLAPI: The messageType " + name + " is not registered");
-                return;
+                return -1;
             }
             ushort messageType = MessageManager.messageTypes[name];
             ushort behaviourOrder = networkedObject.GetOrderIndex(this);
@@ -148,14 +160,20 @@ protected void RegisterMessageHandler(string name, Action<int, byte[]> action)
             if (networkedObject.targetMessageActions[behaviourOrder].ContainsKey(messageType))
             {
                 Debug.LogWarning("MLAPI: Each NetworkedBehaviour can only register one callback per instance per message type");
-                return;
+                return -1;
             }
 
             networkedObject.targetMessageActions[behaviourOrder].Add(messageType, action);
             int counter = MessageManager.AddIncomingMessageHandler(name, action, networkId);
             registeredMessageHandlers.Add(name, counter);
+            return counter;
         }
 
+        /// <summary>
+        /// Deregisters a given message handler
+        /// </summary>
+        /// <param name="name">The MessageType to deregister</param>
+        /// <param name="counter">The messageHandlerId to deregister</param>
         protected void DeregisterMessageHandler(string name, int counter)
         {
             MessageManager.RemoveIncomingMessageHandler(name, counter, networkId);

MLAPI/MonoBehaviours/Prototyping/NetworkedAnimator.cs

@@ -10,7 +10,13 @@ namespace MLAPI.MonoBehaviours.Prototyping
     [AddComponentMenu("MLAPI/NetworkedAnimator")]
     public class NetworkedAnimator : NetworkedBehaviour
     {
+        /// <summary>
+        /// Is proximity enabled
+        /// </summary>
         public bool EnableProximity = false;
+        /// <summary>
+        /// The proximity range
+        /// </summary>
         public float ProximityRange = 50f;
 
         [SerializeField]
@@ -25,14 +31,20 @@ public class NetworkedAnimator : NetworkedBehaviour
         private int transitionHash;
         private float sendTimer;
 
+
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
         // tracking - these should probably move to a Preview component. -- Comment from HLAPI. Needs clarification
         public string param0;
         public string param1;
         public string param2;
         public string param3;
         public string param4;
         public string param5;
+#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
 
+        /// <summary>
+        /// Gets or sets the animator component used for syncing the animations
+        /// </summary>
         public Animator animator
         {
             get { return _animator; }
@@ -42,7 +54,11 @@ public Animator animator
                 ResetParameterOptions();
             }
         }
-
+        /// <summary>
+        /// TODO
+        /// </summary>
+        /// <param name="index"></param>
+        /// <param name="value"></param>
         public void SetParameterAutoSend(int index, bool value)
         {
             if (value)
@@ -54,7 +70,11 @@ public void SetParameterAutoSend(int index, bool value)
                 parameterSendBits &= (uint)(~(1 << index));
             }
         }
-
+        /// <summary>
+        /// TODO
+        /// </summary>
+        /// <param name="index"></param>
+        /// <returns></returns>
         public bool GetParameterAutoSend(int index)
         {
             return (parameterSendBits & (uint)(1 << index)) != 0;
@@ -68,13 +88,19 @@ private bool sendMessagesAllowed
             }
         }
 
+        /// <summary>
+        /// Registers message handlers
+        /// </summary>
         public override void NetworkStart()
         {
             RegisterMessageHandler("MLAPI_HandleAnimationMessage", HandleAnimMsg);
             RegisterMessageHandler("MLAPI_HandleAnimationParameterMessage", HandleAnimParamsMsg);
             RegisterMessageHandler("MLAPI_HandleAnimationTriggerMessage", HandleAnimTriggerMsg);
         }
 
+        /// <summary>
+        /// TODO
+        /// </summary>
         public void ResetParameterOptions()
         {
             Debug.Log("ResetParameterOptions");
@@ -377,11 +403,19 @@ private void ReadParameters(BinaryReader reader, bool autoSend)
             }
         }
 
+        /// <summary>
+        /// TODO
+        /// </summary>
+        /// <param name="triggerName"></param>
         public void SetTrigger(string triggerName)
         {
             SetTrigger(Animator.StringToHash(triggerName));
         }
 
+        /// <summary>
+        /// TODO
+        /// </summary>
+        /// <param name="hash"></param>
         public void SetTrigger(int hash)
         {
             if (isLocalPlayer || isOwner)

MLAPI/MonoBehaviours/Prototyping/NetworkedNavMeshAgent.cs

@@ -12,12 +12,27 @@ namespace MLAPI.MonoBehaviours.Prototyping
     public class NetworkedNavMeshAgent : NetworkedBehaviour
     {
         private NavMeshAgent agent;
+        /// <summary>
+        /// Is proximity enabled
+        /// </summary>
         public bool EnableProximity = false;
+        /// <summary>
+        /// The proximity range
+        /// </summary>
         public float ProximityRange = 50f;
+        /// <summary>
+        /// The delay in seconds between corrections
+        /// </summary>
         public float CorrectionDelay = 3f;
         //TODO rephrase.
+        /// <summary>
+        /// The percentage to lerp on corrections
+        /// </summary>
         [Tooltip("Everytime a correction packet is recieved. This is the percentage (between 0 & 1) that we will move towards the goal.")]
         public float DriftCorrectionPercentage = 0.1f;
+        /// <summary>
+        /// Should we warp on destination change
+        /// </summary>
         public bool WarpOnDestinationChange = false;
 
         private static byte[] stateUpdateBuffer = new byte[36];
@@ -28,6 +43,9 @@ private void Awake()
             agent = GetComponent<NavMeshAgent>();
         }
 
+        /// <summary>
+        /// Registers message handlers
+        /// </summary>
         public override void NetworkStart()
         {
             if (isClient)

MLAPI/MonoBehaviours/Prototyping/NetworkedTransform.cs

@@ -9,16 +9,37 @@ namespace MLAPI.MonoBehaviours.Prototyping
     [AddComponentMenu("MLAPI/NetworkedTransform")]
     public class NetworkedTransform : NetworkedBehaviour
     {
+        /// <summary>
+        /// Sends per second
+        /// </summary>
         [Range(0f, 120f)]
         public float SendsPerSecond = 20;
+        /// <summary>
+        /// Is the sends per second assumed to be the same across all instances
+        /// </summary>
         [Tooltip("This assumes that the SendsPerSecond is synced across clients")]
         public bool AssumeSyncedSends = true;
+        /// <summary>
+        /// Enable interpolation
+        /// </summary>
         [Tooltip("This requires AssumeSyncedSends to be true")]
         public bool InterpolatePosition = true;
+        /// <summary>
+        /// The distance before snaping to the position
+        /// </summary>
         [Tooltip("The transform will snap if the distance is greater than this distance")]
         public float SnapDistance = 10f;
+        /// <summary>
+        /// Should the server interpolate
+        /// </summary>
         public bool InterpolateServer = true;
+        /// <summary>
+        /// The min meters to move before a send is sent
+        /// </summary>
         public float MinMeters = 0.15f;
+        /// <summary>
+        /// The min degrees to rotate before a send it sent
+        /// </summary>
         public float MinDegrees = 1.5f;
         private float timeForLerp;
         private float lerpT;
@@ -30,8 +51,13 @@ public class NetworkedTransform : NetworkedBehaviour
         private float lastSendTime;
         private Vector3 lastSentPos;
         private Quaternion lastSentRot;
-
+        /// <summary>
+        /// Should proximity be enabled
+        /// </summary>
         public bool EnableProximity = false;
+        /// <summary>
+        /// The distance to use for proximity
+        /// </summary>
         [Tooltip("If enable proximity is turned on, on clients within this range will be recieving position updates from the server")]
         public float ProximityRange = 50;
 
@@ -48,7 +74,10 @@ private void OnValidate()
             if (MinMeters < 0)
                 MinMeters = 0;
         }
-
+        
+        /// <summary>
+        /// Registers message handlers
+        /// </summary>
         public override void NetworkStart()
         {
             if (isServer)

MLAPI/NetworkingManagerComponents/DiffieHellman.cs

@@ -79,9 +79,9 @@ public byte[] GetSharedSecret(byte[] pK)
         }
     }
 
-    public static class DHHelper
+    internal static class DHHelper
     {
-        public static byte[] ToArray(this IntX v)
+        internal static byte[] ToArray(this IntX v)
         {
             v.GetInternalState(out uint[] digits, out bool negative);
             byte[] b = DigitConverter.ToBytes(digits);
@@ -90,15 +90,15 @@ public static byte[] ToArray(this IntX v)
             b1[b.Length] = (byte)(negative ? 1 : 0);
             return b1;
         }
-        public static IntX FromArray(byte[] b)
+        internal static IntX FromArray(byte[] b)
         {
             if (b.Length == 0) return new IntX();
             byte[] b1 = new byte[b.Length - 1];
             Array.Copy(b, b1, b1.Length);
             uint[] u = DigitConverter.FromBytes(b1);
             return new IntX(u, b[b.Length - 1]==1);
         }
-        public static bool BitAt(this uint[] data, long index) => (data[index / 32] & (1 << (int)(index % 32))) != 0;
-        public static IntX Abs(this IntX i) => i < 0 ? -i : i;
+        internal static bool BitAt(this uint[] data, long index) => (data[index / 32] & (1 << (int)(index % 32))) != 0;
+        internal static IntX Abs(this IntX i) => i < 0 ? -i : i;
     }
 }

MLAPI/NetworkingManagerComponents/LagCompensationManager.cs

@@ -11,7 +11,7 @@ namespace MLAPI.NetworkingManagerComponents
     /// </summary>
     public static class LagCompensationManager
     {
-        public static List<TrackedObject> SimulationObjects = new List<TrackedObject>();
+        internal static List<TrackedObject> SimulationObjects = new List<TrackedObject>();
 
         /// <summary>
         /// Turns time back a given amount of seconds, invokes an action and turns it back