refactor(prototype): Updated Invoke methods to use non obsolete versions

TwoTenPvP · TwoTenPvP · commit 75e91516f6c1 · 2019-03-21T15:11:01.000+01:00
diff --git a/MLAPI/MonoBehaviours/Prototyping/NetworkedAnimator.cs b/MLAPI/MonoBehaviours/Prototyping/NetworkedAnimator.cs
@@ -127,16 +127,16 @@ private void FixedUpdate()
                                 if (Vector3.Distance(transform.position, client.Value.PlayerObject.transform.position) <= ProximityRange)
                                     clientsInProximity.Add(client.Key);
                             }
-                            InvokeClientRpc(ApplyAnimParamMsg, clientsInProximity, stream);
+                            InvokeClientRpcPerformance(ApplyAnimParamMsg, clientsInProximity, stream);
                         }
                         else
                         {
-                            InvokeClientRpcOnEveryoneExcept(ApplyAnimMsg, OwnerClientId, stream);
+                            InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimMsg, OwnerClientId, stream);
                         }
                     }
                     else
                     {
-                        InvokeServerRpc(SubmitAnimMsg, stream);
+                        InvokeServerRpcPerformance(SubmitAnimMsg, stream);
                     }
                 }
             }
@@ -199,16 +199,16 @@ private void CheckSendRate()
                                     if (Vector3.Distance(transform.position, client.Value.PlayerObject.transform.position) <= ProximityRange)
                                         clientsInProximity.Add(client.Key);
                                 }
-                                InvokeClientRpc(ApplyAnimParamMsg, clientsInProximity, stream);
+                                InvokeClientRpcPerformance(ApplyAnimParamMsg, clientsInProximity, stream);
                             }
                             else
                             {
-                                InvokeClientRpcOnEveryoneExcept(ApplyAnimParamMsg, OwnerClientId, stream);
+                                InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimParamMsg, OwnerClientId, stream);
                             }
                         }
                         else
                         {
-                            InvokeServerRpc(SubmitAnimParamMsg, stream);
+                            InvokeServerRpcPerformance(SubmitAnimParamMsg, stream);
                         }
                     }
                 }
@@ -252,11 +252,11 @@ private void SubmitAnimMsg(uint clientId, Stream stream)
                     if (Vector3.Distance(transform.position, client.Value.PlayerObject.transform.position) <= ProximityRange)
                         clientsInProximity.Add(client.Key);
                 }
-                InvokeClientRpc(ApplyAnimMsg, clientsInProximity, stream);
+                InvokeClientRpcPerformance(ApplyAnimMsg, clientsInProximity, stream);
             }
             else
             {
-                InvokeClientRpcOnEveryoneExcept(ApplyAnimMsg, OwnerClientId, stream);
+                InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimMsg, OwnerClientId, stream);
             }
         }
 
@@ -286,11 +286,11 @@ private void SubmitAnimParamMsg(uint clientId, Stream stream)
                     if (Vector3.Distance(transform.position, client.Value.PlayerObject.transform.position) <= ProximityRange)
                         clientsInProximity.Add(client.Key);
                 }
-                InvokeClientRpc(ApplyAnimParamMsg, clientsInProximity, stream);
+                InvokeClientRpcPerformance(ApplyAnimParamMsg, clientsInProximity, stream);
             }
             else
             {
-                InvokeClientRpcOnEveryoneExcept(ApplyAnimParamMsg, OwnerClientId, stream);
+                InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimParamMsg, OwnerClientId, stream);
             }
         }
 
@@ -311,11 +311,11 @@ private void SubmitAnimTriggerMsg(uint clientId, Stream stream)
                     if (Vector3.Distance(transform.position, client.Value.PlayerObject.transform.position) <= ProximityRange)
                         clientsInProximity.Add(client.Key);
                 }
