Added Binary serialization overloads to send methods

Author: TwoTenPvP

MLAPI/MonoBehaviours/Core/NetworkedBehaviour.cs

@@ -685,6 +685,18 @@ protected void SendToServer(string messageType, string channelName, byte[] data)
             NetworkingManager.singleton.Send(NetworkingManager.singleton.serverClientId, messageType, channelName, data);
         }
 
+        /// <summary>
+        /// Sends a binary serialized class to the server from client 
+        /// </summary>
+        /// <typeparam name="T">The class type to send</typeparam>
+        /// <param name="messageType">User defined messageType</param>
+        /// <param name="channelName">User defined channelName</param>
+        /// <param name="instance">The instance to send</param>
+        protected void SendToServer<T>(string messageType, string channelName, T instance)
+        {
+            SendToServer(messageType, channelName, BinarySerializer.Serialize<T>(instance));
+        }
+
         /// <summary>
         /// Sends a buffer to the server from client. Only handlers on this NetworkedBehaviour will get invoked
         /// </summary>
@@ -706,6 +718,18 @@ protected void SendToServerTarget(string messageType, string channelName, byte[]
             NetworkingManager.singleton.Send(NetworkingManager.singleton.serverClientId, messageType, channelName, data, networkId, networkedObject.GetOrderIndex(this));            
         }
 
+        /// <summary>
+        /// Sends a binary serialized class to the server from client. Only handlers on this NetworkedBehaviour will get invoked
+        /// </summary>
+        /// <typeparam name="T">The class type to send</typeparam>
+        /// <param name="messageType">User defined messageType</param>
+        /// <param name="channelName">User defined channelName</param>
+        /// <param name="instance">The instance to send</param>
+        protected void SendToServerTarget<T>(string messageType, string channelName, T instance)
+        {
+            SendToServerTarget(messageType, channelName, BinarySerializer.Serialize<T>(instance));
+        }
+
         /// <summary>
         /// Sends a buffer to the server from client
         /// </summary>
@@ -727,6 +751,18 @@ protected void SendToLocalClient(string messageType, string channelName, byte[]
             NetworkingManager.singleton.Send(ownerClientId, messageType, channelName, data);
         }
 
+        /// <summary>
+        /// Sends a binary serialized class to the server from client
+        /// </summary>
+        /// <typeparam name="T">The class type to send</typeparam>
+        /// <param name="messageType">User defined messageType</param>
+        /// <param name="channelName">User defined channelName</param>	
+        /// <param name="instance">The instance to send</param>
+        protected void SendToLocalClient<T>(string messageType, string channelName, T instance)
+        {
+            SendToLocalClient(messageType, channelName, BinarySerializer.Serialize<T>(instance));
+        }
+
         /// <summary>
         /// Sends a buffer to the client that owns this object from the server. Only handlers on this NetworkedBehaviour will get invoked
         /// </summary>
@@ -748,6 +784,18 @@ protected void SendToLocalClientTarget(string messageType, string channelName, b
             NetworkingManager.singleton.Send(ownerClientId, messageType, channelName, data, networkId, networkedObject.GetOrderIndex(this));
         }
 
+        /// <summary>
+        /// Sends a buffer to the client that owns this object from the server. Only handlers on this NetworkedBehaviour will get invoked
+        /// </summary>
+        /// <typeparam name="T">The class type to send</typeparam>
+        /// <param name="messageType">User defined messageType</param>
+        /// <param name="channelName">User defined channelName</param>	
+        /// <param name="instance">The instance to send</param>
+        protected void SendToLocalClientTarget<T>(string messageType, string channelName, T instance)
+        {
+            SendToLocalClientTarget(messageType, channelName, BinarySerializer.Serialize<T>(instance));
+        }
+
         /// <summary>
         /// Sends a buffer to all clients except to the owner object from the server
         /// </summary>
@@ -769,6 +817,18 @@ protected void SendToNonLocalClients(string messageType, string channelName, byt
             NetworkingManager.singleton.Send(messageType, channelName, data, ownerClientId);
         }
 
