stubbed some more states

- stubbed some ability stuff
- moved packet things to loop instead of session only
- added mob roaming and aggro
- todo: fix target find/detection/pathfinding speed/line of sight/line aoe length etc
- todo: see "// todo:" in code

FFXIVClassic Map Server/actors/chara/ai/state/AttackState.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using FFXIVClassic.Common;
 using FFXIVClassic_Map_Server.Actors;
 using FFXIVClassic_Map_Server.packets.send.actor;
 using FFXIVClassic_Map_Server.packets.send.actor.battle;
@@ -10,20 +11,31 @@ namespace FFXIVClassic_Map_Server.actors.chara.ai.state
 {
     class AttackState : State
     {
+        private int damage = 0;
+        private bool tooFar = false;
+        private DateTime attackTime;
+
         public AttackState(Character owner, Character target) :
             base(owner, target)
         {
+            owner.ChangeState(SetActorStatePacket.MAIN_STATE_ACTIVE);
+            owner.aiContainer.ChangeTarget(target);
             this.startTime = DateTime.Now;
+            attackTime = startTime;
+            owner.aiContainer.pathFind?.Clear();
             // todo: should handle everything here instead of on next tick..
         }
 
         public override void OnStart()
         {
-
+            // todo: check within attack range
+            
+            owner.LookAt(target);
         }
 
         public override bool Update(DateTime tick)
         {
+            /*
             TryInterrupt();
 
             if (interrupt)
@@ -31,13 +43,33 @@ namespace FFXIVClassic_Map_Server.actors.chara.ai.state
                 OnInterrupt();
                 return true;
             }
-
-            // todo: check weapon delay/haste etc and use that
-            if ((tick - startTime).TotalMilliseconds >= 0)
+            */
+            if (owner.target == null || target.IsDead())
             {
-                OnComplete();
                 return true;
             }
+            if (IsAttackReady())
+            {
+                if (CanAttack())
+                {
+                    TryInterrupt();
+
+                    // todo: check weapon delay/haste etc and use that
+                    if (!interrupt)
+                    {
+                        OnComplete();
+                    }
+                    else
+                    {
+
+                    }
+                    SetInterrupted(false);
+                }
+                else
+                {
+                    // todo: handle interrupt/paralyze etc
+                }
+            }
             return false;
         }
 
@@ -48,18 +80,20 @@ namespace FFXIVClassic_Map_Server.actors.chara.ai.state
 
         public override void OnComplete()
         {
-            var damage = utils.AttackUtils.CalculateDamage(owner, target);
+            damage = utils.AttackUtils.CalculateDamage(owner, target);
 
             // onAttack(actor, target, damage)
+            utils.BattleUtils.DamageTarget(owner, target, damage);
             lua.LuaEngine.CallLuaBattleAction(owner, "onAttack", false, owner, target, damage);
 
-            //var packet = BattleAction1Packet.BuildPacket(owner.actorId, target.actorId);
+            foreach (var player in owner.zone.GetActorsAroundActor<Player>(owner, 50))
+                player.QueuePacket(BattleActionX01Packet.BuildPacket(player.actorId, owner.actorId, target.actorId, 223001, 18, 0, (ushort)BattleActionX01PacketCommand.Attack, (ushort)damage, 0));
+            if (target is Player)
+                ((Player)target).SendPacket("139.bin");
 
-            // todo: find a better place to put this?
-            if (owner.GetState() != SetActorStatePacket.MAIN_STATE_ACTIVE)
-                owner.ChangeState(SetActorStatePacket.MAIN_STATE_ACTIVE);
-
-            isCompleted = true;
+            target.AddHP((short)damage);
+            attackTime = attackTime.AddMilliseconds(owner.GetAttackDelayMs());
+           //this.errorPacket = BattleActionX01Packet.BuildPacket(target.actorId, owner.actorId, target.actorId, 0, effectId, 0, (ushort)BattleActionX01PacketCommand.Attack, (ushort)damage, 0);
         }
 
         public override void TryInterrupt()
@@ -75,7 +109,7 @@ namespace FFXIVClassic_Map_Server.actors.chara.ai.state
                     effectId = list[0].GetStatusEffectId();
                 }
                 // todo: which is actually the swing packet
-                //this.errorPacket = BattleActionX01Packet.BuildPacket(target.actorId, owner.actorId, target.actorId, 0, effectId, 0, (ushort)BattleActionX01PacketCommand.Attack, 0, 0);
+                //this.errorPacket = BattleActionX01Packet.BuildPacket(target.actorId, owner.actorId, target.actorId, 0, effectId, 0, (ushort)BattleActionX01PacketCommand.Attack, (ushort)damage, 0);
                 //owner.zone.BroadcastPacketAroundActor(owner, errorPacket);
                 //errorPacket = null;
                 interrupt = true;
@@ -85,22 +119,43 @@ namespace FFXIVClassic_Map_Server.actors.chara.ai.state
             interrupt = !CanAttack();
         }
 