-                InvokeClientRpc(ApplyAnimTriggerMsg, clientsInProximity, stream);
+                InvokeClientRpcPerformance(ApplyAnimTriggerMsg, clientsInProximity, stream);
             }
             else
             {
-                InvokeClientRpcOnEveryoneExcept(ApplyAnimTriggerMsg, OwnerClientId, stream);
+                InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimTriggerMsg, OwnerClientId, stream);
             }
         }
 
@@ -438,16 +438,16 @@ public void SetTrigger(int hash)
                                     if (Vector3.Distance(transform.position, client.Value.PlayerObject.transform.position) <= ProximityRange)
                                         clientsInProximity.Add(client.Key);
                                 }
-                                InvokeClientRpc(ApplyAnimTriggerMsg, clientsInProximity, stream);
+                                InvokeClientRpcPerformance(ApplyAnimTriggerMsg, clientsInProximity, stream);
                             }
                             else
                             {
-                                InvokeClientRpcOnEveryoneExcept(ApplyAnimTriggerMsg, OwnerClientId, stream);
+                                InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimTriggerMsg, OwnerClientId, stream);
                             }
                         }
                         else
                         {
-                            InvokeServerRpc(SubmitAnimTriggerMsg, stream);
+                            InvokeServerRpcPerformance(SubmitAnimTriggerMsg, stream);
                         }
                     }
                 }
diff --git a/MLAPI/MonoBehaviours/Prototyping/NetworkedNavMeshAgent.cs b/MLAPI/MonoBehaviours/Prototyping/NetworkedNavMeshAgent.cs
@@ -72,7 +72,7 @@ private void Update()
 
                         if (!EnableProximity)
                         {
-                            InvokeClientRpcOnEveryone(OnNavMeshStateUpdate, stream);
+                            InvokeClientRpcOnEveryonePerformance(OnNavMeshStateUpdate, stream);
                         }
                         else
                         {
@@ -82,7 +82,7 @@ private void Update()
                                 if (Vector3.Distance(client.Value.PlayerObject.transform.position, transform.position) <= ProximityRange)
                                     proximityClients.Add(client.Key);
                             }
-                            InvokeClientRpc(OnNavMeshStateUpdate, proximityClients, stream);
+                            InvokeClientRpcPerformance(OnNavMeshStateUpdate, proximityClients, stream);
                         }
                     }
                 }
@@ -105,7 +105,7 @@ private void Update()
 
                         if (!EnableProximity)
                         {
-                            InvokeClientRpcOnEveryone(OnNavMeshCorrectionUpdate, stream);
+                            InvokeClientRpcOnEveryonePerformance(OnNavMeshCorrectionUpdate, stream);
                         }
                         else
                         {
@@ -115,7 +115,7 @@ private void Update()
                                 if (Vector3.Distance(client.Value.PlayerObject.transform.position, transform.position) <= ProximityRange)
                                     proximityClients.Add(client.Key);
                             }
-                            InvokeClientRpc(OnNavMeshCorrectionUpdate, proximityClients, stream);
+                            InvokeClientRpcPerformance(OnNavMeshCorrectionUpdate, proximityClients, stream);
                         }
                     }
                 }
diff --git a/MLAPI/MonoBehaviours/Prototyping/NetworkedTransform.cs b/MLAPI/MonoBehaviours/Prototyping/NetworkedTransform.cs
@@ -157,9 +157,9 @@ private void Update()
                             writer.WriteSinglePacked(transform.rotation.eulerAngles.z);
 
                             if (IsServer)
-                                InvokeClientRpcOnEveryoneExcept(ApplyTransform, OwnerClientId, stream);
+                                InvokeClientRpcOnEveryoneExceptPerformance(ApplyTransform, OwnerClientId, stream);
                             else
-                                InvokeServerRpc(SubmitTransform, stream);
+                                InvokeServerRpcPerformance(SubmitTransform, stream);
                         }
                     }
 
@@ -285,7 +285,7 @@ private void SubmitTransform(uint clientId, Stream stream)
                                     info.lastMissedPosition = null;
                                     info.lastMissedRotation = null;
 
