Upgrade Multiplayer Use cases to NGO 1.8.1 [MTT-8499] (#178)

Elfi0Kuhndorf · web-flow · commit e8fa6ed22331 · 2024-05-28T16:43:45.000+02:00
* upgrade ngo to 1.8.1 and related rpc adjustments

* included OnConnectionEvent into GameUI.cs script

* adjusted scripts to address comments

* fixing PascalCase in Rpcs, removing empty Line and naming refactor
change version numbers in readme file

* remove redundant code in ColorManager
diff --git a/Experimental/MultiplayerUseCases/Assets/Common/Scripts/GameUI.cs b/Experimental/MultiplayerUseCases/Assets/Common/Scripts/GameUI.cs
@@ -13,42 +13,43 @@ public class GameUI : MonoBehaviour
 
         void Start()
         {
-            Refreshlabels(NetworkManager.Singleton && (NetworkManager.Singleton.IsClient || NetworkManager.Singleton.IsServer));
-            NetworkManager.Singleton.OnClientConnectedCallback += OnClientConnectedCallback;
+            RefreshLabels(NetworkManager.Singleton && (NetworkManager.Singleton.IsClient || NetworkManager.Singleton.IsServer));
+            NetworkManager.Singleton.OnConnectionEvent += OnConnectionEvent;
             NetworkManager.Singleton.OnServerStarted += OnServerStarted;
-            NetworkManager.Singleton.OnClientDisconnectCallback += OnClientDisconnectCallback;
         }
 
         void OnDestroy()
         {
             if (NetworkManager.Singleton)
             {
-                NetworkManager.Singleton.OnClientConnectedCallback -= OnClientConnectedCallback;
+                NetworkManager.Singleton.OnConnectionEvent -= OnConnectionEvent;
                 NetworkManager.Singleton.OnServerStarted -= OnServerStarted;
-                NetworkManager.Singleton.OnClientDisconnectCallback -= OnClientDisconnectCallback;
             }
         }
 
         void OnServerStarted()
         {
-            Refreshlabels(true);
+            RefreshLabels(true);
         }
 
-        void OnClientConnectedCallback(ulong obj)
+        void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)
         {
-            if (NetworkManager.Singleton && NetworkManager.Singleton.IsServer)
+            if (connectionEventData.EventType == ConnectionEvent.ClientConnected)
             {
-                return; //you don't want to do actions twice when playing as a host
+                if (NetworkManager.Singleton && NetworkManager.Singleton.IsServer)
+                {
+                    return; //you don't want to do actions twice when playing as a host
+                }
+                RefreshLabels(true);
             }
-            Refreshlabels(true);
-        }
 
-        void OnClientDisconnectCallback(ulong obj)
-        {
-            Refreshlabels(false);
+            else if (connectionEventData.EventType == ConnectionEvent.ClientDisconnected)
+            {
+                    RefreshLabels(false);
+            }
         }
 
