Added fix to other server-only NetworkBehaviors

LPLafontaineB · LPLafontaineB · commit 23aa716ad437 · 2022-02-07T16:39:37.000-05:00
diff --git a/Assets/BossRoom/Scripts/Server/Game/Character/ServerCharacter.cs b/Assets/BossRoom/Scripts/Server/Game/Character/ServerCharacter.cs
@@ -61,13 +61,16 @@ public bool IsNpc
         private void Awake()
         {
             m_ActionPlayer = new ActionPlayer(this);
+            // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization
+            enabled = false;
         }
 
         public override void OnNetworkSpawn()
         {
-            if (!IsServer) { enabled = false; }
-            else
+            // Should only be enabled on server
+            if (IsServer)
             {
+                enabled = true;
                 NetState.DoActionEventServer += OnActionPlayRequest;
                 NetState.ReceivedClientInput += OnClientMoveRequest;
                 NetState.OnStopChargingUpServer += OnStoppedChargingUp;
@@ -103,6 +106,11 @@ public override void OnNetworkDespawn()
                 m_DamageReceiver.damageReceived -= ReceiveHP;
                 m_DamageReceiver.collisionEntered -= CollisionEntered;
             }
+            if (IsServer)
+            {
+                // Disable server components when despawning
+                enabled = false;
+            }
         }
 
         /// <summary>
diff --git a/Assets/BossRoom/Scripts/Server/Game/Character/ServerCharacterMovement.cs b/Assets/BossRoom/Scripts/Server/Game/Character/ServerCharacterMovement.cs
@@ -47,7 +47,7 @@ public class ServerCharacterMovement : NetworkBehaviour
         private void Awake()
         {
             m_NavigationSystem = GameObject.FindGameObjectWithTag(NavigationSystem.NavigationSystemTag).GetComponent<NavigationSystem>();
-            // disable this NetworkBehavior until it is spawned
+            // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization
             enabled = false;
         }
 
diff --git a/Assets/BossRoom/Scripts/Server/Game/Entity/RaiseEventOnLifeChange.cs b/Assets/BossRoom/Scripts/Server/Game/Entity/RaiseEventOnLifeChange.cs
@@ -19,22 +19,31 @@ public class RaiseEventOnLifeChange : NetworkBehaviour
         [SerializeField]
         LifeState m_RaiseCondition;
 
+        void Awake()
+        {
+            // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization
+            enabled = false;
+        }
+
         public override void OnNetworkSpawn()
         {
-            if (!IsServer)
+            if (IsServer)
             {
-                enabled = false;
-                return;
-            }
+                enabled = true;
 
-            Assert.IsNotNull(m_NetworkLifeState, "NetworkLifeState has not been set!");
+                Assert.IsNotNull(m_NetworkLifeState, "NetworkLifeState has not been set!");
 
-            m_NetworkLifeState.LifeState.OnValueChanged += LifeStateChanged;
+                m_NetworkLifeState.LifeState.OnValueChanged += LifeStateChanged;
+            }
         }
 
         public override void OnNetworkDespawn()
         {
-            m_NetworkLifeState.LifeState.OnValueChanged -= LifeStateChanged;
+            if (IsServer)
+            {
+                enabled = false;
+                m_NetworkLifeState.LifeState.OnValueChanged -= LifeStateChanged;
+            }
         }
 
         void LifeStateChanged(LifeState previousValue, LifeState newValue)
diff --git a/Assets/BossRoom/Scripts/Server/Game/Entity/ServerBreakableLogic.cs b/Assets/BossRoom/Scripts/Server/Game/Entity/ServerBreakableLogic.cs
@@ -30,23 +30,30 @@ public class ServerBreakableLogic : NetworkBehaviour, IDamageable
         private void Awake()
         {
             m_State = GetComponent<NetworkBreakableState>();
+            // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization
+            enabled = false;
         }
 
         public override void OnNetworkSpawn()
         {
-            if (!IsServer)
-            {
-                enabled = false;
-            }
-            else
+            if (IsServer)
             {
+                enabled = true;
                 if (m_MaxHealth && m_NetworkHealthState)
                 {
                     m_NetworkHealthState.HitPoints.Value = m_MaxHealth.Value;
                 }
             }
         }
 
