fix: last projectile spell casting (AscensionGameDev#2174)

* fix: last projectile spell casting:
This commit addresses a bug where a spell with ammunition requirements would consume the last projectile without actually casting it out. It is also intended to provide additional chore changes and move player related code out to it's own overrides. Files changed:
1. Entity.cs - Moved projectile removal to player's CastSpell override method. Also moved the player's specific handlers for spell's cooldown to player's CastSpell override method.
2. Player.cs - Removed redundant and repeated code within the UseSpell method (ie. CastSpell(..) is already called within Entity's Update method when required) and added projectile removal and cooldown handlers within the CastSpell override method.

* day's review: polymorphism:
As suggested by review, applies polymorphism to handle the cooldown update.
We now have a virtual method in the Entity class that is overridden in the Player class.
This way, we avoid type checking and let the correct method be called based on the object's type.

* chore: ConsumeSpellProjectile:
refactors the player logic to consume spell projectiles as the ConsumeSpellProjectile method

Author: Arufonsu

Intersect.Server.Core/Entities/Entity.cs

@@ -377,6 +377,20 @@ public virtual void Update(long timeMs)
             }
         }
 
+        /// <summary>
+        ///     Updates the entity's spell cooldown for the specified <paramref name="spellBase"/>.
+        ///     <para> This method is called when a spell is casted by an entity. </para>
+        /// </summary>
+        public virtual void UpdateSpellCooldown(SpellBase spellBase, int spellSlot)
+        {
+            if (spellSlot < 0 || spellSlot >= Options.MaxPlayerSkills)
+            {
+                return;
+            }
+
+            SpellCooldowns[Spells[spellSlot].SpellId] = Timing.Global.MillisecondsUtc + spellBase.CooldownDuration;
+        }
+
         /// <summary>
         ///     Determines if this entity can move in the specified <paramref name="direction"/>.
         /// </summary>
@@ -2477,25 +2491,7 @@ public virtual void CastSpell(Guid spellId, int spellSlot = -1)
                         break;
                 }
 
-                if (spellSlot >= 0 && spellSlot < Options.MaxPlayerSkills)
-                {
-                    // Player cooldown handling is done elsewhere!
-                    if (this is Player player)
-                    {
-                        player.UpdateCooldown(spellBase);
-
-                        // Trigger the global cooldown, if we're allowed to.
-                        if (!spellBase.IgnoreGlobalCooldown)
-                        {
-                            player.UpdateGlobalCooldown();
-                        }
-                    }
-                    else
-                    {
-                        SpellCooldowns[Spells[spellSlot].SpellId] =
-                            Timing.Global.MillisecondsUtc + spellBase.CooldownDuration;
-                    }
-                }
+                UpdateSpellCooldown(spellBase, spellSlot);
             }
             finally
             {

Intersect.Server.Core/Entities/Player.cs

@@ -891,6 +891,26 @@ public override void Update(long timeMs)
             }
         }
 
+        /// <summary>
+        ///     Updates the player's spell cooldown for the specified <paramref name="spellBase"/>.
+        ///     <para> This method is called when a spell is casted by a player. </para>
+        /// </summary>
+        public override void UpdateSpellCooldown(SpellBase spellBase, int spellSlot)
+        {
+            if (spellSlot < 0 || spellSlot >= Options.MaxPlayerSkills)
+            {
+                return;
+            }
+
+            this.UpdateCooldown(spellBase);
+
+            // Trigger the global cooldown, if we're allowed to.
+            if (!spellBase.IgnoreGlobalCooldown)
+            {
+                this.UpdateGlobalCooldown();
+            }
+        }
+        
         public void RemoveEvent(Guid id, bool sendLeave = true)
         {
             Event outInstance;
@@ -5419,7 +5439,6 @@ public void UseSpell(int spellSlot, Entity target)
                 target = this;
             }
 
-
             if (CastTime == 0)
             {
                 CastTime = Timing.Global.Milliseconds + spell.CastDuration;
@@ -5439,36 +5458,16 @@ public void UseSpell(int spellSlot, Entity target)
                 // retargeting for auto self-cast on friendly when targeting hostile
                 CastTarget = target;
 
-                //Check if the caster has the right ammunition if a projectile
-                if (spell.SpellType == SpellType.CombatSpell &&
-                    spell.Combat.TargetType == SpellTargetType.Projectile &&
-                    spell.Combat.ProjectileId != Guid.Empty)
-                {
-                    var projectileBase = spell.Combat.Projectile;
-                    if (projectileBase != null && projectileBase.AmmoItemId != Guid.Empty)
-                    {
-                        TryTakeItem(projectileBase.AmmoItemId, projectileBase.AmmoRequired);
-                    }
-                }
-
                 if (spell.CastAnimationId != Guid.Empty)
                 {
                     PacketSender.SendAnimationToProximity(
                         spell.CastAnimationId, 1, base.Id, MapId, 0, 0, Dir, MapInstanceId
                     ); //Target Type 1 will be global entity
                 }
 
-                // Check if the player isn't casting a spell already.
-                if (!IsCasting)
-                {
-                    // Player is not casting a spell, cast now!
-                    CastTime = 0;
-                    CastSpell(Spells[SpellCastSlot].SpellId, SpellCastSlot);
-                    CastTarget = null;
-                }
-                else
+                //Tell the client we are channeling the spell
+                if (IsCasting)
                 {
-                    //Tell the client we are channeling the spell
                     PacketSender.SendEntityCastTime(this, spellNum);
                 }
             }
@@ -5484,7 +5483,7 @@ public void UseSpell(int spellSlot, Entity target)
         public override void CastSpell(Guid spellId, int spellSlot = -1)
         {
             var spellBase = SpellBase.Get(spellId);
-            if (spellBase == null)
+            if (spellBase == null || spellSlot < 0 || spellSlot >= Options.MaxPlayerSkills)
             {
                 return;
             }
@@ -5506,6 +5505,32 @@ public override void CastSpell(Guid spellId, int spellSlot = -1)
 
                     break;
             }
+
+            UpdateSpellCooldown(spellBase, spellSlot);
+
+            ConsumeSpellProjectile(spellBase);
+        }
+
+        /// <summary>
+        /// Checks if the caster has the required projectile(s) for the spell and tries to take them.
+        /// This method is used when a spell that requires projectile is casted.
+        /// If the spell has a valid ProjectileId, it retrieves the projectile and checks if it has a valid AmmoItemId.
+        /// If it does, it attempts to take the required amount of ammo from the player's inventory.
+        /// </summary>
+        /// <param name="spellBase">The spell that is being cast.</param>
+        private void ConsumeSpellProjectile(SpellBase spellBase)
+        {
+            // Check if the caster has the required projectile(s) for the spell and try to take it/them.
+            if (spellBase.SpellType == SpellType.CombatSpell &&
+                spellBase.Combat.TargetType == SpellTargetType.Projectile &&
+                spellBase.Combat.ProjectileId != Guid.Empty)
+            {
+                var projectileBase = spellBase.Combat.Projectile;
+                if (projectileBase != null && projectileBase.AmmoItemId != Guid.Empty)
+                {
+                    TryTakeItem(projectileBase.AmmoItemId, projectileBase.AmmoRequired);
+                }
+            }
         }
 
         public bool TryGetEquipmentSlot(int equipmentSlot, out int inventorySlot)