Updated Map Server namespace. Moved all other data folders (www and sql) to data folder. Renamed boot name to Project Meteor.

Map Server/Actors/Chara/Ai/AIContainer.cs

@@ -0,0 +1,400 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using System.Collections.Generic;
+using Meteor.Map.Actors;
+using Meteor.Map.actors.chara.ai.state;
+using Meteor.Map.actors.chara.ai.controllers;
+using Meteor.Map.packets.send.actor;
+
+// port of ai code in dsp by kjLotus (https://github.com/DarkstarProject/darkstar/blob/master/src/map/ai)
+namespace Meteor.Map.actors.chara.ai
+{
+    class AIContainer
+    {
+        private Character owner;
+        private Controller controller;
+        private Stack<State> states;
+        private DateTime latestUpdate;
+        private DateTime prevUpdate;
+        public readonly PathFind pathFind;
+        private TargetFind targetFind;
+        private ActionQueue actionQueue;
+        private DateTime lastActionTime;
+
+        public AIContainer(Character actor, Controller controller, PathFind pathFind, TargetFind targetFind)
+        {
+            this.owner = actor;
+            this.states = new Stack<State>();
+            this.controller = controller;
+            this.pathFind = pathFind;
+            this.targetFind = targetFind;
+            latestUpdate = DateTime.Now;
+            prevUpdate = latestUpdate;
+            actionQueue = new ActionQueue(owner);
+        }
+
+        public void UpdateLastActionTime(uint delay = 0)
+        {
+            lastActionTime = DateTime.Now.AddSeconds(delay);
+        }
+
+        public DateTime GetLastActionTime()
+        {
+            return lastActionTime;
+        }
+
+        public void Update(DateTime tick)
+        {
+            prevUpdate = latestUpdate;
+            latestUpdate = tick;
+
+            // todo: trigger listeners
+
+            if (controller == null && pathFind != null)
+            {
+                pathFind.FollowPath();
+            }
+
+            // todo: action queues
+            if (controller != null && controller.canUpdate)
+                controller.Update(tick);
+
+            State top;
+
+            while (states.Count > 0 && (top = states.Peek()).Update(tick))
+            {
+                if (top == GetCurrentState())
+                {
+                    states.Pop().Cleanup();
+                }
+            }
+            owner.PostUpdate(tick);
+        }
+
+        public void CheckCompletedStates()
+        {
+            while (states.Count > 0 && states.Peek().IsCompleted())
+            {
+                states.Peek().Cleanup();
+                states.Pop();
+            }
+        }
+
+        public void InterruptStates()
+        {
+            while (states.Count > 0 && states.Peek().CanInterrupt())
+            {
+                states.Peek().SetInterrupted(true);
+                states.Peek().Cleanup();
+                states.Pop();
+            }
+        }
+
+        public void InternalUseItem(Character target, uint slot, uint itemId)
+        {
+            // todo: can allies use items?
+            if (owner is Player)
+            {
+                if (CanChangeState())
+                {
+                    ChangeState(new ItemState((Player)owner, target, (ushort)slot, itemId));
+                }
+                else
+                {
+                    // You cannot use that item now.
+                    ((Player)owner).SendGameMessage(Server.GetWorldManager().GetActor(), 32544, 0x20, itemId);
+                }
+            }
+        }
+
+        public void ClearStates()
+        {
+            while (states.Count > 0)
+            {
+                states.Peek().Cleanup();
+                states.Pop();
+            }
+        }
+
+        public void ChangeController(Controller controller)
+        {
+            this.controller = controller;
+        }
+
+        public T GetController<T>() where T : Controller
+        {
+            return controller as T;
+        }
+
+        public TargetFind GetTargetFind()
+        {
+            return targetFind;
+        }
+
+        public bool CanFollowPath()
+        {
+            return pathFind != null && (GetCurrentState() == null || GetCurrentState().CanChangeState());
+        }
+
+        public bool CanChangeState()
+        {
+            return GetCurrentState() == null || states.Peek().CanChangeState();
+        }
+
+        public void ChangeTarget(Character target)
+        {
+            if (controller != null)
+            {
+                controller.ChangeTarget(target);
+            }
+        }
+
+        public void ChangeState(State state)
+        {
+            if (CanChangeState())
+            {
+                if (states.Count <= 10)
+                {
+                    CheckCompletedStates();
+                    states.Push(state);
+                }
+                else
+                {
+                    throw new Exception("shit");
+                }
+            }
+        }
+
+        public void ForceChangeState(State state)
+        {
+            if (states.Count <= 10)
+            {
+                CheckCompletedStates();
+                states.Push(state);
+            }
+            else
+            {
+                throw new Exception("force shit");
+            }
+        }
+
+        public bool IsCurrentState<T>() where T : State
+        {
+            return GetCurrentState() is T;
+        }
+
+        public State GetCurrentState()
+        {
+            return states.Count > 0 ? states.Peek() : null;
+        }
+
+        public DateTime GetLatestUpdate()
+        {
+            return latestUpdate;
+        }
+
+        public void Reset()
+        {
+            // todo: reset cooldowns and stuff here too?
+            targetFind?.Reset();
+            pathFind?.Clear();
+            ClearStates();
+            InternalDisengage();
+        }
+
+        public bool IsSpawned()
+        {
+            return !IsDead();
+        }
+
+        public bool IsEngaged()
+        {
+            return owner.currentMainState == SetActorStatePacket.MAIN_STATE_ACTIVE;
+        }
+
+        public bool IsDead()
+        {
+            return owner.currentMainState == SetActorStatePacket.MAIN_STATE_DEAD ||
+                owner.currentMainState == SetActorStatePacket.MAIN_STATE_DEAD2;
+        }
+
+        public bool IsRoaming()
+        {
+            // todo: check mounted?
+            return owner.currentMainState == SetActorStatePacket.MAIN_STATE_PASSIVE;
+        }
+
+        public void Engage(Character target)
+        {
+            if (controller != null)
+                controller.Engage(target);
+            else
+                InternalEngage(target);
+        }
+
+        public void Disengage()
+        {
+            if (controller != null)
+                controller.Disengage();
+            else
+                InternalDisengage();
+        }
+
+        public void Ability(Character target, uint abilityId)
+        {
+            if (controller != null)
+                controller.Ability(target, abilityId);
+            else
+                InternalAbility(target, abilityId);
+        }
+
+        public void Cast(Character target, uint spellId)
+        {
+            if (controller != null)
+                controller.Cast(target, spellId);
+            else
+                InternalCast(target, spellId);
+        }
+
+        public void WeaponSkill(Character target, uint weaponSkillId)
+        {
+            if (controller != null)
+                controller.WeaponSkill(target, weaponSkillId);
+            else
+                InternalWeaponSkill(target, weaponSkillId);
+        }
+
+        public void MobSkill(Character target, uint mobSkillId)
+        {
+            if (controller != null)
+                controller.MonsterSkill(target, mobSkillId);
+            else
+                InternalMobSkill(target, mobSkillId);
+        }
+
+        public void UseItem(Character target, uint slot, uint itemId)
+        {
+            if (controller != null)
+                controller.UseItem(target, slot, itemId);
+        }
+
+        public void InternalChangeTarget(Character target)
+        {
+            // targets are changed in the controller
+            if (IsEngaged() || target == null)
+            {
+
+            }
+            else
+            {
+                Engage(target);
+            }
+        }
+
+        public bool InternalEngage(Character target)
+        {
+            if (IsEngaged())
+            {
+                if (this.owner.target != target)
+                {
+                    ChangeTarget(target);
+                    return true;
+                }
+                return false;
+            }
+
+            if (CanChangeState() || (GetCurrentState() != null && GetCurrentState().IsCompleted()))
+            {
+                ForceChangeState(new AttackState(owner, target));
+                return true;
+            }
+            return false;
+        }
+
+        public void InternalDisengage()
+        {
+            pathFind?.Clear();
+            GetTargetFind()?.Reset();
+
+            owner.updateFlags |= ActorUpdateFlags.HpTpMp;
+            ChangeTarget(null);
+
+            if (owner.currentMainState == SetActorStatePacket.MAIN_STATE_ACTIVE)
+                owner.ChangeState(SetActorStatePacket.MAIN_STATE_PASSIVE);
+
+            ClearStates();
+        }
+
+        public void InternalAbility(Character target, uint abilityId)
+        {
+            if (CanChangeState())
+            {
+                ChangeState(new AbilityState(owner, target, (ushort)abilityId));
+            }
+        }
+
+        public void InternalCast(Character target, uint spellId)
+        {
+            if (CanChangeState())
+            {
+                ChangeState(new MagicState(owner, target, (ushort)spellId));
+            }
+        }
+
+        public void InternalWeaponSkill(Character target, uint weaponSkillId)
+        {
+            if (CanChangeState())
+            {
+                ChangeState(new WeaponSkillState(owner, target, (ushort)weaponSkillId));
+            }
+        }
+
+        public void InternalMobSkill(Character target, uint mobSkillId)
+        {
+            if (CanChangeState())
+            {
+
+            }
+        }
+
+        public void InternalDie(DateTime tick, uint fadeoutTimerSeconds)
+        {
+            pathFind?.Clear();
+            ClearStates();
+            ForceChangeState(new DeathState(owner, tick, fadeoutTimerSeconds));
+        }
+
+        public void InternalDespawn(DateTime tick, uint respawnTimerSeconds)
+        {
+            ClearStates();
+            Disengage();
+            ForceChangeState(new DespawnState(owner, respawnTimerSeconds));
+        }
+
+        public void InternalRaise(Character target)
+        {
+            // todo: place at target
+            // ForceChangeState(new RaiseState(target));
+        }
+    }
+}

Map Server/Actors/Chara/Ai/BattleCommand.cs

