feat: add properties to LiteNetLibBehaviour

insthync · insthync · commit 3a6b53774a4e · 2025-11-06T16:13:39.000+07:00
diff --git a/Scripts/GameApi/LiteNetLibBehaviour.cs b/Scripts/GameApi/LiteNetLibBehaviour.cs
@@ -79,6 +79,16 @@ public byte SyncChannelId
             get { return Identity.SyncChannelId; }
         }
 
+        public byte DefaultRpcChannelId
+        {
+            get { return Identity.DefaultRpcChannelId; }
+        }
+
+        public string SubChannelId
+        {
+            get { return Identity.SubChannelId; }
+        }
+
         public LiteNetLibGameManager Manager
         {
             get { return Identity.Manager; }
@@ -696,57 +706,57 @@ private void RegisterRPC(Dictionary<string, int> dict, string id, LiteNetLibFunc
         #region Elastic RPC with receivers and parameters
         public void RPC(NetFunctionDelegate func, FunctionReceivers receivers)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers);
         }
 
         public void RPC<T1>(NetFunctionDelegate<T1> func, FunctionReceivers receivers, T1 param1)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1);
         }
 
         public void RPC<T1, T2>(NetFunctionDelegate<T1, T2> func, FunctionReceivers receivers, T1 param1, T2 param2)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2);
         }
 
         public void RPC<T1, T2, T3>(NetFunctionDelegate<T1, T2, T3> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3);
         }
 
         public void RPC<T1, T2, T3, T4>(NetFunctionDelegate<T1, T2, T3, T4> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4);
         }
 
         public void RPC<T1, T2, T3, T4, T5>(NetFunctionDelegate<T1, T2, T3, T4, T5> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6, T7>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6, T7, T8>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7, param8);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7, param8);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8, T9> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8, T9 param9)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7, param8, param9);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7, param8, param9);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8, T9 param9, T10 param10)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
         }
         #endregion
 
@@ -810,57 +820,57 @@ public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(NetFunctionDelegate<T1,
         #region All RPC or Server RPC with parameters
         public void RPC(NetFunctionDelegate func)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered);
         }
 
         public void RPC<T1>(NetFunctionDelegate<T1> func, T1 param1)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1);
         }
 
         public void RPC<T1, T2>(NetFunctionDelegate<T1, T2> func, T1 param1, T2 param2)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2);
         }
 
         public void RPC<T1, T2, T3>(NetFunctionDelegate<T1, T2, T3> func, T1 param1, T2 param2, T3 param3)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3);
         }
 
         public void RPC<T1, T2, T3, T4>(NetFunctionDelegate<T1, T2, T3, T4> func, T1 param1, T2 param2, T3 param3, T4 param4)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4);
         }
 
         public void RPC<T1, T2, T3, T4, T5>(NetFunctionDelegate<T1, T2, T3, T4, T5> func, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6> func, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6, T7>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7> func, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6, T7, T8>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8> func, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7, param8);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7, param8);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8, T9> func, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8, T9 param9)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7, param8, param9);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7, param8, param9);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> func, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8, T9 param9, T10 param10)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
         }
         #endregion
 
@@ -924,57 +934,57 @@ public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(NetFunctionDelegate<T1,
         #region Target RPC with parameters
         public void RPC(NetFunctionDelegate func, long connectionId)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId);
         }
 
         public void RPC<T1>(NetFunctionDelegate<T1> func, long connectionId, T1 param1)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1);
         }
 
         public void RPC<T1, T2>(NetFunctionDelegate<T1, T2> func, long connectionId, T1 param1, T2 param2)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2);
         }
 
         public void RPC<T1, T2, T3>(NetFunctionDelegate<T1, T2, T3> func, long connectionId, T1 param1, T2 param2, T3 param3)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3);
         }
 
         public void RPC<T1, T2, T3, T4>(NetFunctionDelegate<T1, T2, T3, T4> func, long connectionId, T1 param1, T2 param2, T3 param3, T4 param4)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4);
         }
 
         public void RPC<T1, T2, T3, T4, T5>(NetFunctionDelegate<T1, T2, T3, T4, T5> func, long connectionId, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6> func, long connectionId, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6, T7>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7> func, long connectionId, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6, T7, T8>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8> func, long connectionId, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7, param8);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7, param8);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8, T9> func, long connectionId, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8, T9 param9)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7, param8, param9);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7, param8, param9);
         }
 
         public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> func, long connectionId, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8, T9 param9, T10 param10)
         {
-            RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
+            RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
         }
         #endregion
 
