feature: homing and direct projectiles (AscensionGameDev#2263)

* adds the following options to projectile editor:
 - homing projectile shot
 - direct projectile shot
 - default (intersect legacy behavior)

Author: WeylonSantana

Intersect (Core)/GameObjects/ProjectileBase.cs

@@ -106,6 +106,10 @@ public string AnimationsJson
 
         public int Range { get; set; } = 1;
 
+        public bool HomingBehavior { get; set; }
+
+        public bool DirectShotBehavior { get; set; }
+
         [Column("SpawnLocations")]
         [JsonIgnore]
         public string SpawnsJson

Intersect (Core)/Network/Packets/Client/TargetPacket.cs

@@ -0,0 +1,20 @@
+using MessagePack;
+
+namespace Intersect.Network.Packets.Client;
+
+[MessagePackObject]
+public partial class TargetPacket : IntersectPacket
+{
+    //Parameterless Constructor for MessagePack
+    public TargetPacket()
+    {
+    }
+
+    public TargetPacket(Guid targetId)
+    {
+        TargetId = targetId;
+    }
+
+    [Key(0)]
+    public Guid TargetId { get; set; }
+}

Intersect.Client/Entities/Animation.cs

@@ -54,6 +54,10 @@ public partial class Animation : IAnimation
 
         private long mUpperTimer;
 
+        private bool mUseExternalRotation;
+
+        private float mExternalRotation;
+
         public AnimationBase MyBase { get; set; }
 
         public Point Size => CalculateAnimationSize();
@@ -110,7 +114,13 @@ public void Draw(bool upper = false, bool alternate = false)
 
             var rotationDegrees = 0f;
             var dontRotate = upper && MyBase.Upper.DisableRotations || !upper && MyBase.Lower.DisableRotations;
-            if ((AutoRotate || mRenderDir != Direction.None) && !dontRotate)
+
+            if (mUseExternalRotation)
+            {
+                rotationDegrees = mExternalRotation;
+            }
+
+            if ((AutoRotate || mRenderDir != Direction.None) && !dontRotate && !mUseExternalRotation)
             {
                 switch (mRenderDir)
                 {
@@ -465,6 +475,16 @@ public void SetDir(Direction dir)
             mRenderDir = dir;
         }
 
+        public void SetRotation(float angleInDegrees)
+        {
+            mUseExternalRotation = true;
+            mExternalRotation = angleInDegrees;
+        }
+
+        public void SetRotation(bool toggle)
+        {
+            mUseExternalRotation = toggle;
+        }
     }
 
 }

Intersect.Client/Entities/Player.cs

@@ -1637,6 +1637,7 @@ private void SetTargetBox(Entity en)
             {
                 TargetBox?.SetEntity(null);
                 TargetBox?.Hide();
+                PacketSender.SendTarget(Guid.Empty);
                 return;
             }
 
@@ -1654,6 +1655,7 @@ private void SetTargetBox(Entity en)
             }
 
             TargetBox?.Show();
+            PacketSender.SendTarget(en.Id);
         }
 
         private void AutoTurnToTarget(Entity en)

Intersect.Client/Entities/Projectiles/Projectile.cs

@@ -1,4 +1,3 @@
-using System;
 using Intersect.Client.Framework.Entities;
 using Intersect.Client.General;
 using Intersect.Enums;
@@ -41,6 +40,10 @@ public partial class Projectile : Entity
 
         public Guid TargetId;
 
+        public int mLastTargetX = -1;
+
+        public int mLastTargetY = -1;
+
         /// <summary>
         ///     The constructor for the inherated projectile class
         /// </summary>