-                                    InvokeClientRpcOnClient(ApplyTransform, NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, writeStream);
+                                    InvokeClientRpcOnClientPerformance(ApplyTransform, NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, writeStream);
                                 }
                                 else
                                 {
@@ -296,7 +296,7 @@ private void SubmitTransform(uint clientId, Stream stream)
                         }
                         else
                         {
-                            InvokeClientRpcOnEveryoneExcept(ApplyTransform, OwnerClientId, writeStream);
+                            InvokeClientRpcOnEveryoneExceptPerformance(ApplyTransform, OwnerClientId, writeStream);
                         }
                     }
                 }
@@ -342,7 +342,7 @@ private void CheckForMissedSends()
                             writer.WriteSinglePacked(rot.y);
                             writer.WriteSinglePacked(rot.z);
 
-                            InvokeClientRpcOnClient(ApplyTransform, NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, stream);
+                            InvokeClientRpcOnClientPerformance(ApplyTransform, NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, stream);
                         }
                     }
                 }

Original file line number	Diff line number	Diff line change
`@@ -127,16 +127,16 @@ private void FixedUpdate()`
`127`	`127`	`if (Vector3.Distance(transform.position, client.Value.PlayerObject.transform.position) <= ProximityRange)`
`128`	`128`	`clientsInProximity.Add(client.Key);`
`129`	`129`	`}`
`130`		`- InvokeClientRpc(ApplyAnimParamMsg, clientsInProximity, stream);`
	`130`	`+ InvokeClientRpcPerformance(ApplyAnimParamMsg, clientsInProximity, stream);`