+        /// <summary>
+        /// Sends a binary serialized class to all clients except to the owner object from the server
+        /// </summary>
+        /// <typeparam name="T">The class type to send</typeparam>
+        /// <param name="messageType">User defined messageType</param>
+        /// <param name="channelName">User defined channelName</param>	
+        /// <param name="instance">The instance to send</param>
+        protected void SendToNonLocalClients<T>(string messageType, string channelName, T instance)
+        {
+            SendToNonLocalClients(messageType, channelName, BinarySerializer.Serialize<T>(instance));
+        }
+
         /// <summary>
         /// Sends a buffer to all clients except to the owner object from the server. Only handlers on this NetworkedBehaviour will get invoked
         /// </summary>
@@ -790,6 +850,18 @@ protected void SendToNonLocalClientsTarget(string messageType, string channelNam
             NetworkingManager.singleton.Send(messageType, channelName, data, ownerClientId, networkId, networkedObject.GetOrderIndex(this));
         }
 
+        /// <summary>
+        /// Sends a binary serialized class to all clients except to the owner object from the server. Only handlers on this NetworkedBehaviour will get invoked
+        /// </summary>
+        /// <typeparam name="T">The class type to send</typeparam>
+        /// <param name="messageType">User defined messageType</param>
+        /// <param name="channelName">User defined channelName</param>	
+        /// <param name="instance">The instance to send</param>
+        protected void SendToNonLocalClientsTarget<T>(string messageType, string channelName, T instance)
+        {
+            SendToNonLocalClientsTarget(messageType, channelName, BinarySerializer.Serialize<T>(instance));
+        }
+
         /// <summary>
         /// Sends a buffer to a client with a given clientId from Server
         /// </summary>
@@ -812,6 +884,19 @@ protected void SendToClient(int clientId, string messageType, string channelName
             NetworkingManager.singleton.Send(clientId, messageType, channelName, data);
         }
 
+        /// <summary>
+        /// Sends a binary serialized class to a client with a given clientId from Server
+        /// </summary>
+        /// <typeparam name="T">The class type to send</typeparam>
+        /// <param name="clientId">The clientId to send the message to</param>
+        /// <param name="messageType">User defined messageType</param>
+        /// <param name="channelName">User defined channelName</param>	
+        /// <param name="instance">The instance to send</param>
+        protected void SendToClient<T>(int clientId, string messageType, string channelName, T instance)
+        {
+            SendToClient(clientId, messageType, channelName, BinarySerializer.Serialize<T>(instance));
+        }
+
         /// <summary>
         /// Sends a buffer to a client with a given clientId from Server. Only handlers on this NetworkedBehaviour gets invoked
         /// </summary>
@@ -834,6 +919,19 @@ protected void SendToClientTarget(int clientId, string messageType, string chann
             NetworkingManager.singleton.Send(clientId, messageType, channelName, data, networkId, networkedObject.GetOrderIndex(this));
         }
 
+        /// <summary>
+        /// Sends a buffer to a client with a given clientId from Server. Only handlers on this NetworkedBehaviour gets invoked
+        /// </summary>
+        /// <typeparam name="T">The class type to send</typeparam>
+        /// <param name="clientId">The clientId to send the message to</param>
+        /// <param name="messageType">User defined messageType</param>
+        /// <param name="channelName">User defined channelName</param>	
+        /// <param name="instance">The instance to send</param>
+        protected void SendToClientTarget<T>(int clientId, string messageType, string channelName, T instance)
+        {
+            SendToClientTarget(clientId, messageType, channelName, BinarySerializer.Serialize<T>(instance));
+        }
+
         /// <summary>
         /// Sends a buffer to multiple clients from the server
         /// </summary>
@@ -856,6 +954,19 @@ protected void SendToClients(int[] clientIds, string messageType, string channel
             NetworkingManager.singleton.Send(clientIds, messageType, channelName, data);
         }
 
+        /// <summary>
+        /// Sends a binary serialized class to multiple clients from the server
+        /// </summary>
+        /// <typeparam name="T">The class type to send</typeparam>
+        /// <param name="clientIds">The clientId's to send to</param>
+        /// <param name="messageType">User defined messageType</param>
+        /// <param name="channelName">User defined channelName</param>	
+        /// <param name="instance">The instance to send</param>
+        protected void SendToClients<T>(int[] clientIds, string messageType, string channelName, T instance)
+        {
+            SendToClients(clientIds, messageType, channelName, BinarySerializer.Serialize<T>(instance));
+        }
+
         /// <summary>
         /// Sends a buffer to multiple clients from the server. Only handlers on this NetworkedBehaviour gets invoked
         /// </summary>
