formatting, PR feedback

fernando-cortez · fernando-cortez · commit 7fb75b8abd91 · 2025-04-28T14:39:05.000-04:00
diff --git a/Assets/Prefabs/Game/EnemySpawner.prefab b/Assets/Prefabs/Game/EnemySpawner.prefab
@@ -484,7 +484,7 @@ MonoBehaviour:
   ShowTopMostFoldoutHeaderGroup: 1
   m_BreakableElements: []
   m_DormantCooldown: 180
-  m_Breakable: {fileID: 5343699662503375493}
+  m_PortalBreakable: {fileID: 5343699662503375493}
   m_WaveSpawner: {fileID: 4844841199312666291}
 --- !u!114 &5343699662503375493
 MonoBehaviour:
diff --git a/Assets/Scripts/Gameplay/Action/ConcreteActions/AOEAction.cs b/Assets/Scripts/Gameplay/Action/ConcreteActions/AOEAction.cs
@@ -69,7 +69,7 @@ private void PerformAoE(ServerCharacter parent)
                 if (enemy != null)
                 {
                     // actually deal the damage
-                    enemy.ReceiveHP(parent, -Config.Amount);
+                    enemy.ReceiveHitPoints(parent, -Config.Amount);
                 }
             }
         }
diff --git a/Assets/Scripts/Gameplay/Action/ConcreteActions/DashAttackAction.cs b/Assets/Scripts/Gameplay/Action/ConcreteActions/DashAttackAction.cs
@@ -103,7 +103,7 @@ private void PerformMeleeAttack(ServerCharacter parent)
 
             if (foe != null)
             {
-                foe.ReceiveHP(parent, -Config.Amount);
+                foe.ReceiveHitPoints(parent, -Config.Amount);
             }
         }
 
diff --git a/Assets/Scripts/Gameplay/Action/ConcreteActions/FXProjectileTargetedAction.cs b/Assets/Scripts/Gameplay/Action/ConcreteActions/FXProjectileTargetedAction.cs
@@ -74,7 +74,7 @@ public override bool OnUpdate(ServerCharacter clientCharacter)
                 m_ImpactedTarget = true;
                 if (m_DamageableTarget != null)
                 {
-                    m_DamageableTarget.ReceiveHP(clientCharacter, -Config.Projectiles[0].Damage);
+                    m_DamageableTarget.ReceiveHitPoints(clientCharacter, -Config.Projectiles[0].Damage);
                 }
             }
             return true;
diff --git a/Assets/Scripts/Gameplay/Action/ConcreteActions/MeleeAction.cs b/Assets/Scripts/Gameplay/Action/ConcreteActions/MeleeAction.cs
@@ -72,7 +72,7 @@ public override bool OnUpdate(ServerCharacter clientCharacter)
                 var foe = DetectFoe(clientCharacter, m_ProvisionalTarget);
                 if (foe != null)
                 {
-                    foe.ReceiveHP(clientCharacter, -Config.Amount);
+                    foe.ReceiveHitPoints(clientCharacter, -Config.Amount);
                 }
             }
 
diff --git a/Assets/Scripts/Gameplay/Action/ConcreteActions/TrampleAction.cs b/Assets/Scripts/Gameplay/Action/ConcreteActions/TrampleAction.cs
@@ -172,7 +172,7 @@ private void CollideWithVictim(ServerCharacter parent, ServerCharacter victim)
 
                 if (victim.gameObject.TryGetComponent(out IDamageable damageable))
                 {
-                    damageable.ReceiveHP(parent, -damage);
+                    damageable.ReceiveHitPoints(parent, -damage);
                 }
             }
 
