using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

using Blizzard.HabboHotel.Users;
using Blizzard.HabboHotel.Music;
using Blizzard.HabboHotel.Items;
using Blizzard.HabboHotel.Wired;

namespace Blizzard.HabboHotel.Rooms
{
    public enum MatrixState
    {
        BLOCKED = 0,
        WALKABLE = 1,
        WALKABLE_LASTSTEP = 2
    }

    public class Room
    {
        Habbo User;
        internal int FloodCount;
        internal DateTime FloodTime;
        internal static RoomItem TileToFreeze;
        internal static Habbo UserToFreeze;
        internal static RoomItem ItemPeriodically;
        internal Room(Habbo cUser)
        {
            User = cUser;
        }

        internal void SendMessage(ServerMessage Message)
        {
            StaticGame.SendPacketToAllRoom(User, Message);
        }

        public void RoomCycle()
        {
            try
            {
                while (true)
                {
                    if (User.CurrentRoomId > 0 && RoomsData.Rooms.ContainsKey(User.CurrentRoomId))
                    {
                        foreach (RoomItem Item in RoomsData.Rooms[User.CurrentRoomId].FloorItems)
                        {
                            #region Battle Ball
                            if (Item.GetBaseItem().Name.StartsWith("bb_"))
                            {
                                #region Pyramids
                                if (Item.GetBaseItem().Name == "bb_pyramid")
                                {
                                    if (Item.ExtraData == "")
                                        Item.ExtraData = "0";

                                    if (Item.ExtraData == "0")
                                        Item.ExtraData = "1";
                                    else
                                        Item.ExtraData = "0";

                                    Item.UpdateState(User);
                                }
                                #endregion
                            }
                            #endregion
                        }
                        Thread.Sleep(10000);
                    }
                    else
                        break;
                }
            }
            catch (Exception e)
            {
                BlizzardSystem.WriteLine("Error during RoomCycle: " + e.ToString());
            }
        }

        internal void GetUserBadges()
        {
            Habbo cUser = StaticGame.VirtualUser[HabboEncode.decodeVL64(User.ActualPacket.Substring(2))];

            if (cUser.Id != User.Id)
            {
                Rotation Rot = new Rotation();
                int sRot = Rot.Calculate(User.X, User.Y, cUser.X, cUser.Y);
                User.RotBody = sRot;
                User.RotHead = sRot;
                User.UpdateState();
            }

            List<BadgesData> Equipped = new List<BadgesData>();
            foreach (BadgesData B in BadgesData.SelectBadgesForUser(cUser.Id))
            {
                if (B.BadgeSlot > 0)
                    Equipped.Add(B);
                else
                    continue;
            }

            ServerMessage Badges = new ServerMessage("Cd");
            Badges.AddInt(cUser.Id);
            Badges.AddInt(Equipped.Count);

            foreach (BadgesData B in Equipped)
            {
                Badges.AddInt(B.BadgeSlot);
                Badges.AddStringWithBreak(B.BadgeId);
            }

            SendMessage(Badges);
        }

        internal void AccessToRoom()
        {
            if (User.IsOnRoom)
            {
                User.RemoveUserFromRoom(false);
            }

            int RoomId = HabboEncode.decodeVL64(User.ActualPacket.Substring(2));
            if (!RoomsData.Rooms.ContainsKey(RoomId))
                return; // Invalid Room

            RoomsData D = RoomsData.Rooms[RoomId];
            if (D.Id <= 0 || D.OwnerId <= 0)
                return;

            // Process Room
            User.CurrentRoomId = RoomId;
            User.VisitedRooms += RoomId + ";";
            if (!StaticGame.VirtualRooms.ContainsKey(RoomId))
                StaticGame.VirtualRooms.Add(RoomId, this);


            BuildMessage CollectRoom = new BuildMessage();
            // Initial Packets
            ServerMessage Initial = new ServerMessage("@S");
            CollectRoom.AddPacket(Initial);

            ServerMessage CheckClient = new ServerMessage("Bf");
            CheckClient.AddStringWithBreak("/client/private/" + RoomId + "/id");
            CollectRoom.AddPacket(CheckClient);

            ServerMessage InitialB = new ServerMessage("Du");
            InitialB.AddStringWithBreak("H");
            CollectRoom.AddPacket(InitialB);

            ServerMessage InitialModel = new ServerMessage("AE");
            InitialModel.AddStringWithBreak(D.Model);
            InitialModel.AddInt(RoomId);
            CollectRoom.AddPacket(InitialModel);

            int SpectatorMode = 0;
            if (SpectatorMode == 1)
            {
                ServerMessage SpectatorMod = new ServerMessage("C~");
                CollectRoom.AddPacket(SpectatorMod);
            }

            // Landscapes, wallpaper and floorpaper!
            ServerMessage mWallPaper = new ServerMessage("@n");
            mWallPaper.AddStringWithBreak("wallpaper");
            mWallPaper.AddStringWithBreak(D.WallPaper);
            CollectRoom.AddPacket(mWallPaper);

            ServerMessage mFloorPaper = new ServerMessage("@n");
            mFloorPaper.AddStringWithBreak("floor");
            mFloorPaper.AddStringWithBreak(D.FloorPaper);
            CollectRoom.AddPacket(mFloorPaper);


            ServerMessage mLandScape = new ServerMessage("@n");
            mLandScape.AddStringWithBreak("landscape");
            mLandScape.AddStringWithBreak(D.LandScape.Replace(',', '.'));
            CollectRoom.AddPacket(mLandScape);

            if (D.OwnerId == User.Id || User.Rank > 5 || User.HavePowersOnThisRoom(RoomId))
            {
                ServerMessage OwnerPowers = new ServerMessage("@o"); // Owner Powers
                CollectRoom.AddPacket(OwnerPowers);
            }

            // Score
            ServerMessage ScoreProcess = new ServerMessage("EY");
            if (D.OwnerId == User.Id)
            {
                ScoreProcess.AddInt(D.Score);
            }
            else
            {
                ScoreProcess.AddInt(-1);
            }
            CollectRoom.AddPacket(ScoreProcess);

            // Events
            ServerMessage Events = new ServerMessage("Er");
            Events.AddStringWithBreak("-1");
            CollectRoom.AddPacket(Events);

            User.SendBuilder(CollectRoom);
        }

        internal void GetMap()
        {
            BuildMessage CollectMaps = new BuildMessage();
            RoomsData D = RoomsData.Rooms[User.CurrentRoomId];
            RoomModel GetModel = D.GetRoomModel();

            ServerMessage ModelHeightMap = new ServerMessage("@_");
            ModelHeightMap.AddStringWithBreak(GetModel.GetPremairParams());
            CollectMaps.AddPacket(ModelHeightMap);

            ServerMessage ModelAnothers = new ServerMessage("GV");
            ModelAnothers.AddStringWithBreak(GetModel.GetSecondairParams());
            CollectMaps.AddPacket(ModelAnothers);
            User.SendBuilder(CollectMaps);
        }

        internal void GetAnnoyingMap()
        {
            ServerMessage Anno = new ServerMessage("Di");
            Anno.AddInt(0);
            User.SendMessage(Anno);
        }

        internal RoomsData GetRoom()
        {
            return RoomsData.Rooms[User.CurrentRoomId];
        }

        public void GenerateMatrix()
        {
            try
            {
                RoomsData Data = RoomsData.Rooms[User.CurrentRoomId];
                Data.GenerateMatrix();
            }
            catch (Exception e) { BlizzardSystem.WriteLine(e.ToString()); }
        }