+        private bool IsAttackReady()
+        {
+            return Program.Tick >= attackTime;
+        }
+
         private bool CanAttack()
         {
+            if (target == null)
+            {
+                return false;
+            }
             // todo: shouldnt need to check if owner is dead since all states would be cleared
             if (owner.aiContainer.IsDead() || target.aiContainer.IsDead())
             {
                 return false;
             }
-            else if (target.zone != owner.zone)
+            else if (!owner.aiContainer.GetTargetFind().CanTarget(target, false, true))
             {
                 return false;
             }
-            else if (target is Player && ((Player)target).playerSession.isUpdatesLocked)
+            else if (Utils.Distance(owner.positionX, owner.positionY, owner.positionZ, target.positionX, target.positionY, target.positionZ) >= 7.5f)
             {
+                //owner.aiContainer.GetpathFind?.PreparePath(target.positionX, target.positionY, target.positionZ, 2.5f, 4);
                 return false;
             }
             return true;
         }
+
+        public override void Cleanup()
+        {
+            if (owner.IsDead())
+                owner.Disengage();
+        }
+
+        public override bool CanChangeState()
+        {
+            return true;
+        }
     }
 }

FFXIVClassic Map Server/actors/chara/ai/state/DeathState.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using FFXIVClassic_Map_Server.Actors;
+using FFXIVClassic_Map_Server.packets.send.actor;
+
+namespace FFXIVClassic_Map_Server.actors.chara.ai.state
+{
+    class DeathState : State
+    {
+        DateTime despawnTime;
+        public DeathState(Character owner, DateTime tick, uint timeToFadeOut) 
+            : base(owner, null)
+        {
+            owner.ChangeState(SetActorStatePacket.MAIN_STATE_DEAD);
+            canInterrupt = false;
+            startTime = tick;
+            despawnTime = startTime.AddSeconds(timeToFadeOut);
+        }
+
+        public override bool Update(DateTime tick)
+        {
+            // todo: handle raise etc
+            if (tick >= despawnTime)
+            {
+                if (owner.currentSubState == SetActorStatePacket.SUB_STATE_PLAYER)
+                {
+                    owner.ChangeState(SetActorStatePacket.MAIN_STATE_PASSIVE);
+                    Server.GetWorldManager().DoZoneChange(((Player)owner), 244, null, 0, 15, -160.048f, 0, -165.737f, 0.0f);
+                }
+                else
+                {
+                    owner.ChangeState(SetActorStatePacket.MAIN_STATE_PASSIVE);
+                    // todo: fadeout animation and crap
+                    //owner.zone.DespawnActor(owner);
+                }
+                return true;
+            }
+            return false;
+        }
+    }
+}