@@ -306,8 +309,34 @@ public override bool Update()
                     {
                         if (Spawns[s] != null && Maps.MapInstance.Get(Spawns[s].SpawnMapId) != null)
                         {
-                            Spawns[s].OffsetX = GetRangeX(Spawns[s].Dir, GetDisplacement(Spawns[s].SpawnTime));
-                            Spawns[s].OffsetY = GetRangeY(Spawns[s].Dir, GetDisplacement(Spawns[s].SpawnTime));
+                            if (TargetId != Guid.Empty && Globals.Entities.ContainsKey(TargetId) && (mMyBase.HomingBehavior || mMyBase.DirectShotBehavior))
+                            {
+                                var target = Globals.Entities[TargetId];
+                                mLastTargetX = target.X;
+                                mLastTargetY = target.Y;
+
+                                Spawns[s].OffsetX = GetProjectileX(Spawns[s], target.X, target.Y - Spawns[s].SpawnY);
+                                Spawns[s].OffsetY = GetProjectileY(Spawns[s], target.Y, target.X - Spawns[s].SpawnX);
+                                SetProjectileRotation(Spawns[s], target.X, target.Y);
+
+                                if (mMyBase.DirectShotBehavior)
+                                {
+                                    TargetId = Guid.Empty;
+                                }
+                            }
+                            else if(mLastTargetX != -1 && mLastTargetY != -1)
+                            {
+                                Spawns[s].OffsetX = GetProjectileX(Spawns[s], mLastTargetX, mLastTargetY - Spawns[s].SpawnY);
+                                Spawns[s].OffsetY = GetProjectileY(Spawns[s], mLastTargetY, mLastTargetX - Spawns[s].SpawnX);
+                                SetProjectileRotation(Spawns[s], mLastTargetX, mLastTargetY);
+                            }
+                            else
+                            {
+                                Spawns[s].OffsetX = GetRangeX(Spawns[s].Dir, GetDisplacement(Spawns[s].SpawnTime));
+                                Spawns[s].OffsetY = GetRangeY(Spawns[s].Dir, GetDisplacement(Spawns[s].SpawnTime));
+                                Spawns[s].Anim.SetRotation(false);
+                            }
+
                             Spawns[s]
                                 .Anim.SetPosition(
                                     Maps.MapInstance.Get(Spawns[s].SpawnMapId).GetX() +
@@ -333,6 +362,36 @@ public override bool Update()
             return true;
         }
 
+        private float GetProjectileX(ProjectileSpawns spawn, int targetX, float directionY)
+        {
+            float directionX = targetX - spawn.SpawnX;
+            var length = (float)Math.Sqrt(directionX * directionX + directionY * directionY);
+            directionX /= length;
+
+            var desiredX = GetDisplacement(spawn.SpawnTime) * directionX;
+            var lerpFactor = 0.1f;
+            return spawn.OffsetX + (desiredX - spawn.OffsetX) * lerpFactor;
+        }
+
+        private float GetProjectileY(ProjectileSpawns spawn, int targetY, float directionX)
+        {
+            float directionY = targetY - spawn.SpawnY;
+            var length = (float)Math.Sqrt(directionX * directionX + directionY * directionY);
+            directionY /= length;
+
+            var desiredY = GetDisplacement(spawn.SpawnTime) * directionY;
+            var lerpFactor = 0.1f;
+            return spawn.OffsetY + (desiredY - spawn.OffsetY) * lerpFactor;
+        }
+
+        private void SetProjectileRotation(ProjectileSpawns spawn, int targetX, int targetY)
+        {
+            var directionX = targetX - spawn.SpawnX;
+            var directionY = targetY - spawn.SpawnY;
+            var angle = (float)(Math.Atan2(directionY, directionX) * (180.0 / Math.PI) + 90);
+            spawn.Anim.SetRotation(angle);
+        }
+
         public void CheckForCollision()
         {
             if (mSpawnCount != 0 || mQuantity < mMyBase.Quantity)

Intersect.Client/Networking/PacketSender.cs

@@ -498,6 +498,11 @@ public static void SendFadeCompletePacket()
             Network.SendPacket(new FadeCompletePacket());
         }
 
+        public static void SendTarget(Guid targetId)
+        {
+            Network.SendPacket(new TargetPacket(targetId));
+        }
+
     }
 
 }