+        public override void OnNetworkDespawn()
+        {
+            if (IsServer)
+            {
+                enabled = false;
+            }
+        }
+
         public void ReceiveHP(ServerCharacter inflicter, int HP)
         {
             if (HP < 0)
diff --git a/Assets/BossRoom/Scripts/Server/Game/Entity/ServerEnemyPortal.cs b/Assets/BossRoom/Scripts/Server/Game/Entity/ServerEnemyPortal.cs
@@ -41,33 +41,38 @@ private void Awake()
         {
             m_WaveSpawner = GetComponent<ServerWaveSpawner>();
             m_State = GetComponent<NetworkBreakableState>();
+            // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization
+            enabled = false;
         }
 
         public override void OnNetworkSpawn()
         {
-            if (!IsServer)
+            if (IsServer)
             {
-                enabled = false;
-                return;
-            }
+                enabled = true;
 
-            foreach (var breakable in m_BreakableElements)
-            {
-                breakable.IsBroken.OnValueChanged += OnBreakableBroken;
-            }
+                foreach (var breakable in m_BreakableElements)
+                {
+                    breakable.IsBroken.OnValueChanged += OnBreakableBroken;
+                }
 
-            MaintainState();
+                MaintainState();
+            }
         }
 
         public override void OnNetworkDespawn()
         {
-            if (m_CoroDormant != null)
-                StopCoroutine(m_CoroDormant);
-
-            foreach (var breakable in m_BreakableElements)
+            if (IsServer)
             {
-                if (breakable)
-                    breakable.IsBroken.OnValueChanged -= OnBreakableBroken;
+                enabled = false;
+                if (m_CoroDormant != null)
+                    StopCoroutine(m_CoroDormant);
+
+                foreach (var breakable in m_BreakableElements)
+                {
+                    if (breakable)
+                        breakable.IsBroken.OnValueChanged -= OnBreakableBroken;
+                }
             }
         }
 
diff --git a/Assets/BossRoom/Scripts/Server/Game/Entity/ServerProjectileLogic.cs b/Assets/BossRoom/Scripts/Server/Game/Entity/ServerProjectileLogic.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.IO;
 using Unity.Netcode;
@@ -56,6 +57,12 @@ public class ServerProjectileLogic : NetworkBehaviour
         /// </summary>
         private bool m_IsDead;
 
+        void Awake()
+        {
+            // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization
+            enabled = false;
+        }
+
         /// <summary>
         /// Set everything up based on provided projectile information.
         /// (Note that this is called before OnNetworkSpawn(), so don't try to do any network stuff here.)
@@ -68,21 +75,29 @@ public void Initialize(ulong creatorsNetworkObjectId, in ActionDescription.Proje
 
         public override void OnNetworkSpawn()
         {
-            if (!IsServer)
+            if (IsServer)
             {
-                enabled = false;
-                return;
-            }
-            m_Started = true;
+                enabled = true;
+
+                m_Started = true;
 
-            m_HitTargets = new List<GameObject>();
-            m_IsDead = false;
+                m_HitTargets = new List<GameObject>();
+                m_IsDead = false;
 
-            m_DestroyAtSec = Time.fixedTime + (m_ProjectileInfo.Range / m_ProjectileInfo.Speed_m_s);
+                m_DestroyAtSec = Time.fixedTime + (m_ProjectileInfo.Range / m_ProjectileInfo.Speed_m_s);
 
-            m_CollisionMask = LayerMask.GetMask(new[] { "NPCs", "Default", "Ground" });
-            m_BlockerMask = LayerMask.GetMask(new[] { "Default", "Ground" });
-            m_NPCLayer = LayerMask.NameToLayer("NPCs");
+                m_CollisionMask = LayerMask.GetMask(new[] {"NPCs", "Default", "Ground"});
+                m_BlockerMask = LayerMask.GetMask(new[] {"Default", "Ground"});
+                m_NPCLayer = LayerMask.NameToLayer("NPCs");
+            }
+        }
+
+        public override void OnNetworkDespawn()
+        {
+            if (IsServer)
+            {
+                enabled = false;
+            }
         }
 
         private void FixedUpdate()
diff --git a/Assets/BossRoom/Scripts/Server/Game/Entity/ServerWaveSpawner.cs b/Assets/BossRoom/Scripts/Server/Game/Entity/ServerWaveSpawner.cs
@@ -95,20 +95,22 @@ public class ServerWaveSpawner : NetworkBehaviour
         void Awake()
         {
             m_Transform = transform;
+            // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization
+            enabled = false;
         }
 
         public override void OnNetworkSpawn()
         {
-            if (!IsServer)
+            if (IsServer)
             {
-                enabled = false;
-                return;
-            }
-            m_Hit = new RaycastHit[1];
-            m_IsStarted = true;
-            if (m_IsSpawnerEnabled)
-            {
-                StartWaveSpawning();
+                enabled = true;
+
+                m_Hit = new RaycastHit[1];
+                m_IsStarted = true;
+                if (m_IsSpawnerEnabled)
+                {
+                    StartWaveSpawning();
+                }
             }
         }
 