diff --git a/Scripts/GameApi/LiteNetLibIdentity.cs b/Scripts/GameApi/LiteNetLibIdentity.cs
@@ -50,6 +50,8 @@ public sealed class LiteNetLibIdentity : MonoBehaviour
         private byte syncChannelId = 0;
         [SerializeField, Tooltip("Default RPCs channel ID")]
         private byte defaultRpcChannelId = 0;
+        [SerializeField, Tooltip("If objects have differences `Sub Channel ID` it will not being subscribed")]
+        private string subChannelId = string.Empty;
         [SerializeField, Tooltip("If this is <= 0f, it will uses interest manager's `defaultVisibleRange` setting")]
         private float visibleRange = 0f;
         [SerializeField, Tooltip("If this is `TRUE` it will always visible no matter how far from player's objects")]
@@ -58,8 +60,6 @@ public sealed class LiteNetLibIdentity : MonoBehaviour
         private bool doNotDestroyWhenDisconnect = false;
         [SerializeField, Tooltip("If this is > 0, it will get instance from pooling system")]
         private int poolingSize = 0;
-        [SerializeField, Tooltip("If objects have differences `sub channel ID` it will not being subscribed")]
-        private string subChannelId = string.Empty;
 #if !UNITY_SERVER
         [SerializeField]
         private bool forceRenderingOffWhileHidding = true;
@@ -163,11 +163,11 @@ public int HashSceneObjectId
         public uint ObjectId { get { return networkedObjectId; } internal set { networkedObjectId = value; } }
         public byte SyncChannelId { get { return syncChannelId; } }
         public byte DefaultRpcChannelId { get { return defaultRpcChannelId; } }
+        public string SubChannelId { get { return subChannelId; } set { subChannelId = value; } }
         public float VisibleRange { get { return visibleRange; } set { visibleRange = value; } }
         public bool AlwaysVisible { get { return alwaysVisible; } set { alwaysVisible = value; } }
         public bool DoNotDestroyWhenDisconnect { get { return doNotDestroyWhenDisconnect; } set { doNotDestroyWhenDisconnect = value; } }
         public int PoolingSize { get { return poolingSize; } set { poolingSize = value; } }
-        public string SubChannelId { get { return subChannelId; } set { subChannelId = value; } }
         /// <summary>
         /// If this is `TRUE` it will disallow other connections to subscribe this networked object
         /// </summary>

Original file line number	Diff line number	Diff line change
`@@ -79,6 +79,16 @@ public byte SyncChannelId`
`79`	`79`	`get { return Identity.SyncChannelId; }`
`80`	`80`	`}`
`81`	`81`
	`82`	`+ public byte DefaultRpcChannelId`
	`83`	`+ {`
	`84`	`+ get { return Identity.DefaultRpcChannelId; }`
	`85`	`+ }`
	`86`	`+`
	`87`	`+ public string SubChannelId`
	`88`	`+ {`
	`89`	`+ get { return Identity.SubChannelId; }`
	`90`	`+ }`
	`91`	`+`
`82`	`92`	`public LiteNetLibGameManager Manager`
`83`	`93`	`{`
`84`	`94`	`get { return Identity.Manager; }`
`@@ -696,57 +706,57 @@ private void RegisterRPC(Dictionary<string, int> dict, string id, LiteNetLibFunc`
`696`	`706`	`#region Elastic RPC with receivers and parameters`
`697`	`707`	`public void RPC(NetFunctionDelegate func, FunctionReceivers receivers)`
`698`	`708`	`{`
`699`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers);`
	`709`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers);`
`700`	`710`	`}`
`701`	`711`
`702`	`712`	`public void RPC<T1>(NetFunctionDelegate<T1> func, FunctionReceivers receivers, T1 param1)`
`703`	`713`	`{`
`704`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1);`
	`714`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1);`