@@ -878,6 +989,19 @@ protected void SendToClientsTarget(int[] clientIds, string messageType, string c
             NetworkingManager.singleton.Send(clientIds, messageType, channelName, data, networkId, networkedObject.GetOrderIndex(this));
         }
 
+        /// <summary>
+        /// Sends a buffer to multiple clients from the server. Only handlers on this NetworkedBehaviour gets invoked
+        /// </summary>
+        /// <typeparam name="T">The class type to send</typeparam>
+        /// <param name="clientIds">The clientId's to send to</param>
+        /// <param name="messageType">User defined messageType</param>
+        /// <param name="channelName">User defined channelName</param>	
+        /// <param name="instance">The instance to send</param>
+        protected void SendToClientsTarget<T>(int[] clientIds, string messageType, string channelName, T instance)
+        {
+            SendToClientsTarget(clientIds, messageType, channelName, BinarySerializer.Serialize<T>(instance));
+        }
+
         /// <summary>
         /// Sends a buffer to multiple clients from the server
         /// </summary>
@@ -900,6 +1024,19 @@ protected void SendToClients(List<int> clientIds, string messageType, string cha
             NetworkingManager.singleton.Send(clientIds, messageType, channelName, data);
         }
 
+        /// <summary>
+        /// Sends a binary serialized class to multiple clients from the server
+        /// </summary>
+        /// <typeparam name="T">The class type to send</typeparam>
+        /// <param name="clientIds">The clientId's to send to</param>
+        /// <param name="messageType">User defined messageType</param>
+        /// <param name="channelName">User defined channelName</param>	
+        /// <param name="instance">The instance to send</param>
+        protected void SendToClients<T>(List<int> clientIds, string messageType, string channelName, T instance)
+        {
+            SendToClients(clientIds, messageType, channelName, BinarySerializer.Serialize<T>(instance));
+        }
+
         /// <summary>
         /// Sends a buffer to multiple clients from the server. Only handlers on this NetworkedBehaviour gets invoked
         /// </summary>
@@ -922,6 +1059,11 @@ protected void SendToClientsTarget(List<int> clientIds, string messageType, stri
             NetworkingManager.singleton.Send(clientIds, messageType, channelName, data, networkId, networkedObject.GetOrderIndex(this));
         }
 
+        protected void SendToClientsTarget<T>(List<int> clientIds, string messageType, string channelName, T instance)
+        {
+            SendToClientsTarget(clientIds, messageType, channelName, BinarySerializer.Serialize<T>(instance));
+        }
+
         /// <summary>
         /// Sends a buffer to all clients from the server
         /// </summary>
@@ -943,6 +1085,18 @@ protected void SendToClients(string messageType, string channelName, byte[] data
             NetworkingManager.singleton.Send(messageType, channelName, data);
         }
 
+        /// <summary>
+        /// Sends a buffer to all clients from the server
+        /// </summary>
+        /// <typeparam name="T">The class type to send</typeparam>
+        /// <param name="messageType">User defined messageType</param>
+        /// <param name="channelName">User defined channelName</param>	
+        /// <param name="instance">The instance to send</param>
+        protected void SendToClients<T>(string messageType, string channelName, T instance)
+        {
+            SendToClients(messageType, channelName, BinarySerializer.Serialize<T>(instance));
+        }
+
         /// <summary>
         /// Sends a buffer to all clients from the server. Only handlers on this NetworkedBehaviour will get invoked
         /// </summary>
@@ -963,6 +1117,18 @@ protected void SendToClientsTarget(string messageType, string channelName, byte[
             }
             NetworkingManager.singleton.Send(messageType, channelName, data, networkId, networkedObject.GetOrderIndex(this));
         }
+
+        /// <summary>
+        /// Sends a buffer to all clients from the server. Only handlers on this NetworkedBehaviour will get invoked
+        /// </summary>
+        /// <typeparam name="T">The class type to send</typeparam>
+        /// <param name="messageType">User defined messageType</param>
+        /// <param name="channelName">User defined channelName</param>	
+        /// <param name="instance">The instance to send</param>
+        protected void SendToClientsTarget<T>(string messageType, string channelName, T instance)
+        {
+            SendToClientsTarget(messageType, channelName, BinarySerializer.Serialize<T>(instance));
+        }
         #endregion
 
         /// <summary>

MLAPI/NetworkingManagerComponents/BinarySerializer.cs

@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Text;
+using UnityEngine;
 
 namespace MLAPI.NetworkingManagerComponents
 {