`131`	`131`	`}`
`132`	`132`	`else`
`133`	`133`	`{`
`134`		`- InvokeClientRpcOnEveryoneExcept(ApplyAnimMsg, OwnerClientId, stream);`
	`134`	`+ InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimMsg, OwnerClientId, stream);`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`	`else`
`138`	`138`	`{`
`139`		`- InvokeServerRpc(SubmitAnimMsg, stream);`
	`139`	`+ InvokeServerRpcPerformance(SubmitAnimMsg, stream);`
`140`	`140`	`}`
`141`	`141`	`}`
`142`	`142`	`}`
`@@ -199,16 +199,16 @@ private void CheckSendRate()`
`199`	`199`	`if (Vector3.Distance(transform.position, client.Value.PlayerObject.transform.position) <= ProximityRange)`
`200`	`200`	`clientsInProximity.Add(client.Key);`
`201`	`201`	`}`
`202`		`- InvokeClientRpc(ApplyAnimParamMsg, clientsInProximity, stream);`
	`202`	`+ InvokeClientRpcPerformance(ApplyAnimParamMsg, clientsInProximity, stream);`
`203`	`203`	`}`
`204`	`204`	`else`
`205`	`205`	`{`
`206`		`- InvokeClientRpcOnEveryoneExcept(ApplyAnimParamMsg, OwnerClientId, stream);`
	`206`	`+ InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimParamMsg, OwnerClientId, stream);`
`207`	`207`	`}`
`208`	`208`	`}`
`209`	`209`	`else`
`210`	`210`	`{`
`211`		`- InvokeServerRpc(SubmitAnimParamMsg, stream);`
	`211`	`+ InvokeServerRpcPerformance(SubmitAnimParamMsg, stream);`
`212`	`212`	`}`
`213`	`213`	`}`
`214`	`214`	`}`
`@@ -252,11 +252,11 @@ private void SubmitAnimMsg(uint clientId, Stream stream)`
`252`	`252`	`if (Vector3.Distance(transform.position, client.Value.PlayerObject.transform.position) <= ProximityRange)`
`253`	`253`	`clientsInProximity.Add(client.Key);`
`254`	`254`	`}`
`255`		`- InvokeClientRpc(ApplyAnimMsg, clientsInProximity, stream);`
	`255`	`+ InvokeClientRpcPerformance(ApplyAnimMsg, clientsInProximity, stream);`
`256`	`256`	`}`
`257`	`257`	`else`
`258`	`258`	`{`
`259`		`- InvokeClientRpcOnEveryoneExcept(ApplyAnimMsg, OwnerClientId, stream);`
	`259`	`+ InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimMsg, OwnerClientId, stream);`
`260`	`260`	`}`
`261`	`261`	`}`
`262`	`262`
`@@ -286,11 +286,11 @@ private void SubmitAnimParamMsg(uint clientId, Stream stream)`
`286`	`286`	`if (Vector3.Distance(transform.position, client.Value.PlayerObject.transform.position) <= ProximityRange)`
`287`	`287`	`clientsInProximity.Add(client.Key);`
`288`	`288`	`}`
`289`		`- InvokeClientRpc(ApplyAnimParamMsg, clientsInProximity, stream);`
	`289`	`+ InvokeClientRpcPerformance(ApplyAnimParamMsg, clientsInProximity, stream);`
`290`	`290`	`}`
`291`	`291`	`else`
`292`	`292`	`{`
`293`		`- InvokeClientRpcOnEveryoneExcept(ApplyAnimParamMsg, OwnerClientId, stream);`
	`293`	`+ InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimParamMsg, OwnerClientId, stream);`
`294`	`294`	`}`
`295`	`295`	`}`
`296`	`296`
`@@ -311,11 +311,11 @@ private void SubmitAnimTriggerMsg(uint clientId, Stream stream)`
`311`	`311`	`if (Vector3.Distance(transform.position, client.Value.PlayerObject.transform.position) <= ProximityRange)`
`312`	`312`	`clientsInProximity.Add(client.Key);`
`313`	`313`	`}`
`314`		`- InvokeClientRpc(ApplyAnimTriggerMsg, clientsInProximity, stream);`
	`314`	`+ InvokeClientRpcPerformance(ApplyAnimTriggerMsg, clientsInProximity, stream);`
`315`	`315`	`}`
`316`	`316`	`else`
`317`	`317`	`{`
`318`		`- InvokeClientRpcOnEveryoneExcept(ApplyAnimTriggerMsg, OwnerClientId, stream);`
	`318`	`+ InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimTriggerMsg, OwnerClientId, stream);`
`319`	`319`	`}`
`320`	`320`	`}`
`321`	`321`
`@@ -438,16 +438,16 @@ public void SetTrigger(int hash)`
`438`	`438`	`if (Vector3.Distance(transform.position, client.Value.PlayerObject.transform.position) <= ProximityRange)`
`439`	`439`	`clientsInProximity.Add(client.Key);`
`440`	`440`	`}`
`441`		`- InvokeClientRpc(ApplyAnimTriggerMsg, clientsInProximity, stream);`
	`441`	`+ InvokeClientRpcPerformance(ApplyAnimTriggerMsg, clientsInProximity, stream);`
`442`	`442`	`}`
`443`	`443`	`else`
`444`	`444`	`{`
`445`		`- InvokeClientRpcOnEveryoneExcept(ApplyAnimTriggerMsg, OwnerClientId, stream);`
	`445`	`+ InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimTriggerMsg, OwnerClientId, stream);`
`446`	`446`	`}`
`447`	`447`	`}`
`448`	`448`	`else`
`449`	`449`	`{`
`450`		`- InvokeServerRpc(SubmitAnimTriggerMsg, stream);`
	`450`	`+ InvokeServerRpcPerformance(SubmitAnimTriggerMsg, stream);`
`451`	`451`	`}`
`452`	`452`	`}`
`453`	`453`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ private void Update()`
`72`	`72`
`73`	`73`	`if (!EnableProximity)`
`74`	`74`	`{`
`75`		`- InvokeClientRpcOnEveryone(OnNavMeshStateUpdate, stream);`
	`75`	`+ InvokeClientRpcOnEveryonePerformance(OnNavMeshStateUpdate, stream);`