`705`	`715`	`}`
`706`	`716`
`707`	`717`	`public void RPC<T1, T2>(NetFunctionDelegate<T1, T2> func, FunctionReceivers receivers, T1 param1, T2 param2)`
`708`	`718`	`{`
`709`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2);`
	`719`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2);`
`710`	`720`	`}`
`711`	`721`
`712`	`722`	`public void RPC<T1, T2, T3>(NetFunctionDelegate<T1, T2, T3> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3)`
`713`	`723`	`{`
`714`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3);`
	`724`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3);`
`715`	`725`	`}`
`716`	`726`
`717`	`727`	`public void RPC<T1, T2, T3, T4>(NetFunctionDelegate<T1, T2, T3, T4> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4)`
`718`	`728`	`{`
`719`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4);`
	`729`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4);`
`720`	`730`	`}`
`721`	`731`
`722`	`732`	`public void RPC<T1, T2, T3, T4, T5>(NetFunctionDelegate<T1, T2, T3, T4, T5> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5)`
`723`	`733`	`{`
`724`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5);`
	`734`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5);`
`725`	`735`	`}`
`726`	`736`
`727`	`737`	`public void RPC<T1, T2, T3, T4, T5, T6>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6)`
`728`	`738`	`{`
`729`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6);`
	`739`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6);`
`730`	`740`	`}`
`731`	`741`
`732`	`742`	`public void RPC<T1, T2, T3, T4, T5, T6, T7>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7)`
`733`	`743`	`{`
`734`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7);`
	`744`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7);`
`735`	`745`	`}`
`736`	`746`
`737`	`747`	`public void RPC<T1, T2, T3, T4, T5, T6, T7, T8>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8)`
`738`	`748`	`{`
`739`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7, param8);`
	`749`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7, param8);`
`740`	`750`	`}`
`741`	`751`
`742`	`752`	`public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8, T9> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8, T9 param9)`
`743`	`753`	`{`
`744`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7, param8, param9);`
	`754`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7, param8, param9);`
`745`	`755`	`}`
`746`	`756`
`747`	`757`	`public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8, T9 param9, T10 param10)`
`748`	`758`	`{`
`749`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);`
	`759`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);`
`750`	`760`	`}`
`751`	`761`	`#endregion`
`752`	`762`
`@@ -810,57 +820,57 @@ public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(NetFunctionDelegate<T1,`
`810`	`820`	`#region All RPC or Server RPC with parameters`
`811`	`821`	`public void RPC(NetFunctionDelegate func)`
`812`	`822`	`{`
`813`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered);`
	`823`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered);`
`814`	`824`	`}`
`815`	`825`
`816`	`826`	`public void RPC<T1>(NetFunctionDelegate<T1> func, T1 param1)`
`817`	`827`	`{`
`818`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1);`
	`828`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1);`
`819`	`829`	`}`
`820`	`830`
`821`	`831`	`public void RPC<T1, T2>(NetFunctionDelegate<T1, T2> func, T1 param1, T2 param2)`
`822`	`832`	`{`
`823`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2);`
	`833`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2);`
`824`	`834`	`}`
`825`	`835`
`826`	`836`	`public void RPC<T1, T2, T3>(NetFunctionDelegate<T1, T2, T3> func, T1 param1, T2 param2, T3 param3)`
`827`	`837`	`{`
`828`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3);`
	`838`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3);`
`829`	`839`	`}`
`830`	`840`
`831`	`841`	`public void RPC<T1, T2, T3, T4>(NetFunctionDelegate<T1, T2, T3, T4> func, T1 param1, T2 param2, T3 param3, T4 param4)`
`832`	`842`	`{`
`833`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4);`
	`843`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4);`
`834`	`844`	`}`
`835`	`845`
`836`	`846`	`public void RPC<T1, T2, T3, T4, T5>(NetFunctionDelegate<T1, T2, T3, T4, T5> func, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5)`
`837`	`847`	`{`
`838`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5);`
	`848`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5);`
`839`	`849`	`}`
`840`	`850`
`841`	`851`	`public void RPC<T1, T2, T3, T4, T5, T6>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6> func, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6)`
`842`	`852`	`{`
`843`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6);`
	`853`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6);`
