using System;
using System.Linq;
using Naruto.Client;
using System.Threading;
using System.Diagnostics;
using Naruto.Interfaces;
using System.Threading.Generic;
using System.Collections.Generic;
using Naruto.Network.GamePackets;
using System.Collections.Concurrent;

namespace Naruto.Game
{
    public unsafe class Screen
    {
        private static TimerRule<GameState> MonsterBuffers, Guards, AliveMonsters, Items, FloorSpells, MatrixMobs;
        public ConcurrentDictionary<uint, Game.EntityAdd> ConcurrentDictionaryPlayers = new ConcurrentDictionary<uint, EntityAdd>();
        public static void CreateTimerFactories()
        {
            MonsterBuffers = new TimerRule<GameState>(monsterBuffersCallback, 500);
            Guards = new TimerRule<GameState>(guardsCallback, 700);
            MatrixMobs = new TimerRule<GameState>(MatrixMobsCallback, 700);
            AliveMonsters = new TimerRule<GameState>(aliveMonstersCallback, 500);
            Items = new TimerRule<GameState>(itemsCallback, 1000);
            FloorSpells = new TimerRule<GameState>(FloorSpellsCallBack, 100);
        }
        private static void FloorSpellsCallBack(GameState client, int time)
        {
            if (!client.Socket.Alive)
            {
                client.Screen.DisposeTimers();
                return;
            }
            if (client.Entity == null) return;
            if (client.Map == null) return;
            Time32 Now = new Time32(time);
            if (client.Entity.FloorSpells.Count != 0)
            {
                foreach (var ID in client.Entity.FloorSpells)
                {
                    switch (ID.Key)
                    {
                    }
                }
            }
        }
        private static void monsterBuffersCallback(GameState client, int time)
        {
            if (!client.Socket.Alive)
            {
                client.Screen.DisposeTimers(); return;
            }
            if (client.Entity == null) return;
            if (client.Map == null) return;
            if (client.Map.FreezeMonsters) return;
            #region Stamina
            //if (client.Entity.StaminaStamp.Next(500, time: time))
            //{
            //    if (client.Vigor < client.MaxVigor)
            //    {
            //        ushort amount = (ushort)(3 + (client.Entity.Action == Game.Enums.ConquerAction.Sit ? 2 : 0));
            //        if (client.Vigor + amount > client.MaxVigor)
            //        {
            //            amount = client.MaxVigor;
            //            client.Vigor = amount;
            //        }
            //        else
            //        {
            //            client.Vigor += amount;
            //        }
            //        Vigor vigor = new Vigor(true);
            //        vigor.Amount = client.Vigor;
            //        vigor.Send(client);
            //    }
            //    if (!client.Entity.ContainsFlag((ulong)FlagsUpdate.Flags.Ride) && !client.Entity.ContainsFlag((ulong)FlagsUpdate.Flags.Fly) || client.Equipment.TryGetItem(18) != null)
            //    {
            //        int limit = 0;
            //        if (client.Entity.HeavenBlessing > 0)
            //            limit = 50;
            //        if (client.Spells != null)
            //        {
            //            if (client.Spells.ContainsKey(12560))
            //            {
            //                var spelll = client.Spells[12560];
            //                var skilll = Database.SpellTable.SpellInformations[12560][spelll.Level];
            //                limit += (int)skilll.Power;
            //            }
            //        }
            //        if (client.Entity.Stamina != 100 + limit)
            //        {
            //            if (client.Entity.Action == Enums.ConquerAction.Sit)
            //            {
            //                if (client.Entity.Stamina <= 90 + limit)
            //                {
            //                    client.Entity.Stamina += 10;
            //                }
            //                else
            //                {
            //                    if (client.Entity.Stamina != 100 + limit)
            //                        client.Entity.Stamina = (byte)(100 + limit);
            //                }
            //            }
            //            else
            //            {
            //                if (client.Entity.Stamina <= 95 + limit)
            //                {
            //                    client.Entity.Stamina += 5;
            //                }
            //                else
            //                {
            //                    if (client.Entity.Stamina != 100 + limit)
            //                        client.Entity.Stamina = (byte)(100 + limit);
            //                }
            //            }
            //        }
            //        client.Entity.StaminaStamp = new Time32(time);
            //    }
            //}
            #endregion
            #region Stamina
            if (client.Entity.StaminaStamp.Next(500, time: time))
            {
                if (client.Vigor < client.Entity.ExtraVigor)
                {
                    client.Vigor += (ushort)(3 + (client.Entity.Action == Game.Enums.ConquerAction.Sit ? 2 : 0));
                    {
                        Vigor vigor = new Vigor(true);
                        vigor.Amount = client.Vigor;
                        vigor.Send(client);
                    }
                }
                if (!client.Entity.ContainsFlag((ulong)FlagsUpdate.Flags.Ride) && !client.Entity.ContainsFlag((ulong)FlagsUpdate.Flags.Fly) || client.Equipment.TryGetItem(18) != null)
                {
                    int limit = 0;
                    if (client.Entity.HeavenBlessing > 0)
                        limit = 50;
                    if (client.Spells != null)
                    {
                        if (client.Spells.ContainsKey(12560))
                        {
                            var spell = client.Spells[12560];
                            var skill = Database.SpellTable.SpellInformations[12560][spell.Level];
                            limit += (int)skill.Power;
                        }
                    }
                    if (client.Entity.Stamina != 100 + limit)
                    {
                        if (client.Entity.Action == Enums.ConquerAction.Sit)
                        {
                            if (client.Entity.Stamina <= 93 + limit)
                            {
                                client.Entity.Stamina += 7;
                            }
                            else
                            {
                                if (client.Entity.Stamina != 100 + limit)
                                    client.Entity.Stamina = (byte)(100 + limit);
                            }
                        }
                        else
                        {
                            if (client.Entity.Stamina <= 97 + limit)
                            {
                                client.Entity.Stamina += 3;
                            }
                            else
                            {
                                if (client.Entity.Stamina != 100 + limit)
                                    client.Entity.Stamina = (byte)(100 + limit);
                            }
                        }
                    }
                    client.Entity.StaminaStamp = new Time32(time);
                }
            }
            #endregion
            #region Energia Aurora Lotus / Flame Lotus
            if (!client.Entity.Dead)
            {
                if (client.Entity.LotusEnergyStamp.Next(1000, time: time))
                {
                    if (client.Entity.Class >= 130 && client.Entity.Class <= 135)
                    {
                        if (client.Entity.ContainsFlag3((ulong)FlagsUpdate.Flags3.AuroraLotus))
                        {
                            if (client.Entity.AuroraLotusEnergy < 220)
                                client.Entity.AuroraLotusEnergy = (uint)Math.Min(220, client.Entity.AuroraLotusEnergy + 2);
                            client.Entity.Lotus(client.Entity.AuroraLotusEnergy, FlagsUpdate.AuroraLotus);
                        }
                    }
                    if (client.Entity.Class >= 140 && client.Entity.Class <= 145)
                    {
                        if (client.Entity.ContainsFlag3((ulong)FlagsUpdate.Flags3.FlameLotus))
                        {
                            if (client.Entity.FlameLotusEnergy < 330)
                                client.Entity.FlameLotusEnergy = (uint)Math.Min(330, client.Entity.FlameLotusEnergy + 3);
                            client.Entity.Lotus(client.Entity.FlameLotusEnergy, FlagsUpdate.FlameLotus);

                        }
                    }
                    client.Entity.LotusEnergyStamp = new Time32(time);
                }
            }
            #endregion
            if (client.Map.ID == 8880 || client.Map.ID == 8881)
            {
                SafeDictionary<uint, PokerTable> ToRem = new SafeDictionary<uint, PokerTable>(40);
                foreach (PokerTable T in PokerTables.Values)
                {
                    if (client.Map.ID == T.Map)
                        if (Kernel.GetDistance(T.X, T.Y, client.Entity.X, client.Entity.Y) > Constants.nScreenDistance)
                            ToRem.Add(T.Id, T);
                }
                foreach (PokerTable T in ToRem.Values)
                    if (PokerTables.ContainsKey(T.Id))
                        PokerTables.Remove(T.Id);
            }
            foreach (IMapObject obj in client.Screen.Objects)
            {
                if (obj != null)
                {
                    if (obj.MapObjType == MapObjectType.Monster)
                    {
                        Entity monster = obj as Entity;
                        if (monster == null) continue;

                        if (monster.ContainsFlag((ulong)FlagsUpdate.Flags.Stigma))
                        {
                            if (monster.StigmaStamp.AddSeconds(monster.StigmaTime).Next(time: time) || monster.Dead)
                            {
                                monster.StigmaTime = 0;
                                monster.StigmaIncrease = 0;
                                monster.RemoveFlag((ulong)FlagsUpdate.Flags.Stigma);
                            }
                        }
                        if (monster.ContainsFlag((ulong)FlagsUpdate.Flags.Dodge))
                        {
                            if (monster.DodgeStamp.AddSeconds(monster.DodgeTime).Next(time: time) || monster.Dead)
                            {
                                monster.DodgeTime = 0;
                                monster.DodgeIncrease = 0;
                                monster.RemoveFlag((ulong)Network.GamePackets.FlagsUpdate.Flags.Dodge);
                            }
                        }
                        if (monster.ContainsFlag((ulong)FlagsUpdate.Flags.Invisibility))
                        {
                            if (monster.InvisibilityStamp.AddSeconds(monster.InvisibilityTime).Next(time: time) || monster.Dead)
                            {
                                monster.RemoveFlag((ulong)FlagsUpdate.Flags.Invisibility);
                            }
                        }
                        if (monster.ContainsFlag((ulong)FlagsUpdate.Flags.StarOfAccuracy))
                        {
                            if (monster.StarOfAccuracyTime != 0)
                            {
                                if (monster.StarOfAccuracyStamp.AddSeconds(monster.StarOfAccuracyTime).Next(time: time) || monster.Dead)
                                {
                                    monster.RemoveFlag((ulong)FlagsUpdate.Flags.StarOfAccuracy);
                                }
                            }
                            else
                            {
                                if (monster.AccuracyStamp.AddSeconds(monster.AccuracyTime).Next(time: time) || monster.Dead)
                                {
                                    monster.RemoveFlag((ulong)FlagsUpdate.Flags.StarOfAccuracy);
                                }
                            }
                        }
                        if (monster.ContainsFlag((ulong)FlagsUpdate.Flags.MagicShield))
                        {
                            if (monster.MagicShieldTime != 0)
                            {
                                if (monster.MagicShieldStamp.AddSeconds(monster.MagicShieldTime).Next(time: time) || monster.Dead)
                                {
                                    monster.MagicShieldIncrease = 0;
                                    monster.MagicShieldTime = 0;
                                    monster.RemoveFlag((ulong)FlagsUpdate.Flags.MagicShield);
                                }
                            }
                            else
                            {
                                if (monster.ShieldStamp.AddSeconds(monster.ShieldTime).Next(time: time) || monster.Dead)
                                {
                                    monster.ShieldIncrease = 0;
                                    monster.ShieldTime = 0;
                                    monster.RemoveFlag((ulong)FlagsUpdate.Flags.MagicShield);
                                }
                            }
                        }
                        if (monster.Dead || monster.Killed)
                        {
                            if (!monster.ContainsFlag((ulong)FlagsUpdate.Flags.Ghost) || monster.Killed)
                            {
                                monster.Killed = false;
                                monster.MonsterInfo.InSight = 0;
                                monster.AddFlag((ulong)Network.GamePackets.FlagsUpdate.Flags.Ghost);
                                monster.AddFlag((ulong)Network.GamePackets.FlagsUpdate.Flags.Dead);
                                monster.AddFlag((ulong)Network.GamePackets.FlagsUpdate.Flags.FadeAway);
                                Network.GamePackets.Attack attack = new Network.GamePackets.Attack(true);
                                attack.Attacker = monster.Killer.UID;
                                attack.Attacked = monster.UID;
                                attack.AttackType = Network.GamePackets.Attack.Kill;
                                attack.X = monster.X;
                                attack.Y = monster.Y;
                                client.Map.Floor[monster.X, monster.Y, MapObjectType.Monster, monster] = true;
                                attack.KOCount = ++monster.Killer.KOCount;
                                if (monster.Killer.EntityFlag == EntityFlag.Player)
                                {
                                    monster.MonsterInfo.ExcludeFromSend = monster.Killer.UID;
                                    monster.Killer.Owner.Send(attack);
                                }
                                monster.MonsterInfo.SendScreen(attack);
                                monster.MonsterInfo.ExcludeFromSend = 0;
                            }
                            if (monster.DeathStamp.AddSeconds(4).Next(time: time))
                            {
                                Data data = new Data(true);
                                data.UID = monster.UID;
                                data.ID = Network.GamePackets.Data.RemoveEntity;
                                monster.MonsterInfo.SendScreen(data);
                            }
                        }
                    }
                }
            }
        }
        private static void guardsCallback(GameState client, int time)
        {
            if (!client.Socket.Alive)
            {
                client.Screen.DisposeTimers(); return;
            }
            if (client.Entity == null) return;
            if (client.Map == null) return;
            if (client.Map.FreezeMonsters) return;
            Time32 Now = new Time32(time);
            foreach (IMapObject obj in client.Screen.Objects)
            {
                if (obj != null)
                {
                    if (obj.MapObjType == MapObjectType.Monster)
                    {
                        Entity monster = obj as Entity;
                        if (!monster.Companion && !monster.Dead && !monster.Killed && monster.MonsterInfo.Guard && !monster.MonsterInfo.Boss && monster.Name != "NemesisTyrant" && monster.Name != "SwordMaster" && monster.Name != "ThrillingSpook" && monster.Name != "LavaBeast" && monster.Name != "SnowBanshee" && monster.Name != "PurpleBanshee" && monster.Name != "SnowBansheeSoul" && monster.Name != "TeratoDragon" && Now >= monster.MonsterInfo.LastMove.AddMilliseconds(monster.MonsterInfo.MinimumSpeed))
                        {
                            if (Now >= monster.MonsterInfo.LastMove.AddMilliseconds(monster.MonsterInfo.MinimumSpeed))
                            {
                                if (monster.MonsterInfo.InSight == 0)
                                {
                                    if (monster.X != monster.MonsterInfo.BoundX || monster.Y != monster.MonsterInfo.BoundY)
                                    {
                                        monster.X = monster.MonsterInfo.BoundX;
                                        monster.Y = monster.MonsterInfo.BoundY;
                                        TwoMovements jump = new TwoMovements();
                                        jump.X = monster.MonsterInfo.BoundX;
                                        jump.Y = monster.MonsterInfo.BoundY;
                                        jump.EntityCount = 1;
                                        jump.FirstEntity = monster.UID;
                                        jump.MovementType = TwoMovements.Jump;
                                        client.SendScreen(jump, true);
                                    }
                                    /*
                                    if (monster.MonsterInfo.Type != 1)
                                       client.Send(new Network.GamePackets.Message("WelCoMe In "+ Constants.ServerName +"#38", client.Entity.Name, monster.MonsterInfo.Name, System.Drawing.Color.White, Message.Talk));
                                       client.Send(new Network.GamePackets.Message("WelCoMe In " + Constants.ServerName + "#00", client.Entity.Name, monster.Name, System.Drawing.Color.White, Message.Talk));
                                    */
                                    if (client.Entity.ContainsFlag((ulong)Network.GamePackets.FlagsUpdate.Flags.FlashingName))
                                        monster.MonsterInfo.InSight = client.Entity.UID;
                                }
                                else
                                {
                                    if (client.Entity.ContainsFlag((ulong)Network.GamePackets.FlagsUpdate.Flags.FlashingName))
                                    {
                                        if (monster.MonsterInfo.InSight == client.Entity.UID)
                                        {
                                            if (!client.Entity.Dead)
                                            {
                                                if (Now >= monster.MonsterInfo.LastMove.AddMilliseconds(monster.MonsterInfo.AttackSpeed))
                                                {
                                                    short distance = Kernel.GetDistance(monster.X, monster.Y, client.Entity.X, client.Entity.Y);

                                                    if (distance <= monster.MonsterInfo.AttackRange)
                                                    {
                                                        monster.MonsterInfo.LastMove = Time32.Now;
                                                        new Game.Attacking.Handle(null, monster, client.Entity);
                                                    }
                                                    else
                                                    {
                                                        if (distance <= monster.MonsterInfo.ViewRange)
                                                        {
                                                            TwoMovements jump = new TwoMovements();
                                                            jump.X = client.Entity.X;
                                                            jump.Y = client.Entity.Y;
                                                            monster.X = client.Entity.X;
                                                            monster.Y = client.Entity.Y;
                                                            jump.EntityCount = 1;
                                                            jump.FirstEntity = monster.UID;
                                                            jump.MovementType = TwoMovements.Jump;
                                                            client.SendScreen(jump, true);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    else
                                    {
                                        if (monster.MonsterInfo.InSight == client.Entity.UID)
                                        {
                                            monster.MonsterInfo.InSight = 0;
                                        }
                                    }
                                }
                                foreach (IMapObject obj2 in client.Screen.Objects)
                                {
                                    if (obj2 == null) continue;
                                    if (obj2.MapObjType == MapObjectType.Monster)
                                    {
                                        Entity monster2 = obj2 as Entity;

                                        if (monster2 == null) continue;
                                        if (monster2.Dead) continue;

                                        if (Now >= monster.MonsterInfo.LastMove.AddMilliseconds(monster.MonsterInfo.AttackSpeed))
                                        {
                                            if (!monster2.MonsterInfo.Guard && (!monster2.Companion || monster2.Owner.Entity.ContainsFlag((ulong)FlagsUpdate.Flags.FlashingName)))
                                            {
                                                short distance = Kernel.GetDistance(monster.X, monster.Y, monster2.X, monster2.Y);

                                                if (distance <= monster.MonsterInfo.AttackRange)
                                                {
                                                    monster.MonsterInfo.LastMove = Time32.Now;
                                                    new Game.Attacking.Handle(null, monster, monster2);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        private static void aliveMonstersCallback(GameState client, int time)
        {
            if (!client.Socket.Alive)
            {
                client.Screen.DisposeTimers();
                return;
            }
            if (client.Entity == null) return;
            if (client.Map == null) return;
            if (client.Map.FreezeMonsters) return;
            Time32 Now = new Time32(time);
            foreach (IMapObject obj in client.Screen.Objects)
            {
                if (obj != null)
                {
                    if (obj.MapObjType == MapObjectType.Monster)
                    {
                        Entity monster = obj as Entity;

                        if (monster == null) continue;
                        if (monster.MonsterInfo.Guard || monster.Companion || monster.Dead) continue;
                        if (monster.MonsterInfo.Reviver)
                        {
                            if (client.Entity.Dead && Now > client.Entity.DeathStamp.AddSeconds(5))
                            {
                                client.Entity.BringToLife();
                                SpellUse use = new SpellUse(true);
                                use.Attacker = monster.UID;
                                use.X = client.Entity.X;
                                use.Y = client.Entity.Y;
                                use.SpellID = 1100;
                                use.AddTarget(client.Entity.UID, 0, null);
                                Kernel.SendWorldMessage(use, Server.GamePool, monster.MapID);
                            }
                            return;
                        }
                        short distance = Kernel.GetDistance(monster.X, monster.Y, client.Entity.X, client.Entity.Y);
                        if (distance > Constants.pScreenDistance)
                        {
                            client.Screen.Remove(obj);
                            continue;
                        }
                        if (monster.MonsterInfo.InSight != 0 && monster.MonsterInfo.InSight != client.Entity.UID)
                        {
                            if (monster.MonsterInfo.InSight > 1000000)
                            {
                                GameState cl;
                                if (Kernel.GamePool.TryGetValue(monster.MonsterInfo.InSight, out cl))
                                {
                                    short dst = Kernel.GetDistance(monster.X, monster.Y, cl.Entity.X, cl.Entity.Y);
                                    if (dst > Constants.pScreenDistance)
                                        monster.MonsterInfo.InSight = 0;
                                }
                                else
                                    monster.MonsterInfo.InSight = 0;
                            }
                            else
                            {
                                Entity companion = client.Map.Companions[monster.MonsterInfo.InSight];
                                if (companion != null)
                                {
                                    short dst = Kernel.GetDistance(monster.X, monster.Y, companion.X, companion.Y);
                                    if (dst > Constants.pScreenDistance)
                                        monster.MonsterInfo.InSight = 0;
                                }
                                else
                                    monster.MonsterInfo.InSight = 0;
                            }
                        }
                        if (Now >= monster.MonsterInfo.LastMove.AddMilliseconds(monster.MonsterInfo.MinimumSpeed))
                        {
                            if (distance <= Constants.pScreenDistance)
                            {
                                #region Companions
                                if (client.Pet != null)
                                {
                                    if (client.Pet.Pets != null)
                                    {
                                        foreach (var pet in client.Pet.Pets.Values)
                                        {
                                            if (pet != null)
                                            {
                                                #region Pets
                                                if (pet.Entity.Companion && !pet.Entity.Dead)
                                                {
                                                    short distance2 = Kernel.GetDistance(monster.X, monster.Y, pet.Entity.X, pet.Entity.Y);
                                                    if (distance > distance2 || client.Entity.ContainsFlag((ulong)FlagsUpdate.Flags.Invisibility) || client.Entity.ContainsFlag((ulong)FlagsUpdate.Flags.Fly))
                                                    {
                                                        if (monster.MonsterInfo.InSight == 0)
                                                        {
                                                            monster.MonsterInfo.InSight = pet.Entity.UID;
                                                        }
                                                        else
                                                        {
                                                            if (monster.MonsterInfo.InSight == pet.Entity.UID)
                                                            {
                                                                if (distance2 > Constants.pScreenDistance)
                                                                {
                                                                    monster.MonsterInfo.InSight = 0;
                                                                }
                                                                else
                                                                {
                                                                    if (distance2 <= monster.MonsterInfo.AttackRange)
                                                                    {
                                                                        if (Now >= monster.MonsterInfo.LastMove.AddMilliseconds(monster.MonsterInfo.AttackSpeed))
                                                                        {
                                                                            monster.MonsterInfo.LastMove = Time32.Now;
                                                                            new Game.Attacking.Handle(null, monster, pet.Entity);
                                                                            if (Time32.Now >= monster.MonsterInfo.Lastpop.AddSeconds(30))
                                                                            {
                                                                                monster.MonsterInfo.Lastpop = Time32.Now;
                                                                                continue;
                                                                            }
                                                                        }
                                                                    }
                                                                    else
                                                                    {
                                                                        if (distance2 > monster.MonsterInfo.ViewRange / 2)
                                                                        {
                                                                            if (distance2 < Constants.pScreenDistance)
                                                                            {
                                                                                if (Now >= monster.MonsterInfo.LastMove.AddMilliseconds(monster.MonsterInfo.RunSpeed))
                                                                                {
                                                                                    monster.MonsterInfo.LastMove = Time32.Now;
                                                                                    Enums.ConquerAngle facing = Kernel.GetAngle(monster.X, monster.Y, pet.Entity.X, pet.Entity.Y);
                                                                                    if (!monster.Move(facing))
                                                                                    {
                                                                                        facing = (Enums.ConquerAngle)Kernel.Random.Next(7);
                                                                                        if (monster.Move(facing))
                                                                                        {
                                                                                            monster.Facing = facing;
                                                                                            GroundMovement move = new GroundMovement(true);
                                                                                            move.Direction = facing;
                                                                                            move.UID = monster.UID;
                                                                                            move.GroundMovementType = GroundMovement.Run;
                                                                                            monster.MonsterInfo.SendScreen(move);
                                                                                            continue;
                                                                                        }
                                                                                    }
                                                                                    else
                                                                                    {
                                                                                        monster.Facing = facing;
                                                                                        GroundMovement move = new GroundMovement(true);
                                                                                        move.Direction = facing;
                                                                                        move.UID = monster.UID;
                                                                                        move.GroundMovementType = GroundMovement.Run;
                                                                                        monster.MonsterInfo.SendScreen(move);
                                                                                        continue;
                                                                                    }
                                                                                }
                                                                            }
                                                                            else
                                                                            {
                                                                                monster.MonsterInfo.InSight = 0;
                                                                            }
                                                                        }
                                                                        else
                                                                        {
                                                                            if (Now >= monster.MonsterInfo.LastMove.AddMilliseconds(monster.MonsterInfo.MoveSpeed))
                                                                            {
                                                                                monster.MonsterInfo.LastMove = Time32.Now;
                                                                                Enums.ConquerAngle facing = Kernel.GetAngle(monster.X, monster.Y, pet.Entity.X, pet.Entity.Y);
                                                                                if (!monster.Move(facing))
                                                                                {
                                                                                    facing = (Enums.ConquerAngle)Kernel.Random.Next(7);
                                                                                    if (monster.Move(facing))
                                                                                    {
                                                                                        monster.Facing = facing;
                                                                                        GroundMovement move = new GroundMovement(true);
                                                                                        move.Direction = facing;
                                                                                        move.UID = monster.UID;
                                                                                        monster.MonsterInfo.SendScreen(move);
                                                                                        continue;
                                                                                    }
                                                                                }
                                                                                else
                                                                                {
                                                                                    monster.Facing = facing;
                                                                                    GroundMovement move = new GroundMovement(true);
                                                                                    move.Direction = facing;
                                                                                    move.UID = monster.UID;
                                                                                    monster.MonsterInfo.SendScreen(move);
                                                                                    continue;
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                #endregion
                                            }

                                        }
                                    }
                                }
                                #endregion
                                #region Player
                                if (monster.MonsterInfo.InSight == 0)
                                {
                                    if (distance <= monster.MonsterInfo.ViewRange)
                                    {
                                        if (!client.Entity.ContainsFlag((ulong)FlagsUpdate.Flags.Invisibility))
                                        {
                                            if (monster.MonsterInfo.SpellID != 0 || !client.Entity.ContainsFlag((ulong)FlagsUpdate.Flags.Fly))
                                            {
                                                monster.MonsterInfo.InSight = client.Entity.UID;
                                            }
                                        }
                                    }
                                }
                                else
                                {
                                    if (monster.MonsterInfo.InSight == client.Entity.UID)
                                    {
                                        if (monster.MonsterInfo.SpellID == 0 && client.Entity.ContainsFlag((ulong)FlagsUpdate.Flags.Fly))
                                        {
                                            monster.MonsterInfo.InSight = 0;
                                            return;
                                        }
                                        if (client.Entity.Dead)
                                        {
                                            monster.MonsterInfo.InSight = 0;
                                            return;
                                        }
                                        if (distance > Constants.pScreenDistance)
                                        {
                                            monster.MonsterInfo.InSight = 0;
                                        }
                                        else
                                        {
                                            if (distance <= monster.MonsterInfo.AttackRange)
                                            {
                                                if (Now >= monster.MonsterInfo.LastMove.AddMilliseconds(monster.MonsterInfo.AttackSpeed))
                                                {
                                                    monster.MonsterInfo.LastMove = Time32.Now;
                                                    new Game.Attacking.Handle(null, monster, client.Entity);
                                                }
                                            }
                                            else
                                            {
                                                if (distance > monster.MonsterInfo.ViewRange / 2)
                                                {
                                                    if (distance < Constants.pScreenDistance)
                                                    {
                                                        if (Now >= monster.MonsterInfo.LastMove.AddMilliseconds(monster.MonsterInfo.RunSpeed))
                                                        {
                                                            monster.MonsterInfo.LastMove = Time32.Now;
                                                            Enums.ConquerAngle facing = Kernel.GetAngle(monster.X, monster.Y, client.Entity.X, client.Entity.Y);
                                                            if (!monster.Move(facing))
                                                            {
                                                                facing = (Enums.ConquerAngle)Kernel.Random.Next(7);
                                                                if (monster.Move(facing))
                                                                {
                                                                    monster.Facing = facing;
                                                                    GroundMovement move = new GroundMovement(true);
                                                                    move.Direction = facing;
                                                                    move.UID = monster.UID;
                                                                    move.GroundMovementType = Network.GamePackets.GroundMovement.Run;
                                                                    monster.MonsterInfo.SendScreen(move);
                                                                }
                                                            }
                                                            else
                                                            {
                                                                monster.Facing = facing;
                                                                GroundMovement move = new GroundMovement(true);
                                                                move.Direction = facing;
                                                                move.UID = monster.UID;
                                                                move.GroundMovementType = Network.GamePackets.GroundMovement.Run;
                                                                monster.MonsterInfo.SendScreen(move);
                                                            }
                                                        }
                                                    }
                                                    else
                                                    {
                                                        monster.MonsterInfo.InSight = 0;
                                                    }
                                                }
                                                else
                                                {
                                                    if (Now >= monster.MonsterInfo.LastMove.AddMilliseconds(monster.MonsterInfo.MoveSpeed))
                                                    {
                                                        monster.MonsterInfo.LastMove = Time32.Now;
                                                        Enums.ConquerAngle facing = Kernel.GetAngle(monster.X, monster.Y, client.Entity.X, client.Entity.Y);
                                                        if (!monster.Move(facing))
                                                        {
                                                            facing = (Enums.ConquerAngle)Kernel.Random.Next(7);
                                                            if (monster.Move(facing))
                                                            {
                                                                monster.Facing = facing;
                                                                GroundMovement move = new GroundMovement(true);
                                                                move.Direction = facing;
                                                                move.UID = monster.UID;
                                                                monster.MonsterInfo.SendScreen(move);
                                                            }
                                                        }
                                                        else
                                                        {
                                                            monster.Facing = facing;
                                                            GroundMovement move = new GroundMovement(true);
                                                            move.Direction = facing;
                                                            move.UID = monster.UID;
                                                            monster.MonsterInfo.SendScreen(move);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                #endregion
                            }
                        }
                    }
                    else if (obj.MapObjType == MapObjectType.Item)
                    {
                        FloorItem item = obj as FloorItem;
                        if (item == null) continue;

                        if (item.Type == FloorItem.Effect)
                        {
                            if (item.ItemID == FloorItem.DaggerStorm || item.ItemID == FloorItem.FuryofEgg || item.ItemID == FloorItem.ShacklingIce || item.ItemID == 31)
                            {
                                if (item.Owner == client)
                                {
                                    if (Time32.Now > item.UseTime.AddSeconds(1))
                                    {
                                        item.UseTime = Time32.Now;
                                        var spell = Database.SpellTable.GetSpell(11600, client);
                                        var attack = new Attack(true);
                                        attack.Attacker = item.Owner.Entity.UID;
                                        attack.AttackType = Attack.Melee;
                                        foreach (var obj1 in client.Screen.Objects)
                                        {
                                            if (Kernel.GetDistance(obj1.X, obj1.Y, obj.X, obj.Y) <= 3)
                                            {
                                                if (obj1.MapObjType == MapObjectType.Monster || obj1.MapObjType == MapObjectType.Player)
                                                {
                                                    var attacked = obj1 as Entity;
                                                    if (Attacking.Handle.CanAttack(client.Entity, attacked, spell, false))
                                                    {
                                                        uint damage = Game.Attacking.Calculate.Melee(client.Entity, attacked, spell, ref attack);
                                                        damage = (uint)((damage) / 12);
                                                        attack.Damage = damage;
                                                        attack.Attacked = attacked.UID;
                                                        attack.X = attacked.X;
                                                        attack.Y = attacked.Y;
                                                        Attacking.Handle.ReceiveAttack(client.Entity, attacked, attack, ref damage, spell);
                                                    }
                                                }
                                                else if (obj1.MapObjType == MapObjectType.SobNpc)
                                                {
                                                    var attacked = obj1 as SobNpcSpawn;
                                                    if (Attacking.Handle.CanAttack(client.Entity, attacked, spell))
                                                    {
                                                        uint damage = Game.Attacking.Calculate.Melee(client.Entity, attacked, ref attack);
                                                        damage = (uint)(damage * spell.PowerPercent);
                                                        attack.Damage = damage;
                                                        attack.Attacked = attacked.UID;
                                                        attack.X = attacked.X;
                                                        attack.Y = attacked.Y;
                                                        Attacking.Handle.ReceiveAttack(client.Entity, attacked, attack, damage, spell);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            if (item.ItemID == 1397)
                            {
                                if (item.Owner == client)
                                {
                                    if (item.OnFloor.AddSeconds(3).Next(time: time))
                                    {
                                        item.UseTime = Time32.Now;
                                        var spell = Database.SpellTable.GetSpell(12550, client);
                                        var attack = new Attack(true);
                                        attack.Attacker = item.Owner.Entity.UID;
                                        attack.AttackType = Attack.Melee;
                                        foreach (var obj1 in client.Screen.Objects)
                                        {
                                            if (Kernel.GetDistance(obj1.X, obj1.Y, obj.X, obj.Y) <= 3)
                                            {
                                                if (obj1.MapObjType == MapObjectType.Player)
                                                {
                                                    var attacked = obj1 as Entity;
                                                    if (Attacking.Handle.CanAttack(client.Entity, attacked, spell, false))
                                                    {
                                                        uint damage = Game.Attacking.Calculate.Melee(client.Entity, attacked, spell, ref attack);
                                                        // damage = (uint)(damage * 3);
                                                        // damage = damage * 10;
                                                        attack.Damage = damage;
                                                        attack.Attacked = attacked.UID;
                                                        attack.X = attacked.X;
                                                        attack.Y = attacked.Y;
                                                        Attacking.Handle.ReceiveAttack(client.Entity, attacked, attack, ref damage, spell);
                                                    }
                                                }
                                                else if (obj1.MapObjType == MapObjectType.Monster)
                                                {
                                                    var attacked = obj1 as Entity;
                                                    if (Attacking.Handle.CanAttack(client.Entity, attacked, spell, false))
                                                    {
                                                        uint damage = Game.Attacking.Calculate.Melee(client.Entity, attacked, spell, ref attack);
                                                        //  damage = (uint)(damage * 3);
                                                        //  damage = damage * 10;
                                                        attack.Damage = damage;
                                                        attack.Attacked = attacked.UID;
                                                        attack.X = attacked.X;
                                                        attack.Y = attacked.Y;
                                                        Attacking.Handle.ReceiveAttack(client.Entity, attacked, attack, ref damage, spell);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
          private static void itemsCallback(GameState client, int time)
        {
            if (!client.Socket.Alive)
            {
                client.Screen.DisposeTimers(); return;
            }
            if (client.Entity == null) return;
            if (client.Map == null) return;
            if (client.Map.FreezeMonsters) return;
            if (!client.Entity.FullyLoaded) return;
            Time32 Now = new Time32(time);
            foreach (IMapObject obj in client.Screen.Objects)
            {
                if (obj != null)
                {
                    if (obj.MapObjType == MapObjectType.Item)
                    {
                        FloorItem item = obj as FloorItem;
                        if (item == null) continue;
                        if (item.Type == FloorItem.Effect)
                        {
                            if (item.ItemID == 1397)
                            {
                                if (item.OnFloor.AddSeconds(3).Next(time: time))
                                {
                                    Attacking.Handle.InfroEcho(item);
                                    item.Type = FloorItem.RemoveEffect;
                                    client.Map.RemoveFloorItem(item);
                                    client.RemoveScreenSpawn(item, true);
                                }
                            }
                            if (item.ItemID == FloorItem.DaggerStorm || item.ItemID == FloorItem.FuryofEgg || item.ItemID == FloorItem.ShacklingIce || item.ItemID == 31)
                            {
                                if (item.OnFloor.AddSeconds(4).Next(time: time))
                                {
                                    item.Type = FloorItem.RemoveEffect;
                                    client.Map.RemoveFloorItem(item);
                                    client.RemoveScreenSpawn(item, true);
                                }
                            }
                            if (item.ItemID == FloorItem.AuroraLotus)
                            {
                                if (item.OnFloor.AddSeconds(7).Next(time: time))
                                {
                                    item.Type = FloorItem.RemoveEffect;
                                    client.Map.RemoveFloorItem(item);
                                    client.RemoveScreenSpawn(item, true);
                                    Attacking.Handle.AuroraLotus(item);
                                }
                            }
                            if (item.ItemID == FloorItem.FlameLotus)
                            {
                                if (item.OnFloor.AddSeconds(7).Next(time: time))
                                {
                                    item.Type = FloorItem.RemoveEffect;
                                    client.Map.RemoveFloorItem(item);
                                    client.RemoveScreenSpawn(item, true);
                                    Attacking.Handle.FlameLotus(item);
                                }
                            }
                            if (item.ItemID == FloorItem.TwilightDance)
                            {
                                if (item.OnFloor.AddMilliseconds(500).Next(time: time))
                                {
                                    item.Type = FloorItem.RemoveEffect;
                                    client.Map.RemoveFloorItem(item);
                                    client.RemoveScreenSpawn(item, true);
                                }
                            }
                        }
                        else
                        {
                            if (item.OnFloor.AddSeconds(Constants.FloorItemSeconds).Next(time: time))
                            {
                                item.Type = FloorItem.Remove;
                                foreach (Interfaces.IMapObject _obj in client.Screen.Objects)
                                    if (_obj != null)
                                        if (_obj.MapObjType == MapObjectType.Player)
                                            (_obj as Entity).Owner.Send(item);
                                client.Map.RemoveFloorItem(item);
                                client.Screen.Remove(item);
                            }
                        }

                    }
                }
            }
        }
        private static void MatrixMobsCallback(GameState client, int time)
        {
            if (!client.Socket.Alive)
            {
                client.Screen.DisposeTimers();
                return;
            }
            if (client.Entity == null)
                return;
            if (client.Map == null)
                return;
            if (client.Map.FreezeMonsters)
                return;

            Time32 Now = new Time32(time);
            foreach (IMapObject obj in client.Screen.Objects)
            {
                if (obj != null)
                {
                    if (obj.MapObjType == MapObjectType.Monster)
                    {
                        Entity monster = obj as Entity;
                        if (monster.Companion) continue;
                        if (monster.Dead || monster.Killed) continue;

                        if (monster.MonsterInfo.Type == 2 || monster.Mesh == 482)
                        {
                            if (Now >= monster.MonsterInfo.LastMove.AddMilliseconds(monster.MonsterInfo.MinimumSpeed))
                            {
                                if (monster.MonsterInfo.InSight == 0)
                                {
                                    ushort xx = (ushort)Kernel.Random.Next(monster.X - 10, monster.X + 10);
                                    ushort yy = (ushort)Kernel.Random.Next(monster.Y - 10, monster.Y + 10);
                                    if (monster.X != xx || monster.Y != yy)
                                    {
                                        monster.X = xx;
                                        monster.Y = yy;
                                        TwoMovements jump = new TwoMovements();
                                        jump.X = xx;
                                        jump.Y = yy;
                                        jump.EntityCount = 1;
                                        jump.FirstEntity = monster.UID;
                                        jump.MovementType = TwoMovements.Jump;
                                        client.SendScreen(jump, true);
                                    }
                                    // if (client.Entity.ContainsFlag(Update.Flags.FlashingName))
                                    //    monster.MonsterInfo.InSight = client.Entity.UID;
                                }
                                else
                                {
                                    //  if (client.Entity.ContainsFlag(Update.Flags.FlashingName))
                                    {
                                        if (monster.MonsterInfo.InSight == client.Entity.UID)
                                        {
                                            if (!client.Entity.Dead)
                                            {
                                                if (Now >= monster.MonsterInfo.LastMove.AddMilliseconds(monster.MonsterInfo.AttackSpeed))
                                                {
                                                    short distance = Kernel.GetDistance(monster.X, monster.Y, client.Entity.X, client.Entity.Y);

                                                    if (distance <= monster.MonsterInfo.AttackRange)
                                                    {
                                                        monster.MonsterInfo.LastMove = Time32.Now;
                                                        new Game.Attacking.Handle(null, monster, client.Entity);
                                                        if (Time32.Now >= monster.MonsterInfo.Lastpop.AddSeconds(30))
                                                        {
                                                            monster.MonsterInfo.Lastpop = Time32.Now;

                                                        }
                                                    }
                                                    else
                                                    {
                                                        if (distance <= monster.MonsterInfo.ViewRange)
                                                        {
                                                            TwoMovements jump = new TwoMovements();
                                                            jump.X = client.Entity.X;
                                                            jump.Y = client.Entity.Y;
                                                            monster.X = client.Entity.X;
                                                            monster.Y = client.Entity.Y;
                                                            jump.EntityCount = 1;
                                                            jump.FirstEntity = monster.UID;
                                                            jump.MovementType = TwoMovements.Jump;
                                                            client.SendScreen(jump, true);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        private IDisposable[] TimerSubscriptions;
        private object DisposalSyncRoot;
        public ConcurrentDictionary<uint, Game.Statue> Statue = new ConcurrentDictionary<uint, Statue>();
        private Interfaces.IMapObject[] _objects;
        private static ConcurrentDictionary<uint, PokerTable> PokerTables;
        public Interfaces.IMapObject[] Objects
        {
            get { return _objects; }
        }
        private ConcurrentDictionary<uint, Interfaces.IMapObject> _objectDictionary;
        public Client.GameState Owner;
        public Screen(Client.GameState client)
        {
            Owner = client;
            _objects = new Interfaces.IMapObject[0];
            PokerTables = new ConcurrentDictionary<uint, PokerTable>();
            _objectDictionary = new ConcurrentDictionary<uint, IMapObject>();
            TimerSubscriptions = new IDisposable[]
            {
                MonsterBuffers.Add(client),
                Guards.Add(client),
                AliveMonsters.Add(client),
                Items.Add(client),
                FloorSpells.Add(client),
                MatrixMobs.Add(client)
            };
            DisposalSyncRoot = new object();
        }
        ~Screen()
        {
            DisposeTimers();
            Clear();
            _objects = null;
            _objectDictionary = null;
            Owner = null;
        }
        public void DisposeTimers()
        {
            lock (DisposalSyncRoot)
            {
                if (TimerSubscriptions == null) return;
                for (int i = 0; i < TimerSubscriptions.Length; i++)
                {
                    if (TimerSubscriptions[i] != null)
                    {
                        TimerSubscriptions[i].Dispose();
                        TimerSubscriptions[i] = null;
                    }
                }
            }
        }
        private void updateBase()
        {
            _objects = _objectDictionary.Values.ToArray();
        }
        public bool Add(Interfaces.IMapObject _object)
        {
            if (_object == null) return false;
            if (_objectDictionary.ContainsKey(_object.UID))
                if (_objectDictionary[_object.UID] == null)
                    _objectDictionary.Remove(_object.UID);
            if (!_objectDictionary.ContainsKey(_object.UID))
            {
                if (Kernel.GetDistance(_object.X, _object.Y, Owner.Entity.X, Owner.Entity.Y) <= Constants.pScreenDistance)
                {
                    _objectDictionary[_object.UID] = _object;
                    updateBase();
                    return true;
                }
            }
            return false;
        }
        public bool Remove(Interfaces.IMapObject _object)
        {
            if (_object == null) return false;
            if (_objectDictionary.Remove(_object.UID))
            {
                updateBase();
                if (_object.MapObjType == MapObjectType.Item)
                {
                    FloorItem item = _object as FloorItem;
                    if (item.Type >= FloorItem.Effect)
                    {
                        item.Type = FloorItem.RemoveEffect;
                        Owner.Send(item);
                    }
                    else
                    {
                        item.Type = FloorItem.Remove;
                        Owner.Send(item);
                        item.Type = FloorItem.Drop;
                    }
                }
                else if (_object.MapObjType == MapObjectType.Player)
                {
                    Owner.Send(new Data(true)
                    {
                        UID = _object.UID,
                        ID = Network.GamePackets.Data.RemoveEntity
                    });
                }
                else if (_object.MapObjType == MapObjectType.StaticEntity)
                {
                    Owner.Send(new Data(true)
                    {
                        UID = _object.UID,
                        ID = Network.GamePackets.Data.RemoveEntity
                    });
                }
                return true;
            }
            return false;
        }
        public bool TryGetValue(uint uid, out Entity entity)
        {
            entity = null;
            Interfaces.IMapObject imo = null;
            if (_objectDictionary.TryGetValue(uid, out imo))
            {
                if (imo == null)
                {
                    _objectDictionary.Remove(uid);
                    updateBase();
                    return false;
                }
                if (imo is Entity)
                {
                    entity = imo as Entity;
                    return true;
                }
            }
            return false;
        }
        public bool GetRaceObject(Func<IMapObject, bool> predicate, out StaticEntity entity)
        {
            entity = null;
            foreach (var obj in Objects)
                if (obj is StaticEntity)
                    if (predicate(obj))
                        entity = obj as StaticEntity;
            return entity != null;
        }
        public bool TryGetSob(uint uid, out SobNpcSpawn sob)
        {
            sob = null;
            Interfaces.IMapObject imo = null;
            if (_objectDictionary.TryGetValue(uid, out imo))
            {
                if (imo == null)
                {
                    _objectDictionary.Remove(uid);
                    updateBase();
                    return false;
                }
                if (imo is SobNpcSpawn)
                {
                    sob = imo as SobNpcSpawn;
                    return true;
                }
            }
            return false;
        }
        public bool TryGetFloorItem(uint uid, out FloorItem item)
        {
            item = null;
            Interfaces.IMapObject imo = null;
            if (_objectDictionary.TryGetValue(uid, out imo))
            {
                if (imo == null)
                {
                    _objectDictionary.Remove(uid);
                    updateBase();
                    return false;
                }
                if (imo is FloorItem)
                {
                    item = imo as FloorItem;
                    return true;
                }
            }
            return false;
        }
        public IEnumerable<T> Select<T>(MapObjectType type) where T : class
        {
            foreach (var obj in Objects)
                if (obj != null)
                    if (obj.MapObjType == type)
                        yield return obj as T;
        }
        public IEnumerable<T> Where<T>(Func<IMapObject, bool> predicate) where T : class
        {
            foreach (var obj in Objects)
                if (obj != null)
                    if (predicate(obj))
                        yield return obj as T;
        }
        public IEnumerable<T> SelectWhere<T>(MapObjectType type, Func<T, bool> predicate) where T : class
        {
            foreach (var obj in Objects)
                if (obj != null)
                    if (obj.MapObjType == type)
                        if (predicate(obj as T))
                            yield return obj as T;
        }
        public bool Contains(Interfaces.IMapObject _object)
        {
            if (_object == null) return false;
            return _objectDictionary.ContainsKey(_object.UID);
        }
        public bool Contains(uint uid)
        {
            return _objectDictionary.ContainsKey(uid);
        }
        public void FullWipe()
        {
            foreach (IMapObject Base in Objects)
            {
                if (Base == null) continue;
                Data data = new Data(true);
                data.UID = Base.UID;
                data.ID = Data.RemoveEntity;
                Owner.Send(data);
                if (Base.MapObjType == Game.MapObjectType.Player)
                {
                    GameState pPlayer = Base.Owner as GameState;
                    pPlayer.Screen.Remove(Owner.Entity);
                }
            }
            Clear();
        }
        public void Clear()
        {
            _objectDictionary.Clear();
            _objects = new IMapObject[0];
        }
        public ConcurrentDictionary<uint, Game.BotShop> BOTSTALL = new ConcurrentDictionary<uint, BotShop>();
        public void Reload(Interfaces.IPacket spawnWith = null)
        {
            CleanUp(spawnWith);
            if (Owner.Entity.MapID == 1002)
            {
                foreach (var statue in Game.Statue.Statues.Values)
                {
                    if (statue > Owner)
                    {
                        Statue.TryAdd(statue.UID, statue);
                    }
                    else if (statue < Owner)
                    {
                        Game.Statue astatue;
                        Statue.TryRemove(statue.UID, out astatue);
                    }
                }
            }
            else
            {
                if (Statue.Count > 0)
                    Statue.Clear();
            }
            try
            {
                foreach (GameState pClient in Kernel.GamePool.Values)
                {
                    if (pClient == null) return;
                    if (pClient.Entity == null) return;
                    if (Owner == null) return;
                    if (Owner.Entity == null) return;
                    if (pClient.Entity.UID != Owner.Entity.UID)
                    {
                        if (pClient.Map.ID == Owner.Map.ID)
                        {
                            short dist = Kernel.GetDistance(pClient.Entity.X, pClient.Entity.Y, Owner.Entity.X, Owner.Entity.Y);
                            if (dist <= Constants.pScreenDistance && !Contains(pClient.Entity))
                            {
                                if (pClient.Guild != null)
                                    pClient.Guild.SendName(Owner);
                                if (Owner.Guild != null)
                                    Owner.Guild.SendName(pClient);
                                if (pClient.Entity.InteractionInProgress && pClient.Entity.InteractionWith != Owner.Entity.UID && pClient.Entity.InteractionSet)
                                {
                                    if (pClient.Entity.Body == 1003 || pClient.Entity.Body == 1004)
                                    {
                                        if (pClient.Entity.InteractionX == pClient.Entity.X && pClient.Entity.Y == pClient.Entity.InteractionY)
                                        {
                                            Attack atak = new Attack(true);
                                            atak.Attacker = pClient.Entity.UID;
                                            atak.Attacked = pClient.Entity.InteractionWith;
                                            atak.X = pClient.Entity.X;
                                            atak.Y = pClient.Entity.Y;
                                            atak.AttackType = 49;
                                            atak.Damage = pClient.Entity.InteractionType;
                                            Owner.Send(atak);
                                        }
                                    }
                                    else
                                    {
                                        if (Kernel.GamePool.ContainsKey(pClient.Entity.InteractionWith))
                                        {
                                            Client.GameState Cs = Kernel.GamePool[pClient.Entity.InteractionWith] as Client.GameState;
                                            if (Cs.Entity.X == pClient.Entity.InteractionX && pClient.Entity.Y == pClient.Entity.InteractionY)
                                            {
                                                Attack atak = new Attack(true);
                                                atak.Attacker = pClient.Entity.UID;
                                                atak.Attacked = pClient.Entity.InteractionWith;
                                                atak.X = pClient.Entity.X;
                                                atak.Y = pClient.Entity.Y;
                                                atak.AttackType = 49;
                                                atak.Damage = pClient.Entity.InteractionType;
                                                Owner.Send(atak);
                                            }
                                        }
                                    }
                                }
                                if (pClient.Entity.MyClones.Count > 0)
                                {
                                    foreach (var clone in pClient.Entity.MyClones.Values)
                                    {
                                        if (clone == null) continue;
                                        if (Kernel.GetDistance(clone.X, clone.Y, Owner.Entity.X, Owner.Entity.Y) <= 18 && !Contains(clone.UID))
                                        {
                                            if (!clone.Dead)
                                                clone.SendSpawn(Owner);
                                        }
                                    }
                                }
                                if (pClient.Pet.Pets.Count > 0)
                                {
                                    foreach (var pet in pClient.Pet.Pets.Values)
                                    {
                                        if (pet == null) continue;
                                        if (pet.Entity == null) continue;
                                        if (Kernel.GetDistance(pet.Entity.X, pet.Entity.Y, Owner.Entity.X, Owner.Entity.Y) <= 18 && !Contains(pet.Entity.UID))
                                        {
                                            if (!pet.Entity.Dead)
                                                pet.Entity.SendSpawn(Owner);
                                        }
                                    }
                                }
                                if (pClient.Map.BaseID == 700)
                                {
                                    if (Owner.InQualifier())
                                    {
                                        if (pClient.InQualifier())
                                        {
                                            Owner.Entity.SendSpawn(pClient);
                                            pClient.Entity.SendSpawn(Owner);
                                            if (pClient.Guild != null)
                                                Owner.Entity.SendSpawn(pClient, false);
                                            if (Owner.Guild != null)
                                                pClient.Entity.SendSpawn(Owner, false);
                                            if (spawnWith != null)
                                                pClient.Send(spawnWith);
                                        }
                                        else
                                        {
                                            Owner.Entity.SendSpawn(pClient);
                                            if (pClient.Guild != null)
                                                Owner.Entity.SendSpawn(pClient, false);
                                            Add(pClient.Entity);
                                            if (spawnWith != null)
                                                pClient.Send(spawnWith);
                                        }
                                    }
                                    else
                                    {
                                        if (pClient.InQualifier())
                                        {
                                            pClient.Entity.SendSpawn(Owner);
                                            if (Owner.Guild != null)
                                                pClient.Entity.SendSpawn(Owner, false);
                                            pClient.Screen.Add(Owner.Entity);
                                            if (spawnWith != null)
                                                Owner.Send(spawnWith);
                                        }
                                        else
                                        {
                                            Owner.Entity.SendSpawn(pClient);
                                            pClient.Entity.SendSpawn(Owner);
                                            if (pClient.Guild != null)
                                                Owner.Entity.SendSpawn(pClient, false);
                                            if (Owner.Guild != null)
                                                pClient.Entity.SendSpawn(Owner, false);
                                            if (spawnWith != null)
                                                pClient.Send(spawnWith);
                                        }
                                    }
                                }
                                else
                                {
                                    Owner.Entity.SendSpawn(pClient);
                                    pClient.Entity.SendSpawn(Owner);
                                    if (pClient.Guild != null)
                                        Owner.Entity.SendSpawn(pClient, false);
                                    if (Owner.Guild != null)
                                        pClient.Entity.SendSpawn(Owner, false);
                                    if (spawnWith != null)
                                        pClient.Send(spawnWith);
                                }
                            }
                        }
                    }
                }
                var Map = Owner.Map;
                #region Npcs
                foreach (Interfaces.INpc npc in Map.Npcs.Values)
                {
                    if (npc == null) continue;
                    if (Kernel.GetDistance(npc.X, npc.Y, Owner.Entity.X, Owner.Entity.Y) > 16) continue;
                    if (Contains(npc.UID)) continue;
                    npc.SendSpawn(Owner, false);
                }
                #endregion
                #region PlayersAdd
                foreach (var p in Game.EntityAdd.DictionaryPlayers.Values)
                {
                    if (p > Owner)
                    {
                        ConcurrentDictionaryPlayers.TryAdd(p.UID, p);
                    }
                    else if (p < Owner)
                    {
                        Game.EntityAdd outbot;
                        ConcurrentDictionaryPlayers.TryRemove(p.UID, out outbot);
                    }
                }
                #endregion
                #region Items + map effects
                foreach (var item in Map.FloorItems.Values)
                {
                    if (item == null) continue;
                    if (Kernel.GetDistance(item.X, item.Y, Owner.Entity.X, Owner.Entity.Y) > 16) continue;
                    if (Contains(item.UID)) continue;
                    if (item.Type == FloorItem.Effect)
                    {
                        if (item.ItemID == FloorItem.DaggerStorm || item.ItemID == FloorItem.FuryofEgg || item.ItemID == FloorItem.ShacklingIce || item.ItemID == 31 || item.ItemID == 1397)
                        {
                            if (item.OnFloor.AddSeconds(4).Next(time: Time32.Now.AllMilliseconds()))
                            {
                                item.Type = FloorItem.RemoveEffect;
                                foreach (Interfaces.IMapObject _obj in Objects)
                                    if (_obj != null)
                                        if (_obj.MapObjType == MapObjectType.Player)
                                            (_obj as Entity).Owner.Send(item);
                                Map.RemoveFloorItem(item);
                            }
                            else
                                item.SendSpawn(Owner, false);
                        }
                        else
                            item.SendSpawn(Owner, false);
                    }
                    else
                    {
                        if ((Time32.Now > item.OnFloor.AddSeconds(Constants.FloorItemSeconds)) || item.PickedUpAlready)
                        {
                            item.Type = Network.GamePackets.FloorItem.Remove;
                            Map.RemoveFloorItem(item);
                        }
                    }
                    item.SendSpawn(Owner);
                    if (item.ItemID == FloorItem.AuroraLotus)
                    {
                        if (item.OnFloor.AddSeconds(7).Next(time: Time32.Now.AllMilliseconds()))
                        {
                            item.Type = Network.GamePackets.FloorItem.RemoveEffect;
                            foreach (Interfaces.IMapObject _obj in Objects)
                                if (_obj != null)
                                    if (_obj.MapObjType == MapObjectType.Player)
                                        (_obj as Entity).Owner.Send(item);
                            Map.RemoveFloorItem(item);
                            Attacking.Handle.AuroraLotus(item);
                        }
                        else
                            item.SendSpawn(Owner, false);
                    }
                    else if (item.ItemID == FloorItem.FlameLotus)
                    {
                        if (item.OnFloor.AddSeconds(7).Next(time: Time32.Now.AllMilliseconds()))
                        {
                            item.Type = Network.GamePackets.FloorItem.RemoveEffect;
                            foreach (Interfaces.IMapObject _obj in Objects)
                                if (_obj != null)
                                    if (_obj.MapObjType == MapObjectType.Player)
                                        (_obj as Entity).Owner.Send(item);
                            Map.RemoveFloorItem(item);
                            Attacking.Handle.FlameLotus(item);
                        }
                        else
                            item.SendSpawn(Owner, false);
                    }
                    else if (item.ItemID == FloorItem.TwilightDance)
                    {
                        if (item.OnFloor.AddSeconds(1).Next(time: Time32.Now.AllMilliseconds()))
                        {
                            item.Type = Network.GamePackets.FloorItem.RemoveEffect;
                            foreach (Interfaces.IMapObject _obj in Objects)
                                if (_obj != null)
                                    if (_obj.MapObjType == MapObjectType.Player)
                                        (_obj as Entity).Owner.Send(item);
                            Map.RemoveFloorItem(item);
                        }
                        else
                            item.SendSpawn(Owner, false);
                    }
                }
                #endregion
                foreach (Game.Entity monster in Map.Entities.Values)
                {
                    if (monster == null) continue;
                    if (Kernel.GetDistance(monster.X, monster.Y, Owner.Entity.X, Owner.Entity.Y) <= 16 && !Contains(monster.UID))
                    {
                        if (!monster.Dead)
                        {
                            monster.SendSpawn(Owner, false);
                            if (monster.MaxHitpoints > 65535)
                            {
                                FlagsUpdate upd = new FlagsUpdate(true)
                                {
                                    UID = monster.UID
                                };
                                upd.Append((byte)FlagsUpdate.DataType.Hitpoints, monster.Hitpoints);
                                Owner.Send(upd);
                            }
                        }
                    }
                }
                #region RaceItems
                if (Owner.Map.StaticEntities.Count != 0)
                {
                    foreach (var item in Owner.Map.StaticEntities.Values)
                    {
                        if (item == null) continue;
                        if (!item.Viable) continue;
                        if (Kernel.GetDistance(item.X, item.Y, Owner.Entity.X, Owner.Entity.Y) > 16) continue;
                        if (Contains(item.UID)) continue;
                        item.SendSpawn(Owner);
                    }
                }
                #endregion
                #region Flooritems
                foreach (var f in Database.FloorItemTable.FloorItems)
                {
                    if (f == null) continue;
                    if (Kernel.GetDistance(f.X, f.Y, Owner.Entity.X, Owner.Entity.Y) <= Constants.pScreenDistance)
                    {
                        if (f.MapID == Owner.Entity.MapID && !Owner.Entity.FloorItems.ContainsKey(f.UID))
                        {
                            Owner.Entity.FloorItems.Add(f.UID, f);
                            f.SendSpawn(Owner);
                        }
                    }
                    else
                    {
                        if (Owner.Entity.FloorItems.ContainsKey(f.UID))
                        {
                            Owner.Entity.FloorItems.Remove(f.UID);
                            Remove(f);
                        }
                    }
                    if (Owner.Entity.MapID != f.MapID && Owner.Entity.FloorItems.ContainsKey(f.UID))
                    {
                        Owner.Entity.FloorItems.Remove(f.UID);
                    }
                }
                #endregion
                foreach (Game.Entity monster in Map.Companions.Values)
                {
                    if (monster == null) continue;
                    if (Kernel.GetDistance(monster.X, monster.Y, Owner.Entity.X, Owner.Entity.Y) <= 18 && !Contains(monster.UID))
                    {
                        if (!monster.Dead)
                        {
                            monster.SendSpawn(Owner);
                        }
                    }
                }
                foreach (var bot in Game.BotShop.STATICSTALLS.Values)
                {
                    if (bot > Owner)
                    {
                        BOTSTALL.TryAdd(bot.UID, bot);
                    }
                    else if (bot < Owner)
                    {
                        Game.BotShop outbot;
                        BOTSTALL.TryRemove(bot.UID, out outbot);
                    }
                }
                if (Owner.Map.ID == 8880 || Owner.Map.ID == 8881 || Owner.Map.ID == 1002)
                {
                    foreach (Game.PokerTable T in Kernel.PokerTables.Values)
                    {
                        if (T.Map == Owner.Map.ID)
                        {
                            if (Kernel.GetDistance(T.X, T.Y, Owner.Entity.X, Owner.Entity.Y) <= Constants.nScreenDistance && !PokerTables.ContainsKey(T.Id))
                            {
                                Owner.Send(Game.PokerPackets.PokerTable(T));
                                PokerTables.Add(T.Id, T);
                            }
                        }
                    }
                }
                if (Owner.Map.ID == Roulette.Database.Roulettes.RouletteTable.MapID)
                {
                    foreach (var R in Roulette.Database.Roulettes.RoulettesPoll.Values)
                    {
                        if (Kernel.GetDistance(R.SpawnPacket.X, R.SpawnPacket.Y, Owner.Entity.X, Owner.Entity.Y) <= Constants.nScreenDistance && !PokerTables.ContainsKey(R.SpawnPacket.UID))
                        {
                            Owner.Send(R.SpawnPacket);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Server.SaveException(e);
            }
        }
        public void CleanUp(Interfaces.IPacket spawnWith)
        {
            bool remove;
            try
            {
                foreach (IMapObject Base in Objects)
                {
                    if (Base == null) continue;
                    remove = false;
                    if (Base.MapObjType == MapObjectType.Monster)
                    {
                        if ((Base as Entity).Dead)
                        {
                            if (Time32.Now > (Base as Entity).DeathStamp.AddSeconds(8))
                                remove = true;
                            else remove = false;
                        }
                        if (Kernel.GetDistance(Owner.Entity.X, Owner.Entity.Y, Base.X, Base.Y) >= Constants.remScreenDistance)
                            remove = true;
                        if (remove)
                        {
                            if ((Base as Entity).MonsterInfo.InSight == Owner.Entity.UID)
                                (Base as Entity).MonsterInfo.InSight = 0;
                        }
                    }
                    else if (Base.MapObjType == MapObjectType.Player)
                    {
                        if (remove = (Kernel.GetDistance(Owner.Entity.X, Owner.Entity.Y, Base.X, Base.Y) >= Constants.pScreenDistance))
                        {
                            GameState pPlayer = Base.Owner as GameState;
                            pPlayer.Screen.Remove(Owner.Entity);
                        }
                    }
                    else if (Base.MapObjType == MapObjectType.Item)
                    {
                        remove = (Kernel.GetDistance(Owner.Entity.X, Owner.Entity.Y, Base.X, Base.Y) >= 22);
                    }
                    else
                    {
                        remove = (Kernel.GetDistance(Owner.Entity.X, Owner.Entity.Y, Base.X, Base.Y) >= Constants.remScreenDistance);
                    }
                    if (Base.MapID != Owner.Map.ID)
                        remove = true;
                    if (remove)
                    {
                        Remove(Base);
                    }
                }
            }
            catch (Exception e)
            {
                Server.SaveException(e);
            }
        }
    }
}