-        void Refreshlabels(bool isConnected)
+        void RefreshLabels(bool isConnected)
         {
             startupLabel.gameObject.SetActive(!isConnected);
             controlsLabel.gameObject.SetActive(isConnected);
diff --git a/Experimental/MultiplayerUseCases/Assets/UseCaseSamples/NetvarVsRpc/Scripts/ColorManager.cs b/Experimental/MultiplayerUseCases/Assets/UseCaseSamples/NetvarVsRpc/Scripts/ColorManager.cs
@@ -1,7 +1,7 @@
 using Unity.Netcode.Samples.MultiplayerUseCases.Common;
 using UnityEngine;
 
-namespace Unity.Netcode.Samples.MultiplayerUseCases.NetVarVsRPC
+namespace Unity.Netcode.Samples.MultiplayerUseCases.NetVarVsRpc
 {
     /// <summary>
     /// Manages the color of a Networked object
@@ -65,23 +65,23 @@ void Update()
 
         void OnClientRequestColorChange()
         {
-            OnServerChangeColorServerRpc();
+            ServerChangeColorRpc();
         }
 
-        [ServerRpc(RequireOwnership = false)] //note: please refer to RPCs documentation to learn more about the pros and cons of the RequireOwnership parameter
-        void OnServerChangeColorServerRpc()
+        [Rpc(SendTo.Server)]
+        void ServerChangeColorRpc()
         {
             Color32 newColor = MultiplayerUseCasesUtilities.GetRandomColor();
             if (m_UseNetworkVariableForColor)
             {
                 m_NetworkedColor.Value = newColor;
                 return;
             }
-            OnClientNotifyColorChangedClientRpc(newColor);
+            ClientNotifyColorChangedRpc(newColor);
         }
 
-        [ClientRpc]
-        void OnClientNotifyColorChangedClientRpc(Color32 newColor)
+        [Rpc(SendTo.ClientsAndHost)]
+        void ClientNotifyColorChangedRpc(Color32 newColor)
         {
             m_Material.color = newColor;
         }
diff --git a/Experimental/MultiplayerUseCases/Assets/UseCaseSamples/NetvarVsRpc/Scripts/ProximityTrigger.cs b/Experimental/MultiplayerUseCases/Assets/UseCaseSamples/NetvarVsRpc/Scripts/ProximityTrigger.cs
@@ -1,7 +1,7 @@
 using Unity.Netcode.Samples.MultiplayerUseCases.Common;
 using UnityEngine;
 
-namespace Unity.Netcode.Samples.MultiplayerUseCases.NetVarVsRPC
+namespace Unity.Netcode.Samples.MultiplayerUseCases.NetVarVsRpc
 {
     /// <summary>
     /// Toggles an object when the local player is close enough
diff --git a/Experimental/MultiplayerUseCases/Assets/UseCaseSamples/NetworkVariables/Scripts/CharacterManager.cs b/Experimental/MultiplayerUseCases/Assets/UseCaseSamples/NetworkVariables/Scripts/CharacterManager.cs
@@ -44,7 +44,7 @@ public override void OnNetworkSpawn()
             if (IsClient)
             {
                 /*
-                 * We call the color change method manually when we connect to ensure that our color is correctly initialized. 
+                 * We call the color change method manually when we connect to ensure that our color is correctly initialized.
                  * This is helpful for when a client joins mid-game and needs to catch up with the current state of the game.
                  */
                 OnClientCustomDataChanged(m_SyncedCustomData.Value, m_SyncedCustomData.Value);
@@ -72,7 +72,7 @@ void Update()
             if (!IsServer)
             {
                 /*
-                 * By default, only the server is allowed to change the value of NetworkVariables. 
+                 * By default, only the server is allowed to change the value of NetworkVariables.
                  * This can be changed through the NetworkVariable's constructor.
                  */
                 return;
@@ -101,7 +101,7 @@ void OnClientHealthChanged(int previousHealth, int newHealth)
         {
             m_HealthBarImage.rectTransform.localScale = new Vector3((float)newHealth / 100.0f, 1);//(float)newHealth / 100.0f;
             OnClientUpdateHealthBarColor(newHealth);
-            //note: you could use the previousHealth to play an healing/damage animation
+            //note: you could use the previousHealth to play a healing/damage animation
         }
 
         void OnClientUpdateHealthBarColor(int newHealth)
diff --git a/Experimental/MultiplayerUseCases/Assets/UseCaseSamples/ProximityChecks/Scripts/ColorManager.cs b/Experimental/MultiplayerUseCases/Assets/UseCaseSamples/ProximityChecks/Scripts/ColorManager.cs
@@ -59,11 +59,11 @@ void Update()
 
         void OnClientRequestColorChange()
         {
-            OnServerChangeColorServerRpc();
+            ServerChangeColorRpc();
         }
 
-        [ServerRpc(RequireOwnership = false)]
-        void OnServerChangeColorServerRpc()
+        [Rpc(SendTo.Server)]
+        void ServerChangeColorRpc()
         {
             m_NetworkedColor.Value = MultiplayerUseCasesUtilities.GetRandomColor();
         }
diff --git a/Experimental/MultiplayerUseCases/Assets/UseCaseSamples/RPCs/Scripts/MoodManager.cs b/Experimental/MultiplayerUseCases/Assets/UseCaseSamples/RPCs/Scripts/MoodManager.cs
@@ -36,27 +36,27 @@ void Update()
             if (m_ElapsedSecondsSinceLastChange >= m_SecondsBetweenDataChanges)
             {
                 m_ElapsedSecondsSinceLastChange = 0;
-                OnServerMoodMessageReceivedServerRpc(s_ChatMessages[Random.Range(0, s_ChatMessages.Length)]);
+                ServerMoodMessageReceivedRpc(s_ChatMessages[Random.Range(0, s_ChatMessages.Length)]);
             }
         }
 
-        [ServerRpc]
-        void OnServerMoodMessageReceivedServerRpc(string message)
+        [Rpc(SendTo.Server)]
+        void ServerMoodMessageReceivedRpc(string message)
         {
             /* Here's an example of the type of operation you could do on the server to prevent malicious actions
              * from bad actors.
              */
             string redactedMessage = OnServerFilterBadWords(message);
-            OnClientMoodMessageReceivedClientRpc(redactedMessage);
+            ClientMoodMessageReceivedRpc(redactedMessage);
         }
 
         string OnServerFilterBadWords(string message)
         {
             return MultiplayerUseCasesUtilities.FilterBadWords(message);
         }
 
-        [ClientRpc]
-        void OnClientMoodMessageReceivedClientRpc(string message)
+        [Rpc(SendTo.ClientsAndHost)]
+        void ClientMoodMessageReceivedRpc(string message)
         {
             if (!m_SpeechBubble)
             {
diff --git a/Experimental/MultiplayerUseCases/Packages/manifest.json b/Experimental/MultiplayerUseCases/Packages/manifest.json
@@ -10,7 +10,7 @@
     "com.unity.learn.iet-framework.authoring": "1.2.2",
     "com.unity.multiplayer.samples.coop": "https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop.git?path=/Packages/com.unity.multiplayer.samples.coop#v2.4.0",
     "com.unity.multiplayer.tools": "1.1.1",
-    "com.unity.netcode.gameobjects": "1.7.1",
+    "com.unity.netcode.gameobjects": "1.8.1",
     "com.unity.render-pipelines.universal": "14.0.11",
     "com.unity.test-framework": "1.1.33",
     "com.unity.textmeshpro": "3.0.6",
diff --git a/Experimental/MultiplayerUseCases/Packages/packages-lock.json b/Experimental/MultiplayerUseCases/Packages/packages-lock.json
@@ -143,7 +143,7 @@
       "url": "https://packages.unity.com"
     },
     "com.unity.netcode.gameobjects": {
-      "version": "1.7.1",
+      "version": "1.8.1",
       "depth": 0,
       "source": "registry",
       "dependencies": {
diff --git a/Experimental/MultiplayerUseCases/README.md b/Experimental/MultiplayerUseCases/README.md
@@ -1,7 +1,7 @@
 # Multiplayer Use Cases
 
-[![UnityVersion](https://img.shields.io/badge/Unity%20Version:-2022.3%20LTS-57b9d3.svg?logo=unity&color=2196F3)](https://unity.com/releases/editor/whats-new/2022.3.0)
-[![NetcodeVersion](https://img.shields.io/badge/Netcode%20Version:-1.7.1-57b9d3.svg?logo=unity&color=2196F3)](https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/releases/tag/ngo%2F1.7.1)
+[![UnityVersion](https://img.shields.io/badge/Unity%20Version:-2022.3%20LTS-57b9d3.svg?logo=unity&color=2196F3)](https://unity.com/releases/editor/whats-new/2022.3.27)
+[![NetcodeVersion](https://img.shields.io/badge/Netcode%20Version:-1.8.1-57b9d3.svg?logo=unity&color=2196F3)](https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/releases/tag/ngo%2F1.8.1)
 <br><br>
 
 This sample provides a series of scenes. Each scene explains a specific API or system commonly used in Netcode for GameObjects. In this sample you will learn more about client-server communication, state synchronization, and other typical mechanics of multiplayer games.

Original file line number	Diff line number	Diff line change
`@@ -13,42 +13,43 @@ public class GameUI : MonoBehaviour`
`13`	`13`
`14`	`14`	`void Start()`
`15`	`15`	`{`
`16`		`- Refreshlabels(NetworkManager.Singleton && (NetworkManager.Singleton.IsClient \|\| NetworkManager.Singleton.IsServer));`
`17`		`- NetworkManager.Singleton.OnClientConnectedCallback += OnClientConnectedCallback;`
	`16`	`+ RefreshLabels(NetworkManager.Singleton && (NetworkManager.Singleton.IsClient \|\| NetworkManager.Singleton.IsServer));`
	`17`	`+ NetworkManager.Singleton.OnConnectionEvent += OnConnectionEvent;`
`18`	`18`	`NetworkManager.Singleton.OnServerStarted += OnServerStarted;`
`19`		`- NetworkManager.Singleton.OnClientDisconnectCallback += OnClientDisconnectCallback;`
`20`	`19`	`}`
`21`	`20`
`22`	`21`	`void OnDestroy()`
`23`	`22`	`{`
`24`	`23`	`if (NetworkManager.Singleton)`
`25`	`24`	`{`
`26`		`- NetworkManager.Singleton.OnClientConnectedCallback -= OnClientConnectedCallback;`
	`25`	`+ NetworkManager.Singleton.OnConnectionEvent -= OnConnectionEvent;`
`27`	`26`	`NetworkManager.Singleton.OnServerStarted -= OnServerStarted;`
`28`		`- NetworkManager.Singleton.OnClientDisconnectCallback -= OnClientDisconnectCallback;`
`29`	`27`	`}`
`30`	`28`	`}`
`31`	`29`
`32`	`30`	`void OnServerStarted()`
`33`	`31`	`{`
`34`		`- Refreshlabels(true);`
	`32`	`+ RefreshLabels(true);`
`35`	`33`	`}`
`36`	`34`
`37`		`- void OnClientConnectedCallback(ulong obj)`
	`35`	`+ void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)`
`38`	`36`	`{`
`39`		`- if (NetworkManager.Singleton && NetworkManager.Singleton.IsServer)`
	`37`	`+ if (connectionEventData.EventType == ConnectionEvent.ClientConnected)`
`40`	`38`	`{`
`41`		`- return; //you don't want to do actions twice when playing as a host`
	`39`	`+ if (NetworkManager.Singleton && NetworkManager.Singleton.IsServer)`
	`40`	`+ {`
	`41`	`+ return; //you don't want to do actions twice when playing as a host`
	`42`	`+ }`
	`43`	`+ RefreshLabels(true);`
`42`	`44`	`}`
`43`		`- Refreshlabels(true);`
`44`		`- }`
`45`	`45`
`46`		`- void OnClientDisconnectCallback(ulong obj)`
`47`		`- {`
`48`		`- Refreshlabels(false);`
	`46`	`+ else if (connectionEventData.EventType == ConnectionEvent.ClientDisconnected)`
	`47`	`+ {`
	`48`	`+ RefreshLabels(false);`
	`49`	`+ }`
`49`	`50`	`}`
`50`	`51`
`51`		`- void Refreshlabels(bool isConnected)`
	`52`	`+ void RefreshLabels(bool isConnected)`
`52`	`53`	`{`
`53`	`54`	`startupLabel.gameObject.SetActive(!isConnected);`
`54`	`55`	`controlsLabel.gameObject.SetActive(isConnected);`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`using Unity.Netcode.Samples.MultiplayerUseCases.Common;`
`2`	`2`	`using UnityEngine;`
`3`	`3`
`4`		`-namespace Unity.Netcode.Samples.MultiplayerUseCases.NetVarVsRPC`
	`4`	`+namespace Unity.Netcode.Samples.MultiplayerUseCases.NetVarVsRpc`
`5`	`5`	`{`
`6`	`6`	`/// <summary>`
`7`	`7`	`/// Manages the color of a Networked object`
`@@ -65,23 +65,23 @@ void Update()`
`65`	`65`
`66`	`66`	`void OnClientRequestColorChange()`
`67`	`67`	`{`
`68`		`- OnServerChangeColorServerRpc();`
	`68`	`+ ServerChangeColorRpc();`
`69`	`69`	`}`
`70`	`70`
`71`		`- [ServerRpc(RequireOwnership = false)] //note: please refer to RPCs documentation to learn more about the pros and cons of the RequireOwnership parameter`
`72`		`- void OnServerChangeColorServerRpc()`
	`71`	`+ [Rpc(SendTo.Server)]`
	`72`	`+ void ServerChangeColorRpc()`
`73`	`73`	`{`
`74`	`74`	`Color32 newColor = MultiplayerUseCasesUtilities.GetRandomColor();`
`75`	`75`	`if (m_UseNetworkVariableForColor)`
`76`	`76`	`{`
`77`	`77`	`m_NetworkedColor.Value = newColor;`
`78`	`78`	`return;`
`79`	`79`	`}`
`80`		`- OnClientNotifyColorChangedClientRpc(newColor);`
	`80`	`+ ClientNotifyColorChangedRpc(newColor);`
`81`	`81`	`}`
`82`	`82`
`83`		`- [ClientRpc]`
`84`		`- void OnClientNotifyColorChangedClientRpc(Color32 newColor)`
	`83`	`+ [Rpc(SendTo.ClientsAndHost)]`
	`84`	`+ void ClientNotifyColorChangedRpc(Color32 newColor)`
`85`	`85`	`{`
`86`	`86`	`m_Material.color = newColor;`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ public override void OnNetworkSpawn()`
`44`	`44`	`if (IsClient)`
`45`	`45`	`{`
`46`	`46`	`/*`
`47`		`- * We call the color change method manually when we connect to ensure that our color is correctly initialized.`
	`47`	`+ * We call the color change method manually when we connect to ensure that our color is correctly initialized.`
`48`	`48`	`* This is helpful for when a client joins mid-game and needs to catch up with the current state of the game.`
`49`	`49`	`*/`
`50`	`50`	`OnClientCustomDataChanged(m_SyncedCustomData.Value, m_SyncedCustomData.Value);`
`@@ -72,7 +72,7 @@ void Update()`
`72`	`72`	`if (!IsServer)`
`73`	`73`	`{`
`74`	`74`	`/*`
`75`		`- * By default, only the server is allowed to change the value of NetworkVariables.`
	`75`	`+ * By default, only the server is allowed to change the value of NetworkVariables.`
`76`	`76`	`* This can be changed through the NetworkVariable's constructor.`
`77`	`77`	`*/`
`78`	`78`	`return;`
`@@ -101,7 +101,7 @@ void OnClientHealthChanged(int previousHealth, int newHealth)`
`101`	`101`	`{`
`102`	`102`	`m_HealthBarImage.rectTransform.localScale = new Vector3((float)newHealth / 100.0f, 1);//(float)newHealth / 100.0f;`
`103`	`103`	`OnClientUpdateHealthBarColor(newHealth);`
`104`		`- //note: you could use the previousHealth to play an healing/damage animation`
	`104`	`+ //note: you could use the previousHealth to play a healing/damage animation`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`void OnClientUpdateHealthBarColor(int newHealth)`
Original file line number	Diff line number	Diff line change
`@@ -59,11 +59,11 @@ void Update()`
`59`	`59`
`60`	`60`	`void OnClientRequestColorChange()`
`61`	`61`	`{`
`62`		`- OnServerChangeColorServerRpc();`
	`62`	`+ ServerChangeColorRpc();`
`63`	`63`	`}`
`64`	`64`
`65`		`- [ServerRpc(RequireOwnership = false)]`
`66`		`- void OnServerChangeColorServerRpc()`
	`65`	`+ [Rpc(SendTo.Server)]`
	`66`	`+ void ServerChangeColorRpc()`
`67`	`67`	`{`
`68`	`68`	`m_NetworkedColor.Value = MultiplayerUseCasesUtilities.GetRandomColor();`
`69`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,27 +36,27 @@ void Update()`
`36`	`36`	`if (m_ElapsedSecondsSinceLastChange >= m_SecondsBetweenDataChanges)`
`37`	`37`	`{`
`38`	`38`	`m_ElapsedSecondsSinceLastChange = 0;`
`39`		`- OnServerMoodMessageReceivedServerRpc(s_ChatMessages[Random.Range(0, s_ChatMessages.Length)]);`
	`39`	`+ ServerMoodMessageReceivedRpc(s_ChatMessages[Random.Range(0, s_ChatMessages.Length)]);`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`43`		`- [ServerRpc]`
`44`		`- void OnServerMoodMessageReceivedServerRpc(string message)`
	`43`	`+ [Rpc(SendTo.Server)]`
	`44`	`+ void ServerMoodMessageReceivedRpc(string message)`
`45`	`45`	`{`
`46`	`46`	`/* Here's an example of the type of operation you could do on the server to prevent malicious actions`
`47`	`47`	`* from bad actors.`
`48`	`48`	`*/`
`49`	`49`	`string redactedMessage = OnServerFilterBadWords(message);`
`50`		`- OnClientMoodMessageReceivedClientRpc(redactedMessage);`
	`50`	`+ ClientMoodMessageReceivedRpc(redactedMessage);`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`string OnServerFilterBadWords(string message)`
`54`	`54`	`{`
`55`	`55`	`return MultiplayerUseCasesUtilities.FilterBadWords(message);`
`56`	`56`	`}`
`57`	`57`
`58`		`- [ClientRpc]`
`59`		`- void OnClientMoodMessageReceivedClientRpc(string message)`
	`58`	`+ [Rpc(SendTo.ClientsAndHost)]`
	`59`	`+ void ClientMoodMessageReceivedRpc(string message)`
`60`	`60`	`{`
`61`	`61`	`if (!m_SpeechBubble)`
`62`	`62`	`{`