        internal void EndEnter()
        {
            try
            {
                BuildMessage CollectRoom = new BuildMessage();
                RoomsData D = RoomsData.Rooms[User.CurrentRoomId];
                RoomModel GetModel = D.GetRoomModel();
                int DoorX = GetModel.DoorX;
                int DoorY = GetModel.DoorY;
                int DoorZ = GetModel.DoorZ;
                int DoorRot = GetModel.DoorDir;

                CollectRoom.AddPacket("@^H");

                ServerMessage WallItems = new ServerMessage("@m");
                List<int> Walls = new List<int>();
                foreach (RoomItem Its in RoomItem.Items)
                {
                    if (Its.RoomId == User.CurrentRoomId && Its.IsWall)
                        Walls.Add(Its.Id);
                }
                WallItems.AddInt(Walls.Count); // Count of this
                foreach (int qId in Walls)
                    this.SerializeWallItem(RoomItem.RegisteredItems[qId], WallItems);
                CollectRoom.AddPacket(WallItems);

                ServerMessage FloorItems = new ServerMessage("@`");
                List<int> Floors = new List<int>();
                foreach (RoomItem Its in RoomItem.Items)
                {
                    if (Its.RoomId == User.CurrentRoomId && !Its.IsWall)
                        Floors.Add(Its.Id);
                }
                FloorItems.AddInt(Floors.Count); // Count of this
                foreach (int qId in Floors)
                    this.SerializeFloorItem(RoomItem.RegisteredItems[qId], FloorItems);
                CollectRoom.AddPacket(FloorItems);

                D.UserList.Add(User);
                D.CurrentUsersInRoom++;
                User.IsOnRoom = true;
                HabboConsole H = new HabboConsole(User);
                H.UpdateMyFriends();

                User.X = DoorX;
                User.Y = DoorY;
                User.Z = DoorZ.ToString();
                User.RotHead = DoorRot;
                User.RotBody = DoorRot;

                // Wired Effect: On User Enter On Room

                ServerMessage NEnterMessage = new ServerMessage(@"@\");
                NEnterMessage.AddInt(1);
                UsersData MyUserOnRoom = User.GetUserData();
                NEnterMessage.AddInt(User.Id);
                NEnterMessage.AddStringWithBreak(MyUserOnRoom.UserName);
                NEnterMessage.AddStringWithBreak(MyUserOnRoom.Motto);
                NEnterMessage.AddStringWithBreak(MyUserOnRoom.Look);
                NEnterMessage.AddInt(User.VirtualId);
                NEnterMessage.AddInt(User.X);
                NEnterMessage.AddInt(User.Y);
                NEnterMessage.AddStringWithBreak(User.Z.ToString().Replace(',', '.'));
                NEnterMessage.AddInt(2);
                NEnterMessage.AddInt(1);
                NEnterMessage.AddStringWithBreak(MyUserOnRoom.Gender);
                NEnterMessage.AddInt(-1);
                NEnterMessage.AddInt(-1);
                NEnterMessage.AddInt(-1);
                NEnterMessage.AddStringWithBreak("");
                NEnterMessage.AddInt(MyUserOnRoom.AchievementPoints);
                this.SendMessage(NEnterMessage);
                this.SendMessage(User.UpdateMyStateMessage("", ""));

                // Add Users

                // Ik]XqIjulli123{2}Wath's Up?{2}hr-3043-1356.hd-180-3.ch-3050-1340-1341.lg-3078-1341.he-3079-96.fa-3147-1322.ca-1814.cc-3007-1341-1341{2}HHRD1.0{2}JIm{2}MbzGAK{2}ZiI{1}GXH{1}GWIj]K^vI{1}LvH{1}@bIHHRD1.0{2}JJ/flatctrl useradmin//{2}{1}
                ServerMessage EnterMessage = new ServerMessage(@"@\");
                EnterMessage.AddInt(D.UserList.Count);
                foreach (Habbo AUser in D.UserList)
                {
                    // IZ[cItachiKM{2}{2}hr-3163-1356.fa-3147-1322.ch-3050-1341-1341.hd-180-2.lg-3078-1341.cc-3007-1341-1341{2}HIQA0{2}JIm{2}MMM{2}XdA{
                    // My User
                    UsersData UserOnRoom = AUser.GetUserData();
                    EnterMessage.AddInt(AUser.Id);
                    EnterMessage.AddStringWithBreak(UserOnRoom.UserName);
                    EnterMessage.AddStringWithBreak(UserOnRoom.Motto);
                    EnterMessage.AddStringWithBreak(UserOnRoom.Look);
                    EnterMessage.AddInt(AUser.VirtualId);
                    EnterMessage.AddInt(AUser.X);
                    EnterMessage.AddInt(AUser.Y);
                    EnterMessage.AddStringWithBreak(AUser.Z.ToString().Replace(',', '.'));
                    EnterMessage.AddInt(2);
                    EnterMessage.AddInt(1);
                    EnterMessage.AddStringWithBreak(UserOnRoom.Gender.ToLower());
                    EnterMessage.AddInt(-1);
                    EnterMessage.AddInt(-1);
                    EnterMessage.AddInt(-1);
                    EnterMessage.AddStringWithBreak("");
                    EnterMessage.AddInt(UserOnRoom.AchievementPoints);
                }
                CollectRoom.AddPacket(EnterMessage);

                ServerMessage HideWalls = new ServerMessage("GX");
                HideWalls.AddBoolean(D.HideWalls);
                CollectRoom.AddPacket(HideWalls);
                ServerMessage PrivateRoom = new ServerMessage("GW");
                PrivateRoom.AddBoolean(true); // Public or Private
                PrivateRoom.AddInt(D.Id); // Id (or Model)
                // Powers
                if (D.OwnerId == User.Id || User.Rank > 5 || User.HavePowersOnThisRoom(User.CurrentRoomId))
                    PrivateRoom.AddBoolean(true); // Have power
                else
                    PrivateRoom.AddBoolean(false); // not have
                CollectRoom.AddPacket(PrivateRoom);


                ServerMessage SRoomData = new ServerMessage("GF");
                SRoomData.AddInt(1);
                SRoomData.AddInt(D.Id);
                SRoomData.AddInt(0);
                SRoomData.AddStringWithBreak(D.Name);
                SRoomData.AddStringWithBreak(D.OwnerName);
                SRoomData.AddInt(D.State);
                SRoomData.AddInt(D.CurrentUsersInRoom); // Users on this
                SRoomData.AddInt(D.MaxUsers);
                SRoomData.AddStringWithBreak(D.Description);
                SRoomData.AddBoolean(true); // dunno!
                BlizzardSystem.WriteLine(D.Category.ToString());
                SRoomData.AddBoolean((D.Category == 3) ? true : false);
                SRoomData.AddInt(D.Score);
                SRoomData.AddInt(D.Category);
                SRoomData.AddStringWithBreak("");
                SRoomData.AddInt(D.TagList.Count); // Tag Count

                foreach (string Tag in D.TagList)
                {
                    SRoomData.AddStringWithBreak(Tag);
                }
                // Icon
                SRoomData.AddInt(D.IconBackground);
                SRoomData.AddInt(D.IconForeground);
                SRoomData.AddInt(D.Icons.Count); // Icon items

                // Serialize Icons
                if (D.Icons.Count > 0)
                {
                    foreach (KeyValuePair<int, int> Icon in D.Icons)
                    {
                        SRoomData.AddInt(Icon.Key);
                        SRoomData.AddInt(Icon.Value);
                    }
                }

                SRoomData.AddBoolean(false);
                SRoomData.AddBoolean(true);
                CollectRoom.AddPacket(SRoomData);

                if (RoomEvent.HasEvent(User.CurrentRoomId))
                {
                    RoomEvent Event = RoomEvent.GetEventForRoom(User.CurrentRoomId);
                    ServerMessage Message = new ServerMessage("Er");
                    Message.AddStringWithBreak(User.Id.ToString());
                    Message.AddStringWithBreak(User.UserName);
                    Message.AddStringWithBreak(Event.RoomId.ToString());
                    Message.AddInt(Event.CategoryId);
                    Message.AddStringWithBreak(Event.Title);
                    Message.AddStringWithBreak(Event.Description);
                    Message.AddStringWithBreak(Event.StartTime.ToString());
                    Message.AddInt(Event.Tags.Count);

                    foreach (string Tag in Event.Tags)
                    {
                        Message.AddStringWithBreak(Tag);
                    }

                    CollectRoom.AddPacket(Message);
                }


                foreach (Habbo UsersOnThisRoom in D.UserList)
                {
                    if (UsersOnThisRoom.IsDancing)
                    {
                        ServerMessage UserDancing = new ServerMessage("G`");
                        UserDancing.AddInt(UsersOnThisRoom.VirtualId);
                        UserDancing.AddInt(UsersOnThisRoom.DanceId);
                        CollectRoom.AddPacket(UserDancing);
                    }

                    if (UsersOnThisRoom.CurrentEffect > 0)
                    {
                        CollectRoom.AddPacket((new EffectsInventory()).ServerShowEffect(UsersOnThisRoom, UsersOnThisRoom.CurrentEffect));
                    }
                }

                if (User.QuestType.Contains("ENTER_OTHER_USERS_ROOM"))
                {
                    User.UpdateQuest(1, 3);
                }

                User.SendBuilder(CollectRoom);
                GenerateMatrix(); // Generate ROomMatrix
                //Init the RoomCycle
                foreach (RoomItem Item in D.FloorItems)
                {
                    // wf_trg_periodically
                    if (Item.GetBaseItem().Name == "wf_trg_periodically")
                    {
                        if (!StaticGame.WiredPeriodicallySystem.ContainsKey(Item.Id))
                        {
                            ItemPeriodically = Item;
                            Thread Periodically = new Thread(new ThreadStart(PeriodicallyWired));
                            Periodically.Start();
                            StaticGame.WiredPeriodicallySystem.Add(Item.Id, Periodically);
                        }
                    }
                    else if (Item.GetBaseItem().Name == "wf_trg_enter_room")
                    {
                        // Wired Condition: User Enter on rom
                        Item.ExtraData = "1";
                        Item.UpdateState(User);

                        foreach (RoomItem sItem in GetItemsForXY(Item.X, Item.Y))
                        {
                            WiredEffects Effects = new WiredEffects(sItem, User);
                            Effects.DoWiredEffects();
                        }
                    }
                }

                if (StaticGame.RoomCycles.ContainsKey(User.CurrentRoomId))
                    return;

                Thread tRoomCycle = new Thread(new ThreadStart(RoomCycle));
                tRoomCycle.Start();
                StaticGame.RoomCycles.Add(User.CurrentRoomId, tRoomCycle);
            }
            catch (Exception e)
            {
                BlizzardSystem.WriteLine("Error loading rooms: " + e.ToString());
            }
        }

        internal void PeriodicallyWired()
        {
            while (true)
            {
                RoomItem Item = ItemPeriodically;
                foreach (RoomItem sItem in GetItemsForXY(Item.X, Item.Y))
                {
                    WiredEffects Effects = new WiredEffects(sItem, User);
                    Effects.DoWiredEffects();
                }
                if (Item.WiredString != "")
                    Thread.Sleep(int.Parse(Item.WiredString));
                else
                    Thread.Sleep(500);
            }
        }

        internal void AddItemToMyRoom()
        {
            // WallItem: AZ@R3 :w=3,3 l=14,51 l
            // NormalItem = AZ@H24 4 1 0
            if (User.QuestType.Contains("PLACE_ITEM"))
                User.UpdateQuest(1, 10);

            RoomsData R = RoomsData.Rooms[User.CurrentRoomId];
            if (R.OwnerId != User.Id && User.Rank <= 7)
                return;

            string Type = User.ActualPacket.Substring(3, 1);
            string Item = User.ActualPacket.Substring(4);
            string[] SplitItem = Item.Split(' ');
            if (SplitItem[0].StartsWith("-"))
            {
                return;
            }
            int ItemId = int.Parse(SplitItem[0]);
            UserItemsData U = UserItemsData.UserItemsbyId[ItemId];
            int FurniId = U.FurniId;
            string ExtraData = U.ExtraData;
            ItemsData fData = U.GetBaseItem();

            // WallItem
            if (SplitItem[1].StartsWith(":"))
            {
                //Console.WriteLine("ItemId = " + ItemId + ", FurniId = " + FurniId + ", Wall = " + (new iFunctions()).MergeParams(SplitItem, 1));
                string WallItem = this.WallPositionCheck(BlizzardSystem.MergeParams(SplitItem, 1));
                if (WallItem == null)
                {
                    ServerMessage InvalidPos = new ServerMessage("HD");
                    InvalidPos.AddInt(11);
                    User.SendMessage(InvalidPos);
                    return;
                }

                if (Type != "S")
                {
                    this.AddWallItem(WallItem, User.CurrentRoomId, FurniId, ExtraData);
                    GeneralInventory Invent = new GeneralInventory(User);
                    Invent.DeleteItem(ItemId);
                }
                else
                {
                    this.AddWallItem(WallItem, User.CurrentRoomId, FurniId, ExtraData);
                    GeneralInventory Invent = new GeneralInventory(User);
                    Invent.DeleteItem(ItemId);
                }
            }
            // NormalItem
            else
            {
                int X = int.Parse(SplitItem[1]);
                int Y = int.Parse(SplitItem[2]);
                int Rot = int.Parse(SplitItem[3]);

                this.AddFloorItem(X, Y, Rot, FurniId, User.CurrentRoomId, ExtraData);
                GeneralInventory Invent = new GeneralInventory(User);
                Invent.DeleteItem(ItemId);
            }
        }

        internal void AddFloorItem(int X, int Y, int Rot, int FurniId, int RoomId, string ExtraData)
        {
            int NewFurniId = RoomItem.GetLastId() + 1;
            BlizzardSystem.MySQL.ExecuteNonQuery("INSERT INTO rooms_items (id, room_id, furni_id, extradata, x, y, w, rot, moodlight, wired_string, wired_items) VALUES (" + NewFurniId + ", '" + RoomId + "', '" + FurniId + "', '" + ExtraData + "', '" + X + "', '" + Y + "', '', '" + Rot + "','','','');");
            ServerMessage WallItem = new ServerMessage("A]");
            RoomItem I = new RoomItem();
            I.Id = NewFurniId;
            I.RoomId = RoomId;
            I.X = X;
            I.Y = Y;
            I.Rot = Rot;
            I.FurniId = FurniId;
            I.ExtraData = ExtraData;
            I.IsWall = false;
            I.WiredString = "";
            I.WiredItems = new List<int>();
            RoomItem.Items.Add(I);
            RoomItem.RegisteredItems.Add(I.Id, I);
            this.SerializeFloorItem(I, WallItem);
            StaticGame.SendPacketToAllRoom(User, WallItem);
            RoomsData R = RoomsData.Rooms[User.CurrentRoomId];
            R.FloorItems.Add(I);
            GenerateMatrix();
        }

        internal void AddWallItem(string W, int RoomId, int FurniId, string ExtraData)
        {
            string Mood = "";
            /*items_information f = new items_information();
            f.GetDataForId(FurniId);
            if (f.Name.Contains("dimmer"))
                Mood = "0;1;pos1#000000,255,0;pos2#000000,255,0;pos3#000000,255,0";*/
            Updater.SQLStoExecute.Add("INSERT INTO rooms_items (id, room_id, furni_id, extradata, x, y, w, rot, moodlight, wired_string, wired_items) VALUES (NULL, '" + RoomId + "', '" + FurniId + "', '" + ExtraData + "', '0', '0', '" + W + "', '0','" + Mood + "','','');");

            int NewFurniId = RoomItem.GetLastId() + 1;
            ServerMessage WallItem = new ServerMessage("AS");
            RoomItem I = new RoomItem();
            I.Id = NewFurniId;
            I.RoomId = RoomId;
            I.W = W;
            I.FurniId = FurniId;
            I.Mood = Mood;
            I.ExtraData = ExtraData;
            I.IsWall = true;
            I.WiredItems = new List<int>();
            RoomItem.Items.Add(I);
            RoomItem.RegisteredItems.Add(I.Id, I);
            this.SerializeWallItem(I, WallItem);
            StaticGame.SendPacketToAllRoom(User, WallItem);
            RoomsData R = RoomsData.Rooms[User.CurrentRoomId];
            R.WallItems.Add(I);
        }

        public string WallPositionCheck(string wallPosition)
        {
            //:w=3,2 l=9,63 l
            try
            {
                if (wallPosition.Contains(Convert.ToChar(13)))
                { return null; }
                if (wallPosition.Contains(Convert.ToChar(9)))
                { return null; }

                string[] posD = wallPosition.Split(' ');
                if (posD[2] != "l" && posD[2] != "r")
                    return null;

                string[] widD = posD[0].Substring(3).Split(',');
                int widthX = int.Parse(widD[0]);
                int widthY = int.Parse(widD[1]);
                if (widthX < 0 || widthY < 0 || widthX > 200 || widthY > 200)
                    return null;

                string[] lenD = posD[1].Substring(2).Split(',');
                int lengthX = int.Parse(lenD[0]);
                int lengthY = int.Parse(lenD[1]);
                if (lengthX < 0 || lengthY < 0 || lengthX > 200 || lengthY > 200)
                    return null;

                return ":w=" + widthX + "," + widthY + " l=" + lengthX + "," + lengthY + " " + posD[2];
            }
            catch
            {
                return null;
            }
        }

        internal void CreateEvent()
        {
            // EZI@OCondones gratis@CSi!J@Boh@Cyes
            string S = User.ActualPacket.Substring(2);
            string[] s = User.ActualPacket.Substring(2).Split('@');

            int RoomId = User.CurrentRoomId;
            int CategoryId = HabboEncode.decodeVL64(s[0]);
            string Title = s[1].Substring(1);
            string Description = s[2].Substring(1, s[2].Length - 2);
            int TagCount = HabboEncode.decodeVL64(s[2].Substring(s[2].Length - 1));
            List<string> Tags = new List<string>();
            if (TagCount > 0)
            {
                if (TagCount == 1)
                    Tags.Add(s[3].Substring(1));

                if (TagCount == 2)
                {
                    Tags.Add(s[3].Substring(1));
                    Tags.Add(s[4].Substring(1));
                }
            }
            string StartTime = DateTime.Now.ToShortTimeString();

            ServerMessage Message = new ServerMessage("Er");
            Message.AddStringWithBreak(User.Id.ToString());
            Message.AddStringWithBreak(User.UserName);
            Message.AddStringWithBreak(RoomId.ToString());
            Message.AddInt(CategoryId);
            Message.AddStringWithBreak(Title);
            Message.AddStringWithBreak(Description);
            Message.AddStringWithBreak(StartTime.ToString());
            Message.AddInt(Tags.Count);

            foreach (string Tag in Tags)
            {
                Message.AddStringWithBreak(Tag);
            }

            SendMessage(Message);

            RoomEvent Event = new RoomEvent();
            Event.RoomId = RoomId;
            Event.CategoryId = CategoryId;
            Event.Title = Title;
            Event.Description = Description;
            Event.Tags = Tags;
            Event.StartTime = StartTime;
            RoomEvent.Events.Add(Event);
        }

        internal void SerializeRoomEventPanel()
        {
            try
            {
                Boolean Allow = true;
                int ErrorCode = 0;

                RoomsData dRoom = RoomsData.Rooms[User.CurrentRoomId];
                if (dRoom.State != 0)
                {
                    Allow = false;
                    ErrorCode = 3;
                }

                ServerMessage CanHaveEvent = new ServerMessage("Eo");
                CanHaveEvent.AddBoolean(Allow);
                CanHaveEvent.AddInt(ErrorCode);
                User.SendMessage(CanHaveEvent);
            }
            catch
            {
                return;
            }
        }

        internal void SerializeWallItem(RoomItem I, ServerMessage Item)
        {
            RoomsData R = RoomsData.Rooms[User.CurrentRoomId];
            if (!R.WallItems.Contains(I))
                R.WallItems.Add(I);
            Item.AddStringWithBreak(I.Id.ToString());
            Item.AddInt(I.GetBaseItem().SpriteId);
            Item.AddStringWithBreak(I.W);
            Item.AddStringWithBreak(I.ExtraData);
            if (I.GetBaseItem().FurniInteractor == "default")
                Item.AddBoolean(false); // Is the boton 'use' enabled?
            else
                Item.AddBoolean(true);

            if (I.GetBaseItem().Name.Contains("dimmer"))
            {
                //Interactor fInt = new Interactor();
                //fInt.UpdateState(WallItem, User, true, false);
            }
        }

        internal void SerializeFloorItem(RoomItem I, ServerMessage Item)
        {
            // AcwZwmcA{1}A]sZwmcAYYJIIH0.0{2}H{2}MH{1}C[!'B{2}{1}
            // RoomItem FloorItem = new RoomItem(this, (int)dItem["furni_id"], (int)dItem["x"], (int)dItem["y"], (int)dItem["rot"], (int)dItem["id"], (string)dItem["extradata"], false, (string)dItem["w"]);
            // FloorItemsOnRoom.Add(FloorItem);
            RoomsData R = RoomsData.Rooms[User.CurrentRoomId];
            if (!R.FloorItems.Contains(I))
                R.FloorItems.Add(I);
            Item.AddInt(I.Id);
            Item.AddInt(I.GetBaseItem().SpriteId);
            Item.AddInt(I.X);
            Item.AddInt(I.Y);
            Item.AddInt(I.Rot);
            string H = GetHForXY(I.X, I.Y, I).ToString().Replace(",", ".");
            if (!H.Contains("."))
                H += ".0";
            Item.AddStringWithBreak(H); 
            Item.AddInt(0);
            Item.AddStringWithBreak(I.ExtraData);
            Item.AddInt(-1);
            if (I.GetBaseItem().FurniInteractor == "default")
                Item.AddBoolean(true); // Is the boton 'use' enabled?
            else
                Item.AddBoolean(true);
        }

        internal void MoveItemToXY(RoomItem Item, int X, int Y, int Rot, int WiredId = 0)
        {
            try
            {
                if (Item == null)
                    return;

                RoomsData R = RoomsData.Rooms[Item.RoomId];

                /*if (R.OwnerId != User.Id && User.Rank <= 7)
                    return;*/
                /*bool O = false;
                while(O == true)
                {
                    if (R.GetRoomModel().MapSizeX < X ||X < 0)
                    {
                        O = false;
                        X--;
                    }
                    else if (R.GetRoomModel().MapSizeX < Y || Y < 0)
                    {
                        O = false;
                        Y--;
                    }
                    else
                        O = true;
                }*/

                int LastX = Item.X;
                int LastY = Item.Y;
                int LastRot = Item.Rot;
                string Sm = "A_";
                if (WiredId > 0)
                    Sm = "Cf";
                ServerMessage Move = new ServerMessage(Sm);
                if (WiredId > 0)
                    this.MoveFloorItem(Item, Move, LastX, LastY, X, Y, Rot, WiredId);
                else
                    this.SetFloorItem(Item, Move, X, Y, Rot);
                Item.Rot = Rot;
                Item.X = X;
                Item.Y = Y;
                Item.IsModify = true;
                StaticGame.SSendPacketToAllRoom(User.CurrentRoomId, Move);
                UpdaterUserState();
                GenerateMatrix();
                List<RoomItem> ItemsOnXY = GetItemsForXY(Item.X, Item.Y);
            }
            catch (Exception e)
            {
                BlizzardSystem.WriteLine("Exception on rooms: " + e.ToString());
            }
        }

        internal bool IsValidTile(int X, int Y)
        {
            RoomsData D = RoomsData.Rooms[User.CurrentRoomId];
            if (X < 0 || Y < 0 || X >= D.GetRoomModel().MapSizeX || Y >= D.GetRoomModel().MapSizeY || this.IsItemOnXY(X, Y))
                return false;
            else
                return true;
        }

        internal void UpdaterUserState()
        {
            List<RoomItem> Is = GetItemsForXY(User.X, User.X);
            if (Is.Count > 0)
            {
                foreach (RoomItem I in Is)
                {
                    if (User.RotBody != I.Rot)
                        User.RotBody = I.Rot;
                    if (User.RotHead != I.Rot)
                        User.RotHead = I.Rot;
                    User.UpdateMyState("", "");
                    ItemsData U = I.GetBaseItem();
                    RoomsData R = RoomsData.Rooms[User.CurrentRoomId];
                    FurniInteractor Inter = new FurniInteractor(User, U, I, R, this);
                    Inter.WalkOnFurni();
                }
            }
            else
            {
                FurniInteractor Inter = new FurniInteractor(User);
                Inter.WalkWithoutFurni(this);
            }
        }

        internal void MoveItem()
        {
            RoomsData R = User.CurrentRoom();
            if (R.OwnerId != User.Id && User.Rank <= 7)
                return;
            string Request = User.ActualPacket.Substring(2);
            string[] Data = (new AnalyzeMessages()).SepareOnVL64Vars(Request);
            int ItemId = HabboEncode.decodeVL64(Data[0]);
            int X = HabboEncode.decodeVL64(Data[1]);
            int Y = HabboEncode.decodeVL64(Data[2]);
            int Rot = HabboEncode.decodeVL64(Data[3]);

            RoomItem Item = RoomItem.RegisteredItems[ItemId];
            if (Item == null)
                return;
            int LastX = Item.X;
            int LastY = Item.Y;
            int LastRot = Item.Rot;
            Item.Rot = Rot;
            Item.X = X;
            Item.Y = Y;
            Item.IsModify = true;
            ServerMessage Move = new ServerMessage("A_");
            this.SetFloorItem(Item, Move, X, Y, Rot);
            StaticGame.SendPacketToAllRoom(User, Move);
            UpdaterUserState();
            GenerateMatrix();

            List<RoomItem> ItemsOnXY = GetItemsForXY(Item.X, Item.Y);
            foreach (RoomItem sItem in ItemsOnXY)
            {
                /*#region Roller Furniture
                if (sItem.GetBaseItem().Name.StartsWith("queue"))
                {
                    string UserZ = this.SecondGetHForXY(sItem.SquareInFront.X, sItem.SquareInFront.Y).ToString().Replace(',', '.');
                    if (!UserZ.Contains("."))
                        UserZ += ".0";
                    // CfPBKPBPAHpNJOGDJH0.45{2}0.45{2}{1}
                    ServerMessage Message = new ServerMessage("Cf");
                    Message.AddInt(Item.X);
                    Message.AddInt(Item.Y);
                    Message.AddInt(sItem.SquareInFront.X);
                    Message.AddInt(sItem.SquareInFront.Y);
                    Message.AddBoolean(false);
                    Message.AddInt(sItem.Id);
                    Message.AddInt(Item.Rot);
                    Message.AddInt(Item.Id);
                    Message.AddStringWithBreak(UserZ);
                    Message.AddStringWithBreak(UserZ);
                    User.SendMessage(Message);
                    Thread.Sleep(300);
                    this.MoveItemToXY(Item, sItem.SquareInFront.X, sItem.SquareInFront.Y, Item.Rot);
                    Thread.Sleep(900);
                }
                #endregion*/
            }

            if (User.QuestType.Contains("MOVE_ITEM"))
                User.UpdateQuest(1, 2);
            if (LastX == X && LastY == Y)
            {
                if (User.QuestType.Contains("ROTATE_ITEM"))
                    User.UpdateQuest(1, 9);
            }
            /*if (LastX == X && LastY == Y && User.X == X && User.Y == Y)
            {
                Interactor FurniInt = new Interactor();
                FurniInt.OnTurn(Item, User);
            }
            else
            {
                Interactor FurniInt = new Interactor();
                FurniInt.WalkWithoutFurni(User);
            }*/
        }

        internal double GetHForXY(int X, int Y, RoomItem Item)
        {
            double H = 0;
            int i = 0;
            List<RoomItem> HForXY = GetItemsForXY(X, Y);
            if (HForXY.Count > 1)
            {
                foreach (RoomItem sItem in HForXY)
                {
                    if (Item.Id == sItem.Id)
                        break;
                    H += Item.GetBaseItem().Height;
                    i++;
                }
            }
            return H;
        }

        internal double SecondGetHForXY(int X, int Y)
        {
            double H = 0;
            int i = 0;
            List<RoomItem> HForXY = GetItemsForXY(X, Y);
            if (HForXY.Count > 0)
            {
                foreach (RoomItem Item in HForXY)
                {
                    i++;
                    H += Item.GetBaseItem().Height;

                }
            }
            return H;
        }

        internal void Whisp()
        {
            string Params = User.ActualClientMessage.GetNextString();
            string ToUser = Params.Split(' ')[0];
            string Message = Params.Substring(ToUser.Length + 1);

            Habbo sUser = StaticGame.GetHabboForName(ToUser);
            if (sUser == null)
                return;

            ServerMessage Whisps = new ServerMessage("@Y");
            Whisps.AddInt(User.VirtualId);
            Whisps.AddStringWithBreak(Message);
            Whisps.AddBoolean(false);
            User.SendMessage(Whisps);
            sUser.SendMessage(Whisps);
        }

        internal void ClickOnFurni()
        {
            if (User.IsFreeze)
                return;
            RoomItem Item;
            RoomsData R = RoomsData.Rooms[User.CurrentRoomId];
            int ExtraInformation;
            try
            {
                string[] s = (new AnalyzeMessages()).SepareOnVL64Vars(User.ActualPacket.Substring(2));
                Item = RoomItem.RegisteredItems[HabboEncode.decodeVL64(s[0])];
                ExtraInformation = HabboEncode.decodeVL64(s[1]);
            } catch {
                string Cleaned = User.ActualPacket.Substring(2, User.ActualPacket.Length - 3);
                int ItemId = HabboEncode.decodeVL64(Cleaned);
                Item = RoomItem.RegisteredItems[ItemId];
                ExtraInformation = 0;
            }

            #region Wired Triggers
            foreach (RoomItem zItem in R.FloorItems)
            {
                if (zItem.GetBaseItem().Name == "wf_trg_state_changed")
                {
                    if (zItem.WiredItems.Contains(Item.Id))
                    {
                        zItem.ExtraData = "1";
                        zItem.UpdateState(User);
                        foreach (RoomItem uItem in this.GetItemsForXY(zItem.X, zItem.Y))
                        {
                            WiredEffects Eff = new WiredEffects(uItem, User);
                            Eff.DoWiredEffects();
                        }
                    }
                }
            }
            #endregion

            if (Item.GetBaseItem().FurniInteractor == "drinks")
            {
                if (Item.ExtraData == "")
                    Item.ExtraData = "0";
                if (Item.ExtraData == "0")
                    Item.ExtraData = "1";
                else if (Item.ExtraData == "1")
                    Item.ExtraData = "0";
                Item.UpdateState(User);

                if (Item.GetBaseItem().Name.Contains("icecream"))
                {
                    User.CarryItem(4);
                }

            } else if (Item.GetBaseItem().FurniInteractor == "musicplayer")
            {
                if (R.OwnerId == User.Id || User.Rank >= 8)
                    (new JukeBox(User)).ShowMyDisk();
            }
            else
            {
                if (Item.GetBaseItem().FurniInteractor == "default")
                {
                    if (User.QuestType.Contains("SWITCH_ITEM_STATE"))
                        User.UpdateQuest(1, 12);

                    #region Battle Banzai
                    if (Item.GetBaseItem().Name.Contains("bb_"))
                    {
                        if (R.OwnerId == User.Id || User.Rank >= 8)
                        {
                            #region Counter
                            if (Item.GetBaseItem().Name.Contains("counter"))
                            {
                                if (Item.ExtraData == "")
                                    Item.ExtraData = "0";

                                if (ExtraInformation == 1)
                                {
                                    if (StaticGame.CounterSystem.ContainsKey(Item.Id))
                                    {
                                        // PAUSE GAME
                                        Thread Battle = StaticGame.CounterSystem[Item.Id];
                                        Battle.Abort();
                                        Battle = null;
                                        StaticGame.CounterSystem.Remove(Item.Id);
                                        R.BattlePause = true;
                                    }
                                    else
                                    {
                                        if (R.BattleOnGame && R.BattlePause)
                                        {
                                            BattleBanzai Batt = new BattleBanzai(Item, R.FloorItems, User, R, this);
                                            Thread Battle = new Thread(new ThreadStart(Batt.StartCounter));
                                            StaticGame.CounterSystem.Add(Item.Id, Battle);
                                            Battle.Start();
                                            Thread.Sleep(1);
                                            R.BattlePause = false;
                                        }
                                        else
                                        {
                                            // PLAY GAME!
                                            R.BattleOnGame = true;
                                            int TimeSeconds = int.Parse(Item.ExtraData);
                                            if (TimeSeconds > 0)
                                            {
                                                BattleBanzai Batt = new BattleBanzai(Item, R.FloorItems, User, R, this);
                                                Batt.StartGame();
                                                Thread Battle = new Thread(new ThreadStart(Batt.StartCounter));
                                                StaticGame.CounterSystem.Add(Item.Id, Battle);
                                                Battle.Start();
                                                Thread.Sleep(1);
                                            }
                                        }
                                    }
                                }
                                else if (ExtraInformation == 2)
                                {
                                    // Times
                                    if (Item.ExtraData == "")
                                        Item.ExtraData = "0";

                                    int Extra = int.Parse(Item.ExtraData);
                                    if (Extra == 0)
                                        Extra = 30;
                                    else if (Extra == 30)
                                        Extra = 60;
                                    else if (Extra == 60)
                                        Extra = 120;
                                    else if (Extra == 120)
                                        Extra = 180;
                                    else if (Extra == 180)
                                        Extra = 300;
                                    else if (Extra == 300)
                                        Extra = 600;
                                    else if (Extra == 600)
                                        Extra = 0;
                                    else
                                        Extra = 0;

                                    Item.ExtraData = Extra.ToString();
                                    Item.UpdateState(User);
                                }
                            }
                            #endregion
                        }

                    }
                    #endregion
                    #region Freeze
                    else if (Item.GetBaseItem().Name.Contains("es_"))
                    {
                        if (R.OwnerId == User.Id || User.Rank >= 8)
                        {
                            #region Counter
                            if (Item.GetBaseItem().Name.Contains("counter"))
                            {
                                if (User.CurrentRoom().OwnerId != User.Id && User.Rank <= 7)
                                    return;
                                if (Item.ExtraData == "")
                                    Item.ExtraData = "0";

                                if (ExtraInformation == 1)
                                {
                                    if (StaticGame.CounterSystem.ContainsKey(Item.Id))
                                    {
                                        // PAUSE GAME
                                        Thread Freeze = StaticGame.CounterSystem[Item.Id];
                                        Freeze.Abort();
                                        Freeze = null;
                                        StaticGame.CounterSystem.Remove(Item.Id);
                                        R.FreezePause = true;
                                    }
                                    else
                                    {
                                        if (R.FreezeOnGame && R.FreezePause)
                                        {
                                            Freeze Freez = new Freeze(Item, R.FloorItems, User, R, this);
                                            Thread Freeze = new Thread(new ThreadStart(Freez.StartCounter));
                                            StaticGame.CounterSystem.Add(Item.Id, Freeze);
                                            Freeze.Start();
                                            Thread.Sleep(1);
                                            R.FreezePause = false;
                                        }
                                        else
                                        {
                                            // PLAY GAME!
                                            R.FreezeOnGame = true;
                                            int TimeSeconds = int.Parse(Item.ExtraData);
                                            if (TimeSeconds > 0)
                                            {
                                                Freeze Freez = new Freeze(Item, R.FloorItems, User, R, this);
                                                Freez.StartGame();
                                                Thread Freeze = new Thread(new ThreadStart(Freez.StartCounter));
                                                StaticGame.CounterSystem.Add(Item.Id, Freeze);
                                                Freeze.Start();
                                                Thread.Sleep(1);
                                            }
                                        }
                                    }
                                }
                                else if (ExtraInformation == 2)
                                {
                                    // Times
                                    int Extra = int.Parse(Item.ExtraData);
                                    if (Extra == 0)
                                        Extra = 30;
                                    else if (Extra == 30)
                                        Extra = 60;
                                    else if (Extra == 60)
                                        Extra = 120;
                                    else if (Extra == 120)
                                        Extra = 180;
                                    else if (Extra == 180)
                                        Extra = 300;
                                    else if (Extra == 300)
                                        Extra = 600;
                                    else if (Extra == 600)
                                        Extra = 0;
                                    else
                                        Extra = 0;

                                    Item.ExtraData = Extra.ToString();
                                    Item.UpdateState(User);
                                }
                            }
                            #endregion
                        }
                        if (R.FreezeOnGame)
                        {
                            if (Item.ExtraData == "")
                                Item.ExtraData = "0";

                            #region Tiles
                            if (Item.GetBaseItem().Name.Contains("tile") || Item.GetBaseItem().Name.Contains("box") && Item.ExtraData != "0")
                            {
                                if (Item.GetBaseItem().Name == "es_box")
                                {
                                    bool IsTile = false;
                                    foreach (RoomItem zItem in GetItemsForXY(Item.X, Item.Y))
                                    {
                                        if (zItem.GetBaseItem().Name == "es_tile")
                                        {
                                            IsTile = true;
                                            Item = zItem;
                                        }
                                    }

                                    if (!IsTile)
                                        return;
                                }

                                if (User.CurrentEffect != 40 && User.CurrentEffect != 41 && User.CurrentEffect != 42 && User.CurrentEffect != 43 && User.CurrentEffect != 49 && User.CurrentEffect != 50 && User.CurrentEffect != 51 && User.CurrentEffect != 52)
                                    return;

                                if (User.frzBalls > 0)
                                {
                                    User.frzBalls--;
                                    TileToFreeze = Item;
                                    if (StaticGame.FreezeSystem.ContainsKey(Item.Id))
                                    {
                                        Thread SubFreeze = StaticGame.FreezeSystem[Item.Id];
                                        StaticGame.FreezeSystem.Remove(Item.Id);
                                        SubFreeze.Abort();
                                    }
                                    Thread sSubFreeze2 = new Thread(new ThreadStart(FreezeTiles));
                                    sSubFreeze2.Start();
                                    StaticGame.FreezeSystem.Add(Item.Id, sSubFreeze2);
                                }
                            }
                            #endregion
                        }
                    }
                    #endregion
                    #region Wired Furniture
                    else if (Item.GetBaseItem().Name.StartsWith("wf_"))
                    {
                        if (R.OwnerId == User.Id || User.Rank >= 8)
                        {
                            #region Wireds
                            if (Item.GetBaseItem().Name.Contains("trg_enter_room"))
                            {
                                // JJHHH[XNjKZHS{2}HHSAH{2}{1}
                                ServerMessage WiredFurni = new ServerMessage("JJ");
                                WiredFurni.AddInt(0);
                                WiredFurni.AddInt(5);
                                WiredFurni.AddInt(0);
                                WiredFurni.AddInt(Item.GetBaseItem().SpriteId);
                                WiredFurni.AddInt(Item.Id);
                                WiredFurni.AddStringWithBreak(Item.WiredString); // User Maybe?
                                WiredFurni.AddInt(0);
                                WiredFurni.AddInt(0);
                                WiredFurni.AddInt(7);
                                WiredFurni.AddInt(0);
                                WiredFurni.AddStringWithBreak("");
                                User.SendMessage(WiredFurni);
                            }
                            else if (Item.GetBaseItem().Name.Contains("wf_act_show_message"))
                            {
                                ServerMessage WiredFurni = new ServerMessage("JK");
                                WiredFurni.AddBoolean(false); // boolean false?
                                WiredFurni.AddInt(5); // Max furnis selected (WTF?)
                                WiredFurni.AddInt(0); // Total furnis selected
                                // here WiredFurni(ItemId2) if you have one item selected, it repeats and blablabla
                                WiredFurni.AddInt(Item.GetBaseItem().SpriteId); // Item SpriteID
                                WiredFurni.AddInt(Item.Id); // ItemID
                                WiredFurni.AddStringWithBreak(Item.WiredString); // Say Message
                                WiredFurni.AddInt(0); // Blah
                                WiredFurni.AddInt(0); // Blah
                                WiredFurni.AddInt(7); // More
                                WiredFurni.AddInt(0); // and mooore!
                                WiredFurni.AddStringWithBreak(""); // char2 :D!
                                User.SendMessage(WiredFurni);
                            }
                            else if (Item.GetBaseItem().Name.Contains("wf_act_teleport_to"))
                            {
                                ServerMessage WiredFurni = new ServerMessage("JK");
                                WiredFurni.AddBoolean(false); // boolean false?
                                WiredFurni.AddInt(5); // Max Furnis Selected
                                WiredFurni.AddInt(Item.WiredItems.Count); // Total furnis selected
                                foreach (int i in Item.WiredItems)
                                {
                                    WiredFurni.AddInt(i);
                                }
                                // here WiredFurni(ItemId2) if you have one item selected, it repeats and blablabla
                                WiredFurni.AddInt(Item.GetBaseItem().SpriteId); // Item SpriteID
                                WiredFurni.AddInt(Item.Id); // ItemID
                                WiredFurni.AddStringWithBreak("HHPBHH"); // some blahblahblah
                                WiredFurni.AddStringWithBreak("HHPBHH"); // some blah
                                User.SendMessage(WiredFurni);
                            }
                            else if (Item.GetBaseItem().Name.Contains("wf_trg_walks_on_furni"))
                            {
                                ServerMessage WiredFurni = new ServerMessage("JJ");
                                WiredFurni.AddBoolean(false); // boolean false?
                                WiredFurni.AddInt(5); // Max Furnis Selected
                                WiredFurni.AddInt(Item.WiredItems.Count); // Total furnis selected
                                foreach (int i in Item.WiredItems)
                                {
                                    WiredFurni.AddInt(i);
                                }
                                // here WiredFurni(ItemId2) if you have one item selected, it repeats and blablabla
                                WiredFurni.AddInt(Item.GetBaseItem().SpriteId); // Item SpriteID
                                WiredFurni.AddInt(Item.Id); // ItemID
                                WiredFurni.AddStringWithBreak("HHIH");
                                WiredFurni.AddStringWithBreak("HHIH");
                                User.SendMessage(WiredFurni);
                            }
                            else if (Item.GetBaseItem().Name.Contains("wf_trg_walks_off_furni"))
                            {
                                ServerMessage WiredFurni = new ServerMessage("JJ");
                                WiredFurni.AddBoolean(false); // boolean false?
                                WiredFurni.AddInt(5); // Max Furnis Selected
                                WiredFurni.AddInt(Item.WiredItems.Count); // Total furnis selected
                                foreach (int i in Item.WiredItems)
                                {
                                    WiredFurni.AddInt(i);
                                }
                                // here WiredFurni(ItemId2) if you have one item selected, it repeats and blablabla
                                WiredFurni.AddInt(Item.GetBaseItem().SpriteId); // Item SpriteID
                                WiredFurni.AddInt(Item.Id); // ItemID
                                WiredFurni.AddStringWithBreak("HHIH");
                                WiredFurni.AddStringWithBreak("HHIH");
                                User.SendMessage(WiredFurni);
                            }
                            else if (Item.GetBaseItem().Name.ToLower() == "wf_trg_game_ends")
                            {
                                ServerMessage WiredFurni = new ServerMessage("JJ");
                                WiredFurni.AddBoolean(false); // boolean false?
                                WiredFurni.AddInt(5); // Max Furnis Selected
                                WiredFurni.AddInt(0);
                                WiredFurni.AddInt(Item.GetBaseItem().SpriteId); // Item SpriteID
                                WiredFurni.AddInt(Item.Id); // ItemID
                                WiredFurni.AddStringWithBreak("HHPBH");
                                WiredFurni.AddStringWithBreak("HHPBH");
                                User.SendMessage(WiredFurni);
                            }
                            else if (Item.GetBaseItem().Name.ToLower() == "wf_trg_game_starts")
                            {
                                ServerMessage WiredFurni = new ServerMessage("JJ");
                                WiredFurni.AddBoolean(false); // boolean false?
                                WiredFurni.AddInt(5); // Max Furnis Selected
                                WiredFurni.AddInt(0);
                                WiredFurni.AddInt(Item.GetBaseItem().SpriteId); // Item SpriteID
                                WiredFurni.AddInt(Item.Id); // ItemID
                                WiredFurni.AddStringWithBreak("HHPBH");
                                WiredFurni.AddStringWithBreak("HHPBH");
                                User.SendMessage(WiredFurni);
                            }
                            else if (Item.GetBaseItem().Name == "wf_act_toggle_state")
                            {
                                ServerMessage WiredFurni = new ServerMessage("JK");
                                WiredFurni.AddBoolean(false); // boolean false?
                                WiredFurni.AddInt(5); // Max Furnis Selected
                                WiredFurni.AddInt(Item.WiredItems.Count); // Total furnis selected
                                foreach (int i in Item.WiredItems)
                                {
                                    WiredFurni.AddInt(i);
                                }
                                // here WiredFurni(ItemId2) if you have one item selected, it repeats and blablabla
                                WiredFurni.AddInt(Item.GetBaseItem().SpriteId); // Item SpriteID
                                WiredFurni.AddInt(Item.Id); // ItemID
                                WiredFurni.AddString("HHH");
                                if (Item.WiredString != "")
                                    WiredFurni.AddInt((int.Parse(Item.WiredString) / 500));
                                else
                                    WiredFurni.AddInt(0);
                                WiredFurni.AddStringWithBreak("H"); // HHH [Wait] HH
                                WiredFurni.AddString("HHH");
                                if (Item.WiredString != "")
                                    WiredFurni.AddInt((int.Parse(Item.WiredString) / 500));
                                else
                                    WiredFurni.AddInt(0);
                                WiredFurni.AddStringWithBreak("H"); // HHH [Wait] HH
                                User.SendMessage(WiredFurni);
                            }
                            else if (Item.GetBaseItem().Name == "wf_trg_state_changed")
                            {
                                ServerMessage WiredFurni = new ServerMessage("JJ");
                                WiredFurni.AddBoolean(false); // boolean false?
                                WiredFurni.AddInt(5); // Max Furnis Selected
                                WiredFurni.AddInt(Item.WiredItems.Count); // Total furnis selected
                                foreach (int i in Item.WiredItems)
                                {
                                    WiredFurni.AddInt(i);
                                }
                                // here WiredFurni(ItemId2) if you have one item selected, it repeats and blablabla
                                WiredFurni.AddInt(Item.GetBaseItem().SpriteId); // Item SpriteID
                                WiredFurni.AddInt(Item.Id); // ItemID
                                WiredFurni.AddStringWithBreak("HHPAH");
                                WiredFurni.AddStringWithBreak("HHPAH");
                                User.SendMessage(WiredFurni);
                            }
                            else if (Item.GetBaseItem().Name.ToLower() == "wf_trg_says_something")
                            {
                                ServerMessage WiredFurni = new ServerMessage("JJ");
                                WiredFurni.AddBoolean(false); // boolean false?
                                WiredFurni.AddInt(5); // Max Furnis Selected
                                WiredFurni.AddInt(0); // No Items
                                WiredFurni.AddInt(Item.GetBaseItem().SpriteId); // Item SpriteID
                                WiredFurni.AddInt(Item.Id); // ItemID
                                WiredFurni.AddStringWithBreak(Item.WiredString);
                                User.SendMessage(WiredFurni);
                            }
                            else if (Item.GetBaseItem().Name == "wf_trg_periodically")
                            {
                                ServerMessage WiredFurni = new ServerMessage("JJ");
                                WiredFurni.AddBoolean(false); // boolean false?
                                WiredFurni.AddInt(5); // Max Furnis Selected
                                WiredFurni.AddInt(0); // No Items
                                WiredFurni.AddInt(Item.GetBaseItem().SpriteId); // Item SpriteID
                                WiredFurni.AddInt(Item.Id); // ItemID
                                WiredFurni.AddInt(1);
                                if (Item.WiredString != "")
                                    WiredFurni.AddInt((int.Parse(Item.WiredString) / 500));
                                else
                                    WiredFurni.AddInt(0);
                                WiredFurni.AddStringWithBreak("HRAH");
                                WiredFurni.AddInt(1);
                                if (Item.WiredString != "")
                                    WiredFurni.AddInt((int.Parse(Item.WiredString) / 500));
                                else
                                    WiredFurni.AddInt(0);
                                WiredFurni.AddStringWithBreak("HRAH");
                                User.SendMessage(WiredFurni);
                            }
                            else if (Item.GetBaseItem().Name.Contains("wf_act_move_rotate"))
                            {
                                ServerMessage WiredFurni = new ServerMessage("JK");
                                WiredFurni.AddBoolean(false); // boolean false?
                                WiredFurni.AddInt(5); // Max Furnis Selected
                                WiredFurni.AddInt(Item.WiredItems.Count); // Total furnis selected
                                foreach (int i in Item.WiredItems)
                                {
                                    WiredFurni.AddInt(i);
                                }
                                // here WiredFurni(ItemId2) if you have one item selected, it repeats and blablabla
                                WiredFurni.AddInt(Item.GetBaseItem().SpriteId); // Item SpriteID
                                WiredFurni.AddInt(Item.Id); // ItemID
                                WiredFurni.AddInt(2); // ??
                                if (Item.WiredString.Contains("|"))
                                {
                                    string[] Separe = Item.WiredString.Split('|');
                                    WiredFurni.AddInt(int.Parse(Separe[0])); // Move
                                    WiredFurni.AddInt(int.Parse(Separe[1])); // Rotate
                                    WiredFurni.AddInt(0);
                                    WiredFurni.AddInt(4);
                                    WiredFurni.AddInt((int.Parse(Separe[2]) / 500)); // Miliseconds
                                    WiredFurni.AddStringWithBreak("H");
                                    WiredFurni.AddInt(2); // ??
                                    WiredFurni.AddInt(int.Parse(Separe[0])); // Move
                                    WiredFurni.AddInt(int.Parse(Separe[1])); // Rotate
                                    WiredFurni.AddInt(0);
                                    WiredFurni.AddInt(4);
                                    WiredFurni.AddInt((int.Parse(Separe[2]) / 500)); // Miliseconds
                                    WiredFurni.AddStringWithBreak("H");
                                }
                                else
                                {
                                    WiredFurni.AddStringWithBreak("HHHPAHH");
                                    WiredFurni.AddStringWithBreak("JHHHPAHH");
                                }
                                User.SendMessage(WiredFurni);
                            }
                            else if (Item.GetBaseItem().Name == "wf_floor_switch1")
                            {
                                Coord Actual = new Coord(User.X, User.Y);
                                if (Item.SquareBehind != Actual && Item.SquareDer != Actual && Item.SquareIzq != Actual && Item.SquareDer != Actual)
                                    return;

                                if (Item.ExtraData == "")
                                    Item.ExtraData = "0";
                                if (Item.ExtraData == "0")
                                    Item.ExtraData = "1";
                                else if (Item.ExtraData == "1")
                                    Item.ExtraData = "0";
                                Item.UpdateState(User);
                            }
                            #endregion
                        }
                    }
                    #endregion
                    else
                    {
                        if (Item.ExtraData == "")
                            Item.ExtraData = "0";
                        if (Item.ExtraData == "0")
                            Item.ExtraData = "1";
                        else if (Item.ExtraData == "1")
                            Item.ExtraData = "0";
                        Item.UpdateState(User);
                    }
                }
                else if (Item.GetBaseItem().FurniInteractor == "gate")
                {
                    string ExtraData = "1";
                    if (Item.ExtraData == "1")
                        ExtraData = "0";

                    Item.IsModify = true;
                    Item.ExtraData = ExtraData;

                    ServerMessage Message = new ServerMessage("AX");
                    Message.AddStringWithBreak(Item.Id.ToString());
                    Message.AddStringWithBreak(Item.ExtraData);
                    SendMessage(Message);
                    GenerateMatrix();
                }
            }
            
        }

        internal void FreezeUsersOnXY(int RoomId, int X, int Y)
        {
            RoomsData R = RoomsData.Rooms[RoomId];
            string scolor;
            foreach (Habbo Habbito in R.UserList)
            {
                if (Habbito.HasFreezeShield)
                    continue;

                if (Habbito.FreezeLives == 0)
                    continue;

                if (Habbito.X == X && Habbito.Y == Y)
                {
                    scolor = "r";
                    if (Habbito.CurrentEffect == 41)
                        scolor = "g";
                    else if (Habbito.CurrentEffect == 42)
                        scolor = "b";
                    else if (Habbito.CurrentEffect == 43)
                        scolor = "y";
                    foreach (RoomItem Item in R.FloorItems)
                    {
                        if(Item.GetBaseItem().Name == "es_score_" + scolor)
                        {
                            Habbito.DeletePoints(Item, scolor);
                            if (Habbito.FreezeLives > 0)
                                FreezeUser(Habbito);
                            break;
                        }
                    }
                }
            }
        }

        internal void RateRoom()
        {
            int Rate = User.ActualClientMessage.GetNextInt();
            RoomsData Data = RoomsData.Rooms[User.CurrentRoomId];

            if (User.RatedRooms.Contains(Data.Id))
                return;

            switch (Rate)
            {
                case -1:
                    if (Data.Score > 0)
                        Data.Score--;
                    break;

                case 1:

                    Data.Score++;
                    break;

                default:

                    return;
            }

            Updater.SQLStoExecute.Add("UPDATE rooms SET score = " + Data.Score + " WHERE id = " + Data.Id);
            User.RatedRooms.Add(Data.Id);

            ServerMessage RatedRoom = new ServerMessage("EY");
            RatedRoom.AddInt(Data.Score);
            SendMessage(RatedRoom);
        }

        internal void FreezeUpdateBoxesOnXY(int RoomId, int X, int Y)
        {
            foreach(RoomItem Item in GetItemsForXY(X, Y))
            {
                if (Item.GetBaseItem().Name == "es_box")
                {
                    if (Item.ExtraData == "")
                        Item.ExtraData = "0";

                    if (Item.ExtraData != "0")
                        return;

                    int rand = (new Random()).Next(1, 11);
                    if (rand <= 4)
                    {
                        Item.ExtraData = "1000";
                    }
                    else if (rand == 5)
                    {
                        Item.ExtraData = "2000";
                    }
                    else if (rand == 6)
                    {
                        Item.ExtraData = "3000";
                    }
                    else if (rand == 7)
                    {
                        Item.ExtraData = "4000";
                    }
                    else if (rand == 8)
                    {
                        Item.ExtraData = "5000";
                    }
                    else if (rand == 9)
                    {
                        Item.ExtraData = "6000";
                    }
                    else if (rand == 10)
                    {
                        Item.ExtraData = "7000";
                    }
                    Item.UpdateState(User);
                }
            }
        }

        public void FreezeAllUsers(Habbo User)
        {
            RoomsData R = RoomsData.Rooms[User.CurrentRoomId];
            foreach (Habbo cUser in R.UserList)
            {
                if (cUser.HasFreezeShield)
                    return;

                if (cUser.FreezeLives == 0)
                    return;

                string scolor = "";
                if(cUser.CurrentEffect == 40)
                    scolor = "r";
                else if (cUser.CurrentEffect == 41)
                    scolor = "g";
                else if (cUser.CurrentEffect == 42)
                    scolor = "b";
                else if (cUser.CurrentEffect == 43)
                    scolor = "y";
                else
                    continue;

                foreach (RoomItem Item in R.FloorItems)
                {
                    if (Item.GetBaseItem().Name == "es_score_" + scolor)
                    {
                        User.DeletePoints(Item, scolor);
                        FreezeUser(User);
                    }
                }
            }

        }

        /*internal bool CanWalk(int X, int Y, Double Z, Boolean LastStep, RoomModel Model)
        {
            if (SquareHasUsers(X, Y, LastStep))
            {
                return false;
            }
            /*if (Matrix[X, Y] == MatrixState.BLOCKED)
            {
                return false;
            }*/
            /*else if (Matrix[X, Y] == MatrixState.WALKABLE_LASTSTEP && !LastStep)
            {
                return false;
            }

            return true;
        }*/

        public bool SquareHasUsers(int X, int Y, bool LastStep)
        {
            if (LastStep)
            {
                return false;
            }
            return SquareHasUsers(X, Y);
        }

        public bool SquareHasUsers(int X, int Y)
        {
            foreach (Habbo zUser in RoomsData.Rooms[User.CurrentRoomId].UserList)
            {
                if (zUser.X == X && zUser.Y == Y)
                    return true;
            }
            return false;
        }

        internal void FreezeTiles()
        {
            RoomItem Item = TileToFreeze;
            if (Item.GetBaseItem().Name == "es_box")
            {
                foreach (RoomItem zItem in GetItemsForXY(Item.X, Item.Y))
                {
                    if (zItem.GetBaseItem().Name == "es_tile")
                        Item = zItem;
                }
            }

            #region Tiles
            if (User.HyperBalls > 0)
                Item.ExtraData = "2100";
            else
                Item.ExtraData = "1000";
                Item.UpdateState(User);
                Thread.Sleep(2100);
                if (User.HyperBalls > 0)
                {
                    User.HyperBalls -= 1;
                    FreezeAllUsers(User);
                    foreach (RoomItem sItem in RoomsData.Rooms[Item.RoomId].FloorItems)
                    {
                        if (sItem.GetBaseItem().Name == "es_tile")
                        {
                            sItem.ExtraData = "11200";
                            sItem.UpdateState(User);
                        }
                    }
                }
                else
                {
                    Item.ExtraData = "11200";
                    Item.UpdateState(User);
                    FreezeUsersOnXY(Item.RoomId, Item.X, Item.Y);
                    // Get Squares
                    #region (SPECIAL) Diagonals
                    if (User.HasFreezeDiagonal)
                    {
                        Coord c9 = new Coord(Item.X--, Item.Y--);
                        foreach (RoomItem it in GetItemsForXY(c9.X, c9.Y))
                        {
                            if (it.GetBaseItem().Name == "es_tile")
                            {
                                it.ExtraData = "11200";
                                it.UpdateState(User);
                                FreezeUsersOnXY(Item.RoomId, c9.X, c9.Y);
                                FreezeUpdateBoxesOnXY(Item.RoomId, c9.X, c9.Y);
                            }
                        }

                        Coord c10 = new Coord(Item.X++, Item.Y--);
                        foreach (RoomItem it in GetItemsForXY(c10.X, c10.Y))
                        {
                            if (it.GetBaseItem().Name == "es_tile")
                            {
                                it.ExtraData = "11200";
                                it.UpdateState(User);
                                FreezeUsersOnXY(Item.RoomId, c10.X, c10.Y);
                                FreezeUpdateBoxesOnXY(Item.RoomId, c10.X, c10.Y);
                            }
                        }

                        Coord c11 = new Coord(Item.X--, Item.Y++);
                        foreach (RoomItem it in GetItemsForXY(c11.X, c11.Y))
                        {
                            if (it.GetBaseItem().Name == "es_tile")
                            {
                                it.ExtraData = "11200";
                                it.UpdateState(User);
                                FreezeUsersOnXY(Item.RoomId, c11.X, c11.Y);
                                FreezeUpdateBoxesOnXY(Item.RoomId, c11.X, c11.Y);
                            }
                        }

                        Coord c12 = new Coord(Item.X++, Item.Y++);
                        foreach (RoomItem it in GetItemsForXY(c12.X, c12.Y))
                        {
                            if (it.GetBaseItem().Name == "es_tile")
                            {
                                it.ExtraData = "11200";
                                it.UpdateState(User);
                                FreezeUsersOnXY(Item.RoomId, c12.X, c12.Y);
                                FreezeUpdateBoxesOnXY(Item.RoomId, c12.X, c12.Y);
                            }
                        }

                        User.HasFreezeDiagonal = false;
                    }
                    #endregion
                    #region InFront
                    Coord c = Item.SquareInFront;
                    foreach (RoomItem it in GetItemsForXY(c.X, c.Y))
                    {
                        if (it.GetBaseItem().Name == "es_tile")
                        {
                            it.ExtraData = "11200";
                            it.UpdateState(User);
                            FreezeUsersOnXY(Item.RoomId, c.X, c.Y);
                            FreezeUpdateBoxesOnXY(Item.RoomId, c.X, c.Y);
                            Coord cb = it.SquareInFront;
                            foreach (RoomItem it2 in GetItemsForXY(cb.X, cb.Y))
                            {
                                if (it2.GetBaseItem().Name == "es_tile")
                                {
                                    it2.ExtraData = "11200";
                                    it2.UpdateState(User);
                                    FreezeUsersOnXY(Item.RoomId, cb.X, cb.Y);
                                    FreezeUpdateBoxesOnXY(Item.RoomId, cb.X, cb.Y);
                                    Coord cc = it2.SquareInFront;
                                    foreach (RoomItem it3 in GetItemsForXY(cc.X, cc.Y))
                                    {
                                        if (it3.GetBaseItem().Name == "es_tile")
                                        {
                                            it3.ExtraData = "11200";
                                            it3.UpdateState(User);
                                            FreezeUsersOnXY(Item.RoomId, cc.X, cc.Y);
                                            FreezeUpdateBoxesOnXY(Item.RoomId, cc.X, cc.Y);
                                            Coord cd = it3.SquareInFront;
                                            foreach (RoomItem it4 in GetItemsForXY(cd.X, cd.Y))
                                            {
                                                if (it4.GetBaseItem().Name == "es_tile")
                                                {
                                                    it4.ExtraData = "11200";
                                                    it4.UpdateState(User);
                                                    FreezeUsersOnXY(Item.RoomId, cd.X, cd.Y);
                                                    FreezeUpdateBoxesOnXY(Item.RoomId, cd.X, cd.Y);
                                                    Coord ce = it4.SquareInFront;
                                                    foreach (RoomItem it5 in GetItemsForXY(ce.X, ce.Y))
                                                    {
                                                        if (it5.GetBaseItem().Name == "es_tile")
                                                        {
                                                            it5.ExtraData = "11200";
                                                            it5.UpdateState(User);
                                                            FreezeUsersOnXY(Item.RoomId, ce.X, ce.Y);
                                                            FreezeUpdateBoxesOnXY(Item.RoomId, ce.X, ce.Y);
                                                        }
                                                    }
                                                }
                                            }
                                        }

                                    }
                                }
                            }
                        }
                    }
                    #endregion
                    #region Behind
                    Coord c2 = Item.SquareBehind;
                    foreach (RoomItem it in GetItemsForXY(c2.X, c2.Y))
                    {
                        if (it.GetBaseItem().Name == "es_tile")
                        {
                            it.ExtraData = "11200";
                            it.UpdateState(User);
                            FreezeUsersOnXY(Item.RoomId, c2.X, c2.Y);
                            FreezeUpdateBoxesOnXY(Item.RoomId, c2.X, c2.Y);
                            Coord cb = it.SquareBehind;
                            foreach (RoomItem it2 in GetItemsForXY(cb.X, cb.Y))
                            {
                                if (it2.GetBaseItem().Name == "es_tile")
                                {
                                    it2.ExtraData = "11200";
                                    it2.UpdateState(User);
                                    FreezeUsersOnXY(Item.RoomId, cb.X, cb.Y);
                                    FreezeUpdateBoxesOnXY(Item.RoomId, cb.X, cb.Y);
                                    Coord cc = it2.SquareBehind;
                                    foreach (RoomItem it3 in GetItemsForXY(cc.X, cc.Y))
                                    {
                                        if (it3.GetBaseItem().Name == "es_tile")
                                        {
                                            it3.ExtraData = "11200";
                                            it3.UpdateState(User);
                                            FreezeUsersOnXY(Item.RoomId, cc.X, cc.Y);
                                            FreezeUpdateBoxesOnXY(Item.RoomId, cc.X, cc.Y);
                                            Coord cd = it3.SquareBehind;
                                            foreach (RoomItem it4 in GetItemsForXY(cd.X, cd.Y))
                                            {
                                                if (it4.GetBaseItem().Name == "es_tile")
                                                {
                                                    it4.ExtraData = "11200";
                                                    it4.UpdateState(User);
                                                    FreezeUsersOnXY(Item.RoomId, cd.X, cd.Y);
                                                    FreezeUpdateBoxesOnXY(Item.RoomId, cd.X, cd.Y);
                                                    Coord ce = it4.SquareBehind;
                                                    foreach (RoomItem it5 in GetItemsForXY(ce.X, ce.Y))
                                                    {
                                                        if (it5.GetBaseItem().Name == "es_tile")
                                                        {
                                                            it5.ExtraData = "11200";
                                                            it5.UpdateState(User);
                                                            FreezeUsersOnXY(Item.RoomId, ce.X, ce.Y);
                                                            FreezeUpdateBoxesOnXY(Item.RoomId, ce.X, ce.Y);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    #endregion
                    #region Der
                    Coord c3 = Item.SquareDer;
                    foreach (RoomItem it in GetItemsForXY(c3.X, c3.Y))
                    {
                        if (it.GetBaseItem().Name == "es_tile")
                        {
                            it.ExtraData = "11200";
                            it.UpdateState(User);
                            FreezeUsersOnXY(Item.RoomId, c3.X, c3.Y);
                            FreezeUpdateBoxesOnXY(Item.RoomId, c3.X, c3.Y);
                            Coord cb = it.SquareDer;
                            foreach (RoomItem it2 in GetItemsForXY(cb.X, cb.Y))
                            {
                                if (it2.GetBaseItem().Name == "es_tile")
                                {
                                    it2.ExtraData = "11200";
                                    it2.UpdateState(User);
                                    FreezeUsersOnXY(Item.RoomId, cb.X, cb.Y);
                                    FreezeUpdateBoxesOnXY(Item.RoomId, cb.X, cb.Y);
                                    Coord cc = it2.SquareDer;
                                    foreach (RoomItem it3 in GetItemsForXY(cc.X, cc.Y))
                                    {
                                        if (it3.GetBaseItem().Name == "es_tile")
                                        {
                                            it3.ExtraData = "11200";
                                            it3.UpdateState(User);
                                            FreezeUsersOnXY(Item.RoomId, cc.X, cc.Y);
                                            FreezeUpdateBoxesOnXY(Item.RoomId, cc.X, cc.Y);
                                            Coord cd = it3.SquareDer;
                                            foreach (RoomItem it4 in GetItemsForXY(cd.X, cd.Y))
                                            {
                                                if (it4.GetBaseItem().Name == "es_tile")
                                                {
                                                    it4.ExtraData = "11200";
                                                    it4.UpdateState(User);
                                                    FreezeUsersOnXY(Item.RoomId, cd.X, cd.Y);
                                                    FreezeUpdateBoxesOnXY(Item.RoomId, cd.X, cd.Y);
                                                    Coord ce = it4.SquareDer;
                                                    foreach (RoomItem it5 in GetItemsForXY(ce.X, ce.Y))
                                                    {
                                                        if (it5.GetBaseItem().Name == "es_tile")
                                                        {
                                                            it5.ExtraData = "11200";
                                                            it5.UpdateState(User);
                                                            FreezeUsersOnXY(Item.RoomId, ce.X, ce.Y);
                                                            FreezeUpdateBoxesOnXY(Item.RoomId, ce.X, ce.Y);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    #endregion
                    #region Izq
                    Coord c4 = Item.SquareIzq;
                    foreach (RoomItem it in GetItemsForXY(c4.X, c4.Y))
                    {
                        if (it.GetBaseItem().Name == "es_tile")
                        {
                            it.ExtraData = "11200";
                            it.UpdateState(User);
                            FreezeUsersOnXY(Item.RoomId, c4.X, c4.Y);
                            FreezeUpdateBoxesOnXY(Item.RoomId, c4.X, c4.Y);
                            Coord cb = it.SquareIzq;
                            foreach (RoomItem it2 in GetItemsForXY(cb.X, cb.Y))
                            {
                                if (it2.GetBaseItem().Name == "es_tile")
                                {
                                    it2.ExtraData = "11200";
                                    it2.UpdateState(User);
                                    FreezeUsersOnXY(Item.RoomId, cb.X, cb.Y);
                                    FreezeUpdateBoxesOnXY(Item.RoomId, cb.X, cb.Y);
                                    Coord cc = it2.SquareIzq;
                                    foreach (RoomItem it3 in GetItemsForXY(cc.X, cc.Y))
                                    {
                                        if (it3.GetBaseItem().Name == "es_tile")
                                        {
                                            it3.ExtraData = "11200";
                                            it3.UpdateState(User);
                                            FreezeUsersOnXY(Item.RoomId, cc.X, cc.Y);
                                            FreezeUpdateBoxesOnXY(Item.RoomId, cc.X, cc.Y);
                                            Coord cd = it3.SquareIzq;
                                            foreach (RoomItem it4 in GetItemsForXY(cd.X, cd.Y))
                                            {
                                                if (it4.GetBaseItem().Name == "es_tile")
                                                {
                                                    it4.ExtraData = "11200";
                                                    it4.UpdateState(User);
                                                    FreezeUsersOnXY(Item.RoomId, cd.X, cd.Y);
                                                    FreezeUpdateBoxesOnXY(Item.RoomId, cd.X, cd.Y);
                                                    Coord ce = it4.SquareIzq;
                                                    foreach (RoomItem it5 in GetItemsForXY(ce.X, ce.Y))
                                                    {
                                                        if (it5.GetBaseItem().Name == "es_tile")
                                                        {
                                                            it5.ExtraData = "11200";
                                                            it5.UpdateState(User);
                                                            FreezeUsersOnXY(Item.RoomId, ce.X, ce.Y);
                                                            FreezeUpdateBoxesOnXY(Item.RoomId, ce.X, ce.Y);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    #endregion
                }
            #endregion
                if (User.frzBalls == 0)
                    User.frzBalls++;
                Thread SubFreeze = StaticGame.FreezeSystem[Item.Id];
                SubFreeze.Abort();
                StaticGame.FreezeSystem.Remove(Item.Id);
        }

        internal void FreezeUser(Habbo sUser)
        {
            Thread Wait = new Thread(new ThreadStart(sWait));
            UserToFreeze = sUser;
            Wait.Start();
            if (StaticGame.FreezeWaitSystem.ContainsKey(User.Id))
            {
                Thread Wait2 = StaticGame.FreezeWaitSystem[User.Id];
                Wait2.Abort();
                StaticGame.FreezeWaitSystem.Remove(User.Id);
            }
            StaticGame.FreezeWaitSystem.Add(User.Id, Wait);
            Thread.Sleep(1);
        }

        internal void sWait()
        {
            Habbo sUser = UserToFreeze;
            int CurrentEffect = sUser.CurrentEffect;
            sUser.IsFreeze = true;
            (new EffectsInventory()).ShowEffect(sUser, 12);
            Thread.Sleep(6000);
            sUser.IsFreeze = false;
            if (CurrentEffect != 49 && CurrentEffect != 50 && CurrentEffect != 51 && CurrentEffect != 52)
                (new EffectsInventory()).ShowEffect(sUser, CurrentEffect + 9); // SHIELD
            else
                (new EffectsInventory()).ShowEffect(sUser, CurrentEffect); // SHIELD
            sUser.HasFreezeShield = true;
            Thread.Sleep(10000);
            if (CurrentEffect != 49 && CurrentEffect != 50 && CurrentEffect != 51 && CurrentEffect != 52)
                (new EffectsInventory()).ShowEffect(sUser, CurrentEffect); // SHIELD
            else
                (new EffectsInventory()).ShowEffect(sUser, CurrentEffect - 9); // SHIELD
            sUser.HasFreezeShield = false;
            Thread.Sleep(1);
            Thread Wait = StaticGame.FreezeWaitSystem[User.Id];
            StaticGame.FreezeWaitSystem.Remove(User.Id);
            Wait.Abort();
        }

        internal ServerMessage SetFloorItem(RoomItem I, ServerMessage Item, int X, int Y, int Rot)
        {
            Item.AddInt(I.Id);
            Item.AddInt(I.GetBaseItem().SpriteId);
            Item.AddInt(X);
            Item.AddInt(Y);
            Item.AddInt(Rot);
            string H = GetHForXY(X, Y, I).ToString().Replace(",", ".");
            if (!H.Contains("."))
                H += ".0";
            Item.AddStringWithBreak(H);
            Item.AddInt(0);
            Item.AddStringWithBreak(I.ExtraData);
            Item.AddInt(-1);
            return Item;
        }

        internal ServerMessage MoveFloorItem(RoomItem I, ServerMessage Item, int LastX, int LastY, int X, int Y, int Rot, int WiredId)
        {
            // CfSAKSAJIj_jA0{2}0{2}h^jA{1}
            Item.AddInt(LastX);
            Item.AddInt(LastY);
            Item.AddInt(X);
            Item.AddInt(Y);
            Item.AddInt(1);
            Item.AddInt(I.Id);
            Item.AddStringWithBreak(GetHForXY(X, Y, I).ToString().Replace(",","."));
            Item.AddStringWithBreak(I.ExtraData);
            Item.AddInt(WiredId);
            return Item;
        }

        internal void PickupFurni()
        {
            if (User.QuestType.Contains("PICKUP_ITEM"))
                User.UpdateQuest(1, 11);

            if (User.CurrentRoom().OwnerId != User.Id && User.Rank <= 7)
                return;

            AnalyzeMessages Mess = new AnalyzeMessages();
            string[] An = Mess.SepareOnVL64Vars(User.ActualPacket.Substring(2));
            int FurniId = HabboEncode.decodeVL64(An[1]);
            RoomItem U = RoomItem.RegisteredItems[FurniId];
            RemoveFurniture(U);

            Updater.SQLStoExecute.Add("INSERT INTO users_items (id, userid, itemid, extradata) VALUES (NULL, " + User.Id + ", " + U.FurniId + ", '" + U.ExtraData + "');");
            UserItemsData Us = new UserItemsData();
            Us.Id = UserItemsData.CalculateLastId() + 1;
            Us.UserId = User.Id;
            Us.FurniId = U.FurniId;
            Us.ExtraData = U.ExtraData;
            UserItemsData.UserItems.Add(Us);
            UserItemsData.UserItemsbyId.Add(Us.Id, Us);
            User.SendMessage(new ServerMessage("Ae"));
            UpdaterUserState();
            GenerateMatrix();
        }

        internal void GetCreditsForFurni()
        {
            int FurniId = HabboEncode.decodeVL64(User.ActualPacket.Substring(2));
            RoomItem U = RoomItem.RegisteredItems[FurniId];

            if (!U.GetBaseItem().Name.Contains("CF_"))
                return;

            int Count = 0;
            string Name = U.GetBaseItem().Name;
            if (Name.Contains("1") && !Name.Contains("10"))
                Count = 1;
            else if (Name.Contains("5") && !Name.Contains("50"))
                Count = 5;
            else if (Name.Contains("20") && !Name.Contains("200"))
                Count = 20;
            else if (Name.Contains("50") && !Name.Contains("500"))
                Count = 50;
            else if (Name.Contains("100"))
                Count = 100;
            else if (Name.Contains("200"))
                Count = 200;
            else if (Name.Contains("500"))
                Count = 500;

            RemoveFurniture(U);
            User.UpdateCredits(User.Credits + Count, true);
        }

        internal void RemoveFurniture(RoomItem I)
        {
            Updater.SQLStoExecute.Add("DELETE FROM rooms_items WHERE id = " + I.Id);
            RoomsData R = RoomsData.Rooms[User.CurrentRoomId];
            if (R.OwnerId != User.Id && User.Rank < 5)
                return;
            if (I.IsWall)
            {
                R.WallItems.Remove(I);
                ServerMessage Message = new ServerMessage("AT");
                Message.AddStringWithBreak(I.Id.ToString());
                Message.AddBoolean(false);
                StaticGame.SSendPacketToAllRoom(I.RoomId, Message);
            }
            else
            {
                R.FloorItems.Remove(I);
                ServerMessage Message = new ServerMessage("A^");
                Message.AddStringWithBreak(I.Id.ToString());
                Message.AddBoolean(false);
                StaticGame.SSendPacketToAllRoom(I.RoomId, Message);
            }            
            RoomItem.Items.Remove(I);
            RoomItem.RegisteredItems.Remove(I.Id);
        }

        internal bool IsItemOnXY(int X, int Y)
        {
            RoomsData R = RoomsData.Rooms[User.CurrentRoomId];

            bool Is = false;
            foreach (RoomItem Floor in R.FloorItems)
            {
                if (Floor.ExtraData == "")
                    Floor.ExtraData = "0";

                if (Floor.X == X && Floor.Y == Y && Floor.GetBaseItem().Name == "es_box" && Floor.ExtraData == "0")
                    return true;

                if (Floor.X == X && Floor.Y == Y && Floor.GetBaseItem().Name == "bb_pyramid" && Floor.ExtraData == "0")
                    return true;

                if (Floor.X == X && Floor.Y == Y && Floor.GetBaseItem().Name.StartsWith("es_gate_") && R.FreezeOnGame)
                    return true;

                if (Floor.X == X && Floor.Y == Y && !Floor.GetBaseItem().CanWalk)
                {
                    if (Floor.GetBaseItem().FurniInteractor == "gate" && Floor.ExtraData == "1")
                        Is = false;
                    else
                        Is = true;
                }
                else
                {
                    Dictionary<int, AffectedTile> AffectedTiles = GetAffectedTiles(Floor.GetBaseItem().Length, Floor.GetBaseItem().Width, Floor.X, Floor.Y, Floor.Rot);
                    foreach (AffectedTile Tile in AffectedTiles.Values)
                    {
                        if (Tile.X == X && Tile.Y == Y && !Floor.GetBaseItem().CanWalk)
                        {
                            if (Floor.GetBaseItem().FurniInteractor == "gate" && Floor.ExtraData == "1" || Floor.GetBaseItem().Name == "es_box" && Floor.ExtraData != "" && Floor.GetBaseItem().Name == "es_box" && Floor.ExtraData != "0")
                                Is = false;
                            else
                                Is = true;
                        }
                    }
                }
            }
            return Is;
        }

        internal List<RoomItem> GetItemsForXY(int X, int Y)
        {
            if (User.CurrentRoomId <= 0)
            {
                return new List<RoomItem>();
            }
            RoomsData R = RoomsData.Rooms[User.CurrentRoomId];
            List<RoomItem> Items = new List<RoomItem>();
            foreach (RoomItem Floor in R.FloorItems)
            {
                if (Floor.X == X && Floor.Y == Y)
                {
                    if (!Items.Contains(Floor))
                        Items.Add(Floor);
                }
                else
                {
                    Dictionary<int, AffectedTile> AffectedTiles = GetAffectedTiles(Floor.GetBaseItem().Length, Floor.GetBaseItem().Width, Floor.X, Floor.Y, Floor.Rot);
                    foreach (AffectedTile Tile in AffectedTiles.Values)
                    {
                        if (Tile.X == X && Tile.Y == Y)
                        {
                            if (!Items.Contains(Floor))
                                Items.Add(Floor);
                        }
                    }
                }
            }
            return Items;
        }

        internal List<AffectedTile> GetTilesForFurni(int Length, int Width, int PosX, int PosY, int Rotation)
        {
            List<AffectedTile> Furnis = new List<AffectedTile>();
            if (Width > 1)
            {
                if (Rotation == 2)
                {
                    int added = 1;
                    for (int i = 1; i < Width; i++)
                    {
                        AffectedTile Furni = new AffectedTile(PosX, PosY + added, added);
                        Furnis.Add(Furni);
                        added++;
                    }
                }
                else if (Rotation == 6)
                {
                    int added = 1;
                    for (int i = 1; i < Width; i++)
                    {
                        AffectedTile Furni = new AffectedTile(PosX, PosY - added, added);
                        Furnis.Add(Furni);
                        added++;
                    }
                }
                else if (Rotation == 0)
                {
                    int added = 1;
                    for (int i = 1; i < Width; i++)
                    {
                        AffectedTile Furni = new AffectedTile(PosX + added, PosY, added);
                        Furnis.Add(Furni);
                        added++;
                    }
                }
                else if (Rotation == 2)
                {
                    int added = 1;
                    for (int i = 1; i < Width; i++)
                    {
                        AffectedTile Furni = new AffectedTile(PosX - added, PosY, added);
                        Furnis.Add(Furni);
                        added++;
                    }
                }
            }

            return Furnis;
        }

        internal Dictionary<int, AffectedTile> GetAffectedTiles(int Length, int Width, int PosX, int PosY, int Rotation)
        {
            int x = 0;
            Dictionary<int, AffectedTile> PointList = new Dictionary<int, AffectedTile>();
            if (Length > 1)
            {
                if (Rotation == 0 || Rotation == 4)
                {
                    for (int i = 1; i < Length; i++)
                    {
                        PointList.Add(x++, new AffectedTile(PosX, PosY + i, i));
                        for (int j = 1; j < Width; j++)
                        {
                            PointList.Add(x++, new AffectedTile(PosX + j, PosY + i, (i < j) ? j : i));
                        }
                    }
                }
                else if (Rotation == 2 || Rotation == 6)
                {
                    for (int i = 1; i < Length; i++)
                    {
                        PointList.Add(x++, new AffectedTile(PosX + i, PosY, i));

                        for (int j = 1; j < Width; j++)
                        {
                            PointList.Add(x++, new AffectedTile(PosX + i, PosY + j, (i < j) ? j : i));
                        }
                    }
                }
            }

            if (Width > 1)
            {
                if (Rotation == 0 || Rotation == 4)
                {
                    for (int i = 1; i < Width; i++)
                    {
                        PointList.Add(x++, new AffectedTile(PosX + i, PosY, i));

                        for (int j = 1; j < Length; j++)
                        {
                            PointList.Add(x++, new AffectedTile(PosX + i, PosY + j, (i < j) ? j : i));
                        }
                    }
                }
                else if (Rotation == 2 || Rotation == 6)
                {
                    for (int i = 1; i < Width; i++)
                    {
                        PointList.Add(x++, new AffectedTile(PosX, PosY + i, i));

                        for (int j = 1; j < Length; j++)
                        {
                            PointList.Add(x++, new AffectedTile(PosX + j, PosY + i, (i < j) ? j : i));
                        }
                    }
                }
            }

            return PointList;
        }

        internal void ShoutChat()
        {
            this.Talk("shout");
        }

        internal int CountSplit(string[] Split)
        {
            int num = -1;
            foreach (string String in Split)
            {
                num++;
            }
            return num;
        }

        internal string CleanStrings(string String1)
        {
            string[] Message = String1.Split(' ');
            int x = this.CountSplit(Message);
            string sFinal = Message[x];
            string suFinal = sFinal;
            int num = 0;
            if (HabboEncode.decodeVL64(sFinal.Substring(sFinal.Length - 2)) > 3)
                num = 2;
            else if ((HabboEncode.decodeVL64(sFinal.Substring(sFinal.Length - 1)) > 0))
                num = 1;
            else if (sFinal.Substring(sFinal.Length - 1) == "H")
                num = 1;
            suFinal = sFinal.Substring(0, sFinal.Length - num);
            return String1.Replace(sFinal, suFinal);
        }

        internal void Chat()
        {
            try
            {
                // x = state
                // @t@Ltextx
                this.Talk("say");
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }

        internal void SaveRoomData()
        {
            try
            {
                // FQI@LItachi rules@PDescription HereI@@RBSAI@Clol@@@@HH
                // FQPC@FNombre@DDescH@@SCSAH@@@@HH
                int RoomId = User.ActualClientMessage.GetNextInt();
                string Title = User.ActualClientMessage.GetNextString();
                string Description = User.ActualClientMessage.GetNextString();
                int RoomType = User.ActualClientMessage.GetNextInt();
                string Password = User.ActualClientMessage.GetNextString();
                int MaxUsers = User.ActualClientMessage.GetNextInt();
                int Category = User.ActualClientMessage.GetNextInt();
                int CountTags = User.ActualClientMessage.GetNextInt();
                List<string> Tags = new List<string>();
                if (CountTags > 0)
                {
                    if (CountTags == 1)
                    {
                        Tags.Add(User.ActualClientMessage.GetNextString());
                    }
                    else if (CountTags == 2)
                    {
                        Tags.Add(User.ActualClientMessage.GetNextString());
                        Tags.Add(User.ActualClientMessage.GetNextString());
                    }
                }
                bool AllowPets = false;
                if (User.ActualClientMessage.oData.StartsWith("A"))
                    AllowPets = true;
                User.ActualClientMessage.oData = User.ActualClientMessage.oData.Substring(0, 1);
                bool AllowPetsEat = false;
                if (User.ActualClientMessage.oData.StartsWith("A"))
                    AllowPetsEat = true;
                User.ActualClientMessage.oData = User.ActualClientMessage.oData.Substring(0, 1);
                bool WalkOnHabbo = false;
                if (User.ActualClientMessage.oData.StartsWith("A"))
                    WalkOnHabbo = true;
                User.ActualClientMessage.oData = User.ActualClientMessage.oData.Substring(0, 1);
                bool HideWalls = false;
                if (User.ActualClientMessage.oData.StartsWith("A"))
                    HideWalls = true;
                User.ActualClientMessage.oData = User.ActualClientMessage.oData.Substring(0, 1);

                int TypeOne = User.ActualClientMessage.GetNextInt();
                int TypeTwo = User.ActualClientMessage.GetNextInt();

                string zTags = "";
                if (Tags.Count > 0)
                {
                    foreach (string T in Tags)
                    {
                        zTags += T + ";";
                    }
                    zTags = zTags.Substring(0, (zTags.Length - 1));
                }

                Updater.SQLStoExecute.Add("UPDATE rooms SET name = '" + Title + "', description = '" + Description + "', state = '" + RoomType + "', maxusers = " + MaxUsers + ", category = " + Category + ", tags = '" + zTags + "', pets = '" + BlizzardSystem.ConvertBoolToEnum(AllowPets) + "', petseat = '" + BlizzardSystem.ConvertBoolToEnum(AllowPetsEat) + "', hidewalls = '" + BlizzardSystem.ConvertBoolToEnum(HideWalls) + "', walkonusers = '" + BlizzardSystem.ConvertBoolToEnum(WalkOnHabbo) + "' WHERE id = " + RoomId);
                RoomsData Data = RoomsData.Rooms[RoomId];
                Data.Name = Title;
                Data.Description = Description;
                Data.State = RoomType;
                Data.MaxUsers = MaxUsers;
                Data.Category = Category;
                Data.TagList = Tags;
                Data.Tags = zTags;
                Data.Pets = AllowPets;
                Data.PetsEat = AllowPetsEat;
                Data.HideWalls = HideWalls;
                Data.WalkOnOtherUsers = WalkOnHabbo;

                ServerMessage Update1 = new ServerMessage("GS");
                Update1.AddInt(RoomId);
                User.SendMessage(Update1);

                ServerMessage Update2 = new ServerMessage("GH");
                Update2.AddInt(RoomId);
                User.SendMessage(Update2);

                ServerMessage HideW = new ServerMessage("GX");
                HideW.AddBoolean(HideWalls);
                SendMessage(HideW);

                ServerMessage Message = new ServerMessage("GF");
                Message.AddBoolean(false);
                Message.AddInt(Data.Id);
                Message.AddBoolean(false); // Events
                Message.AddStringWithBreak(Data.Name);
                Message.AddStringWithBreak(Data.OwnerName);
                Message.AddInt(Data.State); // State (0 = Open, 1 = Locked, 2 = Password)
                Message.AddInt(Data.CurrentUsersInRoom);
                Message.AddInt(Data.MaxUsers);
                Message.AddStringWithBreak(Data.Description);
                Message.AddInt(0);
                Message.AddBoolean((Data.Category == 3));
                Message.AddInt(Data.Score);
                Message.AddInt(Data.Category);
                Message.AddStringWithBreak("");
                Message.AddInt(Data.TagList.Count); // Tag Count
                foreach (string Tag in Data.TagList)
                {
                    Message.AddStringWithBreak(Tag);
                }
                // Icon
                Message.AddInt(Data.IconBackground);
                Message.AddInt(Data.IconForeground);
                Message.AddInt(Data.Icons.Count); // Icon items
                // Serialize Icons
                if (Data.Icons.Count > 0)
                {
                    foreach (KeyValuePair<int, int> Icon in Data.Icons)
                    {
                        Message.AddInt(Icon.Key);
                        Message.AddInt(Icon.Value);
                    }
                }

                // bools extra
                Message.AddBoolean(false);
                Message.AddBoolean(true);
                User.SendMessage(Message);

                //BlizzardSystem.WriteLine("RoomData: RoomID: " + RoomId + ", Title = " + Title + ", Description = " + Description + ", Type = " + RoomType + ", Password = " + Password + ", MaxUsers = " + MaxUsers + ", Category = " + Category + ", Countags = " + CountTags);
            }
            catch { }

        }

        internal void DeleteRoom()
        {
            int RoomId = User.ActualClientMessage.GetNextInt();
            RoomsData D = RoomsData.Rooms[RoomId];
            #region Remove Static Classes
            foreach (Habbo Habbo in D.UserList)
            {
                Habbo.RemoveUserFromRoom(true, true, false);
            }
            D.UserList = new List<Habbo>();
            foreach (RoomItem Item in RoomItem.Items)
            {
                if (Item.RoomId == RoomId)
                {
                    RoomItem.Items.Remove(Item);
                    RoomItem.RegisteredItems.Remove(Item.Id);
                }
            }
            D.WallItems = new List<RoomItem>();
            D.FloorItems = new List<RoomItem>();
            foreach (RoomRights R in RoomRights.Rights)
            {
                if (R.RoomId == RoomId)
                    RoomRights.Rights.Remove(R);
            }
            (new Navigator(User)).DeleteFromFavourites(RoomId);
            if (User.HomeRoom == RoomId)
            {
                Updater.SQLStoExecute.Add("UPDATE users SET roomhome = '0' WHERE id = " + User.Id);
                User.HomeRoom = 0;
            }
            RoomsData.Rooms.Remove(D.Id);
            RoomsData.AllRoom.Remove(D);
            #endregion
            Updater.SQLStoExecute.Add("DELETE FROM rooms WHERE id = " + RoomId);
            Updater.SQLStoExecute.Add("DELETE FROM rooms_rights WHERE roomid = " + RoomId);
            Updater.SQLStoExecute.Add("DELETE FROM rooms_icons WHERE roomid = " + RoomId);
            Updater.SQLStoExecute.Add("DELETE FROM rooms_items WHERE room_id = " + RoomId);
        }

        internal void KickUser()
        {
            // 319 = ignore
            int UserId = User.ActualClientMessage.GetNextInt();
            if(UserId == User.Id)
                return;
            foreach (Habbo zUser in RoomsData.Rooms[User.CurrentRoomId].UserList)
            {
                if (zUser.Id == UserId)
                {
                    zUser.IsKicking = true;
                    zUser.GoalX = GetRoom().GetRoomModel().DoorX;
                    zUser.GoalY = GetRoom().GetRoomModel().DoorY;
                    zUser.RequestToWalk = true;
                    if (StaticGame.WalkingSystem.ContainsKey(zUser.Id))
                    {
                        Thread Movet = StaticGame.WalkingSystem[zUser.Id];
                        StaticGame.WalkingSystem.Remove(zUser.Id);
                        Movet.Abort();
                    }
                    Thread MoveT = new Thread(new ThreadStart(MoveTo));
                    MoveT.Start();
                    StaticGame.WalkingSystem.Add(zUser.Id, MoveT);
                }
            }
        }

        internal void GetRoomData()
        {
            int RoomId = HabboEncode.decodeVL64(User.ActualPacket.Substring(2));

            RoomsData D = RoomsData.Rooms[RoomId];
            ServerMessage RoomData = new ServerMessage("GQ");
            RoomData.AddInt(RoomId);
            RoomData.AddStringWithBreak(D.Name);
            RoomData.AddStringWithBreak(D.Description);
            RoomData.AddInt(D.State);
            RoomData.AddInt(D.Category);
            RoomData.AddInt(D.MaxUsers);
            RoomData.AddInt((D.GetRoomModel().MapSizeX >= 20 || D.GetRoomModel().MapSizeY >= 20) ? 50 : 25);
            RoomData.AddInt(D.TagList.Count);
            foreach (string Tag in D.TagList)
            {
                RoomData.AddStringWithBreak(Tag);
            }
            List<RoomRights> Rights = RoomRights.GetRightsForRoom(RoomId);
            RoomData.AddInt(Rights.Count);
            foreach (RoomRights r in Rights)
            {
                RoomData.AddInt(r.UserId);
                RoomData.AddStringWithBreak(UsersData.UsersRegister[r.UserId].UserName);
            }
            RoomData.AddInt(Rights.Count);
            RoomData.AddBoolean(D.Pets);
            RoomData.AddBoolean(D.PetsEat);
            RoomData.AddBoolean(D.WalkOnOtherUsers);
            RoomData.AddBoolean(D.HideWalls);
            User.SendMessage(RoomData);
        }

        internal void Talk(string state)
        {
            // @t@I(texto)I
            // @w@I(texto)
            string Message = User.ActualClientMessage.GetNextString();
            string State = state;

            foreach (RoomItem Item in RoomsData.Rooms[User.CurrentRoomId].FloorItems)
            {
                if (Item.GetBaseItem().Name == "wf_trg_says_something")
                {
                    if (Item.WiredString.Contains(Message))
                    {
                        User.WhispToMe(Message);
                        foreach(RoomItem zItem in this.GetItemsForXY(Item.X, Item.Y))
                        {
                            WiredEffects Eff = new WiredEffects(zItem, User);
                            Eff.DoWiredEffects();
                        }
                        return;
                    }
                }
            }

            // Filter [bobba filter no :(]
            foreach (WordFilter Filter in WordFilter.Filter)
            {
                Message = Message.Replace(Filter.Word, "*****"); // Replace
            }

            // Flood System
            if (!Message.StartsWith(":") && User.Rank > 4)
            {
                TimeSpan LastMessageTime = DateTime.Now - FloodTime;
                if (LastMessageTime.Seconds > 4)
                {
                    FloodCount = 0;
                }
                if (LastMessageTime.Seconds < 4 && FloodCount > 5)
                {
                    // Flood Block
                    ServerMessage FloodBlock = new ServerMessage("@[");
                    FloodBlock.AddInt(30); // Seconds of block
                    User.SendMessage(FloodBlock);
                    return;
                }
                FloodTime = DateTime.Now;
                FloodCount++;
            }

            TimeSpan ActualTime = (TimeSpan)(DateTime.Now - DateTime.Today);
            //Updater.SQLStoExecute.Add("INSERT INTO rooms_chatlogs (id, userid, roomid, username, hour, minute, message, tito) VALUES (NULL, '" + User.Id + "', '" + User.CurrentRoomId + "', '" + User.UserName + "', '" + DateTime.Now.Minute + "', '" + DateTime.Now.Second + "', '" + Message + "', '0');");

            // Commands system?
            Commands Command = new Commands(User, Message);
            bool notsendpacket = false;
            if (Message.StartsWith(":") && Command.ThereIsACommand(Message))
            {
                Command.ProcessCommands();
                notsendpacket = true;
            }

            // Smiles system
            int SmileState = 0;
            if (Message.Contains(":)") || Message.Contains("=)") || Message.Contains(":D") || Message.Contains("=D"))
            {
                SmileState = 1; // Happy face
            }

            if (Message.Contains(":@") || Message.Contains(">:(") || Message.Contains(">:@"))
            {
                SmileState = 2; // Angry face
            }

            if (Message.Contains(":o") || Message.Contains("D:"))
            {
                SmileState = 3; // Surprise face
            }

            if (Message.Contains(":(") || Message.Contains(":'(") || Message.Contains("=(") || Message.Contains("='("))
            {
                SmileState = 4; // Sad face
            }

            string ChatPacket = "@X";
            if (State == "shout")
            {
                ChatPacket = "@Z";
            }

            // Url System
            string Site = "";

            if (Message.Contains("http://") || Message.Contains("www."))
            {
                string[] Split = Message.Split(' ');

                foreach (string Msg in Split)
                {
                    if (Msg.StartsWith("http://") || Msg.StartsWith("www."))
                    {
                        Site = Msg;
                    }
                }
                Message = Message.Replace(Site, "{0}");
            }

            if (!notsendpacket)
            {
                // @XHhola{2}HHH{1}
                // @ZHHola!{2}HHM{1}
                // @XH{0}{2}HI/link_to?url=http%3A%2F%2Fhabbo.es&hash=35d17be8{2}http://habbo.es{2}IH{1}
                // @XH¡Vamonos a {0}{2}HI/link_to?url=http%3A%2F%2Fhabbo.es%21&hash=29b17485{2}http://habbo.es!{2}HI{1}EiHH{1}
                ServerMessage Chat = new ServerMessage(ChatPacket);
                Chat.AddInt(User.VirtualId);
                Chat.AddStringWithBreak(Message);
                if (Site != "")
                {
                    Chat.AddBoolean(false);
                    Chat.AddBoolean(true);
                    Chat.AddStringWithBreak(Site.Replace("http://", ""));
                    Chat.AddStringWithBreak(Site);
                }
                Chat.AddInt(SmileState);
                // I need to code this for all room
                StaticGame.SendPacketToAllRoom(User, Chat);
            }

            /*DataRow PetY = MySQL.ReadDataRow("SELECT * FROM users_pets WHERE room_id = " + User.CurrentRoomId);
            foreach (DataRow PetD in PetY.Table.Rows)
            {
                int BotId = (int)PetD["id"];
                BotHabbo Pet = new BotHabbo(BotId, true);
                PetBot Bot = new PetBot((new Pet(User)), Pet, User);
                Bot.OnUserSay(Message, State);
            }*/
        }

        internal void UpdateWall()
        {
            string Wall = User.ActualPacket.Substring(2);
            int FurniId = HabboEncode.decodeVL64(Wall);
            UserItemsData uItem = UserItemsData.UserItemsbyId[FurniId];
            int fId = uItem.FurniId;
            string ExtraData = uItem.ExtraData;
            RoomsData rData = RoomsData.Rooms[User.CurrentRoomId];
            if (rData.OwnerId == User.Id)
            {
                GeneralInventory Inventory = new GeneralInventory(User);
                ItemsData fData = ItemsData.RegisteredFurnis[fId];
                string type = "floor";
                string type2 = "floor";
                if (fData.Name.Contains("wallpaper"))
                {
                    type = "wall";
                    type2 = "wallpaper";
                    rData.WallPaper = ExtraData;
                }
                else if (fData.Name.Contains("landscape"))
                {
                    type = "landscape";
                    type2 = "landscape";
                    rData.LandScape = ExtraData;
                }
                else
                    rData.FloorPaper = ExtraData;

                Updater.SQLStoExecute.Add("UPDATE rooms SET " + type + " = '" + ExtraData + "' WHERE id = '" + User.CurrentRoomId + "'");
                Inventory.DeleteItem(FurniId);

                ServerMessage UpdateWall = new ServerMessage("@n");
                UpdateWall.AddStringWithBreak(type2);
                UpdateWall.AddStringWithBreak(ExtraData);
                User.SendMessage(UpdateWall);
            }
            else
            {
                User.SendAlert("No tienes derechos para aplicar ese tapizado a la sala.", 1);
            }
        }

        internal void UpdateRoomIcon()
        {
            // FBPAQAQAJPAIQAJ
            RoomsData Room = RoomsData.Rooms[User.CurrentRoomId];

            string[] s = (new AnalyzeMessages()).SepareOnVL64Vars(User.ActualPacket.Substring(2));
            int Background = HabboEncode.decodeVL64(s[1]);
            int TopLayer = HabboEncode.decodeVL64(s[2]);
            Room.IconBackground = Background;
            Room.IconForeground = TopLayer;
            Updater.SQLStoExecute.Add("UPDATE rooms SET icon_bg = " + Background + " WHERE id = " + Room.Id);
            Updater.SQLStoExecute.Add("UPDATE rooms SET icon_fg = " + TopLayer + " WHERE id = " + Room.Id);
            int AmountOfItems = HabboEncode.decodeVL64(s[3]);
            for (int i = 0; i != AmountOfItems;)
            {
                int Pos;
                int Item;
                if (i > 0)
                {
                    Pos = HabboEncode.decodeVL64(s[4 + 1 + i]);
                    Item = HabboEncode.decodeVL64(s[5 + 1 + i]);
                }
                else
                {
                    Pos = HabboEncode.decodeVL64(s[4]);
                    Item = HabboEncode.decodeVL64(s[5]);
                }
                i++;
                if (Pos < 0 || Pos > 10)
                {
                    return;
                }

                if (Item < 1 || Item > 27)
                {
                    return;
                }

                if (Room.Icons.ContainsKey(Pos) && Room.Icons[Pos] != Item)
                {
                    Room.Icons.Remove(Pos);
                    Room.Icons.Add(Pos, Item);
                    Updater.SQLStoExecute.Add("UPDATE rooms_icons SET itemid = " + Item + " WHERE itempos = " + Pos + " AND roomid = " + Room.Id);
                }
                else if (Room.Icons.ContainsKey(Pos) && Room.Icons[Pos] == Item)
                {
                    continue;
                }
                else
                {
                    Room.Icons.Add(Pos, Item);
                    Updater.SQLStoExecute.Add("INSERT INTO rooms_icons (roomid, itempos, itemid) VALUES (" + Room.Id + ", " + Pos + ", " + Item + ")");
                }
            }

            BuildMessage Builder = new BuildMessage();

            ServerMessage Message3 = new ServerMessage("GI");
            Message3.AddInt(Room.Id);
            Message3.AddBoolean(true);
            Builder.AddPacket(Message3);

            ServerMessage Message2 = new ServerMessage("GH");
            Message2.AddInt(Room.Id);
            Builder.AddPacket(Message2);

            RoomsData Data = Room;
            ServerMessage Message = new ServerMessage("GF");
            Message.AddBoolean(false);
            Message.AddInt(Data.Id);
            Message.AddBoolean(false); // Events
            Message.AddStringWithBreak(Data.Name);
            Message.AddStringWithBreak(Data.OwnerName);
            Message.AddInt(Data.State); // State (0 = Open, 1 = Locked, 2 = Password)
            Message.AddInt(Data.CurrentUsersInRoom);
            Message.AddInt(Data.MaxUsers);
            Message.AddStringWithBreak(Data.Description);
            Message.AddBoolean(false);
            Message.AddBoolean((Data.Category == 3));
            Message.AddInt(Data.Score);
            Message.AddInt(Data.Category);
            Message.AddChar(2);
            Message.AddInt(Data.TagList.Count); // Tag Count

            foreach (string Tag in Data.TagList)
            {
                Message.AddStringWithBreak(Tag);
            }

            // Icon
            Message.AddInt(Data.IconBackground);
            Message.AddInt(Data.IconForeground);
            Message.AddInt(Data.Icons.Count); // Icon items

            // Serialize Icons
            if (Data.Icons.Count > 0)
            {
                foreach (KeyValuePair<int, int> Icon in Data.Icons)
                {
                    Message.AddInt(Icon.Key);
                    Message.AddInt(Icon.Value);
                }
            }

            Message.AddBoolean(false);
            Message.AddBoolean(true);
            Builder.AddPacket(Message);
            User.SendBuilder(Builder);
        }

        internal Boolean CanWalk(iPoint Point)
        {
            if (!GetRoom().WalkOnOtherUsers)
            {
                foreach (Habbo zUser in GetRoom().UserList)
                {
                    if (zUser.X == Point.X && zUser.Y == Point.Y)
                    {
                        return false;
                    }
                }
            }

            return true;
        }

        internal void Move()
        {
            if (User.IsFreeze)
                return;
            if (User.IsWalking)
                User.IsWalking = false;
            int GoalX = User.ActualClientMessage.GetNextInt();
            int GoalY = User.ActualClientMessage.GetNextInt();
            User.GoalX = GoalX;
            User.GoalY = GoalY;
            User.RequestToWalk = true;
            if(StaticGame.WalkingSystem.ContainsKey(User.Id))
            {
                Thread Movet = StaticGame.WalkingSystem[User.Id];
                StaticGame.WalkingSystem.Remove(User.Id);
                Movet.Abort();
            }
            Thread MoveT = new Thread(new ThreadStart(MoveTo));
            MoveT.Start();
            StaticGame.WalkingSystem.Add(User.Id, MoveT);
        }

        public bool ValidTile(int X, int Y, int MapSizeX, int MapSizeY)
        {
            if (X < 0 || Y < 0 || X >= MapSizeX || Y >= MapSizeY)
            {
                return false;
            }

            return true;
        }

        internal void MoveTo()
        {
            try
            {
                if (User.RequestToWalk)
                {
                    // Get Path
                    User.IsWalking = true;
                    if (User.IsTeleportOn && !User.IsKicking)
                    {
                        string UserZ = SecondGetHForXY(User.GoalX, User.GoalY).ToString().Replace(',', '.');
                        if (!UserZ.Contains("."))
                            UserZ += ".0";
                        User.SetPos(User.GoalX, User.GoalY, UserZ);
                    }
                    else
                    {
                        Pathfinder Finder = new Pathfinder(this.GetRoom().Id, this.GetRoom().Matrix, this.GetRoom().HeightMap, this.GetRoom().GetRoomModel(), this);
                        List<iPoint> Coords = Finder.GeneratePath((new iPoint(User.X, User.Y)), (new iPoint(User.GoalX, User.GoalY)));

                        if (Coords == null)
                        {
                            User.GoalX = -1;
                            User.GoalY = -1;
                            User.RequestToWalk = false;
                            User.IsWalking = false;
                            if (User.CurrentState == "mv")
                                User.UpdateState();
                            return;
                        }
                        //B

                        if (!Finder.FoundPath && User.IsKicking)
                        {
                            User.IsKicking = false;
                            User.RemoveUserFromRoom(true, true);
                        }

                        if (!Finder.FoundPath)
                        {
                            User.GoalX = -1;
                            User.GoalY = -1;
                            User.RequestToWalk = false;
                            User.IsWalking = false;
                            if (User.CurrentState == "mv")
                                User.UpdateState();
                            return;
                        }
                        //BlizzardSystem.WriteLine(Coords.Count.ToString());
                        for (int i = 0; Coords.Count != i; )
                        {
                            iPoint C = Coords[0];
                            Coords.Remove(C);

                            if (!Finder.FoundPath)
                            {
                                User.GoalX = -1;
                                User.GoalY = -1;
                                User.RequestToWalk = false;
                                User.IsWalking = false;
                                if (User.CurrentState == "mv")
                                    User.UpdateState();
                                break;
                            }

                            if (!User.IsWalking)
                            {
                                User.RequestToWalk = false;
                                break;
                            }

                            if (User.IsFreeze)
                            {
                                User.GoalX = -1;
                                User.GoalY = -1;
                                if (User.CurrentState == "mv")
                                    User.UpdateState();
                                User.IsWalking = false;
                                User.RequestToWalk = false;
                            }

                            if (C.X == -500 && C.Y == -500)
                            {
                                User.GoalX = -1;
                                User.GoalY = -1;
                                if (User.CurrentState == "mv")
                                    User.UpdateState();
                                User.IsWalking = false;
                                User.RequestToWalk = false;
                                break;
                            }

                            int NextX = C.X;
                            int NextY = C.Y;

                            Rotation Rot = new Rotation();
                            int newRot = Rot.Calculate(User.X, User.Y, NextX, NextY);
                            User.RotBody = newRot;
                            User.RotHead = newRot;
                            User.CurrentState = "mv";
                            string UserZ;
                            if (!User.IsMoonWalking)
                            {
                                UserZ = SecondGetHForXY(NextX, NextY).ToString().Replace(',', '.');
                                if (!UserZ.Contains("."))
                                    UserZ += ".0";
                            }
                            else
                            {
                                User.MoonWalk++;
                                UserZ = User.MoonWalk.ToString() + ".0";
                            }
                            User.UpdateMyState("mv", NextX + "," + NextY + "," + UserZ);
                            User.LastX = User.X;
                            User.LastY = User.Y;
                            User.X = NextX; // user x?
                            User.Y = NextY; // user y?
                            User.Z = UserZ; // a item in the route
                            RoomsData R = RoomsData.Rooms[User.CurrentRoomId];
                            if (R.GetRoomModel().DoorX == User.X && R.GetRoomModel().DoorY == User.Y)
                            {
                                bool NotifyKick = User.IsKicking;
                                User.IsKicking = false;
                                User.RemoveUserFromRoom(true, NotifyKick);
                            }
                            List<RoomItem> Is = GetItemsForXY(NextX, NextY);
                            if (Is.Count > 0)
                            {
                                foreach (RoomItem I in Is)
                                {
                                    ItemsData U = I.GetBaseItem();
                                    FurniInteractor Inter = new FurniInteractor(User, U, I, R, this);
                                    Inter.WalkOnFurni();
                                }
                            }
                            else
                            {
                                FurniInteractor Inter = new FurniInteractor(User);
                                Inter.WalkWithoutFurni(this);
                            }
                            Thread.Sleep(550);

                            if (C.X == User.GoalX && C.Y == User.GoalY)
                            {
                                User.GoalX = -1;
                                User.GoalY = -1;
                                if (User.CurrentState == "mv")
                                    User.UpdateState();
                                User.IsWalking = false;
                                User.RequestToWalk = false;
                                break;
                            }
                        }
                    }
                }
                //return;
            }
            catch (Exception e) { BlizzardSystem.WriteLine(e.ToString()); }
        }

    }

    public class AffectedTile
    {
        int mX;
        int mY;
        int mI;

        public AffectedTile(int x, int y, int i)
        {
            mX = x;
            mY = y;
            mI = i;
        }

        public int X
        {
            get
            {
                return mX;
            }
        }

        public int Y
        {
            get
            {
                return mY;
            }
        }

        public int I
        {
            get
            {
                return mI;
            }
        }
    }
}