@@ -209,7 +209,7 @@ private void Collide(ServerCharacter parent, Collider collider)
                 var damageable = collider.gameObject.GetComponent<IDamageable>();
                 if (damageable != null)
                 {
-                    damageable.ReceiveHP(parent, -Config.SplashDamage);
+                    damageable.ReceiveHitPoints(parent, -Config.SplashDamage);
 
                     // lastly, a special case: if the trampler runs into certain breakables, they are stunned!
                     if ((damageable.GetSpecialDamageFlags() & IDamageable.SpecialDamageFlags.StunOnTrample) == IDamageable.SpecialDamageFlags.StunOnTrample)
diff --git a/Assets/Scripts/Gameplay/DebugCheats/DebugCheatsManager.cs b/Assets/Scripts/Gameplay/DebugCheats/DebugCheatsManager.cs
@@ -153,7 +153,7 @@ void ServerKillTargetRpc(RpcParams serverRpcParams = default)
                     var damageable = obj.GetComponent<IDamageable>();
                     if (damageable != null && damageable.IsDamageable())
                     {
-                        damageable.ReceiveHP(playerServerCharacter, int.MinValue);
+                        damageable.ReceiveHitPoints(playerServerCharacter, int.MinValue);
                         PublishCheatUsedMessage(serverRpcParams.Receive.SenderClientId, "KillTarget");
                     }
                     else
@@ -173,7 +173,7 @@ void ServerKillAllEnemiesRpc(RpcParams serverRpcParams = default)
                 {
                     if (serverCharacter.gameObject.TryGetComponent(out IDamageable damageable))
                     {
-                        damageable.ReceiveHP(null, -serverCharacter.HitPoints);
+                        damageable.ReceiveHitPoints(null, -serverCharacter.HitPoints);
                     }
                 }
             }
@@ -209,7 +209,7 @@ void ServerHealPlayerRpc(RpcParams serverRpcParams = default)
                 {
                     if (playerServerCharacter.gameObject.TryGetComponent(out IDamageable damageable))
                     {
-                        damageable.ReceiveHP(null, baseHp);
+                        damageable.ReceiveHitPoints(null, baseHp);
                     }
                 }
 
diff --git a/Assets/Scripts/Gameplay/GameplayObjects/Breakable.cs b/Assets/Scripts/Gameplay/GameplayObjects/Breakable.cs
@@ -49,8 +49,8 @@ public class Breakable : NetworkBehaviour, IDamageable, ITargetable
         /// Is the item broken or not?
         /// </summary>
         public bool IsBroken => m_NetworkHealthState.HitPoints.Value == 0;
-        
-        public event Action OnBroken;
+
+        public event Action Broken;
 
         public bool IsNpc => true;
 
@@ -70,7 +70,10 @@ public override void OnNetworkSpawn()
 
             if (IsClient)
             {
-                m_NetworkHealthState.HitPoints.OnValueChanged += OnHPChanged;
+                if (m_NetworkHealthState)
+                {
+                    m_NetworkHealthState.HitPoints.OnValueChanged += OnHPChanged;
+                }
 
                 if (IsBroken)
                 {
@@ -81,13 +84,13 @@ public override void OnNetworkSpawn()
 
         public override void OnNetworkDespawn()
         {
-            if (IsClient)
+            if (IsClient && m_NetworkHealthState)
             {
                 m_NetworkHealthState.HitPoints.OnValueChanged -= OnHPChanged;
             }
         }
 
-        public void ReceiveHP(ServerCharacter inflicter, int hitPoints)
+        public void ReceiveHitPoints(ServerCharacter inflicter, int hitPoints)
         {
             if (hitPoints < 0)
             {
@@ -101,7 +104,7 @@ public void ReceiveHP(ServerCharacter inflicter, int hitPoints)
                     }
                 }
 
-                if (m_NetworkHealthState)
+                if (m_NetworkHealthState && m_MaxHealth)
                 {
                     m_NetworkHealthState.HitPoints.Value =
                         Mathf.Clamp(m_NetworkHealthState.HitPoints.Value + hitPoints, 0, m_MaxHealth.Value);
@@ -144,10 +147,10 @@ void OnHPChanged(int previousValue, int newValue)
                     m_Collider.enabled = !IsBroken;
                 }
             }
-            
+
             if (previousValue > 0 && newValue >= 0)
             {
-                OnBroken?.Invoke();
+                Broken?.Invoke();
                 PerformBreakVisualization(false);
             }
             else if (previousValue == 0 && newValue > 0)
@@ -182,6 +185,7 @@ void PerformUnbreakVisualization()
             {
                 Destroy(m_CurrentBrokenVisualization);
             }
+
             foreach (var unbrokenGameObject in m_UnbrokenGameObjects)
             {
                 if (unbrokenGameObject)
@@ -203,7 +207,4 @@ void OnValidate()
         }
 #endif
     }
-
-
 }
-
diff --git a/Assets/Scripts/Gameplay/GameplayObjects/DamageReceiver.cs b/Assets/Scripts/Gameplay/GameplayObjects/DamageReceiver.cs
@@ -16,11 +16,11 @@ public class DamageReceiver : NetworkBehaviour, IDamageable
         [SerializeField]
         NetworkLifeState m_NetworkLifeState;
 
