public Abnormal(Creature.Creature creature, Abnormality abnormality, Creature.Creature caster = null)
 {
     Creature = creature;
     Caster = caster ?? creature;
     Abnormality = abnormality;
     TimeoutUts = Funcs.GetCurrentMilliseconds() + abnormality.Time;
 }

        public static float CheckIntersections(Creature creature, short heading, Point3D moveVector, float distance)
        {
            if (distance <= 0f)
                return 0f;

            WorldPosition targetPosition = moveVector.Clone().Add(creature.Position).ToWorldPosition();

            double minDistance = distance;

            List<Creature> around = Global.VisibleService.FindTargets(creature, creature.Position, distance + 40, TargetingAreaType.All);
            for (int x = 0; x < around.Count; x++)
            {
                if (around[x] == creature)
                    continue;

                short diff = Geom.GetAngleDiff(heading, Geom.GetHeading(creature.Position, around[x].Position));
                if (diff > 90)
                    continue;

                double d = Geom.DistanceToLine(around[x].Position, creature.Position, targetPosition);

                if (d > 40)
                    continue;

                d = creature.Position.DistanceTo(around[x].Position) - 40;

                if (d <= 0)
                    return 0f;

                if (d < minDistance)
                    minDistance = d;
            }

            return (float)(minDistance / distance);
        }

 public SpNpcStatus(Npc npc, int unk1, int unk2, Creature target = null)
 {
     Npc = npc;
     Unk1 = unk1;
     Unk2 = unk2;
     Target = target;
 }

 public virtual void Release()
 {
     Creature = null;
     Npc = null;
     Player = null;
     Random = null;
 }

        public void AddAbility(Creature target, int id, int level)
        {
            if (target == null)
                return;

            lock (target.EffectsLock)
            {
                for (int i = 0; i < target.Effects.Count; i++)
                {
                    if (target.Effects[i].AbilityId == id)
                        target.Effects.Remove(target.Effects[i]);
                }
            }

            Ability abi = Data.Data.Abilities[id];

            if (abi == null)
                return;

            abi.level = level;

            AbilityEffectsProvider.ProvideEffects(target, abi);

            lock (target.EffectsLock)
            {
                target.Effects.Add(abi);
            }

            lock (TargetsLock)
                if (!targets.Contains(target))
                    targets.Add(target);
        }

 public void Release()
 {
     Creature = null;
     Npc = null;
     Projectile = null;
     TargetPosition = null;
 }

        public static bool IsVisible(Player player, Creature creature)
        {
            if (creature is Player && !Communication.Global.PlayerService.IsPlayerOnline((Player)creature))
                return false;

            if (creature == null)
                return false;

            if (!(creature is Item) && !(creature is Gather) && !(creature is Campfire)
                && creature.LifeStats.IsDead())
                return false;

            if (creature is Gather && ((Gather)creature).CurrentGatherCounter <= 0)
                return false;

            double distance = player.Position.DistanceTo(creature.Position);
            if (distance > VisibleDistance)
                return false;

            if (creature is Npc && distance < 75)
                creature.Position.Z = player.Position.Z + 25;

            PlayerLogic.DistanceToCreatureRecalculated(player, creature, distance);

            return true;
        }

        public CreatureLifeStats(Creature creature)
        {
            _hp = creature.GameStats.HpBase + creature.GameStats.HpStamina;
            _mp = creature.GameStats.MpBase + creature.GameStats.MpStamina;

            Creature = creature;
        }

        public override void OnAttacked(Creature attacker, int damage)
        {
            Npc.Target = attacker;

            BattleController.AddDamage(attacker, damage);
            BattleController.AddAggro(attacker, damage);
        }

        public override void Init(Creature creature)
        {
            base.Init(creature);

            MoveController = new NpcMoveController(Npc);
            BattleController = new NpcBattleController(Npc);
        }

        protected int MoveStyle; // 1 normal : 2 run (when see player if agressive)

        #endregion Fields

        #region Constructors

        public SpNpcMove(Creature creature, float x, float y, float z, int style)
        {
            Creature = creature;
            Creature.Position.X = x;
            Creature.Position.Y = y;
            Creature.Position.Z = z;
            MoveStyle = style;
        }

        public static void OnAttack(Creature creature, Creature target)
        {
            creature.Ai.OnAttack(target);

            Player player = creature as Player;
            if (player != null)
                ObserverService.AddObserved(player, target);
        }

        public NpcMoveController(Creature creature)
        {
            Creature = creature;
            Npc = creature as Npc;

            TargetPosition = new Point3D();
            MoveVector = new Point3D();
        }

        public virtual void Init(Creature creature)
        {
            Creature = creature;
            Npc = creature as Npc;
            Player = creature as Player;

            Random = new Random((int) (DateTime.Now.Ticks + Funcs.Random().Next(int.MinValue, (int) Math.Abs(creature.Position.X))));
        }

        public static void InTheVision(Player player, Creature creature)
        {
            FeedbackService.SendCreatureInfo(player.Connection, creature);

            Npc npc = creature as Npc;
            if (npc != null)
                QuestEngine.ShowIcon(player, npc);
        }

        public override void Init(Creature creature)
        {
            base.Init(creature);

            NextRegenUts = Funcs.GetCurrentMilliseconds() + 1000;
            NextDistressUts = Funcs.GetCurrentMilliseconds() + 60000;
            LastBattleUts = 0;
        }

        public static void UpdateCreatureStats(Creature creature)
        {
            StatsService.UpdateStats(creature);

            Player player = creature as Player;
            if (player != null)
                FeedbackService.StatsUpdated(player);
        }

 public SpNpcMove(Creature creature, short speed, float x2, float y2, float z2)
 {
     Creature = creature;
     Speed = speed;
     X2 = x2;
     Y2 = y2;
     Z2 = z2;
 }

        public List<Npc> FindNpcs(Creature creature, float x, float y, float z, double distance, bool findVillagers = false)
        {
            double verticalDistance = distance * 2;

            return creature.VisibleNpcs.Select(npc =>
                                               npc.Position.DistanceTo(x, y) <= distance
                                               && Math.Abs(z - npc.Position.Z) < verticalDistance
                                               /*&& (!npc.NpcTemplate.IsVillager || findVillagers)*/);
        }

        public override void OnAttack(Creature target)
        {
            if (Player.Controller is DeathController)
                return;

            if (!(Player.Controller is BattleController))
                Global.ControllerService.SetController(Player, new BattleController());
            
            ((BattleController) Player.Controller).AddTarget(target);
        }