Fix a Healer ability doesn't work

Author: nanho-lee

Assets/GameData/Action/Mage/MageHeal.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6c16b018e4bfa01b23bea3e0f6ef366ac529f16a749e38c93384e1e38a5c7ab8
-size 1159
+oid sha256:5f28c042dceb2a438a0faec834feaf3b3470fc34629e4ab5e489af33b780ed32
+size 1185

Assets/Scripts/Gameplay/Action/ActionUtils.cs

@@ -30,20 +30,35 @@ public static class ActionUtils
         const float k_VeryCloseTeleportRange = k_CloseDistanceOffset + 1;
 
         /// <summary>
-        /// Does a melee foe hit detect.
+        /// Detects friends and/or foes near us.
         /// </summary>
-        /// <param name="isNPC">true if the attacker is an NPC (and therefore should hit PCs). False for the reverse.</param>
+        /// <param name="wantPcs">true if we should detect PCs</param>
+        /// <param name="wantNpcs">true if we should detect NPCs</param>
         /// <param name="attacker">The collider of the attacking GameObject.</param>
-        /// <param name="range">The range in meters to check for foes.</param>
+        /// <param name="range">The range in meters to check.</param>
+        /// <param name="radius">The radius in meters to check.</param>
         /// <param name="results">Place an uninitialized RayCastHit[] ref in here. It will be set to the results array. </param>
-        /// <remarks>
-        /// This method does not alloc. It returns a maximum of 4 results. Consume the results immediately, as the array will be overwritten with
-        /// the next similar query.
-        /// </remarks>
-        /// <returns>Total number of foes encountered. </returns>
-        public static int DetectMeleeFoe(bool isNPC, Collider attacker, float range, out RaycastHit[] results)
+        /// <returns></returns>
+        public static int DetectNearbyEntitiesUseSphere(bool wantPcs, bool wantNpcs, Collider attacker, float range, float radius, out RaycastHit[] results)
         {
-            return DetectNearbyEntities(isNPC, !isNPC, attacker, range, out results);
+            var myBounds = attacker.bounds;
+
+            if (s_PCLayer == -1)
+                s_PCLayer = LayerMask.NameToLayer("PCs");
+            if (s_NpcLayer == -1)
+                s_NpcLayer = LayerMask.NameToLayer("NPCs");
+
+            int mask = 0;
+            if (wantPcs)
+                mask |= (1 << s_PCLayer);
+            if (wantNpcs)
+                mask |= (1 << s_NpcLayer);
+
+            int numResults = Physics.SphereCastNonAlloc(attacker.transform.position, radius,
+                attacker.transform.forward, s_Hits, range, mask);
+
+            results = s_Hits;
+            return numResults;
         }
 
         /// <summary>

Assets/Scripts/Gameplay/Action/ConcreteActions/DashAttackAction.cs

@@ -98,7 +98,7 @@ private void PerformMeleeAttack(ServerCharacter parent)
             // perform a typical melee-hit. But note that we are using the Radius field for range, not the Range field!
             IDamageable foe = MeleeAction.GetIdealMeleeFoe(Config.IsFriendly ^ parent.IsNpc,
                 parent.physicsWrapper.DamageCollider,
-                                                            Config.Radius,
+                                                            Config.Radius, 0.0f,
                                                             (Data.TargetIds != null && Data.TargetIds.Length > 0 ? Data.TargetIds[0] : 0));
 
             if (foe != null)

Assets/Scripts/Gameplay/Action/ConcreteActions/MeleeAction.cs