-        public void ReceiveHP(ServerCharacter inflicter, int HP)
+        public void ReceiveHitPoints(ServerCharacter inflicter, int hitPoints)
         {
             if (IsDamageable())
             {
-                DamageReceived?.Invoke(inflicter, HP);
+                DamageReceived?.Invoke(inflicter, hitPoints);
             }
         }
 
diff --git a/Assets/Scripts/Gameplay/GameplayObjects/EnemyPortal.cs b/Assets/Scripts/Gameplay/GameplayObjects/EnemyPortal.cs
@@ -4,6 +4,7 @@
 using Unity.Netcode;
 using UnityEngine;
 using UnityEngine.Assertions;
+using UnityEngine.Serialization;
 
 namespace Unity.BossRoom.Gameplay.GameplayObjects
 {
@@ -31,11 +32,11 @@ public class EnemyPortal : NetworkBehaviour, ITargetable
         float m_DormantCooldown;
 
         [SerializeField]
-        Breakable m_Breakable;
+        Breakable m_PortalBreakable;
 
         public bool IsNpc => true;
 
-        public bool IsValidTarget => !m_Breakable.IsBroken;
+        public bool IsValidTarget => !m_PortalBreakable.IsBroken;
 
         // cached reference to our components
         [SerializeField]
@@ -54,7 +55,7 @@ public override void OnNetworkSpawn()
 
             foreach (var breakable in m_BreakableElements)
             {
-                breakable.OnBroken += OnBreakableBroken;
+                breakable.Broken += OnBreakableBroken;
             }
 
             MaintainState();
@@ -69,7 +70,7 @@ public override void OnNetworkDespawn()
             {
                 if (breakable)
                 {
-                    breakable.OnBroken -= OnBreakableBroken;
+                    breakable.Broken -= OnBreakableBroken;
                 }
             }
         }
@@ -93,11 +94,11 @@ void MaintainState()
 
             if (!hasUnbrokenBreakables)
             {
-                m_Breakable.Break();
+                m_PortalBreakable.Break();
             }
             else
             {
-                m_Breakable.Unbreak();
+                m_PortalBreakable.Unbreak();
             }
             m_WaveSpawner.SetSpawnerEnabled(hasUnbrokenBreakables);
             if (!hasUnbrokenBreakables && m_CoroDormant == null)
@@ -125,7 +126,7 @@ void Restart()
                 }
             }
 
-            m_Breakable.Unbreak();
+            m_PortalBreakable.Unbreak();
             m_WaveSpawner.SetSpawnerEnabled(true);
             m_CoroDormant = null;
         }
@@ -148,7 +149,7 @@ public void ForceDestroy()
                 {
                     var serverComponent = state.GetComponent<Breakable>();
                     Assert.IsNotNull(serverComponent);
-                    serverComponent.ReceiveHP(null, Int32.MinValue);
+                    serverComponent.Break();
                 }
             }
         }
diff --git a/Assets/Scripts/Gameplay/GameplayObjects/IDamageable.cs b/Assets/Scripts/Gameplay/GameplayObjects/IDamageable.cs
@@ -14,8 +14,8 @@ public interface IDamageable
         /// Receives HP damage or healing.
         /// </summary>
         /// <param name="inflicter">The Character responsible for the damage. May be null.</param>
-        /// <param name="HP">The damage done. Negative value is damage, positive is healing.</param>
-        void ReceiveHP(ServerCharacter inflicter, int HP);
+        /// <param name="hitPoints">The damage done. Negative value is damage, positive is healing.</param>
+        void ReceiveHitPoints(ServerCharacter inflicter, int hitPoints);
 
         /// <summary>
         /// Get the total damage value.
diff --git a/Assets/Scripts/Gameplay/GameplayObjects/Projectiles/PhysicsProjectile.cs b/Assets/Scripts/Gameplay/GameplayObjects/Projectiles/PhysicsProjectile.cs
@@ -212,7 +212,7 @@ void DetectCollisions()
 
                         if (m_CollisionCache[i].TryGetComponent(out IDamageable damageable))
                         {
-                            damageable.ReceiveHP(spawnerObj, -m_ProjectileInfo.Damage);
+                            damageable.ReceiveHitPoints(spawnerObj, -m_ProjectileInfo.Damage);
                         }
                     }
 