@@ -150,7 +152,11 @@ void StopWaveSpawning()
 
         public override void OnNetworkDespawn()
         {
-            StopWaveSpawning();
+            if (IsServer)
+            {
+                enabled = false;
+                StopWaveSpawning();
+            }
         }
 
         /// <summary>
diff --git a/Assets/BossRoom/Scripts/Server/ServerFloorSwitch.cs b/Assets/BossRoom/Scripts/Server/ServerFloorSwitch.cs
@@ -29,19 +29,33 @@ public class ServerFloorSwitch : NetworkBehaviour
 
         void Awake()
         {
-            m_Collider.isTrigger = true;
+            // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization
+            enabled = false;
+            m_Collider.enabled = false;
         }
 
         public override void OnNetworkSpawn()
         {
-            if (!IsServer)
+            if (IsServer)
             {
-                enabled = false;
+                enabled = true;
+                m_Collider.enabled = true;
+                m_Collider.isTrigger = true;
+
+                FloorSwitchStateChanged(false, m_FloorSwitchState.IsSwitchedOn.Value);
+
+                m_FloorSwitchState.IsSwitchedOn.OnValueChanged += FloorSwitchStateChanged;
             }
+        }
 
-            FloorSwitchStateChanged(false, m_FloorSwitchState.IsSwitchedOn.Value);
+        public override void OnNetworkDespawn()
+        {
+            if (IsServer)
+            {
+                enabled = false;
 
-            m_FloorSwitchState.IsSwitchedOn.OnValueChanged += FloorSwitchStateChanged;
+                m_FloorSwitchState.IsSwitchedOn.OnValueChanged -= FloorSwitchStateChanged;
+            }
         }
 
         void OnTriggerEnter(Collider other)