@@ -69,6 +69,7 @@ public override bool OnUpdate(ServerCharacter clientCharacter)
             if (!m_ExecutionFired && (Time.time - TimeStarted) >= Config.ExecTimeSeconds)
             {
                 m_ExecutionFired = true;
+
                 var foe = DetectFoe(clientCharacter, m_ProvisionalTarget);
                 if (foe != null)
                 {
@@ -85,7 +86,7 @@ public override bool OnUpdate(ServerCharacter clientCharacter)
         /// <returns></returns>
         private IDamageable DetectFoe(ServerCharacter parent, ulong foeHint = 0)
         {
-            return GetIdealMeleeFoe(Config.IsFriendly ^ parent.IsNpc, parent.physicsWrapper.DamageCollider, Config.Range, foeHint);
+            return GetIdealMeleeFoe(Config.IsFriendly ^ parent.IsNpc, parent.physicsWrapper.DamageCollider, Config.Range, Config.Radius, foeHint);
         }
 
         /// <summary>
@@ -96,25 +97,48 @@ private IDamageable DetectFoe(ServerCharacter parent, ulong foeHint = 0)
         /// <param name="isNPC">true if the attacker is an NPC (and therefore should hit PCs). False for the reverse.</param>
         /// <param name="ourCollider">The collider of the attacking GameObject.</param>
         /// <param name="meleeRange">The range in meters to check for foes.</param>
+        /// <param name="meleeRadius">The radius in meters to check for foes.</param>
         /// <param name="preferredTargetNetworkId">The NetworkObjectId of our preferred foe, or 0 if no preference</param>
         /// <returns>ideal target's IDamageable, or null if no valid target found</returns>
-        public static IDamageable GetIdealMeleeFoe(bool isNPC, Collider ourCollider, float meleeRange, ulong preferredTargetNetworkId)
+        /// <remarks>
+        /// If a Radius value is set (greater than 0), collision checking will be done with a Sphere the size of the Radius, not the size of the Box.
+        /// Also, if multiple targets collide as a result, the target with the highest total damage is prioritized.
+        /// </remarks>
+        public static IDamageable GetIdealMeleeFoe(bool isNPC, Collider ourCollider, float meleeRange, float meleeRadius, ulong preferredTargetNetworkId)
         {
             RaycastHit[] results;
-            int numResults = ActionUtils.DetectMeleeFoe(isNPC, ourCollider, meleeRange, out results);
+            int numResults = 0.0f < meleeRadius 
+                ? ActionUtils.DetectNearbyEntitiesUseSphere(isNPC, !isNPC, ourCollider, meleeRange, meleeRadius, out results)
+                : ActionUtils.DetectNearbyEntities(isNPC, !isNPC, ourCollider, meleeRange, out results);
 
             IDamageable foundFoe = null;
 
             //everything that got hit by the raycast should have an IDamageable component, so we can retrieve that and see if they're appropriate targets.
             //we always prefer the hinted foe. If he's still in range, he should take the damage, because he's who the client visualization
             //system will play the hit-react on (in case there's any ambiguity).
+            //if that is not the case, we prioritize the target with the highest total damage.
+            int maxDamage = int.MinValue;
+
             for (int i = 0; i < numResults; i++)
             {
                 var damageable = results[i].collider.GetComponent<IDamageable>();
-                if (damageable != null && damageable.IsDamageable() &&
-                    (damageable.NetworkObjectId == preferredTargetNetworkId || foundFoe == null))
+                if (damageable == null || !damageable.IsDamageable())
+                {
+                    continue;
+                }
+
+                if(damageable.NetworkObjectId == preferredTargetNetworkId)
+                {
+                    foundFoe = damageable;
+                    maxDamage = int.MaxValue;
+                    continue;
+                }
+
+                var totalDamage = damageable.GetTotalDamage();
+                if (foundFoe == null || maxDamage < totalDamage)
                 {
                     foundFoe = damageable;
+                    maxDamage = totalDamage;
                 }
             }
 

Assets/Scripts/Gameplay/GameplayObjects/Breakable.cs

@@ -116,6 +116,11 @@ public void ReceiveHP(ServerCharacter inflicter, int HP)
             }
         }
 
+        public int GetTotalDamage()
+        {
+            return Math.Max(0, m_MaxHealth.Value - m_NetworkHealthState.HitPoints.Value);
+        }
+
         private void Break()
         {
             IsBroken.Value = true;

Assets/Scripts/Gameplay/GameplayObjects/Character/ServerCharacter.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections;
 using Unity.BossRoom.ConnectionManagement;
 using Unity.BossRoom.Gameplay.Actions;
@@ -156,6 +157,7 @@ public override void OnNetworkSpawn()
                 NetLifeState.LifeState.OnValueChanged += OnLifeStateChanged;
                 m_DamageReceiver.DamageReceived += ReceiveHP;
                 m_DamageReceiver.CollisionEntered += CollisionEntered;
+                m_DamageReceiver.GetTotalDamageFunc += GetTotalDamage;
 
                 if (IsNpc)
                 {
@@ -179,6 +181,7 @@ public override void OnNetworkDespawn()
             {
                 m_DamageReceiver.DamageReceived -= ReceiveHP;
                 m_DamageReceiver.CollisionEntered -= CollisionEntered;
+                m_DamageReceiver.GetTotalDamageFunc -= GetTotalDamage;
             }
         }
 
@@ -393,6 +396,11 @@ void CollisionEntered(Collision collision)
             }
         }
 
+        int GetTotalDamage()
+        {
+            return Math.Max(0, CharacterClass.BaseHP.Value - HitPoints);
+        }
+
         /// <summary>
         /// This character's AIBrain. Will be null if this is not an NPC.
         /// </summary>

Assets/Scripts/Gameplay/GameplayObjects/DamageReceiver.cs

@@ -11,6 +11,8 @@ public class DamageReceiver : NetworkBehaviour, IDamageable
 
         public event Action<Collision> CollisionEntered;
 
+        public event Func<int> GetTotalDamageFunc;
+
         [SerializeField]
         NetworkLifeState m_NetworkLifeState;
 
@@ -22,6 +24,16 @@ public void ReceiveHP(ServerCharacter inflicter, int HP)
             }
         }
 
+        public int GetTotalDamage()
+        {
+            if (!IsDamageable())
+            {
+                return 0;
+            }
+
+            return GetTotalDamageFunc?.Invoke() ?? 0;
+        }
+
         public IDamageable.SpecialDamageFlags GetSpecialDamageFlags()
         {
             return IDamageable.SpecialDamageFlags.None;

Assets/Scripts/Gameplay/GameplayObjects/IDamageable.cs

@@ -17,6 +17,12 @@ public interface IDamageable
         /// <param name="HP">The damage done. Negative value is damage, positive is healing.</param>
         void ReceiveHP(ServerCharacter inflicter, int HP);
 
+        /// <summary>
+        /// Get the total damage value.
+        /// </summary>
+        /// <returns>The return value is your total health minus your current health.</returns>
+        int GetTotalDamage();
+
         /// <summary>
         /// The NetworkId of this object.
         /// </summary>

Assets/Scripts/Gameplay/UserInput/ClientInputSender.cs

@@ -420,7 +420,11 @@ void PopulateSkillRequest(Vector3 hitPoint, ActionID actionID, ref ActionRequest
             // figure out the Direction in case we want to send it
             Vector3 offset = hitPoint - m_PhysicsWrapper.Transform.position;
             offset.y = 0;
-            Vector3 direction = offset.normalized;
+
+            //there is a bug where the direction is flipped if the hitPos and current position are almost the same,
+            //so we use the character's direction instead.
+            float directionLength = offset.magnitude;
+            Vector3 direction = float.Epsilon >= directionLength ? (offset / directionLength) : m_PhysicsWrapper.Transform.forward;
 
             switch (actionConfig.Logic)
             {