diff --git a/Assets/Scripts/Gameplay/GameplayObjects/TossedItem.cs b/Assets/Scripts/Gameplay/GameplayObjects/TossedItem.cs
@@ -102,7 +102,7 @@ void Detonate()
             {
                 if (m_CollisionCache[i].gameObject.TryGetComponent(out IDamageable damageReceiver))
                 {
-                    damageReceiver.ReceiveHP(null, -m_DamagePoints);
+                    damageReceiver.ReceiveHitPoints(null, -m_DamagePoints);
 
                     var serverCharacter = m_CollisionCache[i].gameObject.GetComponentInParent<ServerCharacter>();
                     if (serverCharacter)

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ private void PerformAoE(ServerCharacter parent)`
`69`	`69`	`if (enemy != null)`
`70`	`70`	`{`
`71`	`71`	`// actually deal the damage`
`72`		`- enemy.ReceiveHP(parent, -Config.Amount);`
	`72`	`+ enemy.ReceiveHitPoints(parent, -Config.Amount);`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ private void PerformMeleeAttack(ServerCharacter parent)`
`103`	`103`
`104`	`104`	`if (foe != null)`
`105`	`105`	`{`
`106`		`- foe.ReceiveHP(parent, -Config.Amount);`
	`106`	`+ foe.ReceiveHitPoints(parent, -Config.Amount);`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ public override bool OnUpdate(ServerCharacter clientCharacter)`
`74`	`74`	`m_ImpactedTarget = true;`
`75`	`75`	`if (m_DamageableTarget != null)`
`76`	`76`	`{`
`77`		`- m_DamageableTarget.ReceiveHP(clientCharacter, -Config.Projectiles[0].Damage);`
	`77`	`+ m_DamageableTarget.ReceiveHitPoints(clientCharacter, -Config.Projectiles[0].Damage);`
`78`	`78`	`}`
`79`	`79`	`}`
`80`	`80`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ public override bool OnUpdate(ServerCharacter clientCharacter)`
`72`	`72`	`var foe = DetectFoe(clientCharacter, m_ProvisionalTarget);`
`73`	`73`	`if (foe != null)`
`74`	`74`	`{`
`75`		`- foe.ReceiveHP(clientCharacter, -Config.Amount);`
	`75`	`+ foe.ReceiveHitPoints(clientCharacter, -Config.Amount);`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
Original file line number	Diff line number	Diff line change
`@@ -172,7 +172,7 @@ private void CollideWithVictim(ServerCharacter parent, ServerCharacter victim)`
`172`	`172`
`173`	`173`	`if (victim.gameObject.TryGetComponent(out IDamageable damageable))`
`174`	`174`	`{`
`175`		`- damageable.ReceiveHP(parent, -damage);`
	`175`	`+ damageable.ReceiveHitPoints(parent, -damage);`
`176`	`176`	`}`
`177`	`177`	`}`
`178`	`178`
`@@ -209,7 +209,7 @@ private void Collide(ServerCharacter parent, Collider collider)`
`209`	`209`	`var damageable = collider.gameObject.GetComponent<IDamageable>();`
`210`	`210`	`if (damageable != null)`
`211`	`211`	`{`
`212`		`- damageable.ReceiveHP(parent, -Config.SplashDamage);`
	`212`	`+ damageable.ReceiveHitPoints(parent, -Config.SplashDamage);`
`213`	`213`
`214`	`214`	`// lastly, a special case: if the trampler runs into certain breakables, they are stunned!`
`215`	`215`	`if ((damageable.GetSpecialDamageFlags() & IDamageable.SpecialDamageFlags.StunOnTrample) == IDamageable.SpecialDamageFlags.StunOnTrample)`
Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,7 @@ void ServerKillTargetRpc(RpcParams serverRpcParams = default)`
`153`	`153`	`var damageable = obj.GetComponent<IDamageable>();`
`154`	`154`	`if (damageable != null && damageable.IsDamageable())`
`155`	`155`	`{`
`156`		`- damageable.ReceiveHP(playerServerCharacter, int.MinValue);`
	`156`	`+ damageable.ReceiveHitPoints(playerServerCharacter, int.MinValue);`
`157`	`157`	`PublishCheatUsedMessage(serverRpcParams.Receive.SenderClientId, "KillTarget");`
`158`	`158`	`}`
`159`	`159`	`else`
`@@ -173,7 +173,7 @@ void ServerKillAllEnemiesRpc(RpcParams serverRpcParams = default)`
`173`	`173`	`{`
`174`	`174`	`if (serverCharacter.gameObject.TryGetComponent(out IDamageable damageable))`
`175`	`175`	`{`
`176`		`- damageable.ReceiveHP(null, -serverCharacter.HitPoints);`
	`176`	`+ damageable.ReceiveHitPoints(null, -serverCharacter.HitPoints);`
`177`	`177`	`}`
`178`	`178`	`}`
`179`	`179`	`}`
`@@ -209,7 +209,7 @@ void ServerHealPlayerRpc(RpcParams serverRpcParams = default)`
`209`	`209`	`{`
`210`	`210`	`if (playerServerCharacter.gameObject.TryGetComponent(out IDamageable damageable))`
`211`	`211`	`{`
`212`		`- damageable.ReceiveHP(null, baseHp);`
	`212`	`+ damageable.ReceiveHitPoints(null, baseHp);`
`213`	`213`	`}`
`214`	`214`	`}`
`215`	`215`
Original file line number	Diff line number	Diff line change
`@@ -49,8 +49,8 @@ public class Breakable : NetworkBehaviour, IDamageable, ITargetable`
`49`	`49`	`/// Is the item broken or not?`
`50`	`50`	`/// </summary>`
`51`	`51`	`public bool IsBroken => m_NetworkHealthState.HitPoints.Value == 0;`
`52`		`-`
`53`		`- public event Action OnBroken;`
	`52`	`+`
	`53`	`+ public event Action Broken;`
`54`	`54`
`55`	`55`	`public bool IsNpc => true;`
`56`	`56`
`@@ -70,7 +70,10 @@ public override void OnNetworkSpawn()`
`70`	`70`
`71`	`71`	`if (IsClient)`
`72`	`72`	`{`
`73`		`- m_NetworkHealthState.HitPoints.OnValueChanged += OnHPChanged;`
	`73`	`+ if (m_NetworkHealthState)`
	`74`	`+ {`
	`75`	`+ m_NetworkHealthState.HitPoints.OnValueChanged += OnHPChanged;`
	`76`	`+ }`
`74`	`77`
`75`	`78`	`if (IsBroken)`
`76`	`79`	`{`
`@@ -81,13 +84,13 @@ public override void OnNetworkSpawn()`
`81`	`84`
`82`	`85`	`public override void OnNetworkDespawn()`
`83`	`86`	`{`
`84`		`- if (IsClient)`
	`87`	`+ if (IsClient && m_NetworkHealthState)`
`85`	`88`	`{`
`86`	`89`	`m_NetworkHealthState.HitPoints.OnValueChanged -= OnHPChanged;`
`87`	`90`	`}`
`88`	`91`	`}`
`89`	`92`
`90`		`- public void ReceiveHP(ServerCharacter inflicter, int hitPoints)`
	`93`	`+ public void ReceiveHitPoints(ServerCharacter inflicter, int hitPoints)`
`91`	`94`	`{`
`92`	`95`	`if (hitPoints < 0)`
`93`	`96`	`{`
`@@ -101,7 +104,7 @@ public void ReceiveHP(ServerCharacter inflicter, int hitPoints)`
`101`	`104`	`}`
`102`	`105`	`}`
`103`	`106`
`104`		`- if (m_NetworkHealthState)`
	`107`	`+ if (m_NetworkHealthState && m_MaxHealth)`
`105`	`108`	`{`
`106`	`109`	`m_NetworkHealthState.HitPoints.Value =`
`107`	`110`	`Mathf.Clamp(m_NetworkHealthState.HitPoints.Value + hitPoints, 0, m_MaxHealth.Value);`
`@@ -144,10 +147,10 @@ void OnHPChanged(int previousValue, int newValue)`
`144`	`147`	`m_Collider.enabled = !IsBroken;`
`145`	`148`	`}`
`146`	`149`	`}`
`147`		`-`
	`150`	`+`
`148`	`151`	`if (previousValue > 0 && newValue >= 0)`
`149`	`152`	`{`
`150`		`- OnBroken?.Invoke();`
	`153`	`+ Broken?.Invoke();`
`151`	`154`	`PerformBreakVisualization(false);`
`152`	`155`	`}`
`153`	`156`	`else if (previousValue == 0 && newValue > 0)`
`@@ -182,6 +185,7 @@ void PerformUnbreakVisualization()`
`182`	`185`	`{`
`183`	`186`	`Destroy(m_CurrentBrokenVisualization);`
`184`	`187`	`}`
	`188`	`+`
`185`	`189`	`foreach (var unbrokenGameObject in m_UnbrokenGameObjects)`
`186`	`190`	`{`
`187`	`191`	`if (unbrokenGameObject)`
`@@ -203,7 +207,4 @@ void OnValidate()`
`203`	`207`	`}`
`204`	`208`	`#endif`
`205`	`209`	`}`
`206`		`-`
`207`		`-`
`208`	`210`	`}`
`209`		`-`
Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,11 @@ public class DamageReceiver : NetworkBehaviour, IDamageable`
`16`	`16`	`[SerializeField]`
`17`	`17`	`NetworkLifeState m_NetworkLifeState;`
`18`	`18`
`19`		`- public void ReceiveHP(ServerCharacter inflicter, int HP)`
	`19`	`+ public void ReceiveHitPoints(ServerCharacter inflicter, int hitPoints)`
`20`	`20`	`{`
`21`	`21`	`if (IsDamageable())`
`22`	`22`	`{`
`23`		`- DamageReceived?.Invoke(inflicter, HP);`
	`23`	`+ DamageReceived?.Invoke(inflicter, hitPoints);`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using Unity.Netcode;`
`5`	`5`	`using UnityEngine;`
`6`	`6`	`using UnityEngine.Assertions;`
	`7`	`+using UnityEngine.Serialization;`
`7`	`8`
`8`	`9`	`namespace Unity.BossRoom.Gameplay.GameplayObjects`
`9`	`10`	`{`
`@@ -31,11 +32,11 @@ public class EnemyPortal : NetworkBehaviour, ITargetable`
`31`	`32`	`float m_DormantCooldown;`
`32`	`33`
`33`	`34`	`[SerializeField]`
`34`		`- Breakable m_Breakable;`
	`35`	`+ Breakable m_PortalBreakable;`
`35`	`36`
`36`	`37`	`public bool IsNpc => true;`
`37`	`38`
`38`		`- public bool IsValidTarget => !m_Breakable.IsBroken;`
	`39`	`+ public bool IsValidTarget => !m_PortalBreakable.IsBroken;`
`39`	`40`
`40`	`41`	`// cached reference to our components`
`41`	`42`	`[SerializeField]`
`@@ -54,7 +55,7 @@ public override void OnNetworkSpawn()`
`54`	`55`
`55`	`56`	`foreach (var breakable in m_BreakableElements)`
`56`	`57`	`{`
`57`		`- breakable.OnBroken += OnBreakableBroken;`
	`58`	`+ breakable.Broken += OnBreakableBroken;`
`58`	`59`	`}`
`59`	`60`
`60`	`61`	`MaintainState();`
`@@ -69,7 +70,7 @@ public override void OnNetworkDespawn()`
`69`	`70`	`{`
`70`	`71`	`if (breakable)`
`71`	`72`	`{`
`72`		`- breakable.OnBroken -= OnBreakableBroken;`
	`73`	`+ breakable.Broken -= OnBreakableBroken;`
`73`	`74`	`}`
`74`	`75`	`}`
`75`	`76`	`}`
`@@ -93,11 +94,11 @@ void MaintainState()`
`93`	`94`
`94`	`95`	`if (!hasUnbrokenBreakables)`
`95`	`96`	`{`
`96`		`- m_Breakable.Break();`
	`97`	`+ m_PortalBreakable.Break();`
`97`	`98`	`}`
`98`	`99`	`else`
`99`	`100`	`{`
`100`		`- m_Breakable.Unbreak();`
	`101`	`+ m_PortalBreakable.Unbreak();`
`101`	`102`	`}`
`102`	`103`	`m_WaveSpawner.SetSpawnerEnabled(hasUnbrokenBreakables);`
`103`	`104`	`if (!hasUnbrokenBreakables && m_CoroDormant == null)`
`@@ -125,7 +126,7 @@ void Restart()`
`125`	`126`	`}`
`126`	`127`	`}`
`127`	`128`
`128`		`- m_Breakable.Unbreak();`
	`129`	`+ m_PortalBreakable.Unbreak();`
`129`	`130`	`m_WaveSpawner.SetSpawnerEnabled(true);`
`130`	`131`	`m_CoroDormant = null;`
`131`	`132`	`}`
`@@ -148,7 +149,7 @@ public void ForceDestroy()`
`148`	`149`	`{`
`149`	`150`	`var serverComponent = state.GetComponent<Breakable>();`
`150`	`151`	`Assert.IsNotNull(serverComponent);`
`151`		`- serverComponent.ReceiveHP(null, Int32.MinValue);`
	`152`	`+ serverComponent.Break();`
`152`	`153`	`}`
`153`	`154`	`}`
`154`	`155`	`}`