`76`	`76`	`}`
`77`	`77`	`else`
`78`	`78`	`{`
`@@ -82,7 +82,7 @@ private void Update()`
`82`	`82`	`if (Vector3.Distance(client.Value.PlayerObject.transform.position, transform.position) <= ProximityRange)`
`83`	`83`	`proximityClients.Add(client.Key);`
`84`	`84`	`}`
`85`		`- InvokeClientRpc(OnNavMeshStateUpdate, proximityClients, stream);`
	`85`	`+ InvokeClientRpcPerformance(OnNavMeshStateUpdate, proximityClients, stream);`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`	`}`
`@@ -105,7 +105,7 @@ private void Update()`
`105`	`105`
`106`	`106`	`if (!EnableProximity)`
`107`	`107`	`{`
`108`		`- InvokeClientRpcOnEveryone(OnNavMeshCorrectionUpdate, stream);`
	`108`	`+ InvokeClientRpcOnEveryonePerformance(OnNavMeshCorrectionUpdate, stream);`
`109`	`109`	`}`
`110`	`110`	`else`
`111`	`111`	`{`
`@@ -115,7 +115,7 @@ private void Update()`
`115`	`115`	`if (Vector3.Distance(client.Value.PlayerObject.transform.position, transform.position) <= ProximityRange)`
`116`	`116`	`proximityClients.Add(client.Key);`
`117`	`117`	`}`
`118`		`- InvokeClientRpc(OnNavMeshCorrectionUpdate, proximityClients, stream);`
	`118`	`+ InvokeClientRpcPerformance(OnNavMeshCorrectionUpdate, proximityClients, stream);`
`119`	`119`	`}`
`120`	`120`	`}`
`121`	`121`	`}`
Original file line number	Diff line number	Diff line change
`@@ -157,9 +157,9 @@ private void Update()`
`157`	`157`	`writer.WriteSinglePacked(transform.rotation.eulerAngles.z);`
`158`	`158`
`159`	`159`	`if (IsServer)`
`160`		`- InvokeClientRpcOnEveryoneExcept(ApplyTransform, OwnerClientId, stream);`
	`160`	`+ InvokeClientRpcOnEveryoneExceptPerformance(ApplyTransform, OwnerClientId, stream);`
`161`	`161`	`else`
`162`		`- InvokeServerRpc(SubmitTransform, stream);`
	`162`	`+ InvokeServerRpcPerformance(SubmitTransform, stream);`
`163`	`163`	`}`
`164`	`164`	`}`
`165`	`165`
`@@ -285,7 +285,7 @@ private void SubmitTransform(uint clientId, Stream stream)`
`285`	`285`	`info.lastMissedPosition = null;`
`286`	`286`	`info.lastMissedRotation = null;`
`287`	`287`
`288`		`- InvokeClientRpcOnClient(ApplyTransform, NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, writeStream);`
	`288`	`+ InvokeClientRpcOnClientPerformance(ApplyTransform, NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, writeStream);`
`289`	`289`	`}`
`290`	`290`	`else`
`291`	`291`	`{`
`@@ -296,7 +296,7 @@ private void SubmitTransform(uint clientId, Stream stream)`
`296`	`296`	`}`
`297`	`297`	`else`
`298`	`298`	`{`
`299`		`- InvokeClientRpcOnEveryoneExcept(ApplyTransform, OwnerClientId, writeStream);`
	`299`	`+ InvokeClientRpcOnEveryoneExceptPerformance(ApplyTransform, OwnerClientId, writeStream);`
`300`	`300`	`}`
`301`	`301`	`}`
`302`	`302`	`}`
`@@ -342,7 +342,7 @@ private void CheckForMissedSends()`
`342`	`342`	`writer.WriteSinglePacked(rot.y);`
`343`	`343`	`writer.WriteSinglePacked(rot.z);`
`344`	`344`
`345`		`- InvokeClientRpcOnClient(ApplyTransform, NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, stream);`
	`345`	`+ InvokeClientRpcOnClientPerformance(ApplyTransform, NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, stream);`
`346`	`346`	`}`
`347`	`347`	`}`
`348`	`348`	`}`