@@ -0,0 +1,412 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using Meteor.Map.Actors;
+using System;
+using System.Collections.Generic;
+using Meteor.Map.packets.send.actor.battle;
+using Meteor.Map.actors.chara.ai.utils;
+using MoonSharp.Interpreter;
+
+namespace Meteor.Map.actors.chara.ai
+{
+
+    public enum BattleCommandRequirements : ushort
+    {
+        None,
+        DiscipleOfWar = 0x01,
+        DiscipeOfMagic = 0x02,
+        HandToHand = 0x04,
+        Sword = 0x08,
+        Shield = 0x10,
+        Axe = 0x20,
+        Archery = 0x40,
+        Polearm = 0x80,
+        Thaumaturgy = 0x100,
+        Conjury = 0x200
+    }
+
+    public enum BattleCommandPositionBonus : byte
+    {
+        None,
+        Front = 0x01,
+        Rear = 0x02,
+        Flank = 0x04
+    }
+
+    public enum BattleCommandProcRequirement : byte
+    {
+        None,
+        Miss,
+        Evade,
+        Parry,
+        Block
+    }
+
+    public enum BattleCommandValidUser : byte
+    {
+        All,
+        Player,
+        Monster
+    }
+
+    public enum BattleCommandCastType : ushort
+    {
+        None,
+        Weaponskill = 1,
+        Weaponskill2 = 2,
+        BlackMagic = 3,
+        WhiteMagic = 4,
+        SongMagic = 8
+    }
+
+
+    //What type of command it is
+    [Flags]
+    public enum CommandType : ushort
+    {
+        //Type of action
+        None = 0,
+        AutoAttack = 1,
+        WeaponSkill = 2,
+        Ability =3,
+        Spell = 4
+    }
+
+    public enum KnockbackType : ushort
+    {
+        None = 0,
+        Level1 = 1,
+        Level2 = 2,
+        Level3 = 3,
+        Level4 = 4,
+        Level5 = 5,
+        Clockwise1 = 6,
+        Clockwise2 = 7,
+        CounterClockwise1 = 8,
+        CounterClockwise2 = 9,
+        DrawIn = 10
+    }
+
+    class BattleCommand
+    {
+        public ushort id;
+        public string name;
+        public byte job;
+        public byte level;
+        public BattleCommandRequirements requirements;
+        public ValidTarget mainTarget;                      //what the skill has to be used on. ie self for flare, enemy for ring of talons even though both are self-centere aoe
+        public ValidTarget validTarget;                     //what type of character the skill can hit
+        public TargetFindAOEType aoeType;                   //shape of aoe
+        public TargetFindAOETarget aoeTarget;               //where the center of the aoe is (target/self)
+        public byte numHits;                                //amount of hits in the skill
+        public BattleCommandPositionBonus positionBonus;    //bonus for front/flank/rear
+        public BattleCommandProcRequirement procRequirement;//if the skill requires a block/parry/evade before using
+        public float range;                                 //maximum distance to target to be able to use this skill
+        public float minRange;                              //Minimum distance to target to be able to use this skill
+
+        public uint statusId;                               //id of statuseffect that the skill might inflict
+        public uint statusDuration;                         //duration of statuseffect in milliseconds
+        public float statusChance;                          //percent chance of status landing, 0-1.0. Usually 1.0 for buffs
+        public byte castType;                               //casting animation, 2 for blm, 3 for whm, 8 for brd
+        public uint castTimeMs;                             //cast time in milliseconds
+        public uint recastTimeMs;                           //recast time in milliseconds
+        public uint maxRecastTimeSeconds;                   //maximum recast time in seconds
+        public short mpCost;                                //short in case these casts can have negative cost
+        public short tpCost;                                //short because there are certain cases where we want weaponskills to have negative costs (such as Feint)
+        public byte animationType;
+        public ushort effectAnimation;
+        public ushort modelAnimation;
+        public ushort animationDurationSeconds;
+        public uint battleAnimation;
+        public ushort worldMasterTextId;
+        public float aoeRange;                              //Radius for circle and cone aoes, length for box aoes
+        public float aoeMinRange;                           //Minimum range of aoe effect for things like Lunar Dynamo or Arrow Helix
+        public float aoeConeAngle;                          //Angle of aoe cones
+        public float aoeRotateAngle;                        //Amount aoes are rotated about the target position (usually the user's position)
+        public float rangeHeight;                           //Total height a skill can be used against target above or below user
+        public float rangeWidth;                            //Width of box aoes
+        public int[] comboNextCommandId = new int[2];       //next two skills in a combo
+        public short comboStep;                             //Where in a combo string this skill is
+        public CommandType commandType;
+        public ActionProperty actionProperty;
+        public ActionType actionType;
+
+
+        public byte statusTier;                             //tier of status to put on target
+        public double statusMagnitude = 0;                  //magnitude of status to put on target
+        public ushort basePotency;                          //damage variable
+        public float enmityModifier;                        //multiples by damage done to get final enmity
+        public float accuracyModifier;                      //modifies accuracy
+        public float bonusCritRate;                         //extra crit rate
+        public bool isCombo;
+        public bool comboEffectAdded = false;               //If the combo effect is added to multiple hiteffects it plays multiple times, so this keeps track of that
+        public bool isRanged = false;
+
+        public bool actionCrit;                             //Whether any actions were critical hits, used for Excruciate
+
+        public lua.LuaScript script;                        //cached script
+
+        public TargetFind targetFind;
+        public BattleCommandValidUser validUser;
+
+        public BattleCommand(ushort id, string name)
+        {
+            this.id = id;
+            this.name = name;
+            this.range = 0;
+            this.enmityModifier = 1;
+            this.accuracyModifier = 0;
+            this.statusTier = 1;
+            this.statusChance = 50;
+            this.recastTimeMs = (uint) maxRecastTimeSeconds * 1000;
+            this.isCombo = false;
+        }
+
+        public BattleCommand Clone()
+        {
+            return (BattleCommand)MemberwiseClone();
+        }
+        
+        public int CallLuaFunction(Character chara, string functionName, params object[] args)
+        {
+            if (script != null && !script.Globals.Get(functionName).IsNil())
+            {
+                DynValue res = new DynValue();
+                res = script.Call(script.Globals.Get(functionName), args);
+                if (res != null)
+                    return (int)res.Number;
+            }
+
+            return -1;
+        }
+
+        public bool IsSpell()
+        {
+            return mpCost != 0 || castTimeMs != 0;
+        }
+
+        public bool IsInstantCast()
+        {
+            return castTimeMs == 0;
+        }
+
+        //Checks whether the skill can be used on the given targets, uses error to return specific text ids for errors
+        public bool IsValidMainTarget(Character user, Character target, CommandResult error = null)
+        {
+            targetFind = new TargetFind(user, target);
+
+            if (aoeType == TargetFindAOEType.Box)
+            {
+                targetFind.SetAOEBox(validTarget, aoeTarget, aoeRange, rangeWidth, aoeRotateAngle);
+            }
+            else
+            {
+                targetFind.SetAOEType(validTarget, aoeType, aoeTarget, aoeRange, aoeMinRange, rangeHeight, aoeRotateAngle, aoeConeAngle);
+            }
+
+            /*
+            worldMasterTextId
+            32511   Target does not exist
+            32512   cannot be performed on a KO'd target.
+            32513	can only be performed on a KO'd target.
+            32514	cannot be performed on yourself.
+            32515	can only be performed on yourself.
+            32516	cannot be performed on a friendly target.
+            32517	can only be performed on a friendly target.
+            32518	cannot be performed on an enemy.
+            32519	can only be performed on an enemy.
+            32547   That command cannot be performed on the current target.
+            32548   That command cannot be performed on a party member
+            */
+            if (target == null)
+            {
+                error?.SetTextId(32511);
+                return false;
+            }
+
+            //This skill can't be used on a corpse and target is dead
+            if ((mainTarget & ValidTarget.Corpse) == 0 && target.IsDead())
+            {
+                error?.SetTextId(32512);
+                return false;
+            }
+
+            //This skill must be used on a corpse and target is alive
+            if ((mainTarget & ValidTarget.CorpseOnly) != 0 && target.IsAlive())
+            {
+                error?.SetTextId(32513);
+                return false;
+            }
+
+            //This skill can't be used on self and target is self
+            if ((mainTarget & ValidTarget.Self) == 0 && target == user)
+            {
+                error?.SetTextId(32514);
+                return false;
+            }
+
+            //This skill must be used on self and target isn't self
+            if ((mainTarget & ValidTarget.SelfOnly) != 0 && target != user)
+            {
+                error?.SetTextId(32515);
+                return false;
+            }
+
+            //This skill can't be used on an ally and target is an ally
+            if ((mainTarget & ValidTarget.Ally) == 0 && target.allegiance == user.allegiance)
+            {
+                error?.SetTextId(32516);
+                return false;
+            }
+
+            //This skill must be used on an ally and target is not an ally
+            if ((mainTarget & ValidTarget.AllyOnly) != 0 && target.allegiance != user.allegiance)
+            {
+                error?.SetTextId(32517);
+                return false;
+            }
+
+            //This skill can't be used on an enemu and target is an enemy
+            if ((mainTarget & ValidTarget.Enemy) == 0 && target.allegiance != user.allegiance)
+            {
+                error?.SetTextId(32518);
+                return false;
+            }
+
+            //This skill must be used on an enemy and target is an ally
+            if ((mainTarget & ValidTarget.EnemyOnly) != 0 && target.allegiance == user.allegiance)
+            {
+                error?.SetTextId(32519);
+                return false;
+            }
+
+            //This skill can't be used on party members and target is a party member
+            if ((mainTarget & ValidTarget.Party) == 0 && target.currentParty == user.currentParty)
+            {
+                error?.SetTextId(32548);
+                return false;
+            }
+
+            //This skill must be used on party members and target is not a party member
+            if ((mainTarget & ValidTarget.PartyOnly) != 0 && target.currentParty != user.currentParty)
+            {
+                error?.SetTextId(32547);
+                return false;
+            }
+
+            //This skill can't be used on NPCs and target is an npc
+            if ((mainTarget & ValidTarget.NPC) == 0 && target.isStatic)
+            {
+                error?.SetTextId(32547);
+                return false;
+            }
+
+            //This skill must be used on NPCs and target is not an npc
+            if ((mainTarget & ValidTarget.NPCOnly) != 0 && !target.isStatic)
+            {
+                error?.SetTextId(32547);
+                return false;
+            }
+
+            // todo: why is player always zoning?
+            // cant target if zoning
+            if (target is Player && ((Player)target).playerSession.isUpdatesLocked)
+            {
+                user.aiContainer.ChangeTarget(null);
+                return false;
+            }
+
+            if (target.zone != user.zone)
+                return false;
+
+            return true;
+        }
+
+        public ushort CalculateMpCost(Character user)
+        {
+            // todo: use precalculated costs instead
+            var level = user.GetLevel();
+            ushort cost = 0;
+            if (level <= 10)
+                cost = (ushort)(100 + level * 10);
+            else if (level <= 20)
+                cost = (ushort)(200 + (level - 10) * 20);
+            else if (level <= 30)
+                cost = (ushort)(400 + (level - 20) * 40);
+            else if (level <= 40)
+                cost = (ushort)(800 + (level - 30) * 70);
+            else if (level <= 50)
+                cost = (ushort)(1500 + (level - 40) * 130);
+            else if (level <= 60)
+                cost = (ushort)(2800 + (level - 50) * 200);
+            else if (level <= 70)
+                cost = (ushort)(4800 + (level - 60) * 320);
+            else
+                cost = (ushort)(8000 + (level - 70) * 500);
+
+            //scale the mpcost by level
+            cost = (ushort)Math.Ceiling((cost * mpCost * 0.001));
+
+            //if user is player, check if spell is a part of combo
+            if (user is Player)
+            {
+                var player = user as Player;
+                if (player.playerWork.comboNextCommandId[0] == id || player.playerWork.comboNextCommandId[1] == id)
+                    cost = (ushort)Math.Ceiling(cost * (1 - player.playerWork.comboCostBonusRate));
+            }
+
+            return mpCost != 0 ? cost : (ushort)0;
+        }
+
+        //Calculate TP cost taking into considerating the combo bonus rate for players
+        //Should this set tpCost or should it be called like CalculateMp where it gets calculated each time? 
+        //Might cause issues with the delay between starting and finishing a WS
+        public short CalculateTpCost(Character user)
+        {
+            short tp = tpCost;
+            //Calculate tp cost
+            if (user is Player)
+            {
+                var player = user as Player;
+                if (player.playerWork.comboNextCommandId[0] == id || player.playerWork.comboNextCommandId[1] == id)
+                    tp  = (short)Math.Ceiling((float)tpCost * (1 - player.playerWork.comboCostBonusRate));
+            }
+
+            return tp;
+        }
+
+        public List<Character> GetTargets()
+        {
+            return targetFind?.GetTargets<Character>();
+        }
+
+        public ushort GetCommandType()
+        {
+            return (ushort) commandType;
+        }
+
+        public ushort GetActionType()
+        {
+            return (ushort) actionType;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/BattleTrait.cs

@@ -0,0 +1,43 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+namespace Meteor.Map.actors.chara.ai
+{
+    class BattleTrait
+    {
+        public ushort id;
+        public string name;
+        public byte job;
+        public byte level;
+        public uint modifier;
+        public int bonus;
+
+        public BattleTrait(ushort id, string name, byte job, byte level, uint modifier, int bonus)
+        {
+            this.id = id;
+            this.name = name;
+            this.job = job;
+            this.level = level;
+            this.modifier = modifier;
+            this.bonus = bonus;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/Controllers/AllyController.cs

@@ -0,0 +1,98 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using System.Collections.Generic;
+using Meteor.Map.Actors;
+using Meteor.Map.actors.chara.npc;
+
+namespace Meteor.Map.actors.chara.ai.controllers
+{
+    // todo: this is probably not needed, can do everything in their script
+    class AllyController : BattleNpcController
+    {
+        protected new Ally owner;
+        public AllyController(Ally owner) :
+            base(owner)
+        {
+            this.owner = owner;
+        }
+        
+        protected List<Character> GetContentGroupCharas()
+        {
+            List<Character> contentGroupCharas = null;
+
+            if (owner.currentContentGroup != null)
+            {
+                contentGroupCharas = new List<Character>(owner.currentContentGroup.GetMemberCount());
+                foreach (var charaId in owner.currentContentGroup.GetMembers())
+                {
+                    var chara = owner.zone.FindActorInArea<Character>(charaId);
+
+                    if (chara != null)
+                        contentGroupCharas.Add(chara);
+                }
+            }
+
+            return contentGroupCharas;
+        }
+
+        //Iterate over players in the group and if they are fighting, assist them
+        protected override void TryAggro(DateTime tick)
+        {
+            //lua.LuaEngine.CallLuaBattleFunction(owner, "tryAggro", owner, GetContentGroupCharas());
+
+            foreach(Character chara in GetContentGroupCharas())
+            {
+                if(chara.IsPlayer())
+                {
+                    if(owner.aiContainer.GetTargetFind().CanTarget((Character) chara.target) && chara.target is BattleNpc && ((BattleNpc)chara.target).hateContainer.HasHateForTarget(chara))
+                    {
+                        owner.Engage(chara.target.actorId);
+                        owner.hateContainer.AddBaseHate((Character) chara.target);
+                        break;
+                    }
+                }
+            }
+            //base.TryAggro(tick);
+        }
+
+        // server really likes to hang whenever scripts iterate area's actorlist
+        protected override void DoCombatTick(DateTime tick, List<Character> contentGroupCharas = null)
+        {
+            if (contentGroupCharas == null)
+            {
+                contentGroupCharas = GetContentGroupCharas();
+            }
+
+            base.DoCombatTick(tick, contentGroupCharas);
+        }
+
+        protected override void DoRoamTick(DateTime tick, List<Character> contentGroupCharas = null)
+        {
+            if (contentGroupCharas == null)
+            {
+                contentGroupCharas = GetContentGroupCharas();
+            }
+            base.DoRoamTick(tick, contentGroupCharas);
+        }
+    }
+}

Map Server/Actors/Chara/Ai/Controllers/BattleNpcController.cs

@@ -0,0 +1,430 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using System.Collections.Generic;
+using Meteor.Common;
+using Meteor.Map.Actors;
+using Meteor.Map.packets.send.actor;
+using Meteor.Map.actors.area;
+using Meteor.Map.utils;
+using Meteor.Map.actors.chara.ai.state;
+using Meteor.Map.actors.chara.npc;
+
+namespace Meteor.Map.actors.chara.ai.controllers
+{
+    class BattleNpcController : Controller
+    {
+        protected DateTime lastActionTime;
+        protected DateTime lastSpellCastTime;
+        protected DateTime lastSkillTime;
+        protected DateTime lastSpecialSkillTime; // todo: i dont think monsters have "2hr" cooldowns like ffxi
+        protected DateTime deaggroTime;
+        protected DateTime neutralTime;
+        protected DateTime waitTime;
+
+        private bool firstSpell = true;
+        protected DateTime lastRoamUpdate;
+        protected DateTime battleStartTime;
+
+        protected new BattleNpc owner;
+        public BattleNpcController(BattleNpc owner) :
+            base(owner)
+        {
+            this.owner = owner;
+            this.lastUpdate = DateTime.Now;
+            this.waitTime = lastUpdate.AddSeconds(5);
+        }
+
+        public override void Update(DateTime tick)
+        {
+            lastUpdate = tick;
+            if (!owner.IsDead())
+            {
+                // todo: handle aggro/deaggro and other shit here
+                if (!owner.aiContainer.IsEngaged())
+                {
+                    TryAggro(tick);
+                }
+
+                if (owner.aiContainer.IsEngaged())
+                {
+                    DoCombatTick(tick);
+                }
+                //Only move if owner isn't dead and is either too far away from their spawn point or is meant to roam and isn't in combat
+                else if (!owner.IsDead() && (owner.isMovingToSpawn || owner.GetMobMod((uint)MobModifier.Roams) > 0))
+                {
+                    DoRoamTick(tick);
+                }
+            }
+        }
+
+        public bool TryDeaggro()
+        {
+            if (owner.hateContainer.GetMostHatedTarget() == null || !owner.aiContainer.GetTargetFind().CanTarget(owner.target as Character))
+            {
+                return true;
+            }
+            else if (!owner.IsCloseToSpawn())
+            {
+                return true;
+            }
+            return false;
+        }
+
+        //If the owner isn't moving to spawn, iterate over nearby enemies and 
+        //aggro the first one that is within 10 levels and can be detected, then engage
+        protected virtual void TryAggro(DateTime tick)
+        {
+            if (tick >= neutralTime && !owner.isMovingToSpawn)
+            {
+                if (!owner.neutral && owner.IsAlive())
+                {
+                    foreach (var chara in owner.zone.GetActorsAroundActor<Character>(owner, 50))
+                    {
+                        if (chara.allegiance == owner.allegiance)
+                           continue;
+
+                        if (owner.aiContainer.pathFind.AtPoint() && owner.detectionType != DetectionType.None)
+                        {
+                            uint levelDifference = (uint)Math.Abs(owner.GetLevel() - chara.GetLevel());
+
+                            if (levelDifference <= 10 || (owner.detectionType & DetectionType.IgnoreLevelDifference) != 0 && CanAggroTarget(chara))
+                            {
+                                owner.hateContainer.AddBaseHate(chara);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (owner.hateContainer.GetHateList().Count > 0)
+            {
+                Engage(owner.hateContainer.GetMostHatedTarget());
+            }
+        }
+
+        public override bool Engage(Character target)
+        {
+            var canEngage = this.owner.aiContainer.InternalEngage(target);
+            if (canEngage)
+            {
+                //owner.ChangeState(SetActorStatePacket.MAIN_STATE_ACTIVE);
+
+                // reset casting
+                firstSpell = true;
+                // todo: find a better place to put this?
+                if (owner.GetState() != SetActorStatePacket.MAIN_STATE_ACTIVE)
+                    owner.ChangeState(SetActorStatePacket.MAIN_STATE_ACTIVE);
+
+                lastActionTime = DateTime.Now;
+                battleStartTime = lastActionTime;
+                // todo: adjust cooldowns with modifiers
+            }
+            return canEngage;
+        }
+
+        protected bool TryEngage(Character target)
+        {
+            // todo:
+            return true;
+        }
+
+        public override void Disengage()
+        {
+            var target = owner.target;
+            base.Disengage();
+            // todo:
+            lastActionTime = lastUpdate.AddSeconds(5);
+            owner.isMovingToSpawn = true;
+            owner.aiContainer.pathFind.SetPathFlags(PathFindFlags.None);
+            owner.aiContainer.pathFind.PreparePath(owner.spawnX, owner.spawnY, owner.spawnZ, 1.5f, 10);
+            neutralTime = lastActionTime;
+            owner.hateContainer.ClearHate();
+            lua.LuaEngine.CallLuaBattleFunction(owner, "onDisengage", owner, target, Utils.UnixTimeStampUTC(lastUpdate));
+        }
+
+        public override void Cast(Character target, uint spellId)
+        {
+            // todo:
+            if(owner.aiContainer.CanChangeState())
+                owner.aiContainer.InternalCast(target, spellId);
+        }
+
+        public override void Ability(Character target, uint abilityId)
+        {
+            // todo:
+            if (owner.aiContainer.CanChangeState())
+                owner.aiContainer.InternalAbility(target, abilityId);
+        }
+
+        public override void RangedAttack(Character target)
+        {
+            // todo:
+        }
+
+        public override void MonsterSkill(Character target, uint mobSkillId)
+        {
+            // todo:
+        }
+
+        protected virtual void DoRoamTick(DateTime tick, List<Character> contentGroupCharas = null)
+        {
+            if (tick >= waitTime)
+            {
+                neutralTime = tick.AddSeconds(5);
+                if (owner.aiContainer.pathFind.IsFollowingPath())
+                {
+                    owner.aiContainer.pathFind.FollowPath();
+                    lastActionTime = tick.AddSeconds(-5);
+                }
+                else
+                {
+                    if (tick >= lastActionTime)
+                    {
+                        
+                    }
+                }
+                waitTime = tick.AddSeconds(owner.GetMobMod((uint) MobModifier.RoamDelay));
+                owner.OnRoam(tick);
+
+                if (CanMoveForward(0.0f) && !owner.aiContainer.pathFind.IsFollowingPath())
+                {
+                    // will move on next tick
+                    owner.aiContainer.pathFind.SetPathFlags(PathFindFlags.None);
+                    owner.aiContainer.pathFind.PathInRange(owner.spawnX, owner.spawnY, owner.spawnZ, 1.5f, 50.0f);
+                }
+                //lua.LuaEngine.CallLuaBattleFunction(owner, "onRoam", owner, contentGroupCharas);
+            }
+
+            if (owner.aiContainer.pathFind.IsFollowingPath() && owner.aiContainer.CanFollowPath())
+            {
+                owner.aiContainer.pathFind.FollowPath();
+            }
+        }
+
+        protected virtual void DoCombatTick(DateTime tick, List<Character> contentGroupCharas = null)
+        {
+            HandleHate();
+            // todo: magic/attack/ws cooldowns etc
+            if (TryDeaggro())
+            {
+                Disengage();
+                return;
+            }
+            owner.SetMod((uint)Modifier.MovementSpeed, 5);
+            if ((tick - lastCombatTickScript).TotalSeconds > 3)
+            {
+                Move();
+                //if (owner.aiContainer.CanChangeState())
+                    //owner.aiContainer.WeaponSkill(owner.zone.FindActorInArea<Character>(owner.target.actorId), 27155);
+                //lua.LuaEngine.CallLuaBattleFunction(owner, "onCombatTick", owner, owner.target, Utils.UnixTimeStampUTC(tick), contentGroupCharas);
+                lastCombatTickScript = tick;
+            }
+        }
+
+        protected virtual void Move()
+        {
+            if (!owner.aiContainer.CanFollowPath() || owner.statusEffects.HasStatusEffectsByFlag(StatusEffectFlags.PreventMovement))
+            {
+                return;
+            }
+
+            if (owner.aiContainer.pathFind.IsFollowingScriptedPath())
+            {
+                owner.aiContainer.pathFind.FollowPath();
+                return;
+            }
+
+            var vecToTarget = owner.target.GetPosAsVector3() - owner.GetPosAsVector3();
+            vecToTarget /= vecToTarget.Length();
+            vecToTarget = (Utils.Distance(owner.GetPosAsVector3(), owner.target.GetPosAsVector3()) - owner.GetAttackRange() + 0.2f) * vecToTarget;
+
+            var targetPos = vecToTarget + owner.GetPosAsVector3();
+            var distance = Utils.Distance(owner.GetPosAsVector3(), owner.target.GetPosAsVector3());
+            if (distance > owner.GetAttackRange() - 0.2f)
+            {
+                if (CanMoveForward(distance))
+                {
+                    if (!owner.aiContainer.pathFind.IsFollowingPath() && distance > 3)
+                    {
+                        // pathfind if too far otherwise jump to target
+                        owner.aiContainer.pathFind.SetPathFlags(PathFindFlags.None);
+                        owner.aiContainer.pathFind.PreparePath(targetPos, 1.5f, 5);
+                    }
+                    owner.aiContainer.pathFind.FollowPath();
+                    if (!owner.aiContainer.pathFind.IsFollowingPath())
+                    {
+                        if (owner.target is Player)
+                        {
+                            foreach (var chara in owner.zone.GetActorsAroundActor<Character>(owner, 1))
+                            {
+                                if (chara == owner)
+                                    continue;
+
+                                float mobDistance = Utils.Distance(owner.positionX, owner.positionY, owner.positionZ, chara.positionX, chara.positionY, chara.positionZ);
+                                if (mobDistance < 0.50f && (chara.updateFlags & ActorUpdateFlags.Position) == 0)
+                                {
+                                    owner.aiContainer.pathFind.PathInRange(targetPos, 1.3f, chara.GetAttackRange());
+                                    break;
+                                }
+                            }
+                        }
+                        FaceTarget();
+                    }
+                }
+            }
+            else
+            {
+                FaceTarget();
+            }
+            lastRoamUpdate = DateTime.Now;
+        }
+
+        protected void FaceTarget()
+        {
+            // todo: check if stunned etc
+            if (owner.statusEffects.HasStatusEffectsByFlag(StatusEffectFlags.PreventTurn) )
+            {
+            }
+            else
+            {
+                owner.LookAt(owner.target);
+            }
+        }
+
+        protected bool CanMoveForward(float distance)
+        {
+            // todo: check spawn leash and stuff
+            if (!owner.IsCloseToSpawn())
+            {
+                return false;
+            }
+            if (owner.GetSpeed() == 0)
+            {
+                return false;
+            }
+            return true;
+        }
+
+        public virtual bool CanAggroTarget(Character target)
+        {
+            if (owner.neutral || owner.detectionType == DetectionType.None || owner.IsDead())
+            {
+                return false;
+            }
+
+            // todo: can mobs aggro mounted targets?
+            if (target.IsDead() || target.currentMainState == SetActorStatePacket.MAIN_STATE_MOUNTED)
+            {
+                return false;
+            }
+
+            if (owner.aiContainer.IsSpawned() && !owner.aiContainer.IsEngaged() && CanDetectTarget(target))
+            {
+                return true;
+            }
+            return false;
+        }
+
+        public virtual bool CanDetectTarget(Character target, bool forceSight = false)
+        {
+            if (owner.IsDead())
+                return false;
+
+            // todo: this should probably be changed to only allow detection at end of path?
+            if (owner.aiContainer.pathFind.IsFollowingScriptedPath() || owner.aiContainer.pathFind.IsFollowingPath() && !owner.aiContainer.pathFind.AtPoint())
+            {
+                return false;
+            }
+
+            // todo: handle sight/scent/hp etc
+            if (target.IsDead() || target.currentMainState == SetActorStatePacket.MAIN_STATE_MOUNTED)
+                return false;
+
+            float verticalDistance = Math.Abs(target.positionY - owner.positionY);
+            if (verticalDistance > 8)
+                return false;
+
+            var distance = Utils.Distance(owner.positionX, owner.positionY, owner.positionZ, target.positionX, target.positionY, target.positionZ);
+
+            bool detectSight = forceSight || (owner.detectionType & DetectionType.Sight) != 0;
+            bool hasSneak = false;
+            bool hasInvisible = false;
+            bool isFacing = owner.IsFacing(target);
+
+            // use the mobmod sight range before defaulting to 20 yalms
+            if (detectSight && !hasInvisible && isFacing && distance < owner.GetMobMod((uint)MobModifier.SightRange))
+                return CanSeePoint(target.positionX, target.positionY, target.positionZ);
+
+            // todo: check line of sight and aggroTypes
+            if (distance > 20)
+            {
+                return false;
+            }
+
+            // todo: seems ffxiv doesnt even differentiate between sneak/invis?
+            {
+                hasSneak = target.GetMod(Modifier.Stealth) > 0;
+                hasInvisible = hasSneak;
+            }
+
+
+
+            if ((owner.detectionType & DetectionType.Sound) != 0 && !hasSneak && distance < owner.GetMobMod((uint)MobModifier.SoundRange))
+                return CanSeePoint(target.positionX, target.positionY, target.positionZ);
+
+            if ((owner.detectionType & DetectionType.Magic) != 0 && target.aiContainer.IsCurrentState<MagicState>())
+                return CanSeePoint(target.positionX, target.positionY, target.positionZ);
+
+            if ((owner.detectionType & DetectionType.LowHp) != 0 && target.GetHPP() < 75)
+                return CanSeePoint(target.positionX, target.positionY, target.positionZ);
+
+            return false;
+        }
+
+        public virtual bool CanSeePoint(float x, float y, float z)
+        {
+            return NavmeshUtils.CanSee((Zone)owner.zone, owner.positionX, owner.positionY, owner.positionZ, x, y, z);
+        }
+
+        protected virtual void HandleHate()
+        {
+            ChangeTarget(owner.hateContainer.GetMostHatedTarget());
+        }
+
+        public override void ChangeTarget(Character target)
+        {
+            if (target != owner.target)
+            {
+                owner.target = target;
+                owner.currentLockedTarget = target?.actorId ?? Actor.INVALID_ACTORID;
+                owner.currentTarget = target?.actorId ?? Actor.INVALID_ACTORID;
+
+                 foreach (var player in owner.zone.GetActorsAroundActor<Player>(owner, 50))
+                    player.QueuePacket(owner.GetHateTypePacket(player));
+
+                base.ChangeTarget(target);
+            }
+        }
+    }
+}

Map Server/Actors/Chara/Ai/Controllers/Controller.cs

@@ -0,0 +1,97 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using Meteor.Map.Actors;
+
+namespace Meteor.Map.actors.chara.ai.controllers
+{
+    abstract class Controller
+    {
+        protected Character owner;
+
+        protected DateTime lastCombatTickScript;
+        protected DateTime lastUpdate;
+        public bool canUpdate = true;
+        protected bool autoAttackEnabled = true;
+        protected bool castingEnabled = true;
+        protected bool weaponSkillEnabled = true;
+        protected PathFind pathFind;
+        protected TargetFind targetFind;
+
+        public Controller(Character owner)
+        {
+            this.owner = owner;
+        }
+
+        public abstract void Update(DateTime tick);
+        public abstract bool Engage(Character target);
+        public abstract void Cast(Character target, uint spellId);
+        public virtual void WeaponSkill(Character target, uint weaponSkillId) { }
+        public virtual void MonsterSkill(Character target, uint mobSkillId) { }
+        public virtual void UseItem(Character target, uint slot, uint itemId) { }
+        public abstract void Ability(Character target, uint abilityId);
+        public abstract void RangedAttack(Character target);
+        public virtual void Spawn() { }
+        public virtual void Despawn() { }
+
+
+        public virtual void Disengage()
+        {
+            owner.aiContainer.InternalDisengage();
+        }
+
+        public virtual void ChangeTarget(Character target)
+        {
+            owner.aiContainer.InternalChangeTarget(target);
+        }
+
+        public bool IsAutoAttackEnabled()
+        {
+            return autoAttackEnabled;
+        }
+
+        public void SetAutoAttackEnabled(bool isEnabled)
+        {
+            autoAttackEnabled = isEnabled;
+        }
+
+        public bool IsCastingEnabled()
+        {
+            return castingEnabled;
+        }
+
+        public void SetCastingEnabled(bool isEnabled)
+        {
+            castingEnabled = isEnabled;
+        }
+
+        public bool IsWeaponSkillEnabled()
+        {
+            return weaponSkillEnabled;
+        }
+
+        public void SetWeaponSkillEnabled(bool isEnabled)
+        {
+            weaponSkillEnabled = isEnabled;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/Controllers/PetController.cs

@@ -0,0 +1,89 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using Meteor.Map.Actors;
+
+namespace Meteor.Map.actors.chara.ai.controllers
+{
+    class PetController : Controller
+    {
+        private Character petMaster;
+
+        public PetController(Character owner) :
+            base(owner)
+        {
+            this.lastUpdate = Program.Tick;
+        }
+
+        public override void Update(DateTime tick)
+        {
+            // todo: handle pet stuff on tick
+        }
+
+        public override void ChangeTarget(Character target)
+        {
+            base.ChangeTarget(target);
+        }
+
+        public override bool Engage(Character target)
+        {
+            // todo: check distance, last swing time, status effects
+            return true;
+        }
+
+        public override void Disengage()
+        {
+            // todo:
+            return;
+        }
+
+        public override void Cast(Character target, uint spellId)
+        {
+
+        }
+
+        public override void Ability(Character target, uint abilityId)
+        {
+
+        }
+
+        public override void RangedAttack(Character target)
+        {
+
+        }
+
+        public Character GetPetMaster()
+        {
+            return petMaster;
+        }
+
+        public void SetPetMaster(Character master)
+        {
+            petMaster = master;
+
+            if (master is Player)
+                owner.allegiance = CharacterTargetingAllegiance.Player;
+            else
+                owner.allegiance = CharacterTargetingAllegiance.BattleNpcs;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/Controllers/PlayerController.cs

@@ -0,0 +1,108 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using Meteor.Map.Actors;
+
+namespace Meteor.Map.actors.chara.ai.controllers
+{
+    class PlayerController : Controller
+    {
+        private new Player owner;
+        public PlayerController(Player owner) :
+            base(owner)
+        {
+            this.owner = owner;
+            this.lastUpdate = DateTime.Now;
+        }
+
+        public override void Update(DateTime tick)
+        {
+            /*
+            if (owner.newMainState != owner.currentMainState)
+            {
+                if (owner.newMainState == SetActorStatePacket.MAIN_STATE_ACTIVE)
+                {
+                    owner.Engage();
+                }
+                else
+                {
+                    owner.Disengage();
+                }
+                owner.currentMainState = (ushort)owner.newMainState;
+            }*/
+        }
+
+        public override void ChangeTarget(Character target)
+        {
+            owner.target = target;
+            base.ChangeTarget(target);
+        }
+
+        public override bool Engage(Character target)
+        {
+            var canEngage = this.owner.aiContainer.InternalEngage(target);
+            if (canEngage)
+            {
+                if (owner.statusEffects.HasStatusEffect(StatusEffectId.Sleep))
+                {
+                    // That command cannot be performed.
+                    owner.SendGameMessage(Server.GetWorldManager().GetActor(), 32553, 0x20);
+                    return false;
+                }
+                // todo: adjust cooldowns with modifiers
+            }
+            return canEngage;
+        }
+
+        public override void Disengage()
+        {
+            // todo:
+            base.Disengage();
+            return;
+        }
+
+        public override void Cast(Character target, uint spellId)
+        {
+            owner.aiContainer.InternalCast(target, spellId);
+        }
+
+        public override void WeaponSkill(Character target, uint weaponSkillId)
+        {
+            owner.aiContainer.InternalWeaponSkill(target, weaponSkillId);
+        }
+
+        public override void Ability(Character target, uint abilityId)
+        {
+            owner.aiContainer.InternalAbility(target, abilityId);
+        }
+
+        public override void RangedAttack(Character target)
+        {
+
+        }
+
+        public override void UseItem(Character target, uint slot, uint itemId)
+        {
+            owner.aiContainer.InternalUseItem(target, slot, itemId);
+        }
+    }
+}

Map Server/Actors/Chara/Ai/HateContainer.cs

@@ -0,0 +1,108 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System.Collections.Generic;
+using Meteor.Map.Actors;
+
+namespace Meteor.Map.actors.chara.ai
+{
+    // todo: actually implement enmity properly
+    class HateEntry
+    {
+        public Character actor;
+        public uint cumulativeEnmity;
+        public uint volatileEnmity;
+        public bool isActive;
+
+        public HateEntry(Character actor, uint cumulativeEnmity = 0, uint volatileEnmity = 0, bool isActive = false)
+        {
+            this.actor = actor;
+            this.cumulativeEnmity = cumulativeEnmity;
+            this.volatileEnmity = volatileEnmity;
+            this.isActive = isActive;
+        }
+    }
+
+    class HateContainer
+    {
+        private Dictionary<Character, HateEntry> hateList;
+        private Character owner;
+
+        public HateContainer(Character owner)
+        {
+            this.owner = owner;
+            this.hateList = new Dictionary<Character, HateEntry>();
+        }
+
+        public void AddBaseHate(Character target)
+        {
+            if (!HasHateForTarget(target))
+                hateList.Add(target, new HateEntry(target, 1, 0, true));
+        }
+
+        public void UpdateHate(Character target, int damage)
+        {
+            AddBaseHate(target);
+            //hateList[target].volatileEnmity += (uint)damage;
+            hateList[target].cumulativeEnmity += (uint)damage;
+        }
+
+        public void ClearHate(Character target = null)
+        {
+            if (target != null)
+                hateList.Remove(target);
+            else
+                hateList.Clear();
+        }
+
+        private void UpdateHate(HateEntry entry)
+        {
+
+        }
+
+        public Dictionary<Character, HateEntry> GetHateList()
+        {
+            // todo: return unmodifiable collection?
+            return hateList;
+        }
+
+        public bool HasHateForTarget(Character target)
+        {
+            return hateList.ContainsKey(target);
+        }
+
+        public Character GetMostHatedTarget()
+        {
+            uint enmity = 0;
+            Character target = null;
+
+            foreach(var entry in hateList.Values)
+            {
+                if (entry.cumulativeEnmity > enmity && entry.isActive)
+                {
+                    enmity = entry.cumulativeEnmity;
+                    target = entry.actor;
+                }
+            }
+            return target;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/Helpers/ActionQueue.cs

@@ -0,0 +1,73 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using System.Collections.Generic;
+using Meteor.Map.Actors;
+using Meteor.Map.lua;
+
+namespace Meteor.Map.actors.chara.ai
+{
+    class Action
+    {
+        public DateTime startTime;
+        public uint durationMs;
+        public bool checkState;
+        // todo: lua function
+        LuaScript script;
+    }
+
+    class ActionQueue
+    {
+        private Character owner;
+        private Queue<Action> actionQueue;
+        private Queue<Action> timerQueue;
+
+        public bool IsEmpty { get { return actionQueue.Count > 0 || timerQueue.Count > 0; } }
+
+        public ActionQueue(Character owner)
+        {
+            this.owner = owner;
+            actionQueue = new Queue<Action>();
+            timerQueue = new Queue<Action>();
+        }
+
+        public void PushAction(Action action)
+        {
+
+        }
+
+        public void Update(DateTime tick)
+        {
+
+        }
+
+        public void HandleAction(Action action)
+        {
+
+        }
+
+        public void CheckAction(DateTime tick)
+        {
+
+        }
+    }
+}

Map Server/Actors/Chara/Ai/Helpers/PathFind.cs

@@ -0,0 +1,227 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using System.Collections.Generic;
+using Meteor.Map.Actors;
+using Meteor.Map.utils;
+using Meteor.Common;
+using Meteor.Map.actors.area;
+
+// port of https://github.com/DarkstarProject/darkstar/blob/master/src/map/ai/helpers/pathfind.h
+
+namespace Meteor.Map.actors.chara.ai
+{
+    // todo: check for obstacles, los, etc
+    public enum PathFindFlags
+    {
+        None,
+        Scripted = 0x01,
+        IgnoreNav = 0x02,
+    }
+    class PathFind
+    {
+        private Character owner;
+        private List<Vector3> path;
+        private bool canFollowPath;
+        float distanceFromPoint;
+
+        private PathFindFlags pathFlags;
+
+        public PathFind(Character owner)
+        {
+            this.owner = owner;
+        }
+
+        public void PreparePath(Vector3 dest, float stepSize = 1.25f, int maxPath = 40, float polyRadius = 0.0f)
+        {
+            PreparePath(dest.X, dest.Y, dest.Z, stepSize, maxPath, polyRadius);
+        }
+
+        public void PreparePath(float x, float y, float z, float stepSize = 1.25f, int maxPath = 40, float polyRadius = 0.0f)
+        {
+            var pos = new Vector3(owner.positionX, owner.positionY, owner.positionZ);
+            var dest = new Vector3(x, y, z);
+
+            Zone zone;
+            if (owner.GetZone() is PrivateArea || owner.GetZone() is PrivateAreaContent)
+                zone = (Zone)((PrivateArea)owner.GetZone()).GetParentZone();
+            else
+                zone = (Zone)owner.GetZone();
+
+            var sw = new System.Diagnostics.Stopwatch();
+            sw.Start();
+
+            if ((pathFlags & PathFindFlags.IgnoreNav) != 0)
+                path = new List<Vector3>(1) { new Vector3(x, y, z) };
+            else
+                path = NavmeshUtils.GetPath(zone, pos, dest, stepSize, maxPath, polyRadius);
+
+            if (path != null)
+            {
+                if (owner.oldPositionX == 0.0f && owner.oldPositionY == 0.0f && owner.oldPositionZ == 0.0f)
+                {
+                    owner.oldPositionX = owner.positionX;
+                    owner.oldPositionY = owner.positionY;
+                    owner.oldPositionZ = owner.positionZ;
+                }
+
+                // todo: something went wrong
+                if (path.Count == 0)
+                {
+                    owner.positionX = owner.oldPositionX;
+                    owner.positionY = owner.oldPositionY;
+                    owner.positionZ = owner.oldPositionZ;
+                }
+
+                sw.Stop();
+                zone.pathCalls++;
+                zone.pathCallTime += sw.ElapsedMilliseconds;
+
+                //if (path.Count == 1)
+                //    Program.Log.Info($"mypos: {owner.positionX} {owner.positionY} {owner.positionZ} | targetPos: {x} {y} {z} | step {stepSize} | maxPath {maxPath} | polyRadius {polyRadius}");
+
+                //Program.Log.Error("[{0}][{1}] Created {2} points in {3} milliseconds", owner.actorId, owner.actorName, path.Count, sw.ElapsedMilliseconds);
+            }
+        }
+
+        public void PathInRange(Vector3 dest, float minRange, float maxRange)
+        {
+            PathInRange(dest.X, dest.Y, dest.Z, minRange, maxRange);
+        }
+
+        public void PathInRange(float x, float y, float z, float minRange, float maxRange = 5.0f)
+        {
+            var dest = owner.FindRandomPoint(x, y, z, minRange, maxRange);
+            // todo: this is dumb..
+            distanceFromPoint = owner.GetAttackRange();
+            PreparePath(dest.X, dest.Y, dest.Z);
+        }
+
+
+        public void SetPathFlags(PathFindFlags flags)
+        {
+            this.pathFlags = flags;
+        }
+
+        public bool IsFollowingPath()
+        {
+            return path?.Count > 0;
+        }
+
+        public bool IsFollowingScriptedPath()
+        {
+            return (pathFlags & PathFindFlags.Scripted) != 0;
+        }
+
+        public void FollowPath()
+        {
+            if (path?.Count > 0)
+            {
+                var point = path[0];
+
+                StepTo(point);
+
+                if (AtPoint(point))
+                {
+                    path.Remove(point);
+                    owner.OnPath(point);
+                    //Program.Log.Error($"{owner.actorName} arrived at point {point.X} {point.Y} {point.Z}");
+                }
+
+                if (path.Count == 0 && owner.target != null)
+                    owner.LookAt(owner.target);
+            }
+        }
+
+        public bool AtPoint(Vector3 point = null)
+        {
+            if (point == null && path != null && path.Count > 0)
+            {
+                point = path[path.Count - 1];
+            }
+            else
+            {
+                distanceFromPoint = 0;
+                return true;
+            }
+
+            if (distanceFromPoint == 0)
+                return owner.positionX == point.X && owner.positionZ == point.Z;
+            else
+                return Utils.Distance(owner.positionX, owner.positionY, owner.positionZ, point.X, point.Y, point.Z) <= (distanceFromPoint + 4.5f);
+        }
+
+        public void StepTo(Vector3 point, bool run = false)
+        {
+            float speed = GetSpeed();
+
+            float stepDistance = speed / 3;
+            float distanceTo = Utils.Distance(owner.positionX, owner.positionY, owner.positionZ, point.X, point.Y, point.Z);
+
+            owner.LookAt(point);
+
+            if (distanceTo <= distanceFromPoint + stepDistance)
+            {
+                if (distanceFromPoint <= owner.GetAttackRange())
+                {
+                    owner.QueuePositionUpdate(point);
+                }
+                else
+                {
+                    float x = owner.positionX - (float)Math.Cos(owner.rotation + (float)(Math.PI / 2)) * (distanceTo - distanceFromPoint);
+                    float z = owner.positionZ + (float)Math.Sin(owner.rotation + (float)(Math.PI / 2)) * (distanceTo - distanceFromPoint);
+
+                    owner.QueuePositionUpdate(x, owner.positionY, z);
+                }
+            }
+            else
+            {
+                float x = owner.positionX - (float)Math.Cos(owner.rotation + (float)(Math.PI / 2)) * (distanceTo - distanceFromPoint);
+                float z = owner.positionZ + (float)Math.Sin(owner.rotation + (float)(Math.PI / 2)) * (distanceTo - distanceFromPoint);
+
+                owner.QueuePositionUpdate(x, owner.positionY, z);
+            }
+        }
+
+        public void Clear()
+        {
+            path?.Clear();
+            pathFlags = PathFindFlags.None;
+            distanceFromPoint = 0.0f;
+        }
+
+        private float GetSpeed()
+        {
+            float baseSpeed = owner.GetSpeed();
+
+            if (!(owner is Player))
+            {
+                if (owner is BattleNpc)
+                {
+                    //owner.ChangeSpeed(0.0f, SetActorSpeedPacket.DEFAULT_WALK - 2.0f, SetActorSpeedPacket.DEFAULT_RUN - 2.0f, SetActorSpeedPacket.DEFAULT_ACTIVE - 2.0f);
+                }
+                // baseSpeed += ConfigConstants.NPC_SPEED_MOD;
+            }
+            return baseSpeed;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/Helpers/TargetFind.cs

@@ -0,0 +1,509 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Meteor.Map.Actors;
+using Meteor.Common;
+using Meteor.Map.actors.chara.ai.controllers;
+using Meteor.Map.actors.group;
+
+// port of dsp's ai code https://github.com/DarkstarProject/darkstar/blob/master/src/map/ai/
+
+namespace Meteor.Map.actors.chara.ai
+{
+    [Flags]
+    public enum ValidTarget : ushort
+    {
+        None = 0x00,
+        Self = 0x01,                    //Can be used on self (if this flag isn't set and target is self, return false)
+        SelfOnly = 0x02,                //Must be used on self (if this flag is set and target isn't self, return false)
+        Party = 0x4,                    //Can be used on party members
+        PartyOnly = 0x8,                //Must be used on party members
+        Ally = 0x10,                    //Can be used on allies
+        AllyOnly = 0x20,                //Must be used on allies
+        NPC = 0x40,                     //Can be used on static NPCs
+        NPCOnly = 0x80,                 //Must be used on static NPCs
+        Enemy = 0x100,                  //Can be used on enemies
+        EnemyOnly = 0x200,              //Must be used on enemies
+        Object = 0x400,                 //Can be used on objects
+        ObjectOnly = 0x800,             //Must be used on objects
+        Corpse = 0x1000,                //Can be used on corpses
+        CorpseOnly = 0x2000,            //Must be used on corpses
+
+        //These are only used for ValidTarget, not MainTarget
+        MainTargetParty = 0x4000,       //Can be used on main target's party (This will basically always be true.)
+        MainTargetPartyOnly = 0x8000,   //Must be used on main target's party (This is for Protect basically.)
+    }
+
+    /// <summary> Targeting from/to different entity types </summary>
+    enum TargetFindCharacterType : byte
+    {
+        None,
+        /// <summary> Player can target all <see cref="Player">s in party </summary>
+        PlayerToPlayer,
+        /// <summary> Player can target all <see cref="BattleNpc"/>s (excluding player owned <see cref="Pet"/>s) </summary>
+        PlayerToBattleNpc,
+        /// <summary> BattleNpc can target other <see cref="BattleNpc"/>s </summary>
+        BattleNpcToBattleNpc,
+        /// <summary> BattleNpc can target <see cref="Player"/>s and their <see cref="Pet"/>s </summary>
+        BattleNpcToPlayer,
+    }
+
+    /// <summary> Type of AOE region to create </summary>
+    enum TargetFindAOEType : byte
+    {
+        None,
+        /// <summary> Really a cylinder, uses maxDistance parameter in SetAOEType </summary>
+        Circle,
+        /// <summary> Create a cone with param in radians </summary>
+        Cone,
+        /// <summary> Box using self/target coords and </summary>
+        Box
+    }
+
+    /// <summary> Set AOE around self or target </summary>
+    enum TargetFindAOETarget : byte
+    {
+        /// <summary> Set AOE's origin at target's position </summary>
+        Target,
+        /// <summary> Set AOE's origin to own position. </summary>
+        Self
+    }
+
+    /// <summary> Target finding helper class </summary>
+    class TargetFind
+    {
+        private Character owner;
+        private Character mainTarget;           //This is the target that the skill is being used on
+        private Character masterTarget;         //If mainTarget is a pet, this is the owner
+        private TargetFindCharacterType findType;
+        private ValidTarget validTarget;
+        private TargetFindAOETarget aoeTarget;
+        private TargetFindAOEType aoeType;
+        private Vector3 aoeTargetPosition;      //This is the center of circle of cone AOEs and the position where line aoes come out. If we have mainTarget this might not be needed?
+        private float aoeTargetRotation;        //This is the direction the aoe target is facing
+        private float maxDistance;              //Radius for circle and cone AOEs, length for line AOEs
+        private float minDistance;              //Minimum distance to that target must be to be able to be hit
+        private float width;                    //Width of line AOEs
+        private float height;                   //All AoEs are boxes or cylinders. Height is usually 10y regardless of maxDistance, but some commands have different values. Height is total height, so targets can be at most half this distance away on Y axis
+        private float aoeRotateAngle;           //This is the angle that cones and line aoes are rotated about aoeTargetPosition for skills that come out of a side other than the front
+        private float coneAngle;                //The angle of the cone itself in Pi Radians
+        private float param;
+        private List<Character> targets;
+
+        public TargetFind(Character owner, Character mainTarget = null)
+        {
+            Reset();
+            this.owner = owner;
+            this.mainTarget = mainTarget == null ? owner : mainTarget;
+        }
+
+        public void Reset()
+        {
+            this.mainTarget = owner;
+            this.findType = TargetFindCharacterType.None;
+            this.validTarget = ValidTarget.Enemy;
+            this.aoeType = TargetFindAOEType.None;
+            this.aoeTarget = TargetFindAOETarget.Target;
+            this.aoeTargetPosition = null;
+            this.aoeTargetRotation = 0;
+            this.maxDistance = 0.0f;
+            this.minDistance = 0.0f;
+            this.width = 0.0f;
+            this.height = 0.0f;
+            this.aoeRotateAngle = 0.0f;
+            this.coneAngle = 0.0f;
+            this.param = 0.0f;
+            this.targets = new List<Character>();
+        }
+
+        public List<T> GetTargets<T>() where T : Character
+        {
+            return new List<T>(targets.OfType<T>());
+        }
+
+        public List<Character> GetTargets()
+        {
+            return targets;
+        }
+
+        /// <summary>
+        /// Call this before <see cref="FindWithinArea"/> <para/>
+        /// </summary>
+        /// <param name="maxDistance">
+        /// <see cref="TargetFindAOEType.Circle"/> - radius of circle <para/>
+        /// <see cref="TargetFindAOEType.Cone"/> - height of cone <para/>
+        /// <see cref="TargetFindAOEType.Box"/> - width of box / 2 (todo: set box length not just between user and target)
+        /// </param>
+        /// <param name="param"> param in degrees of cone (todo: probably use radians and forget converting at runtime) </param>
+        public void SetAOEType(ValidTarget validTarget, TargetFindAOEType aoeType, TargetFindAOETarget aoeTarget, float maxDistance, float minDistance, float height, float aoeRotate, float coneAngle, float param = 0.0f)
+        {
+            this.validTarget = validTarget;
+            this.aoeType = aoeType;
+            this.maxDistance = maxDistance;
+            this.minDistance = minDistance;
+            this.param = param;
+            this.height = height;
+            this.aoeRotateAngle = aoeRotate;
+            this.coneAngle = coneAngle;
+        }
+
+        /// <summary>
+        /// Call this to prepare Box AOE
+        /// </summary>
+        /// <param name="validTarget"></param>
+        /// <param name="aoeTarget"></param>
+        /// <param name="length"></param>
+        /// <param name="width"></param>
+        public void SetAOEBox(ValidTarget validTarget, TargetFindAOETarget aoeTarget, float length, float width, float aoeRotateAngle)
+        {
+            this.validTarget = validTarget;
+            this.aoeType = TargetFindAOEType.Box;
+            this.aoeTarget = aoeTarget;
+            this.aoeRotateAngle = aoeRotateAngle;
+            float x = owner.positionX - (float)Math.Cos(owner.rotation + (float)(Math.PI / 2)) * (length);
+            float z = owner.positionZ + (float)Math.Sin(owner.rotation + (float)(Math.PI / 2)) * (length);
+            this.maxDistance = length;
+            this.width = width;
+        }
+
+        /// <summary>
+        /// Find and try to add a single target to target list
+        /// </summary>
+        public void FindTarget(Character target, ValidTarget flags)
+        {
+            validTarget = flags;
+            // todo: maybe this should only be set if successfully added?
+            AddTarget(target, false);
+        }
+
+        /// <summary>
+        /// <para> Call SetAOEType before calling this </para>
+        /// Find targets within area set by <see cref="SetAOEType"/>
+        /// </summary>
+        public void FindWithinArea(Character target, ValidTarget flags, TargetFindAOETarget aoeTarget)
+        {
+            targets.Clear();
+            validTarget = flags;
+            // are we creating aoe circles around target or self
+            if (aoeTarget == TargetFindAOETarget.Self)
+            {
+                this.aoeTargetPosition = owner.GetPosAsVector3();
+                this.aoeTargetRotation = owner.rotation + (float) (aoeRotateAngle * Math.PI);
+            }
+            else
+            {
+                this.aoeTargetPosition = target.GetPosAsVector3();
+                this.aoeTargetRotation = target.rotation + (float) (aoeRotateAngle * Math.PI);
+            }
+
+            masterTarget = TryGetMasterTarget(target) ?? target;
+
+            // todo: this is stupid
+            bool withPet = (flags & ValidTarget.Ally) != 0 || masterTarget.allegiance != owner.allegiance;
+
+            if (masterTarget != null && CanTarget(masterTarget))
+                targets.Add(masterTarget);
+
+            if (aoeType != TargetFindAOEType.None)
+            {
+                AddAllInRange(target, withPet);
+            }
+
+            //if (targets.Count > 8)
+                //targets.RemoveRange(8, targets.Count - 8);
+        }
+
+        /// <summary>
+        /// Find targets within a box using owner's coordinates and target's coordinates as length
+        /// with corners being `maxDistance` yalms to either side of self and target
+        /// </summary>
+        private bool IsWithinBox(Character target, bool withPet)
+        {
+            Vector3 vec = target.GetPosAsVector3() - aoeTargetPosition;
+            Vector3 relativePos = new Vector3();
+
+            //Get target's position relative to owner's position where owner's front is facing positive z axis
+            relativePos.X = (float)(vec.X * Math.Cos(aoeTargetRotation) - vec.Z * Math.Sin(aoeTargetRotation));
+            relativePos.Z = (float)(vec.X * Math.Sin(aoeTargetRotation) + vec.Z * Math.Cos(aoeTargetRotation));
+
+            float halfHeight = height / 2;
+            float halfWidth = width / 2;
+
+            Vector3 closeBottomLeft = new Vector3(-halfWidth, -halfHeight, minDistance);
+            Vector3 farTopRight = new Vector3(halfWidth, halfHeight, maxDistance);
+
+            return relativePos.IsWithinBox(closeBottomLeft, farTopRight);
+        }
+
+        private bool IsWithinCone(Character target, bool withPet)
+        {
+            double distance = Utils.XZDistance(aoeTargetPosition, target.GetPosAsVector3());
+
+            //Make sure target is within the correct range first
+            if (!IsWithinCircle(target))
+                return false;
+
+            //This might not be 100% right or the most optimal way to do this
+            //Get between taget's position and our position
+            return target.GetPosAsVector3().IsWithinCone(aoeTargetPosition, aoeTargetRotation, coneAngle);
+        }
+
+        private void AddTarget(Character target, bool withPet)
+        {
+            if (CanTarget(target))
+            {
+                // todo: add pets too
+                targets.Add(target);
+            }
+        }
+
+        private void AddAllInParty(Character target, bool withPet)
+        {
+            var party = target.currentParty as Party;
+            if (party != null)
+            {
+                foreach (var actorId in party.members)
+                {
+                    AddTarget(owner.zone.FindActorInArea<Character>(actorId), withPet);
+                }
+            }
+        }
+
+        private void AddAllInAlliance(Character target, bool withPet)
+        {
+            // todo:
+            AddAllInParty(target, withPet);
+        }
+
+        private void AddAllBattleNpcs(Character target, bool withPet)
+        {
+            int dist = (int)maxDistance;
+            var actors = owner.zone.GetActorsAroundActor<BattleNpc>(target, dist);
+
+            foreach (BattleNpc actor in actors)
+            {
+                AddTarget(actor, false);
+            }
+        }
+
+        private void AddAllInZone(Character target, bool withPet)
+        {
+            var actors = owner.zone.GetAllActors<Character>();
+            foreach (Character actor in actors)
+            {
+                AddTarget(actor, withPet);
+            }
+        }
+
+        private void AddAllInRange(Character target, bool withPet)
+        {
+            int dist = (int)maxDistance;
+            var actors = owner.zone.GetActorsAroundActor<Character>(target, dist);
+
+            foreach (Character actor in actors)
+            {
+                AddTarget(actor, false);
+            }
+
+        }
+
+        private void AddAllInHateList()
+        {
+            if (!(owner is BattleNpc))
+            {
+                Program.Log.Error($"TargetFind.AddAllInHateList() owner [{owner.actorId}] {owner.customDisplayName} {owner.actorName} is not a BattleNpc");
+            }
+            else
+            {
+                foreach (var hateEntry in ((BattleNpc)owner).hateContainer.GetHateList())
+                {
+                    AddTarget(hateEntry.Value.actor, false);
+                }
+            }
+        }
+
+        public bool CanTarget(Character target, bool withPet = false, bool retarget = false, bool ignoreAOE = false)
+        {
+            // already targeted, dont target again
+            if (target == null || !retarget && targets.Contains(target))
+                return false;
+
+            if (target == null)
+                return false;
+
+            //This skill can't be used on a corpse and target is dead
+            if ((validTarget & ValidTarget.Corpse) == 0 && target.IsDead())
+                return false;
+
+            //This skill must be used on a corpse and target is alive
+            if ((validTarget & ValidTarget.CorpseOnly) != 0 && target.IsAlive())
+                return false;
+
+            //This skill can't be used on self and target is self
+            if ((validTarget & ValidTarget.Self) == 0 && target == owner)
+                return false;
+
+            //This skill must be used on self and target isn't self
+            if ((validTarget & ValidTarget.SelfOnly) != 0 && target != owner)
+                return false;
+
+            //This skill can't be used on an ally and target is an ally
+            if ((validTarget & ValidTarget.Ally) == 0 && target.allegiance == owner.allegiance)
+                return false;
+
+            //This skill must be used on an ally and target is not an ally
+            if ((validTarget & ValidTarget.AllyOnly) != 0 && target.allegiance != owner.allegiance)
+                return false;
+
+            //This skill can't be used on an enemu and target is an enemy
+            if ((validTarget & ValidTarget.Enemy) == 0 && target.allegiance != owner.allegiance)
+                return false;
+
+            //This skill must be used on an enemy and target is an ally
+            if ((validTarget & ValidTarget.EnemyOnly) != 0 && target.allegiance == owner.allegiance)
+                return false;
+
+            //This skill can't be used on party members and target is a party member
+            if ((validTarget & ValidTarget.Party) == 0 && target.currentParty == owner.currentParty)
+                return false;
+
+            //This skill must be used on party members and target is not a party member
+            if ((validTarget & ValidTarget.PartyOnly) != 0 && target.currentParty != owner.currentParty)
+                return false;
+
+            //This skill can't be used on NPCs and target is an npc
+            if ((validTarget & ValidTarget.NPC) == 0 && target.isStatic)
+                return false;
+
+            //This skill must be used on NPCs and target is not an npc
+            if ((validTarget & ValidTarget.NPCOnly) != 0 && !target.isStatic)
+                return false;
+
+            // todo: why is player always zoning?
+            // cant target if zoning
+            if (target is Player && ((Player)target).playerSession.isUpdatesLocked)
+            {
+                owner.aiContainer.ChangeTarget(null);
+                return false;
+            }
+
+            if (/*target.isZoning || owner.isZoning || */target.zone != owner.zone)
+                return false;
+
+            if (validTarget == ValidTarget.Self && aoeType == TargetFindAOEType.None && owner != target)
+                return false;
+
+            //This skill can't be used on main target's party members and target is a party member of main target
+            if ((validTarget & ValidTarget.MainTargetParty) == 0 && target.currentParty == mainTarget.currentParty)
+                return false;
+
+            //This skill must be used on main target's party members  and target is not a party member of main target
+            if ((validTarget & ValidTarget.MainTargetPartyOnly) != 0 && target.currentParty != mainTarget.currentParty)
+                return false;
+
+
+            // this is fuckin retarded, think of a better way l8r
+            if (!ignoreAOE)
+            {
+                // hit everything within zone or within aoe region
+                if (param == -1.0f || aoeType == TargetFindAOEType.Circle && !IsWithinCircle(target))
+                    return false;
+
+                if (aoeType == TargetFindAOEType.Cone && !IsWithinCone(target, withPet))
+                    return false;
+
+                if (aoeType == TargetFindAOEType.Box && !IsWithinBox(target, withPet))
+                    return false;
+
+                if (aoeType == TargetFindAOEType.None && targets.Count != 0)
+                    return false;
+            }
+            return true;
+        }
+
+        private bool IsWithinCircle(Character target)
+        {
+            //Check if XZ is in circle and that y difference isn't larger than half height
+            return target.GetPosAsVector3().IsWithinCircle(aoeTargetPosition, maxDistance, minDistance) && Math.Abs(owner.positionY - target.positionY) <= (height / 2);
+        }
+
+        private bool IsPlayer(Character target)
+        {
+            if (target is Player)
+                return true;
+
+            // treat player owned pets as players too
+            return TryGetMasterTarget(target) is Player;
+        }
+
+        private Character TryGetMasterTarget(Character target)
+        {
+            // if character is a player owned pet, treat as a player
+            if (target.aiContainer != null)
+            {
+                var controller = target.aiContainer.GetController<PetController>();
+                if (controller != null)
+                    return controller.GetPetMaster();
+            }
+            return null;
+        }
+
+        private bool IsBattleNpcOwner(Character target)
+        {
+            // i know i copied this from dsp but what even
+            if (!(owner is Player) || target is Player)
+                return true;
+
+            // todo: check hate list
+            if (owner is BattleNpc && ((BattleNpc)owner).hateContainer.GetMostHatedTarget() != target)
+            {
+                return false;
+            }
+            return false;
+        }
+
+        public Character GetValidTarget(Character target, ValidTarget findFlags)
+        {
+            if (target == null || target is Player && ((Player)target).playerSession.isUpdatesLocked)
+                return null;
+
+            if ((findFlags & ValidTarget.Ally) != 0)
+            {
+                return owner.pet;
+            }
+
+            // todo: this is beyond retarded
+            var oldFlags = this.validTarget;
+            this.validTarget = findFlags;
+            if (CanTarget(target, false, true))
+            {
+                this.validTarget = oldFlags;
+                return target;
+            }
+            this.validTarget = oldFlags;
+
+            return null;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/State/AbilityState.cs

@@ -0,0 +1,169 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using Meteor.Common;
+using Meteor.Map.Actors;
+using Meteor.Map.packets.send.actor.battle;
+
+namespace Meteor.Map.actors.chara.ai.state
+{
+    class AbilityState : State
+    {
+
+        private BattleCommand skill;
+
+        public AbilityState(Character owner, Character target, ushort skillId) :
+            base(owner, target)
+        {
+            this.startTime = DateTime.Now;
+            this.skill = Server.GetWorldManager().GetBattleCommand(skillId);
+            var returnCode = skill.CallLuaFunction(owner, "onAbilityPrepare", owner, target, skill);
+
+            this.target = (skill.mainTarget & ValidTarget.SelfOnly) != 0 ? owner : target;
+
+            errorResult = new CommandResult(owner.actorId, 32553, 0);
+            if (returnCode == 0)
+            {
+                OnStart();
+            }
+            else
+            {
+                errorResult = null;
+                interrupt = true;
+            }
+        }
+
+        public override void OnStart()
+        {
+            var returnCode = skill.CallLuaFunction(owner, "onAbilityStart", owner, target, skill);
+
+            if (returnCode != 0)
+            {
+                interrupt = true;
+                errorResult = new CommandResult(owner.actorId, (ushort)(returnCode == -1 ? 32558 : returnCode), 0);
+            }
+            else
+            {
+                if (!skill.IsInstantCast())
+                {
+                    float castTime = skill.castTimeMs;
+
+                    // command casting duration
+                    if (owner is Player)
+                    {
+                        // todo: modify spellSpeed based on modifiers and stuff
+                        ((Player)owner).SendStartCastbar(skill.id, Utils.UnixTimeStampUTC(DateTime.Now.AddMilliseconds(castTime)));
+                    }
+                    owner.GetSubState().chantId = 0xf0;
+                    owner.SubstateModified();
+                    //You ready [skill] (6F000002: BLM, 6F000003: WHM, 0x6F000008: BRD)
+                    owner.DoBattleAction(skill.id, (uint)0x6F000000 | skill.castType, new CommandResult(target.actorId, 30126, 1, 0, 1));
+                }
+            }
+        }
+
+        public override bool Update(DateTime tick)
+        {
+            if (skill != null)
+            {
+                TryInterrupt();
+
+                if (interrupt)
+                {
+                    OnInterrupt();
+                    return true;
+                }
+
+                // todo: check weapon delay/haste etc and use that
+                var actualCastTime = skill.castTimeMs;
+
+                if ((tick - startTime).TotalMilliseconds >= skill.castTimeMs)
+                {
+                    OnComplete();
+                    return true;
+                }
+                return false;
+            }
+            return true;
+        }
+
+        public override void OnInterrupt()
+        {
+            // todo: send paralyzed/sleep message etc.
+            if (errorResult != null)
+            {
+                owner.DoBattleAction(skill.id, errorResult.animation, errorResult);
+                errorResult = null;
+            }
+        }
+
+        public override void OnComplete()
+        {
+            owner.LookAt(target);
+            bool hitTarget = false;
+
+            skill.targetFind.FindWithinArea(target, skill.validTarget, skill.aoeTarget);
+            isCompleted = true;
+
+            owner.DoBattleCommand(skill, "ability");
+        }
+
+        public override void TryInterrupt()
+        {
+            if (interrupt)
+                return;
+
+            if (owner.statusEffects.HasStatusEffectsByFlag((uint)StatusEffectFlags.PreventAbility))
+            {
+                // todo: sometimes paralyze can let you attack, get random percentage of actually letting you attack
+                var list = owner.statusEffects.GetStatusEffectsByFlag((uint)StatusEffectFlags.PreventAbility);
+                uint effectId = 0;
+                if (list.Count > 0)
+                {
+                    // todo: actually check proc rate/random chance of whatever effect
+                    effectId = list[0].GetStatusEffectId();
+                }
+                interrupt = true;
+                return;
+            }
+
+            interrupt = !CanUse();
+        }
+
+        private bool CanUse()
+        {
+            return skill.IsValidMainTarget(owner, target);
+        }
+
+        public BattleCommand GetWeaponSkill()
+        {
+            return skill;
+        }
+
+        public override void Cleanup()
+        {
+            owner.GetSubState().chantId = 0x0;
+            owner.SubstateModified();
+            owner.aiContainer.UpdateLastActionTime(skill.animationDurationSeconds);
+        }
+    }
+}

Map Server/Actors/Chara/Ai/State/AttackState.cs

@@ -0,0 +1,232 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using Meteor.Common;
+using Meteor.Map.Actors;
+using Meteor.Map.packets.send.actor;
+using Meteor.Map.packets.send.actor.battle;
+namespace Meteor.Map.actors.chara.ai.state
+{
+    class AttackState : State
+    {
+        private DateTime attackTime;
+
+        public AttackState(Character owner, Character target) :
+            base(owner, target)
+        {
+            this.canInterrupt = false;
+            this.startTime = DateTime.Now;
+
+            owner.ChangeState(SetActorStatePacket.MAIN_STATE_ACTIVE);
+            ChangeTarget(target);
+            attackTime = startTime;
+            owner.aiContainer.pathFind?.Clear();
+        }
+
+        public override void OnStart()
+        {
+
+        }
+
+        public override bool Update(DateTime tick)
+        {
+            if ((target == null || owner.target != target || owner.target?.actorId != owner.currentLockedTarget) && owner.isAutoAttackEnabled)
+                owner.aiContainer.ChangeTarget(target = owner.zone.FindActorInArea<Character>(owner.currentTarget));
+
+            if (target == null || target.IsDead())
+            {
+                if (owner.IsMonster() || owner.IsAlly())
+                    target = ((BattleNpc)owner).hateContainer.GetMostHatedTarget();
+            }
+            else
+            {
+                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
+                    }
+                    attackTime = DateTime.Now.AddMilliseconds(owner.GetAttackDelayMs());
+                }
+            }
+            return false;
+        }
+
+        public override void OnInterrupt()
+        {
+            // todo: send paralyzed/sleep message etc.
+            if (errorResult != null)
+            {
+                owner.zone.BroadcastPacketAroundActor(owner, CommandResultX01Packet.BuildPacket(errorResult.targetId, errorResult.animation, 0x765D, errorResult));
+                errorResult = null;
+            }
+        }
+
+        public override void OnComplete()
+        {
+            //BattleAction action = new BattleAction(target.actorId, 0x765D, (uint) HitEffect.Hit, 0, (byte) HitDirection.None);
+            errorResult = null;
+
+            // todo: implement auto attack damage bonus in Character.OnAttack
+            /*
+              ≪Auto-attack Damage Bonus≫
+              Class        Bonus 1       Bonus 2
+              Pugilist     Intelligence  Strength
+              Gladiator    Mind          Strength
+              Marauder     Vitality      Strength
+              Archer       Dexterity     Piety
+              Lancer       Piety         Strength
+              Conjurer     Mind          Piety
+              Thaumaturge  Mind          Piety
+              * The above damage bonus also applies to “Shot” attacks by archers.
+             */
+            // handle paralyze/intimidate/sleep/whatever in Character.OnAttack
+
+
+            // todo: Change this to use a BattleCommand like the other states
+
+            //List<BattleAction> actions = new List<BattleAction>();
+            CommandResultContainer actions = new CommandResultContainer();
+
+            //This is all temporary until the skill sheet is finishd and the different auto attacks are added to the database
+            //Some mobs have multiple unique auto attacks that they switch between as well as ranged auto attacks, so we'll need a way to handle that
+            //For now, just use a temporary hardcoded BattleCommand that's the same for everyone.
+            BattleCommand attackCommand = new BattleCommand(22104, "Attack");
+            attackCommand.range = 5;
+            attackCommand.rangeHeight = 10;
+            attackCommand.worldMasterTextId = 0x765D;
+            attackCommand.mainTarget = (ValidTarget)768;
+            attackCommand.validTarget = (ValidTarget)17152;
+            attackCommand.commandType = CommandType.AutoAttack;
+            attackCommand.numHits = (byte)owner.GetMod(Modifier.HitCount);
+            attackCommand.basePotency = 100;
+            ActionProperty property = (owner.GetMod(Modifier.AttackType) != 0) ? (ActionProperty)owner.GetMod(Modifier.AttackType) : ActionProperty.Slashing;
+            attackCommand.actionProperty = property;
+            attackCommand.actionType = ActionType.Physical;
+
+            uint anim = (17 << 24 | 1 << 12);
+
+            if (owner is Player)
+                anim = (25 << 24 | 1 << 12);
+
+            attackCommand.battleAnimation = anim;
+
+            if (owner.CanUse(target, attackCommand))
+            {
+                attackCommand.targetFind.FindWithinArea(target, attackCommand.validTarget, attackCommand.aoeTarget);
+                owner.DoBattleCommand(attackCommand, "autoattack");
+            }
+        }
+
+        public override void TryInterrupt()
+        {
+            if (owner.statusEffects.HasStatusEffectsByFlag((uint)StatusEffectFlags.PreventAttack))
+            {
+                // todo: sometimes paralyze can let you attack, calculate proc rate
+                var list = owner.statusEffects.GetStatusEffectsByFlag((uint)StatusEffectFlags.PreventAttack);
+                uint statusId = 0;
+                if (list.Count > 0)
+                {
+                    statusId = list[0].GetStatusId();
+                }
+                interrupt = true;
+                return;
+            }
+
+            interrupt = !CanAttack();
+        }
+
+        private bool IsAttackReady()
+        {
+            // todo: this enforced delay should really be changed if it's not retail..
+            return Program.Tick >= attackTime && Program.Tick >= owner.aiContainer.GetLastActionTime();
+        }
+
+        private bool CanAttack()
+        {
+            if (!owner.isAutoAttackEnabled || target.allegiance == owner.allegiance)
+            {
+                return false;
+            }
+
+            if (target == null)
+            {
+                return false;
+            }
+
+            if (!owner.IsFacing(target))
+            {
+                return false;
+            }
+            // todo: shouldnt need to check if owner is dead since all states would be cleared
+            if (owner.IsDead() || target.IsDead())
+            {
+                if (owner.IsMonster() || owner.IsAlly())
+                    ((BattleNpc)owner).hateContainer.ClearHate(target);
+
+                owner.aiContainer.ChangeTarget(null);
+                return false;
+            }
+            else if (!owner.IsValidTarget(target, ValidTarget.Enemy) || !owner.aiContainer.GetTargetFind().CanTarget(target, false, true))
+            {
+                return false;
+            }
+            // todo: use a mod for melee range
+            else if (Utils.Distance(owner.positionX, owner.positionY, owner.positionZ, target.positionX, target.positionY, target.positionZ) > owner.GetAttackRange())
+            {
+                if (owner is Player)
+                {
+                    //The target is too far away
+                    ((Player)owner).SendGameMessage(Server.GetWorldManager().GetActor(), 32537, 0x20);
+                }
+                return false;
+            }
+            return true;
+        }
+
+        public override void Cleanup()
+        {
+            if (owner.IsDead())
+                owner.Disengage();
+        }
+
+        public override bool CanChangeState()
+        {
+            return true;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/State/DeathState.cs

@@ -0,0 +1,63 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using Meteor.Map.Actors;
+using Meteor.Map.packets.send.actor;
+
+namespace Meteor.Map.actors.chara.ai.state
+{
+    class DeathState : State
+    {
+        DateTime despawnTime;
+        public DeathState(Character owner, DateTime tick, uint timeToFadeOut) 
+            : base(owner, null)
+        {
+            owner.Disengage();
+            owner.ChangeState(SetActorStatePacket.MAIN_STATE_DEAD);
+            owner.statusEffects.RemoveStatusEffectsByFlags((uint)StatusEffectFlags.LoseOnDeath);
+            //var deathStatePacket = SetActorStatePacket.BuildPacket(owner.actorId, SetActorStatePacket.MAIN_STATE_DEAD2, owner.currentSubState);
+            //owner.zone.BroadcastPacketAroundActor(owner, deathStatePacket);
+            canInterrupt = false;
+            startTime = tick;
+            despawnTime = startTime.AddSeconds(timeToFadeOut);
+        }
+
+        public override bool Update(DateTime tick)
+        {
+            // todo: set a flag on chara for accept raise, play animation and spawn
+            if (owner.GetMod((uint)Modifier.Raise) > 0)
+            {
+                owner.Spawn(tick);
+                return true;
+            }
+
+            // todo: handle raise etc
+            if (tick >= despawnTime)
+            {
+                // todo: for players, return them to homepoint
+                owner.Despawn(tick);
+                return true;
+            }
+            return false;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/State/DespawnState.cs

@@ -0,0 +1,51 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using Meteor.Map.Actors;
+using Meteor.Map.packets.send.actor;
+
+namespace Meteor.Map.actors.chara.ai.state
+{
+    class DespawnState : State
+    {
+        private DateTime respawnTime;
+        public DespawnState(Character owner, uint respawnTimeSeconds) :
+            base(owner, null)
+        {
+            startTime = Program.Tick;
+            respawnTime = startTime.AddSeconds(respawnTimeSeconds);
+            owner.ChangeState(SetActorStatePacket.MAIN_STATE_DEAD2);
+            owner.OnDespawn();
+        }
+
+        public override bool Update(DateTime tick)
+        {
+            if (tick >= respawnTime)
+            {
+                owner.ResetTempVars();
+                owner.Spawn(tick);
+                return true;
+            }
+            return false;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/State/InactiveState.cs

@@ -0,0 +1,59 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using Meteor.Map.Actors;
+
+namespace Meteor.Map.actors.chara.ai.state
+{
+    class InactiveState : State
+    {
+        private DateTime endTime;
+        private uint durationMs;
+        public InactiveState(Character owner, uint durationMs, bool canChangeState) :
+            base(owner, null)
+        {
+            if (!canChangeState)
+                owner.aiContainer.InterruptStates();
+            this.durationMs = durationMs;
+            endTime = DateTime.Now.AddMilliseconds(durationMs);
+        }
+
+        public override bool Update(DateTime tick)
+        {
+            if (durationMs == 0)
+            {
+                if (owner.IsDead())
+                    return true;
+
+                if (!owner.statusEffects.HasStatusEffectsByFlag(StatusEffectFlags.PreventMovement))
+                    return true;
+            }
+
+            if (durationMs != 0 && tick > endTime)
+            {
+                return true;
+            }
+
+            return false;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/State/ItemState.cs

@@ -0,0 +1,38 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using Meteor.Map.Actors;
+using Meteor.Map.dataobjects;
+
+namespace Meteor.Map.actors.chara.ai.state
+{
+    class ItemState : State
+    {
+        ItemData item;
+        new Player owner;
+        public ItemState(Player owner, Character target, ushort slot, uint itemId) :
+            base(owner, target)
+        {
+            this.owner = owner;
+            this.target = target;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/State/MagicState.cs

@@ -0,0 +1,213 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using System.Collections.Generic;
+using Meteor.Common;
+using Meteor.Map.Actors;
+using Meteor.Map.packets.send.actor.battle;
+
+namespace Meteor.Map.actors.chara.ai.state
+{
+    class MagicState : State
+    {
+
+        private BattleCommand spell;
+        private Vector3 startPos;
+
+        public MagicState(Character owner, Character target, ushort spellId) :
+            base(owner, target)
+        {
+            this.startPos = owner.GetPosAsVector3();
+            this.startTime = DateTime.Now;
+            this.spell = Server.GetWorldManager().GetBattleCommand(spellId);
+            var returnCode = spell.CallLuaFunction(owner, "onMagicPrepare", owner, target, spell);
+
+            //modify skill based on status effects
+            //Do this here to allow buffs like Resonance to increase range before checking CanCast()
+            owner.statusEffects.CallLuaFunctionByFlag((uint)StatusEffectFlags.ActivateOnCastStart, "onMagicCast", owner, spell);
+
+            this.target = (spell.mainTarget & ValidTarget.SelfOnly) != 0 ? owner : target;
+
+            errorResult = new CommandResult(owner.actorId, 32553, 0);
+            if (returnCode == 0 && owner.CanUse(this.target, spell, errorResult))
+            {
+                OnStart();
+            }
+            else
+            {
+                interrupt = true;
+            }
+        }
+
+        public override void OnStart()
+        {
+            var returnCode = spell.CallLuaFunction(owner, "onMagicStart", owner, target, spell);
+
+            if (returnCode != 0)
+            {
+                interrupt = true;
+                errorResult = new CommandResult(target.actorId, (ushort)(returnCode == -1 ? 32553 : returnCode), 0, 0, 0, 1);
+            }
+            else
+            {
+                // todo: check within attack range
+                float[] baseCastDuration = { 1.0f, 0.25f };
+
+                //There are no positional spells, so just check onCombo, need to check first because certain spells change aoe type/accuracy
+                //If owner is a player and the spell being used is part of the current combo
+                if (owner is Player && ((Player)owner).GetClass() == spell.job)
+                {
+                    Player p = (Player)owner;
+                    if (spell.comboStep == 1 || ((p.playerWork.comboNextCommandId[0] == spell.id || p.playerWork.comboNextCommandId[1] == spell.id)))
+                    {
+                        spell.CallLuaFunction(owner, "onCombo", owner, target, spell);
+                        spell.isCombo = true;
+                    }
+                }
+
+                //Check combo stuff here because combos can impact spell cast times
+
+                float spellSpeed = spell.castTimeMs;
+
+                if (!spell.IsInstantCast())
+                {
+                // command casting duration
+                    if (owner is Player)
+                    {
+                        // todo: modify spellSpeed based on modifiers and stuff
+                        ((Player)owner).SendStartCastbar(spell.id, Utils.UnixTimeStampUTC(DateTime.Now.AddMilliseconds(spellSpeed)));
+                    }
+                    owner.GetSubState().chantId = 0xf0;
+                    owner.SubstateModified();
+                    owner.DoBattleAction(spell.id, (uint) 0x6F000000 | spell.castType, new CommandResult(target.actorId, 30128, 1, 0, 1)); //You begin casting (6F000002: BLM, 6F000003: WHM, 0x6F000008: BRD)
+                }
+            }
+        }
+
+        public override bool Update(DateTime tick)
+        {
+            if (spell != null)
+            {
+                TryInterrupt();
+
+                if (interrupt)
+                {
+                    OnInterrupt();
+                    return true;
+                }
+
+                // todo: check weapon delay/haste etc and use that
+                var actualCastTime = spell.castTimeMs;
+
+                if ((tick - startTime).TotalMilliseconds >= spell.castTimeMs)
+                {
+                    OnComplete();
+                    return true;
+                }
+                return false;
+            }
+            return true;
+        }
+
+        public override void OnInterrupt()
+        {
+            // todo: send paralyzed/sleep message etc.
+            if (errorResult != null)
+            {
+                owner.GetSubState().chantId = 0x0;
+                owner.SubstateModified();
+                owner.DoBattleAction(spell.id, errorResult.animation, errorResult);
+                errorResult = null;
+            }
+        }
+
+        public override void OnComplete()
+        {
+            //How do combos/hitdirs work for aoe abilities or does that not matter for aoe?
+            HitDirection hitDir = owner.GetHitDirection(target);
+            bool hitTarget = false;
+
+            spell.targetFind.FindWithinArea(target, spell.validTarget, spell.aoeTarget);
+            isCompleted = true;
+            var targets = spell.targetFind.GetTargets();
+
+            owner.DoBattleCommand(spell, "magic");
+        }
+
+        public override void TryInterrupt()
+        {
+            if (interrupt)
+                return;
+
+            if (owner.statusEffects.HasStatusEffectsByFlag((uint)StatusEffectFlags.PreventSpell))
+            {
+                // todo: sometimes paralyze can let you attack, get random percentage of actually letting you attack
+                var list = owner.statusEffects.GetStatusEffectsByFlag((uint)StatusEffectFlags.PreventSpell);
+                uint effectId = 0;
+                if (list.Count > 0)
+                {
+                    // todo: actually check proc rate/random chance of whatever effect
+                    effectId = list[0].GetStatusEffectId();
+                }
+                interrupt = true;
+                return;
+            }
+
+            if (HasMoved())
+            {
+                errorResult = new CommandResult(owner.actorId, 30211, 0);
+                errorResult.animation = 0x7F000002;
+                interrupt = true;
+                return;
+            }
+
+            interrupt = !CanCast();
+        }
+
+        private bool CanCast()
+        {
+            return owner.CanUse(target, spell);
+        }
+
+        private bool HasMoved()
+        {
+            return (owner.GetPosAsVector3() != startPos);
+        }
+
+        public override void Cleanup()
+        {
+            owner.GetSubState().chantId = 0x0;
+            owner.SubstateModified();
+
+            if (owner is Player)
+            {
+                ((Player)owner).SendEndCastbar();
+            }
+            owner.aiContainer.UpdateLastActionTime(spell.animationDurationSeconds);
+        }
+
+        public BattleCommand GetSpell()
+        {
+            return spell;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/State/State.cs

@@ -0,0 +1,85 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using Meteor.Map.Actors;
+using Meteor.Map.packets.send.actor.battle;
+
+namespace Meteor.Map.actors.chara.ai.state
+{
+    class State
+    {
+        protected Character owner;
+        protected Character target;
+
+        protected bool canInterrupt;
+        protected bool interrupt = false;
+
+        protected DateTime startTime;
+
+        protected CommandResult errorResult;
+
+        protected bool isCompleted;
+
+        public State(Character owner, Character target)
+        {
+            this.owner = owner;
+            this.target = target;
+            this.canInterrupt = true;
+            this.interrupt = false;
+        }
+
+        public virtual bool Update(DateTime tick) { return true; }
+        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() { }
+
+        public bool CanInterrupt()
+        {
+            return canInterrupt;
+        }
+
+        public void SetInterrupted(bool interrupt)
+        {
+            this.interrupt = interrupt;
+        }
+
+        public bool IsCompleted()
+        {
+            return isCompleted;
+        }
+
+        public void ChangeTarget(Character target)
+        {
+            this.target = target;
+        }
+
+        public Character GetTarget()
+        {
+            return target;
+        }
+
+    }
+}

Map Server/Actors/Chara/Ai/State/WeaponSkillState.cs

@@ -0,0 +1,199 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using Meteor.Common;
+using Meteor.Map.Actors;
+using Meteor.Map.packets.send.actor.battle;
+
+namespace Meteor.Map.actors.chara.ai.state
+{
+    class WeaponSkillState : State
+    {
+
+        private BattleCommand skill;
+        private HitDirection hitDirection;
+        public WeaponSkillState(Character owner, Character target, ushort skillId) :
+            base(owner, target)
+        {
+            this.startTime = DateTime.Now;
+            this.skill = Server.GetWorldManager().GetBattleCommand(skillId);
+
+            var returnCode = skill.CallLuaFunction(owner, "onSkillPrepare", owner, target, skill);
+
+            this.target = (skill.mainTarget & ValidTarget.SelfOnly) != 0 ? owner : target;
+
+            errorResult = new CommandResult(owner.actorId, 32553, 0);
+            if (returnCode == 0 && owner.CanUse(this.target, skill, errorResult))
+            {
+                OnStart();
+            }
+            else
+            {
+                errorResult = null;
+                interrupt = true;
+            }
+        }
+
+        public override void OnStart()
+        {
+            var returnCode = skill.CallLuaFunction(owner, "onSkillStart", owner, target, skill);
+
+            if (returnCode != 0)
+            {
+                interrupt = true;
+                errorResult = new CommandResult(owner.actorId, (ushort)(returnCode == -1 ? 32558 : returnCode), 0);
+            }
+            else
+            {
+                hitDirection = owner.GetHitDirection(target);
+
+                //Do positionals and combo effects first because these can influence accuracy and amount of targets/numhits, which influence the rest of the steps
+                //If there is no positon required or if the position bonus should be activated
+                if ((skill.positionBonus & utils.BattleUtils.ConvertHitDirToPosition(hitDirection)) == skill.positionBonus)
+                {
+                    //If there is a position bonus
+                    if (skill.positionBonus != BattleCommandPositionBonus.None)
+                        skill.CallLuaFunction(owner, "weaponskill", "onPositional", owner, target, skill);
+
+                    //Combo stuff
+                    if (owner is Player)
+                    {
+                        Player p = (Player)owner;
+                        //If skill is part of owner's class/job, it can be used in a combo
+                        if (skill.job == p.GetClass() || skill.job == p.GetCurrentClassOrJob())
+                        {
+                            //If owner is a player and the skill being used is part of the current combo
+                            if (p.playerWork.comboNextCommandId[0] == skill.id || p.playerWork.comboNextCommandId[1] == skill.id)
+                            {
+                                skill.CallLuaFunction(owner, "onCombo", owner, target, skill);
+                                skill.isCombo = true;
+                            }
+                            //or if this just the start of a combo
+                            else if (skill.comboStep == 1)
+                                skill.isCombo = true;
+                        }
+                    }
+
+                    if (!skill.IsInstantCast())
+                    {
+                        float castTime = skill.castTimeMs;
+
+                        // command casting duration
+                        if (owner is Player)
+                        {
+                            // todo: modify spellSpeed based on modifiers and stuff
+                            ((Player)owner).SendStartCastbar(skill.id, Utils.UnixTimeStampUTC(DateTime.Now.AddMilliseconds(castTime)));
+                        }
+                        owner.GetSubState().chantId = 0xf0;
+                        owner.SubstateModified();
+                        //You ready [skill] (6F000002: BLM, 6F000003: WHM, 0x6F000008: BRD)
+                        owner.DoBattleAction(skill.id, (uint)0x6F000000 | skill.castType, new CommandResult(target.actorId, 30126, 1, 0, 1));
+                    }
+                }
+            }
+        }
+
+        public override bool Update(DateTime tick)
+        {
+            if (skill != null)
+            {
+                TryInterrupt();
+
+                if (interrupt)
+                {
+                    OnInterrupt();
+                    return true;
+                }
+
+                // todo: check weapon delay/haste etc and use that
+                var actualCastTime = skill.castTimeMs;
+
+                if ((tick - startTime).TotalMilliseconds >= skill.castTimeMs)
+                {
+                    OnComplete();
+                    return true;
+                }
+                return false;
+            }
+            return true;
+        }
+
+        public override void OnInterrupt()
+        {
+            // todo: send paralyzed/sleep message etc.
+            if (errorResult != null)
+            {
+                owner.DoBattleAction(skill.id, errorResult.animation, errorResult);
+                errorResult = null;
+            }
+        }
+
+        public override void OnComplete()
+        {
+            owner.LookAt(target);
+            skill.targetFind.FindWithinArea(target, skill.validTarget, skill.aoeTarget);
+            isCompleted = true;
+
+            owner.DoBattleCommand(skill, "weaponskill");
+            owner.statusEffects.RemoveStatusEffectsByFlags((uint) StatusEffectFlags.LoseOnAttacking);
+
+            lua.LuaEngine.GetInstance().OnSignal("weaponskillUsed");
+        }
+
+        public override void TryInterrupt()
+        {
+            if (interrupt)
+                return;
+
+            if (owner.statusEffects.HasStatusEffectsByFlag((uint)StatusEffectFlags.PreventWeaponSkill))
+            {
+                // todo: sometimes paralyze can let you attack, get random percentage of actually letting you attack
+                var list = owner.statusEffects.GetStatusEffectsByFlag((uint)StatusEffectFlags.PreventWeaponSkill);
+                uint effectId = 0;
+                if (list.Count > 0)
+                {
+                    // todo: actually check proc rate/random chance of whatever effect
+                    effectId = list[0].GetStatusEffectId();
+                }
+                interrupt = true;
+                return;
+            }
+
+            interrupt = !CanUse();
+        }
+
+        private bool CanUse()
+        {
+            return owner.CanUse(target, skill);
+        }
+
+        public BattleCommand GetWeaponSkill()
+        {
+            return skill;
+        }
+
+        public override void Cleanup()
+        {
+            owner.aiContainer.UpdateLastActionTime(skill.animationDurationSeconds);
+        }
+    }
+}

Map Server/Actors/Chara/Ai/StatusEffect.cs

@@ -0,0 +1,723 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using Meteor.Map.Actors;
+using Meteor.Map.lua;
+using Meteor.Map.packets.send.actor.battle;
+using System;
+using MoonSharp.Interpreter;
+using Meteor.Common;
+
+namespace Meteor.Map.actors.chara.ai
+{
+    enum StatusEffectId : uint
+    {
+        RageofHalone = 221021,
+        
+        Quick = 223001,
+        Haste = 223002,
+        Slow = 223003,
+        Petrification = 223004,
+        Paralysis = 223005,
+        Silence = 223006,
+        Blind = 223007,
+        Mute = 223008,
+        Slowcast = 223009,
+        Glare = 223010,
+        Poison = 223011,
+        Transfixion = 223012,
+        Pacification = 223013,
+        Amnesia = 223014,
+        Stun = 223015,
+        Daze = 223016,
+        ExposedFront = 223017,
+        ExposedRight = 223018,
+        ExposedRear = 223019,
+        ExposedLeft = 223020,
+        Incapacitation = 223021,
+        Incapacitation2 = 223022,
+        Incapacitation3 = 223023,
+        Incapacitation4 = 223024,
+        Incapacitation5 = 223025,
+        Incapacitation6 = 223026,
+        Incapacitation7 = 223027,
+        Incapacitation8 = 223028,
+        HPBoost = 223029,
+        HPPenalty = 223030,
+        MPBoost = 223031,
+        MPPenalty = 223032,
+        AttackUp = 223033,
+        AttackDown = 223034,
+        AccuracyUp = 223035,
+        AccuracyDown = 223036,
+        DefenseUp = 223037,
+        DefenseDown = 223038,
+        EvasionUp = 223039,
+        EvasionDown = 223040,
+        MagicPotencyUp = 223041,
+        MagicPotencyDown = 223042,
+        MagicAccuracyUp = 223043,
+        MagicAccuracyDown = 223044,
+        MagicDefenseUp = 223045,
+        MagicDefenseDown = 223046,
+        MagicResistanceUp = 223047,
+        MagicResistanceDown = 223048,
+        CombatFinesse = 223049,
+        CombatHindrance = 223050,
+        MagicFinesse = 223051,
+        MagicHindrance = 223052,
+        CombatResilience = 223053,
+        CombatVulnerability = 223054,
+        MagicVulnerability = 223055,
+        MagicResilience = 223056,
+        Inhibited = 223057,
+        AegisBoon = 223058,
+        Deflection = 223059,
+        Outmaneuver = 223060,
+        Provoked = 223061,
+        Sentinel = 223062,
+        Cover = 223063,
+        Rampart = 223064,
+        StillPrecision = 223065,
+        Cadence = 223066,
+        DiscerningEye = 223067,
+        TemperedWill = 223068,
+        Obsess = 223069,
+        Ambidexterity = 223070,
+        BattleCalm = 223071,
+        MasterofArms = 223072,
+        Taunted = 223073,
+        Blindside = 223074,
+        Featherfoot = 223075,
+        PresenceofMind = 223076,
+        CoeurlStep = 223077,
+        EnduringMarch = 223078,
+        MurderousIntent = 223079,
+        Entrench = 223080,
+        Bloodbath = 223081,
+        Retaliation = 223082,
+        Foresight = 223083,
+        Defender = 223084,
+        Rampage = 223085,           //old effect
+        Enraged = 223086,
+        Warmonger = 223087,
+        Disorientx1 = 223088,
+        Disorientx2 = 223089,
+        Disorientx3 = 223090,
+        KeenFlurry = 223091,
+        ComradeinArms = 223092,
+        Ferocity = 223093,
+        Invigorate = 223094,
+        LineofFire = 223095,
+        Jump = 223096,
+        Collusion = 223097,
+        Diversion = 223098,
+        SpeedSurge = 223099,
+        LifeSurge = 223100,
+        SpeedSap = 223101,
+        LifeSap = 223102,
+        Farshot = 223103,
+        QuellingStrike = 223104,
+        RagingStrike = 223105,      //old effect
+        HawksEye = 223106,
+        SubtleRelease = 223107,
+        Decoy = 223108,             //Untraited
+        Profundity = 223109,
+        TranceChant = 223110,
+        RoamingSoul = 223111,
+        Purge = 223112,
+        Spiritsong = 223113,
+        Resonance = 223114,         //Old Resonance? Both have the same icons and description
+        Soughspeak = 223115,
+        PresenceofMind2 = 223116,
+        SanguineRite = 223117,      //old effect
+        PunishingBarbs = 223118,
+        DarkSeal = 223119,          //old effect
+        Emulate = 223120,
+        ParadigmShift = 223121,
+        ConcussiveBlowx1 = 223123,
+        ConcussiveBlowx2 = 223124,
+        ConcussiveBlowx3 = 223125,
+        SkullSunder = 223126,
+        Bloodletter = 223127,       //comboed effect
+        Levinbolt = 223128,
+        Protect = 223129,           //untraited protect
+        Shell = 223130,             //old shell
+        Reraise = 223131,
+        ShockSpikes = 223132,
+        Stoneskin = 223133,
+        Scourge = 223134,
+        Bio = 223135,
+        Dia = 223136,
+        Banish = 223137,
+        StygianSpikes = 223138,
+        ATKAbsorbed = 223139,
+        DEFAbsorbed = 223140,
+        ACCAbsorbed = 223141,
+        EVAAbsorbed = 223142,
+        AbsorbATK = 223143,
+        AbsorbDEF = 223144,
+        AbsorbACC = 223145,
+        AbsorbEVA = 223146,
+        SoulWard = 223147,
+        Burn = 223148,
+        Frost = 223149,
+        Shock = 223150,
+        Drown = 223151,
+        Choke = 223152,
+        Rasp = 223153,
+        Flare = 223154,
+        Freeze = 223155,
+        Burst = 223156,
+        Flood = 223157,
+        Tornado = 223158,
+        Quake = 223159,
+        Berserk = 223160,
+        RegimenofRuin = 223161,
+        RegimenofTrauma = 223162,
+        RegimenofDespair = 223163,
+        RegimenofConstraint = 223164,
+        Weakness = 223165,
+        Scavenge = 223166,
+        Fastcast = 223167,
+        MidnightHowl = 223168,
+        Outlast = 223169,
+        Steadfast = 223170,
+        DoubleNock = 223171,
+        TripleNock = 223172,
+        Covered = 223173,
+        PerfectDodge = 223174,
+        ExpertMining = 223175,
+        ExpertLogging = 223176,
+        ExpertHarvesting = 223177,
+        ExpertFishing = 223178,
+        ExpertSpearfishing = 223179,
+        Regen = 223180,
+        Refresh = 223181,
+        Regain = 223182,
+        TPBleed = 223183,
+        Empowered = 223184,
+        Imperiled = 223185,
+        Adept = 223186,
+        Inept = 223187,
+        Quick2 = 223188,
+        Quick3 = 223189,
+        WristFlick = 223190,
+        Glossolalia = 223191,
+        SonorousBlast = 223192,
+        Comradery = 223193,
+        StrengthinNumbers = 223194,
+
+        BrinkofDeath = 223197,
+        CraftersGrace = 223198,
+        GatherersGrace = 223199,
+        Rebirth = 223200,
+        Stealth = 223201,
+        StealthII = 223202,
+        StealthIII = 223203,
+        StealthIV = 223204,
+        Combo = 223205,
+        GoringBlade = 223206,
+        Berserk2 = 223207,              //new effect
+        Rampage2 = 223208,              //new effect
+        FistsofFire = 223209,
+        FistsofEarth = 223210,
+        FistsofWind = 223211,
+        PowerSurgeI = 223212,
+        PowerSurgeII = 223213,
+        PowerSurgeIII = 223214,
+        LifeSurgeI = 223215,
+        LifeSurgeII = 223216,
+        LifeSurgeIII = 223217,
+        DreadSpike = 223218,
+        BloodforBlood = 223219,
+        Barrage = 223220,
+        RagingStrike2 = 223221,
+
+        Swiftsong = 223224,
+        SacredPrism = 223225,
+        ShroudofSaints = 223226,
+        ClericStance = 223227,
+        BlissfulMind = 223228,
+        DarkSeal2 = 223229,         //new effect
+        Resonance2 = 223230,
+        Excruciate = 223231,
+        Necrogenesis = 223232,
+        Parsimony = 223233,
+        SanguineRite2 = 223234,     //untraited effect
+        Aero = 223235,
+        Outmaneuver2 = 223236,
+        Blindside2 = 223237,
+        Decoy2 = 223238,            //Traited
+        Protect2 = 223239,          //Traited
+        SanguineRite3 = 223240,     //Traited
+        Bloodletter2 = 223241,      //uncomboed effect
+        FullyBlissfulMind = 223242,
+        MagicEvasionDown = 223243,
+        HundredFists = 223244,
+        SpinningHeel = 223245,
+        DivineVeil = 223248,
+        HallowedGround = 223249,
+        Vengeance = 223250,
+        Antagonize = 223251,
+        MightyStrikes = 223252,
+        BattleVoice = 223253,
+        BalladofMagi = 223254,
+        PaeonofWar = 223255,
+        MinuetofRigor = 223256,
+        GoldLung = 223258,
+        Goldbile = 223259,
+        AurumVeil = 223260,
+        AurumVeilII = 223261,
+        Flare2 = 223262,
+        Resting = 223263,
+        DivineRegen = 223264,
+        DefenseAndEvasionUp = 223265,
+        MagicDefenseAndEvasionUp = 223266,
+        AttackUp2 = 223267,
+        MagicPotencyUp2 = 223268,
+        DefenseAndEvasionDown = 223269,
+        MagicDefenseAndEvasionDown = 223270,
+        Poison2 = 223271,
+        DeepBurn = 223272,
+        LunarCurtain = 223273,
+        DefenseUp2 = 223274,
+        AttackDown2 = 223275,
+        Sanction = 223992,
+        IntactPodlingToting = 223993,
+        RedRidingHooded = 223994,
+        Medicated = 223998,
+        WellFed = 223999,
+
+        Sleep = 228001,
+        Bind = 228011,
+        Fixation = 228012,
+        Bind2 = 228013,
+        Heavy = 228021,
+        Charm = 228031,
+        Flee = 228041,
+        Doom = 228051,
+        SynthesisSupport = 230001,
+        WoodyardAccess = 230002,
+        SmithsForgeAccess = 230003,
+        ArmorersForgeAccess = 230004,
+        GemmaryAccess = 230005,
+        TanneryAccess = 230006,
+        ClothshopAccess = 230007,
+        LaboratoryAccess = 230008,
+        CookeryAccess = 230009,
+        MinersSupport = 230010,
+        BotanistsSupport = 230011,
+        FishersSupport = 230012,
+        GearChange = 230013,
+        GearDamage = 230014,
+        HeavyGearDamage = 230015,
+        Lamed = 230016,
+        Lamed2 = 230017,
+        Lamed3 = 230018,
+        Poison3 = 231002,
+        Envenom = 231003,
+        Berserk4 = 231004,
+        GuardiansAspect = 253002,
+
+
+        // custom effects here
+        // status for having procs fall off
+        EvadeProc = 300000,
+        BlockProc = 300001,
+        ParryProc = 300002,
+        MissProc = 300003,
+        EXPChain = 300004
+    }
+
+    [Flags]
+    enum StatusEffectFlags : uint
+    {
+        None = 0,
+
+        //Loss flags - Do we need loseonattacking/caststart? Could just be done with activate flags
+        LoseOnDeath =                   1 << 0,     // effects removed on death
+        LoseOnZoning =                  1 << 1,     // effects removed on zoning
+        LoseOnEsuna =                   1 << 2,     // effects which can be removed with esuna (debuffs)
+        LoseOnDispel =                  1 << 3,     // some buffs which player might be able to dispel from mob
+        LoseOnLogout =                  1 << 4,     // effects removed on logging out
+        LoseOnAttacking =               1 << 5,     // effects removed when owner attacks another entity
+        LoseOnCastStart =               1 << 6,     // effects removed when owner starts casting
+        LoseOnAggro =                   1 << 7,     // effects removed when owner gains enmity (swiftsong)
+        LoseOnClassChange =             1 << 8,     //Effect falls off whhen changing class
+
+        //Activate flags
+        ActivateOnCastStart =           1 << 9,     //Activates when a cast starts.
+        ActivateOnCommandStart =        1 << 10,    //Activates when a command is used, before iterating over targets. Used for things like power surge, excruciate.
+        ActivateOnCommandFinish =       1 << 11,    //Activates when the command is finished, after all targets have been iterated over. Used for things like Excruciate and Resonance falling off.
+        ActivateOnPreactionTarget =     1 << 12,    //Activates after initial rates are calculated for an action against owner
+        ActivateOnPreactionCaster =     1 << 13,    //Activates after initial rates are calculated for an action by owner
+        ActivateOnDamageTaken =         1 << 14,
+        ActivateOnHealed =              1 << 15,
+
+        //Should these be rolled into DamageTaken?
+        ActivateOnMiss =                1 << 16,    //Activates when owner misses
+        ActivateOnEvade =               1 << 17,    //Activates when owner evades
+        ActivateOnParry =               1 << 18,    //Activates when owner parries
+        ActivateOnBlock =               1 << 19,    //Activates when owner evades
+        ActivateOnHit =                 1 << 20,    //Activates when owner hits
+        ActivateOnCrit =                1 << 21,    //Activates when owner crits
+
+        //Prevent flags. Sleep/stun/petrify/etc combine these
+        PreventSpell =                  1 << 22,    // effects which prevent using spells, such as silence
+        PreventWeaponSkill =            1 << 23,    // effects which prevent using weaponskills, such as pacification
+        PreventAbility =                1 << 24,    // effects which prevent using abilities, such as amnesia
+        PreventAttack =                 1 << 25,    // effects which prevent basic attacks
+        PreventMovement =               1 << 26,    // effects which prevent movement such as bind, still allows turning in place
+        PreventTurn =                   1 << 27,    // effects which prevent turning, such as stun
+        PreventUntarget =               1 << 28,    // effects which prevent changing targets, such as fixation
+        Stance =                        1 << 29     // effects that do not have a timer
+    }
+
+    enum StatusEffectOverwrite : byte
+    {
+        None,
+        Always,
+        GreaterOrEqualTo,
+        GreaterOnly,
+    }
+
+    class StatusEffect
+    {
+        // todo: probably use get;set;
+        private Character owner;
+        private Character source;
+        private StatusEffectId id;
+        private string name;                        // name of this effect
+        private DateTime startTime;                 // when was this effect added
+        private DateTime endTime;                   // when this status falls off
+        private DateTime lastTick;                  // when did this effect last tick
+        private uint duration;                      // how long should this effect last in seconds
+        private uint tickMs;                        // how often should this effect proc
+        private double magnitude;                   // a value specified by scripter which is guaranteed to be used by all effects
+        private byte tier;                          // same effect with higher tier overwrites this
+        private double extra;                       // optional value
+        private StatusEffectFlags flags;            // death/erase/dispel etc
+        private StatusEffectOverwrite overwrite;    // how to handle adding an effect with same id (see StatusEfectOverwrite)
+        private bool silentOnGain = false;          //Whether a message is sent when the status is gained
+        private bool silentOnLoss = false;          //Whether a message is sent when the status is lost
+        private bool hidden = false;                //Whether this status is shown. Used for things that aren't really status effects like exp chains and procs
+        private ushort statusGainTextId = 30328;    //The text id used when the status is gained. 30328: [Command] grants you the effect of [status] (Used for buffs)
+        private ushort statusLossTextId = 30331;    //The text id used when the status effect falls off when its time runs out. 30331: You are no longer under the effect of [status] (Used for buffs)
+        public LuaScript script;
+
+        HitEffect animationEffect;
+
+        public StatusEffect(Character owner, uint id, double magnitude, uint tickMs, uint duration, byte tier = 0)
+        {
+            this.owner = owner;
+            this.source = owner;
+            this.id = (StatusEffectId)id;
+            this.magnitude = magnitude;
+            this.tickMs = tickMs;
+            this.duration = duration;
+            this.tier = tier;
+
+            this.startTime = DateTime.Now;
+            this.lastTick = startTime;
+        }
+
+        public StatusEffect(Character owner, StatusEffect effect)
+        {
+            this.owner = owner;
+            this.source = owner;
+            this.id = effect.id;
+            this.magnitude = effect.magnitude;
+            this.tickMs = effect.tickMs;
+            this.duration = effect.duration;
+            this.tier = effect.tier;
+            this.startTime = effect.startTime;
+            this.lastTick = effect.lastTick;
+
+            this.name = effect.name;
+            this.flags = effect.flags;
+            this.overwrite = effect.overwrite;
+            this.statusGainTextId = effect.statusGainTextId;
+            this.statusLossTextId = effect.statusLossTextId;
+            this.extra = effect.extra;
+            this.script = effect.script;
+            this.silentOnGain = effect.silentOnGain;
+            this.silentOnLoss = effect.silentOnLoss;
+            this.hidden = effect.hidden;
+        }
+
+        public StatusEffect(uint id, string name, uint flags, uint overwrite, uint tickMs, bool hidden, bool silentOnGain, bool silentOnLoss, ushort statusGainTextId, ushort statusLossTextId)
+        {
+            this.id = (StatusEffectId)id;
+            this.name = name;
+            this.flags = (StatusEffectFlags)flags;
+            this.overwrite = (StatusEffectOverwrite)overwrite;
+            this.tickMs = tickMs;
+            this.hidden = hidden;
+            this.silentOnGain = silentOnGain;
+            this.silentOnLoss = silentOnLoss;
+            this.statusGainTextId = statusGainTextId;
+            this.statusLossTextId = statusLossTextId;
+        }
+
+        // return true when duration has elapsed
+        public bool Update(DateTime tick, CommandResultContainer resultContainer = null)
+        {
+            if (tickMs != 0 && (tick - lastTick).TotalMilliseconds >= tickMs)
+            {
+                lastTick = tick;
+                if (LuaEngine.CallLuaStatusEffectFunction(this.owner, this, "onTick", this.owner, this, resultContainer) > 0)
+                    return true;
+            }
+
+            if (duration >= 0 && tick >= endTime)
+            {
+                return true;
+            }
+            return false;
+        }
+
+        public int CallLuaFunction(Character chara, string functionName, params object[] args)
+        {
+
+            DynValue res = new DynValue();
+
+            return lua.LuaEngine.CallLuaStatusEffectFunction(chara, this, functionName, args);
+            if (!script.Globals.Get(functionName).IsNil())
+            {
+                res = script.Call(script.Globals.Get(functionName), args);
+                if (res != null)
+                    return (int)res.Number;
+            }
+
+        }
+
+        public Character GetOwner()
+        {
+            return owner;
+        }
+
+        public Character GetSource()
+        {
+            return source ?? owner;
+        }
+
+        public uint GetStatusEffectId()
+        {
+            return (uint)id;
+        }
+
+        public ushort GetStatusId()
+        {
+            return (ushort)(id - 200000);
+        }
+
+        public DateTime GetStartTime()
+        {
+            return startTime;
+        }
+
+        public DateTime GetEndTime()
+        {
+            return endTime;
+        }
+
+        public string GetName()
+        {
+            return name;
+        }
+
+        public uint GetDuration()
+        {
+            return duration;
+        }
+
+        public uint GetTickMs()
+        {
+            return tickMs;
+        }
+
+        public double GetMagnitude()
+        {
+            return magnitude;
+        }
+
+        public byte GetTier()
+        {
+            return tier;
+        }
+
+        public double GetExtra()
+        {
+            return extra;
+        }
+
+        public uint GetFlags()
+        {
+            return (uint)flags;
+        }
+
+        public byte GetOverwritable()
+        {
+            return (byte)overwrite;
+        }
+
+        public bool GetSilentOnGain()
+        {
+            return silentOnGain;
+        }
+
+        public bool GetSilentOnLoss()
+        {
+            return silentOnLoss;
+        }
+
+        public bool GetHidden()
+        {
+            return hidden;
+        }
+
+        public ushort GetStatusGainTextId()
+        {
+            return statusGainTextId;
+        }
+
+        public ushort GetStatusLossTextId()
+        {
+            return statusLossTextId;
+        }
+
+        public void SetStartTime(DateTime time)
+        {
+            this.startTime = time;
+            this.lastTick = time;
+        }
+
+        public void SetEndTime(DateTime time)
+        {
+            //If it's a stance, just set endtime to highest number possible for XIV
+            if ((flags & StatusEffectFlags.Stance) != 0)
+            {
+                endTime = Utils.UnixTimeStampToDateTime(4294967295);
+            }
+            else
+            {
+                endTime = time;
+            }
+        }
+
+        //Refresh the status, updating the end time based on the duration of the status and broadcasts the new time
+        public void RefreshTime()
+        {
+            endTime = DateTime.Now.AddSeconds(GetDuration());
+            int index = Array.IndexOf(owner.charaWork.status, GetStatusId());
+
+            if (index >= 0)
+                owner.statusEffects.SetTimeAtIndex(index, (uint) Utils.UnixTimeStampUTC(endTime));
+        }
+
+        public void SetOwner(Character owner)
+        {
+            this.owner = owner;
+        }
+
+        public void SetSource(Character source)
+        {
+            this.source = source;
+        }
+
+        public void SetName(string name)
+        {
+            this.name = name;
+        }
+
+        public void SetMagnitude(double magnitude)
+        {
+            this.magnitude = magnitude;
+        }
+
+        public void SetDuration(uint duration)
+        {
+            this.duration = duration;
+        }
+
+        public void SetTickMs(uint tickMs)
+        {
+            this.tickMs = tickMs;
+        }
+
+        public void SetTier(byte tier)
+        {
+            this.tier = tier;
+        }
+
+        public void SetExtra(double val)
+        {
+            this.extra = val;
+        }
+
+        public void SetFlags(uint flags)
+        {
+            this.flags = (StatusEffectFlags)flags;
+        }
+
+        public void SetOverwritable(byte overwrite)
+        {
+            this.overwrite = (StatusEffectOverwrite)overwrite;
+        }
+
+        public void SetSilentOnGain(bool silent)
+        {
+            this.silentOnGain = silent;
+        }
+
+        public void SetSilentOnLoss(bool silent)
+        {
+            this.silentOnLoss = silent;
+        }
+
+        public void SetHidden(bool hidden)
+        {
+            this.hidden = hidden;
+        }
+
+        public void SetStatusGainTextId(ushort textId)
+        {
+            this.statusGainTextId = textId;
+        }
+
+        public void SetStatusLossTextId(ushort textId)
+        {
+            this.statusLossTextId = textId;
+        }
+
+
+        public void SetAnimation(uint hitEffect)
+        {
+            animationEffect = (HitEffect)hitEffect;
+        }
+
+        public uint GetAnimation()
+        {
+            return (uint)animationEffect;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/StatusEffectContainer.cs

@@ -0,0 +1,445 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Meteor.Common;
+using Meteor.Map.Actors;
+using Meteor.Map.lua;
+using Meteor.Map.packets.send.actor;
+using Meteor.Map.packets.send.actor.battle;
+using Meteor.Map.utils;
+
+namespace Meteor.Map.actors.chara.ai
+{
+    class StatusEffectContainer
+    {
+        private Character owner;
+        private readonly Dictionary<uint, StatusEffect> effects;
+        public static readonly int MAX_EFFECTS = 20;
+        private bool sendUpdate = false;
+        private DateTime lastTick;// Do all effects tick at the same time like regen?
+        private List<SubPacket> statusSubpackets;
+        private ActorPropertyPacketUtil statusTimerPropPacketUtil;
+
+        public StatusEffectContainer(Character owner)
+        {
+            this.owner = owner;
+            this.effects = new Dictionary<uint, StatusEffect>();
+            statusSubpackets = new List<SubPacket>();
+            statusTimerPropPacketUtil = new ActorPropertyPacketUtil("charawork/Status", owner);
+        }
+
+        public void Update(DateTime tick)
+        {
+            CommandResultContainer resultContainer = new CommandResultContainer();
+
+            //Regen/Refresh/Regain effects tick every 3 seconds
+            if ((DateTime.Now - lastTick).Seconds >= 3)
+            {
+                RegenTick(tick, resultContainer);
+                lastTick = DateTime.Now;
+            }
+
+            // list of effects to remove
+            var removeEffects = new List<StatusEffect>();
+            var effectsList = effects.Values;
+            for (int i = effectsList.Count - 1; i >= 0; i--)
+            {
+                // effect's update function returns true if effect has completed
+                if (effectsList.ElementAt(i).Update(tick, resultContainer))
+                    removeEffects.Add(effectsList.ElementAt(i));
+            }
+
+            // remove effects from this list
+            foreach (var effect in removeEffects)
+            {
+                RemoveStatusEffect(effect, resultContainer, effect.GetStatusLossTextId());
+            }
+
+            resultContainer.CombineLists();
+
+            if (resultContainer.GetList().Count > 0)
+            {
+                owner.DoBattleAction(0, 0x7c000062, resultContainer.GetList());
+            }
+        }
+
+        //regen/refresh/regain
+        public void RegenTick(DateTime tick, CommandResultContainer resultContainer)
+        {
+            ushort dotTick = (ushort) owner.GetMod(Modifier.RegenDown);
+            ushort regenTick = (ushort) owner.GetMod(Modifier.Regen);
+            ushort refreshtick = (ushort) owner.GetMod(Modifier.Refresh);
+            short regainTick = (short) owner.GetMod(Modifier.Regain);
+
+            //DoTs tick before regen and the full dot damage is displayed, even if some or all of it is nullified by regen. Only effects like stoneskin actually alter the number shown
+            if (dotTick > 0)
+            {
+                //Unsure why 10105 is the textId used
+                //Also unsure why magicshield is used
+                CommandResult action = new CommandResult(owner.actorId, 10105, (uint)(HitEffect.MagicEffectType | HitEffect.MagicShield | HitEffect.NoResist), dotTick);
+                utils.BattleUtils.HandleStoneskin(owner, action);
+                // todo: figure out how to make red numbers appear for enemies getting hurt by dots
+                resultContainer.AddAction(action);
+                owner.DelHP(action.amount, resultContainer);
+            }
+
+            //DoTs are the only effect to show numbers, so that doesnt need to be handled for these
+            if (regenTick != 0)
+                owner.AddHP(regenTick);
+
+            if (refreshtick != 0)
+                owner.AddMP(refreshtick);
+
+            if (regainTick != 0)
+                owner.AddTP(regainTick);
+        }
+
+        public bool HasStatusEffect(uint id)
+        {
+            return effects.ContainsKey(id);
+        }
+
+        public bool HasStatusEffect(StatusEffectId id)
+        {
+            return effects.ContainsKey((uint)id);
+        }
+
+        public bool AddStatusEffect(uint id, CommandResultContainer actionContainer = null, ushort worldmasterTextId = 30328)
+        {
+            var se = Server.GetWorldManager().GetStatusEffect(id);
+
+            if (se != null)
+            {
+                worldmasterTextId = se.GetStatusGainTextId();
+            }
+
+            return AddStatusEffect(se, owner, actionContainer, worldmasterTextId);
+        }
+
+        public bool AddStatusEffect(uint id, byte tier, CommandResultContainer actionContainer = null, ushort worldmasterTextId = 30328)
+        {
+            var se = Server.GetWorldManager().GetStatusEffect(id);
+
+            if (se != null)
+            {
+                se.SetTier(tier);
+                worldmasterTextId = se.GetStatusGainTextId();
+            }
+
+            return AddStatusEffect(se, owner, actionContainer, worldmasterTextId);
+        }
+
+        public bool AddStatusEffect(uint id, byte tier, double magnitude, CommandResultContainer actionContainer = null, ushort worldmasterTextId = 30328)
+        {
+            var se = Server.GetWorldManager().GetStatusEffect(id);
+
+            if (se != null)
+            {
+                se.SetMagnitude(magnitude);
+                se.SetTier(tier);
+                worldmasterTextId = se.GetStatusGainTextId();
+            }
+
+            return AddStatusEffect(se, owner, actionContainer, worldmasterTextId);
+        }
+
+        public bool AddStatusEffect(uint id, byte tier, double magnitude, uint duration, int tickMs, CommandResultContainer actionContainer = null, ushort worldmasterTextId = 30328)
+        {
+            var se = Server.GetWorldManager().GetStatusEffect(id);
+
+            if (se != null)
+            {
+                se.SetDuration(duration);
+                se.SetOwner(owner);
+                worldmasterTextId = se.GetStatusGainTextId();
+            }
+            return AddStatusEffect(se ?? new StatusEffect(this.owner, id, magnitude, 3000, duration, tier), owner, actionContainer, worldmasterTextId);
+        }
+
+        public bool AddStatusEffect(StatusEffect newEffect, Character source, CommandResultContainer actionContainer = null, ushort worldmasterTextId = 30328)
+        {
+            /*
+                worldMasterTextId
+                32001 [@2B([@IF($E4($EB(1),$EB(2)),you,[@IF($E9(7),[@SHEETEN(xtx/displayName,2,$E9(7),1,1)],$EB(2))])])] [@IF($E4($EB(1),$EB(2)),resist,resists)] the effect of [@SHEET(xtx/status,$E8(11),3)].
+                32002 [@SHEET(xtx/status,$E8(11),3)] fails to take effect.
+            */
+
+            var effect = GetStatusEffectById(newEffect.GetStatusEffectId());
+
+            bool canOverwrite = false;
+            if (effect != null)
+            {
+                var overwritable = effect.GetOverwritable();
+                canOverwrite = (overwritable == (uint)StatusEffectOverwrite.Always) ||
+                   (overwritable == (uint)StatusEffectOverwrite.GreaterOnly && (effect.GetDuration() < newEffect.GetDuration() || effect.GetMagnitude() < newEffect.GetMagnitude())) ||
+                   (overwritable == (uint)StatusEffectOverwrite.GreaterOrEqualTo && (effect.GetDuration() <= newEffect.GetDuration() || effect.GetMagnitude() <= newEffect.GetMagnitude()));
+            }
+
+            if (canOverwrite || effect == null)
+            {
+                // send packet to client with effect added message
+                if (newEffect != null && !newEffect.GetSilentOnGain())
+                {
+                    if (actionContainer != null)
+                        actionContainer.AddAction(new CommandResult(owner.actorId, worldmasterTextId, newEffect.GetStatusEffectId() | (uint)HitEffect.StatusEffectType));
+                }
+
+                // wont send a message about losing effect here
+                if (canOverwrite)
+                    effects.Remove(newEffect.GetStatusEffectId());
+
+                newEffect.SetStartTime(DateTime.Now);
+                newEffect.SetEndTime(DateTime.Now.AddSeconds(newEffect.GetDuration()));
+                newEffect.SetOwner(owner);
+
+                if (effects.Count < MAX_EFFECTS)
+                {
+                    newEffect.CallLuaFunction(this.owner, "onGain", this.owner, newEffect, actionContainer);
+
+                    effects.Add(newEffect.GetStatusEffectId(), newEffect);
+
+                    if (!newEffect.GetHidden())
+                    {
+                        int index = 0;
+
+                        //If effect is already in the list of statuses, get that index, otherwise find the first open index
+                        if (owner.charaWork.status.Contains(newEffect.GetStatusId()))
+                            index = Array.IndexOf(owner.charaWork.status, newEffect.GetStatusId());
+                        else
+                            index = Array.IndexOf(owner.charaWork.status, (ushort) 0);
+                        
+                        SetStatusAtIndex(index, newEffect.GetStatusId());
+                        //Stance statuses need their time set to an extremely high number so their icon doesn't flash
+                        //Adding getduration with them doesn't work because it overflows
+                        uint time = (newEffect.GetFlags() & (uint) StatusEffectFlags.Stance) == 0 ? Utils.UnixTimeStampUTC(newEffect.GetEndTime()) : 0xFFFFFFFF;
+                        SetTimeAtIndex(index, time);
+                    }
+                    owner.RecalculateStats();
+                }
+                return true;
+            }
+            return false;
+        }
+
+        //playEffect determines whether the effect of the animation that's going to play with actionContainer is going to play on owner
+        //Generally, for abilities removing an effect, this is true and for effects removing themselves it's false.
+        public bool RemoveStatusEffect(StatusEffect effect, CommandResultContainer actionContainer = null, ushort worldmasterTextId = 30331, bool playEffect = true)
+        {
+            bool removedEffect = false;
+            if (effect != null && effects.ContainsKey(effect.GetStatusEffectId()))
+            {
+                // send packet to client with effect remove message
+                if (!effect.GetSilentOnLoss())
+                {
+                    //Only send a message if we're using an actioncontainer and the effect normally sends a message when it's lost
+                    if (actionContainer != null)
+                        actionContainer.AddAction(new CommandResult(owner.actorId, worldmasterTextId, effect.GetStatusEffectId() | (playEffect ? 0 : (uint)HitEffect.StatusLossType)));
+                }
+
+                //hidden effects not in charawork
+                var index = Array.IndexOf(owner.charaWork.status, effect.GetStatusId());
+                if (!effect.GetHidden() && index != -1)
+                {
+                    SetStatusAtIndex(index, 0);
+                    SetTimeAtIndex(index, 0);
+                }
+
+                // function onLose(actor, effect)
+                effects.Remove(effect.GetStatusEffectId());
+                effect.CallLuaFunction(owner, "onLose", owner, effect, actionContainer);
+                owner.RecalculateStats();
+                removedEffect = true;
+            }
+
+            return removedEffect;
+        }
+
+        public bool RemoveStatusEffect(uint effectId, CommandResultContainer resultContainer = null, ushort worldmasterTextId = 30331, bool playEffect = true)
+        {
+            return RemoveStatusEffect(GetStatusEffectById(effectId), resultContainer, worldmasterTextId, playEffect);
+        }
+
+        public StatusEffect CopyEffect(StatusEffect effect)
+        {
+            var newEffect = new StatusEffect(owner, effect);
+            newEffect.SetOwner(owner);
+            // todo: should source be copied too?
+            return AddStatusEffect(newEffect, effect.GetSource()) ? newEffect : null;
+        }
+
+        public bool RemoveStatusEffectsByFlags(uint flags, CommandResultContainer resultContainer = null)
+        {
+            // build list of effects to remove
+            var removeEffects = GetStatusEffectsByFlag(flags);
+
+            // remove effects from main list
+            foreach (var effect in removeEffects)
+                RemoveStatusEffect(effect, resultContainer, effect.GetStatusLossTextId(), true);
+
+            // removed an effect with one of these flags
+            return removeEffects.Count > 0;
+        }
+
+        public StatusEffect GetStatusEffectById(uint id, byte tier = 0xFF)
+        {
+            StatusEffect effect;
+
+            if (effects.TryGetValue(id, out effect) && effect.GetStatusEffectId() == id && (tier != 0xFF ? effect.GetTier() == tier : true))
+                return effect;
+
+            return null;
+        }
+
+        public List<StatusEffect> GetStatusEffectsByFlag(uint flag)
+        {
+            var list = new List<StatusEffect>();
+            foreach (var effect in effects.Values)
+                if ((effect.GetFlags() & flag) != 0)
+                    list.Add(effect);
+
+            return list;
+        }
+
+        public StatusEffect GetRandomEffectByFlag(uint flag)
+        {
+            var list = GetStatusEffectsByFlag(flag);
+
+            if (list.Count > 0)
+                return list[Program.Random.Next(list.Count)];
+
+            return null;
+        }
+
+        // todo: why the fuck cant c# convert enums/
+        public bool HasStatusEffectsByFlag(StatusEffectFlags flags)
+        {
+            return HasStatusEffectsByFlag((uint)flags);
+        }
+
+        public bool HasStatusEffectsByFlag(uint flag)
+        {
+            foreach (var effect in effects.Values)
+            {
+                if ((effect.GetFlags() & flag) != 0)
+                    return true;
+            }
+            return false;
+        }
+
+        public IEnumerable<StatusEffect> GetStatusEffects()
+        {
+            return effects.Values;
+        }
+
+        void SaveStatusEffectsToDatabase(StatusEffectFlags removeEffectFlags = StatusEffectFlags.None)
+        {
+            if (owner is Player)
+            {
+                Database.SavePlayerStatusEffects((Player)owner);
+            }
+        }
+
+        public void CallLuaFunctionByFlag(uint flag, string function, params object[] args)
+        {
+            var effects = GetStatusEffectsByFlag(flag);
+
+            object[] argsWithEffect = new object[args.Length + 1];
+
+            for (int i = 0; i < args.Length; i++)
+                argsWithEffect[i + 1] = args[i];
+
+            foreach (var effect in effects)
+            {
+                argsWithEffect[0] = effect;
+                effect.CallLuaFunction(owner, function, argsWithEffect);
+            }
+        }
+
+        //Sets the status id at an index.
+        //Changing a status to another doesn't seem to work. If updating an index that already has an effect, set it to 0 first then to the correct status
+        public void SetStatusAtIndex(int index, ushort statusId)
+        {
+            owner.charaWork.status[index] = statusId;
+
+            statusSubpackets.Add(SetActorStatusPacket.BuildPacket(owner.actorId, (ushort)index, statusId));
+            owner.updateFlags |= ActorUpdateFlags.Status;
+        }
+
+        public void SetTimeAtIndex(int index, uint time)
+        {
+            owner.charaWork.statusShownTime[index] = time;
+            statusTimerPropPacketUtil.AddProperty($"charaWork.statusShownTime[{index}]");
+            owner.updateFlags |= ActorUpdateFlags.StatusTime;
+        }
+
+        public List<SubPacket> GetStatusPackets()
+        {
+            return statusSubpackets;
+        }
+
+        public List<SubPacket> GetStatusTimerPackets()
+        {
+            return statusTimerPropPacketUtil.Done();
+        }
+
+        public void ResetPropPacketUtil()
+        {
+            statusTimerPropPacketUtil = new ActorPropertyPacketUtil("charaWork/status", owner);
+        }
+
+        //Overwrites effectToBeReplaced with a new status effect
+        //Returns the message of the new effect being added
+        //Doing this instead of simply calling remove then add so that the new effect is in the same slot as the old one
+        //There should be a better way to do this
+        //Currently causes the icons to blink whenb eing rpelaced
+        public CommandResult ReplaceEffect(StatusEffect effectToBeReplaced, uint newEffectId, byte tier, double magnitude, uint duration)
+        {
+            StatusEffect newEffect = Server.GetWorldManager().GetStatusEffect(newEffectId);
+            newEffect.SetTier(tier);
+            newEffect.SetMagnitude(magnitude);
+            newEffect.SetDuration(duration);
+            newEffect.SetOwner(effectToBeReplaced.GetOwner());
+            effectToBeReplaced.CallLuaFunction(owner, "onLose", owner, effectToBeReplaced);
+            newEffect.CallLuaFunction(owner, "onGain", owner, newEffect);
+            effects.Remove(effectToBeReplaced.GetStatusEffectId());
+
+            newEffect.SetStartTime(DateTime.Now);
+            newEffect.SetEndTime(DateTime.Now.AddSeconds(newEffect.GetDuration()));
+            uint time = (newEffect.GetFlags() & (uint)StatusEffectFlags.Stance) == 0 ? Utils.UnixTimeStampUTC(newEffect.GetEndTime()) : 0xFFFFFFFF;
+            int index = Array.IndexOf(owner.charaWork.status, effectToBeReplaced.GetStatusId());
+
+            //owner.charaWork.status[index] = newEffect.GetStatusId();
+            owner.charaWork.statusShownTime[index] = time;
+            effects[newEffectId] = newEffect;
+            
+            SetStatusAtIndex(index, 0);
+
+            //charawork/status
+            SetStatusAtIndex(index, (ushort) (newEffectId - 200000));
+            SetTimeAtIndex(index, time);
+
+            return new CommandResult(owner.actorId, 30330, (uint) HitEffect.StatusEffectType | newEffectId);
+        }
+    }
+}

Map Server/Actors/Chara/Ai/Utils/AttackUtils.cs

@@ -0,0 +1,40 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using Meteor.Map.Actors;
+namespace Meteor.Map.actors.chara.ai.utils
+{
+    static class AttackUtils
+    {
+        public static int CalculateDamage(Character attacker, Character defender)
+        {
+            int dmg = CalculateBaseDamage(attacker, defender);
+
+            return dmg;
+        }
+
+        public static int CalculateBaseDamage(Character attacker, Character defender)
+        {
+            // todo: actually calculate damage
+            return Program.Random.Next(10) * 10;
+        }
+    }
+}

Map Server/Actors/Chara/Ai/Utils/BattleUtils.cs

@@ -0,0 +1,924 @@
+/*
+===========================================================================
+Copyright (C) 2015-2019 Project Meteor Dev Team
+
+This file is part of Project Meteor Server.
+
+Project Meteor Server is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Project Meteor Server is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
+===========================================================================
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Meteor.Map.Actors;
+using Meteor.Map.packets.send.actor.battle;
+using Meteor.Map.actors.chara.npc;
+using Meteor.Common;
+
+namespace Meteor.Map.actors.chara.ai.utils
+{
+    static class BattleUtils
+    {
+
+        public static Dictionary<HitType, ushort> PhysicalHitTypeTextIds = new Dictionary<HitType, ushort>()
+        {
+            { HitType.Miss,     30311 },
+            { HitType.Evade,    30310 },
+            { HitType.Parry,    30308 },
+            { HitType.Block,    30306 },
+            { HitType.Hit,      30301 },
+            { HitType.Crit,     30302 }
+        };
+
+        public static Dictionary<HitType, ushort> MagicalHitTypeTextIds = new Dictionary<HitType, ushort>()
+        {
+            { HitType.SingleResist,30318 },
+            { HitType.DoubleResist,30317 },
+            { HitType.TripleResist, 30316 },//Triple Resists seem to use the same text ID as full resists
+            { HitType.FullResist,30316 },
+            { HitType.Hit,      30319 },
+            { HitType.Crit,     30392 }     //Unsure why crit is separated from the rest of the ids
+        };
+
+        public static Dictionary<HitType, ushort> MultiHitTypeTextIds = new Dictionary<HitType, ushort>()
+        {
+            { HitType.Miss,     30449 },    //The attack misses.
+            { HitType.Evade,    0 },        //Evades were removed before multi hit skills got their own messages, so this doesnt exist
+            { HitType.Parry,    30448 },    //[Target] parries, taking x points of damage.
+            { HitType.Block,    30447 },    //[Target] blocks, taking x points of damage.
+            { HitType.Hit,      30443 },    //[Target] tales x points of damage
+            { HitType.Crit,     30444 }     //Critical! [Target] takes x points of damage.
+        };
+
+        public static Dictionary<HitType, HitEffect> HitTypeEffectsPhysical = new Dictionary<HitType, HitEffect>()
+        {
+            { HitType.Miss,     0 },
+            { HitType.Evade,    HitEffect.Evade },
+            { HitType.Parry,    HitEffect.Parry },
+            { HitType.Block,    HitEffect.Block },
+            { HitType.Hit,      HitEffect.Hit },
+            { HitType.Crit,     HitEffect.Crit | HitEffect.CriticalHit }
+        };
+
+        //Magic attacks can't miss, be blocked, or parried. Resists are technically evades
+        public static Dictionary<HitType, HitEffect> HitTypeEffectsMagical = new Dictionary<HitType, HitEffect>()
+        {
+            { HitType.SingleResist,     HitEffect.WeakResist },
+            { HitType.DoubleResist,     HitEffect.WeakResist },
+            { HitType.TripleResist,     HitEffect.WeakResist },
+            { HitType.FullResist,       HitEffect.FullResist },
+            { HitType.Hit,              HitEffect.NoResist },
+            { HitType.Crit,             HitEffect.Crit }
+        };
+
+        public static Dictionary<KnockbackType, HitEffect> KnockbackEffects = new Dictionary<KnockbackType, HitEffect>()
+        {
+            { KnockbackType.None, 0 },
+            { KnockbackType.Level1, HitEffect.KnockbackLv1 },
+            { KnockbackType.Level2, HitEffect.KnockbackLv2 },
+            { KnockbackType.Level3, HitEffect.KnockbackLv3 },
+            { KnockbackType.Level4, HitEffect.KnockbackLv4 },
+            { KnockbackType.Level5, HitEffect.KnockbackLv5 },
+            { KnockbackType.Clockwise1, HitEffect.KnockbackClockwiseLv1 },
+            { KnockbackType.Clockwise2, HitEffect.KnockbackClockwiseLv2 },
+            { KnockbackType.CounterClockwise1, HitEffect.KnockbackCounterClockwiseLv1 },
+            { KnockbackType.CounterClockwise2, HitEffect.KnockbackCounterClockwiseLv2 },
+            { KnockbackType.DrawIn, HitEffect.DrawIn }
+        };
+
+        public static Dictionary<byte, ushort> ClassExperienceTextIds = new Dictionary<byte, ushort>()
+        {
+            { 2, 33934 },   //Pugilist
+            { 3, 33935 },   //Gladiator
+            { 4, 33936 },   //Marauder
+            { 7, 33937 },   //Archer
+            { 8, 33938 },   //Lancer
+            { 10, 33939 },  //Sentinel, this doesn't exist anymore but it's still in the files so may as well put it here just in case
+            { 22, 33940 },  //Thaumaturge
+            { 23, 33941 },  //Conjurer
+            { 29, 33945 },  //Carpenter, for some reason there's a a few different messages between 33941 and 33945
+            { 30, 33946 },  //Blacksmith
+            { 31, 33947 },  //Armorer
+            { 32, 33948 },  //Goldsmith
+            { 33, 33949 },  //Leatherworker
+            { 34, 33950 },  //Weaver
+            { 35, 33951 },  //Alchemist
+            { 36, 33952 },  //Culinarian
+            { 39, 33953 },  //Miner
+            { 40, 33954 },  //Botanist
+            { 41, 33955 }   //Fisher
+        };
+
+        //Most of these numbers I'm fairly certain are correct. The repeated numbers at levels 23 and 48 I'm less sure about but they do match some weird spots in the EXP graph
+
+        public static ushort[] BASEEXP =   {150, 150, 150, 150, 150, 150, 150, 150, 150, 150,  //Level <= 10
+                                        150, 150, 150, 150, 150, 150, 150, 150, 160, 170,   //Level <= 20
+                                        180, 190, 190, 200, 210, 220, 230, 240, 250, 260,   //Level <= 30
+                                        270, 280, 290, 300, 310, 320, 330, 340, 350, 360,   //Level <= 40
+                                        370, 380, 380, 390, 400, 410, 420, 430, 430, 440};  //Level <= 50
+
+        public static bool TryAttack(Character attacker, Character defender, CommandResult action, ref CommandResult error)
+        {
+            // todo: get hit rate, hit count, set hit effect
+            //action.effectId |= (uint)(HitEffect.RecoilLv2 | HitEffect.Hit | HitEffect.HitVisual1);
+            return true;
+        }
+
+        private static double CalculateDlvlModifier(short dlvl)
+        {
+            //this is just a really, really simplified version of the graph from http://kanican.livejournal.com/55915.html
+            //actual formula is definitely more complicated
+            //I'm going to assum these formulas are linear, and they're clamped so the modifier never goes below 0.
+            double modifier = 0;
+
+
+            if (dlvl >= 0)
+                modifier = (.35 * dlvl) + .225;
+            else
+                modifier = (.01 * dlvl) + .25;
+
+            return modifier.Clamp(0, 1);
+        }
+
+        //Damage calculations
+        //Calculate damage of action
+        //We could probably just do this when determining the action's hit type
+        public static void CalculatePhysicalDamageTaken(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            short dlvl = (short)(defender.GetLevel() - attacker.GetLevel());
+
+            // todo: physical resistances
+
+            //dlvl, Defense, and Vitality all effect how much damage is taken after hittype takes effect
+            //player attacks cannot do more than 9999 damage.
+            //VIT is turned into Defense at a 3:2 ratio in calculatestats, so don't need to do that here
+            double damageTakenPercent = 1 - (defender.GetMod(Modifier.DamageTakenDown) / 100.0);
+            action.amount = (ushort)(action.amount - CalculateDlvlModifier(dlvl) * (defender.GetMod((uint)Modifier.Defense))).Clamp(0, 9999);
+            action.amount = (ushort)(action.amount * damageTakenPercent).Clamp(0, 9999);
+        }
+
+
+        public static void CalculateSpellDamageTaken(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            short dlvl = (short)(defender.GetLevel() - attacker.GetLevel());
+
+            // todo: elemental resistances
+            //Patch 1.19:
+            //Magic Defense has been abolished and no longer appears in equipment attributes.
+            //The effect of elemental attributes has been changed to that of reducing damage from element-based attacks.
+
+            //http://kanican.livejournal.com/55370.html:
+            //elemental resistance stats are not actually related to resists (except for status effects), instead they impact damage taken
+
+
+            //dlvl, Defense, and Vitality all effect how much damage is taken after hittype takes effect
+            //player attacks cannot do more than 9999 damage.
+            double damageTakenPercent = 1 - (defender.GetMod(Modifier.DamageTakenDown) / 100.0);
+            action.amount = (ushort)(action.amount - CalculateDlvlModifier(dlvl) * (defender.GetMod((uint)Modifier.Defense) + 0.67 * defender.GetMod((uint)Modifier.Vitality))).Clamp(0, 9999);
+            action.amount = (ushort)(action.amount * damageTakenPercent).Clamp(0, 9999);
+        }
+
+        
+        public static void CalculateBlockDamage(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            double percentBlocked;
+
+            //Aegis boon forces a full block
+            if (defender.statusEffects.HasStatusEffect(StatusEffectId.AegisBoon))
+                percentBlocked = 1.0;
+            else
+            {
+                //Is this a case where VIT gives Block?
+                percentBlocked = defender.GetMod((uint)Modifier.Block) * 0.002;//Every point of Block adds .2% to how much is blocked
+                percentBlocked += defender.GetMod((uint)Modifier.Vitality) * 0.001;//Every point of vitality adds .1% to how much is blocked
+            }
+
+            action.amountMitigated = (ushort)(action.amount * percentBlocked);
+            action.amount = (ushort)(action.amount * (1.0 - percentBlocked));
+        }
+
+        //don't know exact crit bonus formula
+        public static void CalculateCritDamage(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            short dlvl = (short)(defender.GetLevel() - attacker.GetLevel());
+            double bonus = (.04 * (dlvl * dlvl)) - 2 * dlvl;
+            bonus += 1.20;
+            double potencyModifier = (-.075 * dlvl) + 1.73;
+
+            // + potency bonus
+            //bonus += attacker.GetMod((uint) Modifier.CriticalPotency) * potencyModifier;
+            // - Crit resilience
+            //bonus -= attacker.GetMod((uint)Modifier.CriticalResilience) * potencyModifier;
+
+            //need to add something for bonus potency as a part of skill (ie thundara, which breaks the cap)
+            action.amount = (ushort)(action.amount * bonus.Clamp(1.15, 1.75));//min bonus of 115, max bonus of 175
+        }
+
+        public static void CalculateParryDamage(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            double percentParry = 0.75;
+
+            action.amountMitigated = (ushort)(action.amount * (1 - percentParry));
+            action.amount = (ushort)(action.amount * percentParry);
+        }
+
+        //There are 3 or 4 tiers of resist that are flat 25% decreases in damage. 
+        //It's possible we could just calculate the damage at the same time as we determine the hit type (the same goes for the rest of the hit types)
+        //Or we could have HitTypes for DoubleResist, TripleResist, and FullResist that get used here.
+        public static void CalculateResistDamage(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            //Every tier of resist is a 25% reduction in damage. ie SingleResist is 25% damage taken down, Double is 50% damage taken down, etc
+            double percentResist = 0.25 * (action.hitType - HitType.SingleResist + 1);
+
+            action.amountMitigated = (ushort)(action.amount * (1 - percentResist));
+            action.amount = (ushort)(action.amount * percentResist);
+        }
+
+        //It's weird that stoneskin is handled in C# and all other buffs are in scripts right now
+        //But it's because stoneskin acts like both a preaction and postaction buff in that it falls off after damage is dealt but impacts how much damage is dealt
+        public static void HandleStoneskin(Character defender, CommandResult action)
+        {
+            var mitigation = Math.Min(action.amount, defender.GetMod(Modifier.Stoneskin));
+
+            action.amount = (ushort) (action.amount - mitigation).Clamp(0, 9999);
+            defender.SubtractMod((uint)Modifier.Stoneskin, mitigation);
+        }
+
+        public static void DamageTarget(Character attacker, Character defender, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer= null)
+        {
+            if (defender != null)
+            {
+
+                //Bugfix, mobs that instantly died were insta disappearing due to lastAttacker == null.
+                if (defender is BattleNpc)
+                {
+                    var bnpc = defender as BattleNpc;
+                    if (bnpc.lastAttacker == null)
+                        bnpc.lastAttacker = attacker;
+                }
+
+                defender.DelHP((short)action.amount, actionContainer);
+                attacker.OnDamageDealt(defender, skill, action, actionContainer);
+                defender.OnDamageTaken(attacker, skill, action, actionContainer);
+
+                // todo: other stuff too
+                if (defender is BattleNpc)
+                {
+                    var bnpc = defender as BattleNpc;
+                    if (!bnpc.hateContainer.HasHateForTarget(attacker))
+                    {
+                        bnpc.hateContainer.AddBaseHate(attacker);
+                    }
+                    bnpc.hateContainer.UpdateHate(attacker, action.enmity);
+                    bnpc.lastAttacker = attacker;
+                }
+            }
+        }
+
+        public static void HealTarget(Character caster, Character target, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
+        {
+            if (target != null)
+            {
+                target.AddHP(action.amount, actionContainer);
+
+                target.statusEffects.CallLuaFunctionByFlag((uint)StatusEffectFlags.ActivateOnHealed, "onHealed", caster, target, skill, action, actionContainer);
+            }
+        }
+
+
+        #region Rate Functions
+
+        //How is accuracy actually calculated?
+        public static double GetHitRate(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            double hitRate = 80.0;
+
+            //Add raw hit rate buffs, subtract raw evade buffs, take into account skill's accuracy modifier.
+            double hitBuff = attacker.GetMod(Modifier.RawHitRate);
+            double evadeBuff = defender.GetMod(Modifier.RawEvadeRate);
+            float modifier = skill != null ? skill.accuracyModifier : 0;
+            hitRate += (hitBuff + modifier).Clamp(0, 100.0);
+            hitRate -= evadeBuff;
+            return hitRate.Clamp(0, 100.0);
+        }
+
+        //Whats the parry formula?
+        public static double GetParryRate(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            //Can't parry with shield, can't parry rear attacks
+            if (defender.GetMod((uint)Modifier.CanBlock) != 0 || action.param == (byte) HitDirection.Rear)
+                return 0;
+
+            double parryRate = 10.0;
+
+            parryRate += defender.GetMod(Modifier.Parry) * 0.1;//.1% rate for every point of Parry
+
+            return parryRate + (defender.GetMod(Modifier.RawParryRate));
+        }
+
+        public static double GetCritRate(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            if (action.actionType == ActionType.Status)
+                return 0.0;
+            
+            //using 10.0 for now since gear isn't working
+            double critRate = 10.0;// 0.16 * attacker.GetMod((uint)Modifier.CritRating);//Crit rating adds .16% per point
+
+            //Add additional crit rate from skill
+            //Should this be a raw percent or a flat crit raitng? the wording on skills/buffs isn't clear.
+            critRate += 0.16 * (skill != null ? skill.bonusCritRate : 0);
+
+            return critRate + attacker.GetMod(Modifier.RawCritRate);
+        }
+
+        //http://kanican.livejournal.com/55370.html
+        // todo: figure that out
+        public static double GetResistRate(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            // todo: add elemental stuff
+            //Can only resist spells?
+            if (action.commandType != CommandType.Spell && action.actionProperty <= ActionProperty.Projectile)
+                return 0.0;
+
+            return 15.0 + defender.GetMod(Modifier.RawResistRate);
+        }
+
+        //Block Rate follows 4 simple rules:
+        //(1) Every point in DEX gives +0.1% rate
+        //(2) Every point in "Block Rate" gives +0.2% rate
+        //(3) True block proc rate is capped at 75%. No clue on a possible floor.
+        //(4) The baseline rate is based on dLVL only(mob stats play no role). The baseline rate is summarized in this raw data sheet: https://imgbox.com/aasLyaJz
+        public static double GetBlockRate(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            //Shields are required to block and can't block from rear.
+            if (defender.GetMod((uint)Modifier.CanBlock) == 0 || action.param == (byte)HitDirection.Rear)
+                return 0;
+
+            short dlvl = (short)(defender.GetLevel() - attacker.GetLevel());
+            double blockRate = (2.5 * dlvl) + 5; // Base block rate
+
+            //Is this one of those thing where DEX gives block rate and this would be taking DEX into account twice?
+            blockRate += defender.GetMod((uint)Modifier.Dexterity) * 0.1;// .1% for every dex
+            blockRate += defender.GetMod((uint)Modifier.BlockRate) * 0.2;// .2% for every block rate
+
+            return Math.Min(blockRate, 25.0) + defender.GetMod((uint)Modifier.RawBlockRate);
+        }
+
+        #endregion
+
+        public static bool TryCrit(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            if ((Program.Random.NextDouble() * 100) <= action.critRate)
+            {
+                action.hitType = HitType.Crit;
+                CalculateCritDamage(attacker, defender, skill, action);
+
+                if(skill != null)
+                    skill.actionCrit = true;
+
+                return true;
+            }
+
+            return false;
+        }
+
+        //This probably isn't totally correct but it's close enough for now. 
+        //Full Resists seem to be calculated in a different way because the resist rates don't seem to line up with kanikan's testing (their tests didn't show any full resists)
+        //Non-spells with elemental damage can be resisted, it just doesnt say in the chat that they were. As far as I can tell, all mob-specific attacks are considered not to be spells
+        public static bool TryResist(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            //The rate degrades for each check. Meaning with 100% resist, the attack will always be resisted, but it won't necessarily be a triple or full resist
+            //Rates beyond 100 still increase the chance for higher resist tiers though
+            double rate = action.resistRate;
+
+            int i = -1;
+
+            while ((Program.Random.NextDouble() * 100) <= rate && i < 4)
+            {
+                rate /= 2;
+                i++;
+            }
+
+            if (i != -1)
+            {
+                action.hitType = (HitType) ((int) HitType.SingleResist + i);
+                CalculateResistDamage(attacker, defender, skill, action);
+                return true;
+            }
+
+            return false;
+        }
+
+        public static bool TryBlock(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            if ((Program.Random.NextDouble() * 100) <= action.blockRate)
+            {
+                action.hitType = HitType.Block;
+                CalculateBlockDamage(attacker, defender, skill, action);
+                return true;
+            }
+
+            return false;
+        }
+
+        public static bool TryParry(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            if ((Program.Random.NextDouble() * 100) <= action.parryRate)
+            {
+                action.hitType = HitType.Parry;
+                CalculateParryDamage(attacker, defender, skill, action);
+                return true;
+            }
+
+            return false;
+        }
+
+        //TryMiss instead of tryHit because hits are the default and don't change damage
+        public static bool TryMiss(Character attacker, Character defender, BattleCommand skill, CommandResult action)
+        {
+            if ((Program.Random.NextDouble() * 100) >= GetHitRate(attacker, defender, skill, action))
+            {
+                action.hitType = (ushort)HitType.Miss;
+                //On misses, the entire amount is considered mitigated
+                action.amountMitigated = action.amount;
+                action.amount = 0;
+                return true;
+            }
+            return false;
+        }
+
+        /*
+         * Hit Effecthelpers. Different types of hit effects hits use some flags for different things, so they're split into physical, magical, heal, and status
+         */
+        public static void DoAction(Character caster, Character target, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
+        {
+            switch (action.actionType)
+            {
+                case (ActionType.Physical):
+                    FinishActionPhysical(caster, target, skill, action, actionContainer);
+                    break;
+                case (ActionType.Magic):
+                    FinishActionSpell(caster, target, skill, action, actionContainer);
+                    break;
+                case (ActionType.Heal):
+                    FinishActionHeal(caster, target, skill, action, actionContainer);
+                    break;
+                case (ActionType.Status):
+                    FinishActionStatus(caster, target, skill, action, actionContainer);
+                    break;
+                default:
+                    action.effectId = (uint) HitEffect.AnimationEffectType;
+                    actionContainer.AddAction(action);
+                    break;
+            }
+        }
+
+        //Determine the hit type, set the hit effect, modify damage based on stoneskin and hit type, hit target
+        public static void FinishActionPhysical(Character attacker, Character defender, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
+        {
+            //Figure out the hit type and change damage depending on hit type
+            if (!TryMiss(attacker, defender, skill, action))
+            {
+                //Handle Stoneskin here because it seems like stoneskin mitigates damage done before taking into consideration crit/block/parry damage reductions.
+                //This is based on the fact that a 0 damage attack due to stoneskin will heal for 0 with Aegis Boon, meaning Aegis Boon didn't mitigate any damage
+                HandleStoneskin(defender, action);
+
+                //Crits can't be blocked (is this true for Aegis Boon and Divine Veil?) or parried so they are checked first.
+                if (!TryCrit(attacker, defender, skill, action))
+                    //Block and parry order don't really matter because if you can block you can't parry and vice versa
+                    if (!TryBlock(attacker, defender, skill, action))
+                        if(!TryParry(attacker, defender, skill, action))
+                            //Finally if it's none of these, the attack was a hit
+                            action.hitType = HitType.Hit;
+            }
+
+            //Actions have different text ids depending on whether they're a part of a multi-hit ws or not.
+            Dictionary<HitType, ushort> textIds = PhysicalHitTypeTextIds;
+
+            //If this is the first hit of a multi hit command, add the "You use [command] on [target]" action
+            //Needs to be done here because certain buff messages appear before it.
+            if (skill != null && skill.numHits > 1)
+            {
+                if (action.hitNum == 1)
+                    actionContainer?.AddAction(new CommandResult(attacker.actorId, 30441, 0));
+
+                textIds = MultiHitTypeTextIds;
+            }
+
+            //Set the correct textId
+            action.worldMasterTextId = textIds[action.hitType];
+
+            //Set the hit effect
+            SetHitEffectPhysical(attacker, defender, skill, action, actionContainer);
+
+            //Modify damage based on defender's stats
+            CalculatePhysicalDamageTaken(attacker, defender, skill, action);
+
+            actionContainer.AddAction(action);
+            action.enmity = (ushort) (action.enmity * (skill != null ? skill.enmityModifier : 1));
+
+            //Damage the target
+            DamageTarget(attacker, defender, skill, action, actionContainer);
+        }
+
+        public static void FinishActionSpell(Character attacker, Character defender, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
+        {
+            //I'm assuming that like physical attacks stoneskin is taken into account before mitigation
+            HandleStoneskin(defender, action);
+
+            //Determine the hit type of the action
+            //Spells don't seem to be able to miss, instead magic acc/eva is used for resists (which are generally called evades in game)
+            //Unlike blocks and parries, crits do not go through resists.
+            if (!TryResist(attacker, defender, skill, action))
+            {
+                if (!TryCrit(attacker, defender, skill, action))
+                    action.hitType = HitType.Hit;
+            }
+
+            //There are no multi-hit spells, so we don't need to take that into account
+            action.worldMasterTextId = MagicalHitTypeTextIds[action.hitType];
+
+            //Set the hit effect
+            SetHitEffectSpell(attacker, defender, skill, action);
+
+            HandleStoneskin(defender, action);
+
+            CalculateSpellDamageTaken(attacker, defender, skill, action);
+
+            actionContainer.AddAction(action);
+
+            DamageTarget(attacker, defender, skill, action, actionContainer);
+        }
+
+        public static void FinishActionHeal(Character attacker, Character defender, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
+        {
+            //Set the hit effect
+            SetHitEffectHeal(attacker, defender, skill, action);
+
+            actionContainer.AddAction(action);
+
+            HealTarget(attacker, defender, skill, action, actionContainer);
+        }
+
+        public static void FinishActionStatus(Character attacker, Character defender, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
+        {
+            //Set the hit effect
+            SetHitEffectStatus(attacker, defender, skill, action);
+
+            TryStatus(attacker, defender, skill, action, actionContainer, false);
+
+            actionContainer.AddAction(action);
+        }
+
+        public static void SetHitEffectPhysical(Character attacker, Character defender, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer)
+        {
+            var hitEffect = HitEffect.HitEffectType;
+            HitType hitType = action.hitType;
+
+            //Don't know what recoil is actually based on, just guessing
+            //Crit is 2 and 3 together
+            if (hitType == HitType.Crit)
+                hitEffect |= HitEffect.CriticalHit;
+            else
+            {
+                //It's not clear what recoil level is based on for physical attacks
+                double percentDealt = (100.0 * (action.amount / defender.GetMaxHP()));
+                if (percentDealt > 5.0)
+                    hitEffect |= HitEffect.RecoilLv2;
+                else if (percentDealt > 10)
+                    hitEffect |= HitEffect.RecoilLv3;
+            }
+
+            hitEffect |= HitTypeEffectsPhysical[hitType];
+
+            //For combos that land, add the combo effect
+            if (skill != null && skill.isCombo && action.ActionLanded() && !skill.comboEffectAdded)
+            {
+                hitEffect |= (HitEffect)(skill.comboStep << 15);
+                skill.comboEffectAdded = true;
+            }
+
+            //if attack hit the target, take into account protective status effects
+            if (hitType >= HitType.Parry)
+            {
+                //Protect / Shell only show on physical/ magical attacks respectively.
+                if (defender.statusEffects.HasStatusEffect(StatusEffectId.Protect) || defender.statusEffects.HasStatusEffect(StatusEffectId.Protect2))
+                    if (action != null)
+                        hitEffect |= HitEffect.Protect;
+
+                if (defender.statusEffects.HasStatusEffect(StatusEffectId.Stoneskin))
+                    if (action != null)
+                        hitEffect |= HitEffect.Stoneskin;
+            }
+
+            action.effectId = (uint)hitEffect;
+        }
+
+        public static void SetHitEffectSpell(Character attacker, Character defender, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
+        {
+            var hitEffect = HitEffect.MagicEffectType;
+            HitType hitType = action.hitType;
+
+
+            hitEffect |= HitTypeEffectsMagical[hitType];
+
+            if (skill != null && skill.isCombo && !skill.comboEffectAdded)
+            {
+                hitEffect |= (HitEffect)(skill.comboStep << 15);
+                skill.comboEffectAdded = true;
+            }
+
+            //if attack hit the target, take into account protective status effects
+            if (action.ActionLanded())
+            {
+                //Protect / Shell only show on physical/ magical attacks respectively.
+                //The magic hit effect category only has a flag for shell (and another shield effect that seems unused)
+                //Even though traited protect gives magic defense, the shell effect doesn't play on attacks
+                //This also means stoneskin doesnt show, but it does reduce damage
+                if (defender.statusEffects.HasStatusEffect(StatusEffectId.Shell))
+                    if (action != null)
+                        hitEffect |= HitEffect.MagicShell;
+            }
+            action.effectId = (uint)hitEffect;
+        }
+
+
+        public static void SetHitEffectHeal(Character caster, Character receiver, BattleCommand skill, CommandResult action)
+        {
+            var hitEffect = HitEffect.MagicEffectType | HitEffect.Heal;
+            //Heals use recoil levels in some way as well. Possibly for very low health clutch heals or based on percentage of current health healed (not max health).
+            // todo: figure recoil levels out for heals
+            hitEffect |= HitEffect.RecoilLv3;
+            //do heals crit?
+
+            action.effectId = (uint)hitEffect;
+        }
+
+        public static void SetHitEffectStatus(Character caster, Character receiver, BattleCommand skill, CommandResult action)
+        {
+            var hitEffect = (uint)HitEffect.StatusEffectType | skill.statusId;
+            action.effectId = hitEffect;
+
+            action.hitType = HitType.Hit;
+        }
+
+        public static uint CalculateSpellCost(Character caster, Character target, BattleCommand spell)
+        {
+            var scaledCost = spell.CalculateMpCost(caster);
+
+            // todo: calculate cost for mob/player
+            if (caster is BattleNpc)
+            {
+
+            }
+            else
+            {
+
+            }
+            return scaledCost;
+        }
+
+
+        //IsAdditional is needed because additional actions may be required for some actions' effects
+        //For instance, Goring Blade's bleed effect requires another action so the first action can still show damage numbers
+        //Sentinel doesn't require an additional action because it doesn't need to show those numbers
+        //this is stupid
+        public static void TryStatus(Character caster, Character target, BattleCommand skill, CommandResult action, CommandResultContainer results, bool isAdditional = true)
+        {
+            double rand = Program.Random.NextDouble();
+
+            //Statuses only land for non-resisted attacks and attacks that hit
+            if (skill != null && skill.statusId != 0 && (action.ActionLanded()) && rand < skill.statusChance)
+            {
+                StatusEffect effect = Server.GetWorldManager().GetStatusEffect(skill.statusId);
+                //Because combos might change duration or tier
+                if (effect != null)
+                {
+                    effect.SetDuration(skill.statusDuration);
+                    effect.SetTier(skill.statusTier);
+                    effect.SetMagnitude(skill.statusMagnitude);
+                    effect.SetOwner(target);
+                    effect.SetSource(caster);
+
+                    if (target.statusEffects.AddStatusEffect(effect, caster))
+                    {
+                        //If we need an extra action to show the status text
+                        if (isAdditional)
+                            results.AddAction(target.actorId, effect.GetStatusGainTextId(), skill.statusId | (uint) HitEffect.StatusEffectType);
+                    }
+                    else
+                        action.worldMasterTextId = 32002;//Is this right?
+                }
+                else
+                {
+                    //until all effects are scripted and added to db just doing this
+                    if (target.statusEffects.AddStatusEffect(skill.statusId, skill.statusTier, skill.statusMagnitude, skill.statusDuration, 3000))
+                    {
+                        //If we need an extra action to show the status text
+                        if (isAdditional)
+                            results.AddAction(target.actorId, 30328, skill.statusId | (uint) HitEffect.StatusEffectType);
+                    }
+                    else
+                        action.worldMasterTextId = 32002;//Is this right?
+                }
+            }
+        }
+
+        //Convert a HitDirection to a BattleCommandPositionBonus. Basically just combining left/right into flank
+        public static BattleCommandPositionBonus ConvertHitDirToPosition(HitDirection hitDir)
+        {
+            BattleCommandPositionBonus position = BattleCommandPositionBonus.None;
+
+            switch (hitDir)
+            {
+                case (HitDirection.Front):
+                    position = BattleCommandPositionBonus.Front;
+                    break;
+                case (HitDirection.Right):
+                case (HitDirection.Left):
+                    position = BattleCommandPositionBonus.Flank;
+                    break;
+                case (HitDirection.Rear):
+                    position = BattleCommandPositionBonus.Rear;
+                    break;
+            }
+            return position;
+        }
+
+
+        #region experience helpers
+        //See 1.19 patch notes for exp info.
+        public static ushort GetBaseEXP(Player player, BattleNpc mob)
+        {
+            //The way EXP seems to work for most enemies is that it gets the lower character's level, gets the base exp for that level, then uses dlvl to modify that exp
+            //Less than -19 dlvl gives 0 exp and no message is sent.
+            //This equation doesn't seem to work for certain bosses or NMs.
+            //Some enemies might give less EXP? Unsure on this. It seems like there might have been a change in base exp amounts after 1.19
+
+            //Example:
+            //Level 50 in a party kills a level 45 enemy
+            //Base exp is 400, as that's the base EXP for level 45
+            //That's multiplied by the dlvl modifier for -5, which is 0.5625, which gives 225
+            //That's then multiplied by the party modifier, which seems to be 0.667 regardless of party size, which gives 150
+            //150 is then modified by bonus experience from food, rested exp, links, and chains
+
+            int dlvl = mob.GetLevel() - player.GetLevel();
+            if (dlvl <= -20)
+                return 0;
+
+            int baseLevel = Math.Min(player.GetLevel(), mob.GetLevel());
+            ushort baseEXP = BASEEXP[baseLevel - 1];
+
+            double dlvlModifier = 1.0;
+
+            //There's 2 functions depending on if the dlvl is positive or negative. 
+            if (dlvl >= 0)
+                //I'm not sure if this caps out at some point. This is correct up to at least +9 dlvl though.
+                dlvlModifier += 0.2 * dlvl;
+            else
+                //0.1x + 0.0025x^2
+                dlvlModifier += 0.1 * dlvl + 0.0025 * (dlvl * dlvl);
+
+            //The party modifier isn't clear yet. It seems like it might just be 0.667 for any number of members in a group, but the 1.19 notes say it's variable
+            //There also seem to be some cases where it simply doesn't apply but it isn't obvious if that's correct or when it applies if it is correct
+            double partyModifier = player.currentParty.GetMemberCount() == 1 ? 1.0 : 0.667;
+
+            baseEXP = (ushort) (baseEXP * dlvlModifier * partyModifier);
+
+            return baseEXP;
+        }
+
+        //Gets the EXP bonus when enemies link
+        public static byte GetLinkBonus(ushort linkCount)
+        {
+            byte bonus = 0;
+
+            switch (linkCount)
+            {
+                case (0):
+                    break;
+                case (1):
+                    bonus = 25;
+                    break;
+                case (2):
+                    bonus = 50;
+                    break;
+                case (3):
+                    bonus = 75;
+                    break;
+                case (4):
+                default:
+                    bonus = 100;
+                    break;
+            }
+
+            return bonus;
+        }
+
+        //Gets EXP chain bonus for Attacker fighting Defender
+        //Official text on EXP Chains:     An EXP Chain occurs when players consecutively defeat enemies of equal or higher level than themselves within a specific amount of time.
+        //Assuming this means that there is no bonus for enemies below player's level and EXP chains are specific to the person, not party
+        public static byte GetChainBonus(ushort tier)
+        {
+            byte bonus = 0;
+
+            switch (tier)
+            {
+                case (0):
+                    break;
+                case (1):
+                    bonus = 20;
+                    break;
+                case (2):
+                    bonus = 25;
+                    break;
+                case (3):
+                    bonus = 30;
+                    break;
+                case (4):
+                    bonus = 40;
+                    break;
+                default:
+                    bonus = 50;
+                    break;
+            }
+            return bonus;
+        }
+
+        public static byte GetChainTimeLimit(ushort tier)
+        {
+            byte timeLimit = 0;
+
+            switch (tier)
+            {
+                case (0):
+                    timeLimit = 100;
+                    break;
+                case (1):
+                    timeLimit = 80;
+                    break;
+                case (2):
+                    timeLimit = 60;
+                    break;
+                case (3):
+                    timeLimit = 20;
+                    break;
+                default:
+                    timeLimit = 10;
+                    break;
+            }
+
+            return timeLimit;
+        }
+
+        //Calculates bonus EXP for Links and Chains
+        public static void AddBattleBonusEXP(Player attacker, BattleNpc defender, CommandResultContainer actionContainer)
+        {
+            ushort baseExp = GetBaseEXP(attacker, defender);
+
+            //Only bother calculating the rest if there's actually exp to be gained.
+            //0 exp sends no message
+            if (baseExp > 0)
+            {
+                int totalBonus = 0;//GetMod(Modifier.bonusEXP)
+
+                var linkCount = defender.GetMobMod(MobModifier.LinkCount);
+                totalBonus += GetLinkBonus((byte)Math.Min(linkCount, 255));
+
+                StatusEffect effect = attacker.statusEffects.GetStatusEffectById((uint)StatusEffectId.EXPChain);
+                ushort expChainNumber = 0;
+                uint timeLimit = 100;
+                if (effect != null)
+                {
+                    expChainNumber = effect.GetTier();
+                    timeLimit = (uint)(GetChainTimeLimit(expChainNumber));
+                    actionContainer?.AddEXPAction(new CommandResult(attacker.actorId, 33919, 0, expChainNumber, (byte)timeLimit));
+                }
+
+                totalBonus += GetChainBonus(expChainNumber);
+
+                StatusEffect newChain = Server.GetWorldManager().GetStatusEffect((uint)StatusEffectId.EXPChain);
+                newChain.SetDuration(timeLimit);
+                newChain.SetTier((byte)(Math.Min(expChainNumber + 1, 255)));
+                attacker.statusEffects.AddStatusEffect(newChain, attacker);
+
+                actionContainer?.AddEXPActions(attacker.AddExp(baseExp, (byte)attacker.GetClass(), (byte)(totalBonus.Min(255))));
+            }
+        }
+
+        #endregion
+    }
+}