`844`	`854`	`}`
`845`	`855`
`846`	`856`	`public void RPC<T1, T2, T3, T4, T5, T6, T7>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7> func, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7)`
`847`	`857`	`{`
`848`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7);`
	`858`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7);`
`849`	`859`	`}`
`850`	`860`
`851`	`861`	`public void RPC<T1, T2, T3, T4, T5, T6, T7, T8>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8> func, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8)`
`852`	`862`	`{`
`853`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7, param8);`
	`863`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7, param8);`
`854`	`864`	`}`
`855`	`865`
`856`	`866`	`public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8, T9> func, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8, T9 param9)`
`857`	`867`	`{`
`858`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7, param8, param9);`
	`868`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7, param8, param9);`
`859`	`869`	`}`
`860`	`870`
`861`	`871`	`public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> func, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8, T9 param9, T10 param10)`
`862`	`872`	`{`
`863`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);`
	`873`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);`
`864`	`874`	`}`
`865`	`875`	`#endregion`
`866`	`876`
`@@ -924,57 +934,57 @@ public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(NetFunctionDelegate<T1,`
`924`	`934`	`#region Target RPC with parameters`
`925`	`935`	`public void RPC(NetFunctionDelegate func, long connectionId)`
`926`	`936`	`{`
`927`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId);`
	`937`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId);`
`928`	`938`	`}`
`929`	`939`
`930`	`940`	`public void RPC<T1>(NetFunctionDelegate<T1> func, long connectionId, T1 param1)`
`931`	`941`	`{`
`932`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1);`
	`942`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1);`
`933`	`943`	`}`
`934`	`944`
`935`	`945`	`public void RPC<T1, T2>(NetFunctionDelegate<T1, T2> func, long connectionId, T1 param1, T2 param2)`
`936`	`946`	`{`
`937`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2);`
	`947`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2);`
`938`	`948`	`}`
`939`	`949`
`940`	`950`	`public void RPC<T1, T2, T3>(NetFunctionDelegate<T1, T2, T3> func, long connectionId, T1 param1, T2 param2, T3 param3)`
`941`	`951`	`{`
`942`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3);`
	`952`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3);`
`943`	`953`	`}`
`944`	`954`
`945`	`955`	`public void RPC<T1, T2, T3, T4>(NetFunctionDelegate<T1, T2, T3, T4> func, long connectionId, T1 param1, T2 param2, T3 param3, T4 param4)`
`946`	`956`	`{`
`947`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4);`
	`957`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4);`
`948`	`958`	`}`
`949`	`959`
`950`	`960`	`public void RPC<T1, T2, T3, T4, T5>(NetFunctionDelegate<T1, T2, T3, T4, T5> func, long connectionId, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5)`
`951`	`961`	`{`
`952`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5);`
	`962`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5);`
`953`	`963`	`}`
`954`	`964`
`955`	`965`	`public void RPC<T1, T2, T3, T4, T5, T6>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6> func, long connectionId, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6)`
`956`	`966`	`{`
`957`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6);`
	`967`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6);`
`958`	`968`	`}`
`959`	`969`
`960`	`970`	`public void RPC<T1, T2, T3, T4, T5, T6, T7>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7> func, long connectionId, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7)`
`961`	`971`	`{`
`962`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7);`
	`972`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7);`
`963`	`973`	`}`
`964`	`974`
`965`	`975`	`public void RPC<T1, T2, T3, T4, T5, T6, T7, T8>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8> func, long connectionId, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8)`
`966`	`976`	`{`
`967`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7, param8);`
	`977`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7, param8);`
`968`	`978`	`}`
`969`	`979`
`970`	`980`	`public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8, T9> func, long connectionId, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8, T9 param9)`
`971`	`981`	`{`
`972`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7, param8, param9);`
	`982`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7, param8, param9);`
`973`	`983`	`}`
`974`	`984`
`975`	`985`	`public void RPC<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(NetFunctionDelegate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> func, long connectionId, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8, T9 param9, T10 param10)`
`976`	`986`	`{`
`977`		`- RPC(func.Method.Name, Identity.DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);`
	`987`	`+ RPC(func.Method.Name, DefaultRpcChannelId, DeliveryMethod.ReliableOrdered, connectionId, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);`
`978`	`988`	`}`
`979`	`989`	`#endregion`
`980`	`990`