FFXIVClassic Map Server/actors/chara/ai/state/MagicState.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using FFXIVClassic.Common;
+using FFXIVClassic_Map_Server.Actors;
+using FFXIVClassic_Map_Server.packets.send.actor;
+using FFXIVClassic_Map_Server.packets.send.actor.battle;
+namespace FFXIVClassic_Map_Server.actors.chara.ai.state
+{
+    class MagicState : State
+    {
+
+        private Ability spell;
+
+        public MagicState(Character owner, Character target, ushort spellId) :
+            base(owner, target)
+        {
+            this.startTime = DateTime.Now;
+            // todo: lookup spell from global table
+            this.spell = Server.GetWorldManager().GetAbility(spellId);
+
+            if (spell != null)
+            {
+                if (spell.CanPlayerUse(owner, target))
+                    OnStart();
+            }
+        }
+
+        public override void OnStart()
+        {
+            // todo: check within attack range
+
+            owner.LookAt(target);
+        }
+
+        public override bool Update(DateTime tick)
+        {
+            TryInterrupt();
+
+            if (interrupt)
+            {
+                OnInterrupt();
+                return true;
+            }
+
+            // todo: check weapon delay/haste etc and use that
+            if ((tick - startTime).TotalMilliseconds >= 0)
+            {
+                OnComplete();
+                return true;
+            }
+            return false;
+        }
+
+        public override void OnInterrupt()
+        {
+            // todo: send paralyzed/sleep message etc.
+        }
+
+        public override void OnComplete()
+        {
+            //this.errorPacket = BattleActionX01Packet.BuildPacket(target.actorId, owner.actorId, target.actorId, 0, effectId, 0, (ushort)BattleActionX01PacketCommand.Attack, (ushort)damage, 0);
+            isCompleted = true;
+        }
+
+        public override void TryInterrupt()
+        {
+            if (owner.statusEffects.HasStatusEffectsByFlag((uint)StatusEffectFlags.PreventAction))
+            {
+                // todo: sometimes paralyze can let you attack, get random percentage of actually letting you attack
+                var list = owner.statusEffects.GetStatusEffectsByFlag((uint)StatusEffectFlags.PreventAction);
+                uint effectId = 0;
+                if (list.Count > 0)
+                {
+                    // todo: actually check proc rate/random chance of whatever effect
+                    effectId = list[0].GetStatusEffectId();
+                }
+                // todo: which is actually the swing packet
+                //this.errorPacket = BattleActionX01Packet.BuildPacket(target.actorId, owner.actorId, target.actorId, 0, effectId, 0, (ushort)BattleActionX01PacketCommand.Attack, (ushort)damage, 0);
+                //owner.zone.BroadcastPacketAroundActor(owner, errorPacket);
+                //errorPacket = null;
+                interrupt = true;
+                return;
+            }
+
+            interrupt = !CanAttack();
+        }
+
+        private bool CanAttack()
+        {
+            if (target == null)
+            {
+                return false;
+            }
+            // todo: shouldnt need to check if owner is dead since all states would be cleared
+            if (owner.aiContainer.IsDead() || target.aiContainer.IsDead())
+            {
+                return false;
+            }
+            else if (!owner.aiContainer.GetTargetFind().CanTarget(target, false, true))
+            {
+                return false;
+            }
+            else if (Utils.Distance(owner.positionX, owner.positionY, owner.positionZ, target.positionX, target.positionY, target.positionZ) >= 7.5f)
+            {
+                owner.aiContainer.pathFind?.PreparePath(target.positionX, target.positionY, target.positionZ, 2.5f, 4);
+                return false;
+            }
+            return true;
+        }
+    }
+}

FFXIVClassic Map Server/actors/chara/ai/state/State.cs

@@ -34,7 +34,7 @@ namespace FFXIVClassic_Map_Server.actors.chara.ai.state
         public virtual void OnStart() {  }
         public virtual void OnInterrupt() { }
         public virtual void OnComplete() { isCompleted = true; }
-
+        public virtual bool CanChangeState() { return false; }
         public virtual void TryInterrupt() { }
 
         public virtual void Cleanup() { }