diff --git a/Assets/BossRoom/Scripts/Server/ServerSwitchedDoor.cs b/Assets/BossRoom/Scripts/Server/ServerSwitchedDoor.cs
@@ -28,7 +28,7 @@ public class ServerSwitchedDoor : NetworkBehaviour
 
         void Awake()
         {
-            // don't let Update() run until after OnNetworkSpawn()
+            // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization
             enabled = false;
 
             if (m_SwitchesThatOpenThisDoor.Length == 0)
@@ -37,11 +37,24 @@ void Awake()
 
         public override void OnNetworkSpawn()
         {
-            enabled = IsServer;
+            if (IsServer)
+            {
+                enabled = true;
+
+                DoorStateChanged(false, m_NetworkDoorState.IsOpen.Value);
+
+                m_NetworkDoorState.IsOpen.OnValueChanged += DoorStateChanged;
+            }
+        }
 
-            DoorStateChanged(false, m_NetworkDoorState.IsOpen.Value);
+        public override void OnNetworkDespawn()
+        {
+            if (IsServer)
+            {
+                enabled = false;
 
-            m_NetworkDoorState.IsOpen.OnValueChanged += DoorStateChanged;
+                m_NetworkDoorState.IsOpen.OnValueChanged -= DoorStateChanged;
+            }
         }
 
         void Update()

Original file line number	Diff line number	Diff line change
`@@ -61,13 +61,16 @@ public bool IsNpc`
`61`	`61`	`private void Awake()`
`62`	`62`	`{`
`63`	`63`	`m_ActionPlayer = new ActionPlayer(this);`
	`64`	`+ // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization`
	`65`	`+ enabled = false;`
`64`	`66`	`}`
`65`	`67`
`66`	`68`	`public override void OnNetworkSpawn()`
`67`	`69`	`{`
`68`		`- if (!IsServer) { enabled = false; }`
`69`		`- else`
	`70`	`+ // Should only be enabled on server`
	`71`	`+ if (IsServer)`
`70`	`72`	`{`
	`73`	`+ enabled = true;`
`71`	`74`	`NetState.DoActionEventServer += OnActionPlayRequest;`
`72`	`75`	`NetState.ReceivedClientInput += OnClientMoveRequest;`
`73`	`76`	`NetState.OnStopChargingUpServer += OnStoppedChargingUp;`
`@@ -103,6 +106,11 @@ public override void OnNetworkDespawn()`
`103`	`106`	`m_DamageReceiver.damageReceived -= ReceiveHP;`
`104`	`107`	`m_DamageReceiver.collisionEntered -= CollisionEntered;`
`105`	`108`	`}`
	`109`	`+ if (IsServer)`
	`110`	`+ {`
	`111`	`+ // Disable server components when despawning`
	`112`	`+ enabled = false;`
	`113`	`+ }`
`106`	`114`	`}`
`107`	`115`
`108`	`116`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public class ServerCharacterMovement : NetworkBehaviour`
`47`	`47`	`private void Awake()`
`48`	`48`	`{`
`49`	`49`	`m_NavigationSystem = GameObject.FindGameObjectWithTag(NavigationSystem.NavigationSystemTag).GetComponent<NavigationSystem>();`
`50`		`- // disable this NetworkBehavior until it is spawned`
	`50`	`+ // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization`
`51`	`51`	`enabled = false;`
`52`	`52`	`}`
`53`	`53`
Original file line number	Diff line number	Diff line change
`@@ -30,23 +30,30 @@ public class ServerBreakableLogic : NetworkBehaviour, IDamageable`
`30`	`30`	`private void Awake()`
`31`	`31`	`{`
`32`	`32`	`m_State = GetComponent<NetworkBreakableState>();`
	`33`	`+ // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization`
	`34`	`+ enabled = false;`
`33`	`35`	`}`
`34`	`36`
`35`	`37`	`public override void OnNetworkSpawn()`
`36`	`38`	`{`
`37`		`- if (!IsServer)`
`38`		`- {`
`39`		`- enabled = false;`
`40`		`- }`
`41`		`- else`
	`39`	`+ if (IsServer)`
`42`	`40`	`{`
	`41`	`+ enabled = true;`
`43`	`42`	`if (m_MaxHealth && m_NetworkHealthState)`
`44`	`43`	`{`
`45`	`44`	`m_NetworkHealthState.HitPoints.Value = m_MaxHealth.Value;`
`46`	`45`	`}`
`47`	`46`	`}`
`48`	`47`	`}`
`49`	`48`
	`49`	`+ public override void OnNetworkDespawn()`
	`50`	`+ {`
	`51`	`+ if (IsServer)`
	`52`	`+ {`
	`53`	`+ enabled = false;`
	`54`	`+ }`
	`55`	`+ }`
	`56`	`+`
`50`	`57`	`public void ReceiveHP(ServerCharacter inflicter, int HP)`
`51`	`58`	`{`
`52`	`59`	`if (HP < 0)`
Original file line number	Diff line number	Diff line change
`@@ -41,33 +41,38 @@ private void Awake()`
`41`	`41`	`{`
`42`	`42`	`m_WaveSpawner = GetComponent<ServerWaveSpawner>();`
`43`	`43`	`m_State = GetComponent<NetworkBreakableState>();`
	`44`	`+ // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization`
	`45`	`+ enabled = false;`
`44`	`46`	`}`
`45`	`47`
`46`	`48`	`public override void OnNetworkSpawn()`
`47`	`49`	`{`
`48`		`- if (!IsServer)`
	`50`	`+ if (IsServer)`
`49`	`51`	`{`
`50`		`- enabled = false;`
`51`		`- return;`
`52`		`- }`
	`52`	`+ enabled = true;`
`53`	`53`
`54`		`- foreach (var breakable in m_BreakableElements)`
`55`		`- {`
`56`		`- breakable.IsBroken.OnValueChanged += OnBreakableBroken;`
`57`		`- }`
	`54`	`+ foreach (var breakable in m_BreakableElements)`
	`55`	`+ {`
	`56`	`+ breakable.IsBroken.OnValueChanged += OnBreakableBroken;`
	`57`	`+ }`
`58`	`58`
`59`		`- MaintainState();`
	`59`	`+ MaintainState();`
	`60`	`+ }`
`60`	`61`	`}`
`61`	`62`
`62`	`63`	`public override void OnNetworkDespawn()`
`63`	`64`	`{`
`64`		`- if (m_CoroDormant != null)`
`65`		`- StopCoroutine(m_CoroDormant);`
`66`		`-`
`67`		`- foreach (var breakable in m_BreakableElements)`
	`65`	`+ if (IsServer)`
`68`	`66`	`{`
`69`		`- if (breakable)`
`70`		`- breakable.IsBroken.OnValueChanged -= OnBreakableBroken;`
	`67`	`+ enabled = false;`
	`68`	`+ if (m_CoroDormant != null)`
	`69`	`+ StopCoroutine(m_CoroDormant);`
	`70`	`+`
	`71`	`+ foreach (var breakable in m_BreakableElements)`
	`72`	`+ {`
	`73`	`+ if (breakable)`
	`74`	`+ breakable.IsBroken.OnValueChanged -= OnBreakableBroken;`
	`75`	`+ }`
`71`	`76`	`}`
`72`	`77`	`}`
`73`	`78`
Original file line number	Diff line number	Diff line change
`@@ -95,20 +95,22 @@ public class ServerWaveSpawner : NetworkBehaviour`
`95`	`95`	`void Awake()`
`96`	`96`	`{`
`97`	`97`	`m_Transform = transform;`
	`98`	`+ // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization`
	`99`	`+ enabled = false;`
`98`	`100`	`}`
`99`	`101`
`100`	`102`	`public override void OnNetworkSpawn()`
`101`	`103`	`{`
`102`		`- if (!IsServer)`
	`104`	`+ if (IsServer)`
`103`	`105`	`{`
`104`		`- enabled = false;`
`105`		`- return;`
`106`		`- }`
`107`		`- m_Hit = new RaycastHit[1];`
`108`		`- m_IsStarted = true;`
`109`		`- if (m_IsSpawnerEnabled)`
`110`		`- {`
`111`		`- StartWaveSpawning();`
	`106`	`+ enabled = true;`
	`107`	`+`
	`108`	`+ m_Hit = new RaycastHit[1];`
	`109`	`+ m_IsStarted = true;`
	`110`	`+ if (m_IsSpawnerEnabled)`
	`111`	`+ {`
	`112`	`+ StartWaveSpawning();`
	`113`	`+ }`
`112`	`114`	`}`
`113`	`115`	`}`
`114`	`116`
`@@ -150,7 +152,11 @@ void StopWaveSpawning()`
`150`	`152`
`151`	`153`	`public override void OnNetworkDespawn()`
`152`	`154`	`{`
`153`		`- StopWaveSpawning();`
	`155`	`+ if (IsServer)`
	`156`	`+ {`
	`157`	`+ enabled = false;`
	`158`	`+ StopWaveSpawning();`
	`159`	`+ }`
`154`	`160`	`}`
`155`	`161`
`156`	`162`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -29,19 +29,33 @@ public class ServerFloorSwitch : NetworkBehaviour`
`29`	`29`
`30`	`30`	`void Awake()`
`31`	`31`	`{`
`32`		`- m_Collider.isTrigger = true;`
	`32`	`+ // Disable this NetworkBehavior until it is spawned. This prevents unwanted behavior when this is loaded before being spawned, such as during client synchronization`
	`33`	`+ enabled = false;`
	`34`	`+ m_Collider.enabled = false;`
`33`	`35`	`}`
`34`	`36`
`35`	`37`	`public override void OnNetworkSpawn()`
`36`	`38`	`{`
`37`		`- if (!IsServer)`
	`39`	`+ if (IsServer)`
`38`	`40`	`{`
`39`		`- enabled = false;`
	`41`	`+ enabled = true;`
	`42`	`+ m_Collider.enabled = true;`
	`43`	`+ m_Collider.isTrigger = true;`
	`44`	`+`
	`45`	`+ FloorSwitchStateChanged(false, m_FloorSwitchState.IsSwitchedOn.Value);`
	`46`	`+`
	`47`	`+ m_FloorSwitchState.IsSwitchedOn.OnValueChanged += FloorSwitchStateChanged;`
`40`	`48`	`}`
	`49`	`+ }`
`41`	`50`
`42`		`- FloorSwitchStateChanged(false, m_FloorSwitchState.IsSwitchedOn.Value);`
	`51`	`+ public override void OnNetworkDespawn()`
	`52`	`+ {`
	`53`	`+ if (IsServer)`
	`54`	`+ {`
	`55`	`+ enabled = false;`
`43`	`56`
`44`		`- m_FloorSwitchState.IsSwitchedOn.OnValueChanged += FloorSwitchStateChanged;`
	`57`	`+ m_FloorSwitchState.IsSwitchedOn.OnValueChanged -= FloorSwitchStateChanged;`
	`58`	`+ }`
`45`	`59`	`}`
`46`	`60`
`47`	`61`	`void OnTriggerEnter(Collider other)`