namespace Holo.Virtual.Rooms
{
    using Holo;
    using Holo.Managers;
    using Holo.Virtual.Rooms.Bots;
    using Holo.Virtual.Rooms.Games;
    using Holo.Virtual.Rooms.Items;
    using Holo.Virtual.Rooms.Pathfinding;
    using Holo.Virtual.Users;
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Runtime.CompilerServices;
    using System.Text;
    using System.Threading;

    public class virtualRoom
    {
        private HashSet<int> _activeGroups;
        private Hashtable _Bots;
        private string _Heightmap;
        private string _publicroomItems;
        private Thread _statusHandler;
        private StringBuilder _statusUpdates;
        private Hashtable _Users;
        private int doorH;
        internal int doorX;
        internal int doorY;
        private byte doorZ;
        internal FloorItemManager floorItemManager;
        internal bool hasSwimmingPool;
        internal bool isPublicroom;
        internal gameLobby Lobby;
        internal int roomID;
        private Thread specialCastHandler;
        private byte[,] sqFLOORHEIGHT;
        private double[,] sqITEMHEIGHT;
        private byte[,] sqITEMROT;
        private furnitureStack[,] sqSTACK;
        private squareState[,] sqSTATE;
        private squareTrigger[,] sqTRIGGER;
        private bool[,] sqUNIT;
        internal WallItemManager wallItemManager;

        public virtualRoom(int roomID, bool isPublicroom)
        {
            int num5;
            this.roomID = roomID;
            this.isPublicroom = isPublicroom;
            string parameter = DB.runRead("SELECT model FROM rooms WHERE id = '" + roomID + "'");
            this.doorX = DB.runRead("SELECT door_x FROM room_modeldata WHERE model = '" + parameter + "'", null);
            this.doorY = DB.runRead("SELECT door_y FROM room_modeldata WHERE model = '" + parameter + "'", null);
            this.doorH = DB.runRead("SELECT door_h FROM room_modeldata WHERE model = '" + parameter + "'", null);
            this.doorZ = byte.Parse(DB.runRead("SELECT door_z FROM room_modeldata WHERE model = '" + parameter + "'"));
            this._Heightmap = DB.runRead("SELECT heightmap FROM room_modeldata WHERE model = '" + parameter + "'");
            string[] strArray = this._Heightmap.Split(new char[] { Convert.ToChar(13) });
            int length = strArray[0].Length;
            int num2 = strArray.Length - 1;
            this.sqSTATE = new squareState[length, num2];
            this.sqFLOORHEIGHT = new byte[length, num2];
            this.sqITEMROT = new byte[length, num2];
            this.sqITEMHEIGHT = new double[length, num2];
            this.sqUNIT = new bool[length, num2];
            this.sqSTACK = new furnitureStack[length, num2];
            this.sqTRIGGER = new squareTrigger[length, num2];
            for (int i = 0; i < num2; i++)
            {
                for (int j = 0; j < length; j++)
                {
                    string s = strArray[i].Substring(j, 1).Trim().ToLower();
                    if (s == "x")
                    {
                        this.sqSTATE[j, i] = squareState.Blocked;
                    }
                    else
                    {
                        this.sqSTATE[j, i] = squareState.Open;
                        try
                        {
                            this.sqFLOORHEIGHT[j, i] = byte.Parse(s);
                        }
                        catch
                        {
                        }
                    }
                }
            }
            if (isPublicroom)
            {
                string[] strArray2 = DB.runRead("SELECT publicroom_items FROM room_modeldata WHERE model = '" + parameter + "'").Split("\n".ToCharArray());
                for (num5 = 0; num5 < strArray2.Length; num5++)
                {
                    string[] strArray3 = strArray2[num5].Split(new char[] { ' ' });
                    int num6 = int.Parse(strArray3[2]);
                    int num7 = int.Parse(strArray3[3]);
                    squareState state = (squareState) int.Parse(strArray3[6]);
                    this.sqSTATE[num6, num7] = state;
                    if (state == squareState.Seat)
                    {
                        this.sqITEMROT[num6, num7] = byte.Parse(strArray3[5]);
                        this.sqITEMHEIGHT[num6, num7] = 1.0;
                    }
                    object obj2 = this._publicroomItems;
                    this._publicroomItems = string.Concat(new object[] { obj2, strArray3[0], " ", strArray3[1], " ", strArray3[2], " ", strArray3[3], " ", strArray3[4], " ", strArray3[5], Convert.ToChar(13) });
                }
                int[] numArray = DB.runReadColumn("SELECT id FROM room_modeldata_triggers WHERE model = '" + parameter + "'", 0, null);
                if (numArray.Length > 0)
                {
                    for (num5 = 0; num5 < numArray.Length; num5++)
                    {
                        string str3 = DB.runRead("SELECT object FROM room_modeldata_triggers WHERE id = '" + numArray[num5] + "'");
                        int[] numArray2 = DB.runReadRow("SELECT x,y,goalx,goaly,stepx,stepy,roomid,state FROM room_modeldata_triggers WHERE id = '" + numArray[num5] + "'", null);
                        this.sqTRIGGER[numArray2[0], numArray2[1]] = new squareTrigger(str3, numArray2[2], numArray2[3], numArray2[4], numArray2[5], numArray2[7] == 1, numArray2[6]);
                    }
                }
                if (DB.checkExists("SELECT specialcast_interval FROM room_modeldata WHERE model = '" + parameter + "' AND specialcast_interval > 0"))
                {
                    this.specialCastHandler = new Thread(new ParameterizedThreadStart(this.handleSpecialCasts));
                    this.specialCastHandler.Priority = ThreadPriority.Lowest;
                    this.specialCastHandler.Start(parameter);
                }
                this.hasSwimmingPool = DB.checkExists("SELECT swimmingpool FROM room_modeldata WHERE model = '" + parameter + "' AND swimmingpool = '1'");
                if (DB.checkExists("SELECT id FROM games_lobbies WHERE id = '" + roomID + "'"))
                {
                    string[] strArray4 = DB.runReadRow("SELECT type,rank FROM games_lobbies WHERE id = '" + roomID + "'");
                    this.Lobby = new gameLobby(this, strArray4[0] == "bb", strArray4[1]);
                }
            }
            else
            {
                int[] numArray3 = DB.runReadColumn("SELECT id FROM furniture WHERE roomid = '" + roomID + "' ORDER BY h ASC", 0, null);
                this.floorItemManager = new FloorItemManager(this);
                this.wallItemManager = new WallItemManager(this);
                if (numArray3.Length > 0)
                {
                    int[] numArray4 = DB.runReadColumn("SELECT tid FROM furniture WHERE roomid = '" + roomID + "' ORDER BY h ASC", 0, null);
                    int[] numArray5 = DB.runReadColumn("SELECT x FROM furniture WHERE roomid = '" + roomID + "' ORDER BY h ASC", 0, null);
                    int[] numArray6 = DB.runReadColumn("SELECT y FROM furniture WHERE roomid = '" + roomID + "' ORDER BY h ASC", 0, null);
                    int[] numArray7 = DB.runReadColumn("SELECT z FROM furniture WHERE roomid = '" + roomID + "' ORDER BY h ASC", 0, null);
                    string[] strArray5 = DB.runReadColumn("SELECT h FROM furniture WHERE roomid = '" + roomID + "' ORDER BY h ASC", 0);
                    string[] strArray6 = DB.runReadColumn("SELECT var FROM furniture WHERE roomid = '" + roomID + "' ORDER BY h ASC", 0);
                    string[] strArray7 = DB.runReadColumn("SELECT wallpos FROM furniture WHERE roomid = '" + roomID + "' ORDER BY h ASC", 0);
                    for (num5 = 0; num5 < numArray3.Length; num5++)
                    {
                        if (strArray7[num5] == "")
                        {
                            this.floorItemManager.addItem(numArray3[num5], numArray4[num5], numArray5[num5], numArray6[num5], numArray7[num5], double.Parse(strArray5[num5]), strArray6[num5]);
                        }
                        else
                        {
                            this.wallItemManager.addItem(numArray3[num5], numArray4[num5], strArray7[num5], strArray6[num5], false);
                        }
                    }
                }
            }
            this._Users = new Hashtable();
            this._Bots = new Hashtable();
            this.loadBots();
            this._activeGroups = new HashSet<int>();
            this._statusUpdates = new StringBuilder();
            this._statusHandler = new Thread(new ThreadStart(this.cycleStatuses));
            this._statusHandler.Start();
            this.sqSTATE[this.doorX, this.doorY] = squareState.Open;
        }

        internal void addUser(virtualUser User)
        {
            if ((User._teleporterID != 0) || (User._ROOMACCESS_PRIMARY_OK && User._ROOMACCESS_SECONDARY_OK))
            {
                User.statusManager = new virtualRoomUserStatusManager(User.userID, this.roomID);
                User.roomUser = new virtualRoomUser(User.userID, this.roomID, this.getFreeRoomIdentifier(), User, User.statusManager);
                if (User._teleporterID == 0)
                {
                    User.roomUser.X = this.doorX;
                    User.roomUser.Y = this.doorY;
                    User.roomUser.Z1 = this.doorZ;
                    User.roomUser.Z2 = this.doorZ;
                    User.roomUser.H = this.doorH;
                }
                else
                {
                    floorItem item = this.floorItemManager.getItem(User._teleporterID);
                    User.roomUser.X = item.X;
                    User.roomUser.Y = item.Y;
                    User.roomUser.H = item.H;
                    User.roomUser.Z1 = item.Z;
                    User.roomUser.Z2 = item.Z;
                    User._teleporterID = 0;
                    this.sendData(string.Concat(new object[] { @"A\", item.ID, "/", User._Username, "/", item.Sprite }));
                }
                User.roomUser.goalX = -1;
                this._Users.Add(User.roomUser.roomUID, User.roomUser);
                if (!this.isPublicroom)
                {
                    if (User._hasRights && !User._isOwner)
                    {
                        User.statusManager.addStatus("flatctrl", "onlyfurniture");
                    }
                    if (User._isOwner)
                    {
                        User.statusManager.addStatus("flatctrl", "useradmin");
                    }
                    User.roomUser.hasVoted = DB.checkExists(string.Concat(new object[] { "SELECT userid FROM room_votes WHERE userid = '", User.userID, "' AND roomid = '", this.roomID, "'" }));
                }
                else if (this.hasSwimmingPool)
                {
                    User.roomUser.SwimOutfit = DB.runRead("SELECT figure_swim FROM users WHERE id = '" + User.userID + "'");
                }
                if (this.Lobby != null)
                {
                    User.roomUser.gamePoints = DB.runReadUnsafe(string.Concat(new object[] { "SELECT ", this.Lobby.Type, "_totalpoints FROM users WHERE id = '", User.userID, "'" }), null);
                    this.sendData(string.Concat(new object[] { "CzI", Holo.Encoding.encodeVL64(User.roomUser.roomUID), User.roomUser.gamePoints, Convert.ToChar(2), rankManager.getGameRankTitle(this.Lobby.isBattleBall, User.roomUser.gamePoints), Convert.ToChar(2) }));
                }
                this.sendData(@"@\" + User.roomUser.detailsString);
                if (!((User._groupID <= 0) || this._activeGroups.Contains(User._groupID)))
                {
                    string str = DB.runRead("SELECT badge FROM groups_details WHERE id = '" + User._groupID + "'");
                    this.sendData(string.Concat(new object[] { "DuI", Holo.Encoding.encodeVL64(User._groupID), str, Convert.ToChar(2) }));
                    this._activeGroups.Add(User._groupID);
                }
                roomManager.updateRoomVisitorCount(this.roomID, this._Users.Count);
            }
        }

        internal void checkEmotion(virtualRoomUser sourceUser, string Message)
        {
            string[] strArray = new string[] { "sml", "agr", "sad", "srp" };
            string[] strArray2 = new string[] { ":)", ":D" };
            string[] strArray3 = new string[] { ">:(", ":@", ":/" };
            string[] strArray4 = new string[] { ":(", ":'(" };
            string[] strArray5 = new string[] { ":o", ":O", ":0" };
            string[][] strArray6 = new string[][] { strArray2, strArray3, strArray4, strArray5 };
            for (int i = 0; i < strArray6.Length; i++)
            {
                string[] separator = strArray6[i];
                if (Message.Split(separator, StringSplitOptions.None).Length > 1)
                {
                    string str = strArray[i];
                    sourceUser.statusManager.handleStatus("gest", str, 0x1388);
                    break;
                }
            }
        }

        internal bool containsUser(int roomUID)
        {
            return this._Users.ContainsKey(roomUID);
        }

        private void cycleStatuses()
        {
            try
            {
                squareState[,] stateArray;
                int[] numArray;
                squareTrigger trigger;
                int num;
                int num2;
                squareState state;
                double num3;
                bool flag;
                goto Label_0A76;
            Label_0007:
            Label_0671:
                foreach (virtualRoomUser user in ((Hashtable) this._Users.Clone()).Values)
                {
                    if (user.goalX == -1)
                    {
                        goto Label_0671;
                    }
                    stateArray = (squareState[,]) this.sqSTATE.Clone();
                    try
                    {
                        if ((stateArray[user.goalX, user.goalY] == squareState.Seat) || (stateArray[user.goalX, user.goalY] == squareState.Bed))
                        {
                            stateArray[user.goalX, user.goalY] = squareState.Open;
                        }
                        if (this.sqUNIT[user.goalX, user.goalY])
                        {
                            stateArray[user.goalX, user.goalY] = squareState.Blocked;
                        }
                    }
                    catch
                    {
                    }
                    numArray = new Pathfinder(stateArray, this.sqFLOORHEIGHT, this.sqUNIT).getNext(user.X, user.Y, user.goalX, user.goalY);
                    user.statusManager.removeStatus("mv");
                    if (numArray == null)
                    {
                        user.goalX = -1;
                        if (this.sqTRIGGER[user.X, user.Y] != null)
                        {
                            trigger = this.sqTRIGGER[user.X, user.Y];
                            if (this.hasSwimmingPool)
                            {
                                if ((trigger.Object == "curtains1") || (trigger.Object == "curtains2"))
                                {
                                    user.walkLock = true;
                                    user.User.sendData("A`");
                                    this.sendSpecialCast(trigger.Object, "close");
                                }
                                else if (user.SwimOutfit != "")
                                {
                                    if ((trigger.Object == "door") && (user.User._Tickets != 0x8235))
                                    {
                                        user.walkLock = true;
                                        user.goalX = -1;
                                        user.goalY = 0;
                                        this.moveUser(user, trigger.stepX, trigger.stepY, true);
                                        this.sendSpecialCast("door", "close");
                                        this.sendData("A}");
                                        user.User._Tickets--;
                                        user.User.sendData("A|" + user.User._Tickets);
                                        DB.runQuery("UPDATE users SET tickets = tickets - 1 WHERE id = '" + user.userID + "' LIMIT 1");
                                    }
                                    else if (trigger.Object.Substring(0, 6) == "Splash")
                                    {
                                        this.sendData("AG" + trigger.Object);
                                        if (trigger.Object.Substring(8) == "enter")
                                        {
                                            user.statusManager.dropCarrydItem();
                                            user.statusManager.addStatus("swim", "");
                                        }
                                        else
                                        {
                                            user.statusManager.removeStatus("swim");
                                        }
                                        this.moveUser(user, trigger.stepX, trigger.stepY, false);
                                        user.goalX = trigger.goalX;
                                        user.goalY = trigger.goalY;
                                    }
                                }
                            }
                        }
                        else if (user.walkDoor)
                        {
                            if (this._Users.Count > 1)
                            {
                                this.removeUser(user.roomUID, true, "");
                                goto Label_0671;
                            }
                            this.removeUser(user.roomUID, true, "");
                            return;
                        }
                        this._statusUpdates.Append(user.statusString + Convert.ToChar(13));
                    }
                    else
                    {
                        num = numArray[0];
                        num2 = numArray[1];
                        state = this.sqSTATE[num, num2];
                        this.sqUNIT[user.X, user.Y] = false;
                        this.sqUNIT[num, num2] = true;
                        user.Z1 = Rotation.Calculate(user.X, user.Y, num, num2);
                        user.Z2 = user.Z1;
                        user.statusManager.removeStatus("sit");
                        user.statusManager.removeStatus("lay");
                        num3 = 0.0;
                        if (state == squareState.Rug)
                        {
                            num3 = this.sqITEMHEIGHT[num, num2];
                        }
                        else
                        {
                            num3 = this.sqFLOORHEIGHT[num, num2];
                        }
                        user.statusManager.addStatus("mv", string.Concat(new object[] { num, ",", num2, ",", num3.ToString().Replace(',', '.') }));
                        this._statusUpdates.Append(user.statusString + Convert.ToChar(13));
                        user.X = num;
                        user.Y = num2;
                        user.H = num3;
                        switch (state)
                        {
                            case squareState.Seat:
                                user.statusManager.removeStatus("dance");
                                user.Z1 = this.sqITEMROT[num, num2];
                                user.Z2 = user.Z1;
                                user.statusManager.addStatus("sit", this.sqITEMHEIGHT[num, num2].ToString().Replace(',', '.'));
                                break;

                            case squareState.Bed:
                                user.statusManager.removeStatus("dance");
                                user.Z1 = this.sqITEMROT[num, num2];
                                user.Z2 = user.Z1;
                                user.statusManager.addStatus("lay", this.sqITEMHEIGHT[num, num2].ToString().Replace(',', '.'));
                                break;
                        }
                    }
                }
                foreach (virtualBot bot in this._Bots.Values)
                {
                    if (bot.goalX == -1)
                    {
                        continue;
                    }
                    stateArray = (squareState[,]) this.sqSTATE.Clone();
                    try
                    {
                        if (stateArray[bot.goalX, bot.goalY] == squareState.Seat)
                        {
                            stateArray[bot.goalX, bot.goalY] = squareState.Open;
                        }
                        if (this.sqUNIT[bot.goalX, bot.goalY])
                        {
                            stateArray[bot.goalX, bot.goalY] = squareState.Blocked;
                        }
                    }
                    catch
                    {
                    }
                    numArray = new Pathfinder(stateArray, this.sqFLOORHEIGHT, this.sqUNIT).getNext(bot.X, bot.Y, bot.goalX, bot.goalY);
                    bot.removeStatus("mv");
                    if (numArray == null)
                    {
                        if ((bot.X == bot.goalX) && (bot.Y == bot.goalY))
                        {
                            bot.checkOrders();
                        }
                        bot.goalX = -1;
                        this._statusUpdates.Append(bot.statusString + Convert.ToChar(13));
                    }
                    else
                    {
                        num = numArray[0];
                        num2 = numArray[1];
                        this.sqUNIT[bot.X, bot.Y] = false;
                        this.sqUNIT[num, num2] = true;
                        bot.Z1 = Rotation.Calculate(bot.X, bot.Y, num, num2);
                        bot.Z2 = bot.Z1;
                        bot.removeStatus("sit");
                        num3 = this.sqFLOORHEIGHT[num, num2];
                        if (this.sqSTATE[num, num2] == squareState.Rug)
                        {
                            num3 = this.sqITEMHEIGHT[num, num2];
                        }
                        else
                        {
                            num3 = this.sqFLOORHEIGHT[num, num2];
                        }
                        bot.addStatus("mv", string.Concat(new object[] { num, ",", num2, ",", num3.ToString().Replace(',', '.') }));
                        this._statusUpdates.Append(bot.statusString + Convert.ToChar(13));
                        bot.X = num;
                        bot.Y = num2;
                        bot.H = num3;
                        if (this.sqSTATE[num, num2] == squareState.Seat)
                        {
                            bot.removeStatus("dance");
                            bot.Z1 = this.sqITEMROT[num, num2];
                            bot.Z2 = bot.Z1;
                            bot.addStatus("sit", this.sqITEMHEIGHT[num, num2].ToString().Replace(',', '.'));
                        }
                    }
                }
                if (this._statusUpdates.Length > 0)
                {
                    this.sendData("@b" + this._statusUpdates.ToString());
                    this._statusUpdates = new StringBuilder();
                }
                Thread.Sleep(410);
                Out.WriteTrace("Status update loop");
            Label_0A76:
                flag = true;
                goto Label_0007;
            }
            catch (Exception exception)
            {
                Out.WriteError(exception.Message);
            }
        }

        ~virtualRoom()
        {
        }

        private int getFreeRoomIdentifier()
        {
            int key = 0;
            while (true)
            {
                if (!(this._Bots.ContainsKey(key) || this._Users.ContainsKey(key)))
                {
                    return key;
                }
                key++;
                Out.WriteTrace("Get free room identifier");
            }
        }

        internal int[] getMapBorders()
        {
            return new int[] { this.sqUNIT.GetUpperBound(0), this.sqUNIT.GetUpperBound(1) };
        }

        private int getRandomRoomIdentifier()
        {
            if (this._Users.Count <= 0)
            {
                return -1;
            }
            while (true)
            {
                int key = new Random(DateTime.Now.Millisecond).Next(0, this._Users.Count);
                if (this._Bots.ContainsKey(key) || this._Users.ContainsKey(key))
                {
                    return key;
                }
                Out.WriteTrace("Get random room identifier");
            }
        }

        internal virtualRoomUser getRoomUser(int roomUID)
        {
            return (virtualRoomUser) this._Users[roomUID];
        }

        internal squareTrigger getTrigger(int X, int Y)
        {
            try
            {
                return this.sqTRIGGER[X, Y];
            }
            catch
            {
                return null;
            }
        }

        internal virtualUser getUser(int roomUID)
        {
            return ((virtualRoomUser) this._Users[roomUID]).User;
        }

        private void handleSpecialCasts(object o)
        {
            try
            {
                string str3;
                bool flag;
                string emitter = DB.runRead("SELECT specialcast_emitter FROM room_modeldata WHERE model = '" + ((string) o) + "'");
                int[] numArray = DB.runReadRow("SELECT specialcast_interval,specialcast_rnd_min,specialcast_rnd_max FROM room_modeldata WHERE model = '" + ((string) o) + "'", null);
                int millisecondsTimeout = numArray[0];
                int minValue = numArray[1];
                int num3 = numArray[2];
                numArray = null;
                string str2 = "";
                goto Label_016F;
            Label_0054: //
                str3 = ""; //
                int num4 = new Random().Next(minValue, num3 + 1);
            Label_006D:
                switch (emitter)
                {
                    case "cam1":
                        switch (num4)
                        {
                            case 1:
                            {
                                int num5 = this.getRandomRoomIdentifier();
                                if (num5 != -1)
                                {
                                    str3 = "targetcamera " + num5;
                                }
                                goto Label_0120;
                            }
                            case 2:
                                str3 = "setcamera 1";
                                goto Label_0120;

                            case 3:
                                str3 = "setcamera 2";
                                goto Label_0120;
                        }
                        goto Label_0120;

                    case "sf":
                        str3 = num4.ToString();
                        goto Label_0120;

                    case "lamp":
                        str3 = "setlamp " + num4;
                        break;
                }
            Label_0120:
                if (str3 == "")
                {
                    goto Label_006D;
                }
                if (str3 != str2)
                {
                    this.sendSpecialCast(emitter, str3);
                    str2 = str3;
                }
                Thread.Sleep(millisecondsTimeout);
                Out.WriteTrace("Special cast loop");
            Label_016F:
                flag = true;
            }
            catch
            {

            }

        }

        internal void kickUsers(byte casterRank, string Message)
        {
            foreach (virtualRoomUser user in ((Hashtable) this._Users.Clone()).Values)
            {
                if (user.User._Rank < casterRank)
                {
                    this.removeUser(user.roomUID, true, Message);
                }
            }
        }

        internal void loadBots()
        {
            int[] numArray = DB.runReadColumn("SELECT id FROM roombots WHERE roomid = '" + this.roomID + "'", 0, null);
            for (int i = 0; i < numArray.Length; i++)
            {
                virtualBot bot = new virtualBot(numArray[i], this.getFreeRoomIdentifier(), this);
                bot.H = this.sqFLOORHEIGHT[bot.X, bot.Y];
                this.sqUNIT[bot.X, bot.Y] = true;
                this._Bots.Add(bot.roomUID, bot);
                this.sendData(@"@\" + bot.detailsString);
                this.sendData("@b" + bot.statusString);
            }
        }

        internal void moveUser(virtualRoomUser roomUser, int toX, int toY, bool secondRefresh)
        {
            new userMover(this.MOVEUSER).BeginInvoke(roomUser, toX, toY, secondRefresh, null, null);
        }

        private void MOVEUSER(virtualRoomUser roomUser, int toX, int toY, bool secondRefresh)
        {
            try
            {
                this.sqUNIT[roomUser.X, roomUser.Y] = false;
                this.sqUNIT[toX, toY] = true;
                roomUser.Z1 = Rotation.Calculate(roomUser.X, roomUser.Y, toX, toY);
                roomUser.Z2 = roomUser.Z1;
                roomUser.statusManager.removeStatus("sit");
                double num = 0.0;
                if (this.sqSTATE[toX, toY] == squareState.Rug)
                {
                    num = this.sqITEMHEIGHT[toX, toY];
                }
                else
                {
                    num = this.sqFLOORHEIGHT[toX, toY];
                }
                roomUser.statusManager.addStatus("mv", string.Concat(new object[] { toX, ",", toY, ",", num.ToString().Replace(',', '.') }));
                this.sendData("@b" + roomUser.statusString);
                Thread.Sleep(310);
                roomUser.X = toX;
                roomUser.Y = toY;
                roomUser.H = num;
                roomUser.statusManager.removeStatus("mv");
                if (secondRefresh)
                {
                    if (this.sqSTATE[toX, toY] == squareState.Seat)
                    {
                        roomUser.statusManager.removeStatus("dance");
                        roomUser.Z1 = this.sqITEMROT[toX, toY];
                        roomUser.Z2 = roomUser.Z1;
                        roomUser.statusManager.addStatus("sit", this.sqITEMHEIGHT[toX, toY].ToString().Replace(',', '.'));
                        roomUser.statusManager.removeStatus("mv");
                    }
                    this.sendData("@b" + roomUser.statusString);
                }
            }
            catch
            {
            }
        }

        internal void muteUsers(byte casterRank, string Message)
        {
            Message = "BK" + stringManager.getString("scommand_muted") + "\r" + Message;
            foreach (virtualRoomUser user in ((Hashtable) this._Users.Clone()).Values)
            {
                if (!(user.User._isMuted || (user.User._Rank >= casterRank)))
                {
                    user.User._isMuted = true;
                    user.User.sendData(Message);
                }
            }
        }

        internal void Refresh(virtualBot roomBot)
        {
            try
            {
                if (roomBot.goalX == -1)
                {
                    this._statusUpdates.Append(roomBot.statusString + Convert.ToChar(13));
                }
            }
            catch
            {
            }
        }

        internal void Refresh(virtualRoomUser roomUser)
        {
            if (roomUser.goalX == -1)
            {
                this._statusUpdates.Append(roomUser.statusString + Convert.ToChar(13));
            }
        }

        internal void refreshCoord(int X, int Y)
        {
            foreach (virtualRoomUser user in this._Users.Values)
            {
                if ((user.X == X) && (user.Y == Y))
                {
                    if (this.sqSTATE[X, Y] == squareState.Seat)
                    {
                        if (!user.statusManager.containsStatus("sit"))
                        {
                            user.Z1 = this.sqITEMROT[X, Y];
                            user.Z2 = user.Z1;
                            user.statusManager.addStatus("sit", this.sqITEMHEIGHT[X, Y].ToString().Replace(',', '.'));
                            this.Refresh(user);
                        }
                    }
                    else if (this.sqSTATE[X, Y] == squareState.Bed)
                    {
                        if (!user.statusManager.containsStatus("bed"))
                        {
                            user.Z1 = this.sqITEMROT[X, Y];
                            user.Z2 = user.Z1;
                            user.statusManager.addStatus("lay", this.sqITEMHEIGHT[X, Y].ToString().Replace(',', '.'));
                            this.Refresh(user);
                        }
                    }
                    else
                    {
                        user.statusManager.removeStatus("sit");
                        user.statusManager.removeStatus("lay");
                        user.H = this.sqFLOORHEIGHT[X, Y];
                        this.Refresh(user);
                    }
                    break;
                }
            }
        }

        internal void removeUser(int roomUID, bool sendKick, string moderatorMessage)
        {
            if (this._Users.Contains(roomUID))
            {
                virtualRoomUser user = (virtualRoomUser) this._Users[roomUID];
                if (sendKick)
                {
                    user.User.sendData("@R");
                    if (moderatorMessage != "")
                    {
                        user.User.sendData(string.Concat(new object[] { "B!", moderatorMessage, Convert.ToChar(2), "holo.cast.modkick" }));
                    }
                }
                this.sqUNIT[user.X, user.Y] = false;
                user.User.statusManager.Clear();
                user.User.statusManager = null;
                user.User._roomID = 0;
                user.User._inPublicroom = false;
                user.User._ROOMACCESS_PRIMARY_OK = false;
                user.User._ROOMACCESS_SECONDARY_OK = false;
                user.User._isOwner = false;
                user.User._hasRights = false;
                user.User.Room = null;
                user.User.roomUser = null;
                this._Users.Remove(roomUID);
                if (this._Users.Count <= 0)
                {
                    this._Users.Clear();
                    this._Bots.Clear();
                    this._statusUpdates = null;
                    if (!this.isPublicroom)
                    {
                        this.floorItemManager.Clear();
                        this.wallItemManager.Clear();
                    }
                    try
                    {
                        this.specialCastHandler.Abort();
                    }
                    catch
                    {
                    }
                    roomManager.removeRoom(this.roomID);
                    this._statusHandler.Abort();
                }
                else
                {
                    if (user.User._groupID > 0)
                    {
                        bool flag = true;
                        foreach (virtualRoomUser user2 in this._Users.Values)
                        {
                            if ((user2.roomUID != user.roomUID) && (user2.User._groupID == user.User._groupID))
                            {
                                flag = false;
                                break;
                            }
                        }
                        if (flag)
                        {
                            this._activeGroups.Remove(user.User._groupID);
                        }
                    }
                    this.sendData("@]" + roomUID);
                    roomManager.updateRoomVisitorCount(this.roomID, this._Users.Count);
                }
            }
        }

        internal void sendData(string Data)
        {
            try
            {
                foreach (virtualRoomUser user in this._Users.Values)
                {
                    user.User.sendData(Data);
                }
            }
            catch
            {
            }
        }

        internal void sendData(int userID, string Data)
        {
            foreach (virtualRoomUser user in this._Users.Values)
            {
                if (user.userID == userID)
                {
                    user.User.sendData(Data);
                    break;
                }
            }
        }

        internal void sendData(string Data, int msSleep)
        {
            new sendDataSleep(this.SENDDATASLEEP).BeginInvoke(Data, msSleep, null, null);
        }

        internal void sendData(string Username, string Data)
        {
            foreach (virtualRoomUser user in this._Users.Values)
            {
                if (user.User._Username == Username)
                {
                    user.User.sendData(Data);
                    break;
                }
            }
        }

        private void SENDDATASLEEP(string Data, int msSleep)
        {
            Thread.Sleep(msSleep);
            foreach (virtualRoomUser user in this._Users.Values)
            {
                user.User.sendData(Data);
            }
        }

        internal void sendDataToRights(string Data)
        {
            try
            {
                foreach (virtualRoomUser user in this._Users.Values)
                {
                    if (user.User._hasRights || rankManager.containsRight(user.User._Rank, "fuse_pick_up_any_furni"))
                    {
                        user.User.sendData(Data);
                    }
                }
            }
            catch
            {
            }
        }

        internal void sendNewVoteAmount(int voteAmount)
        {
            string data = "EY" + Holo.Encoding.encodeVL64(voteAmount);
            foreach (virtualRoomUser user in this._Users.Values)
            {
                if (user.hasVoted)
                {
                    user.User.sendData(data);
                }
            }
        }

        internal void sendSaying(virtualBot sourceBot, string Message)
        {
            string data = string.Concat(new object[] { "@X", Holo.Encoding.encodeVL64(sourceBot.roomUID), Message, Convert.ToChar(2) });
            foreach (virtualRoomUser user in this._Users.Values)
            {
                if ((Math.Abs((int) (user.X - sourceBot.X)) < 6) && (Math.Abs((int) (user.Y - sourceBot.Y)) < 6))
                {
                    user.User.sendData(data);
                }
            }
        }

        internal void sendSaying(virtualRoomUser sourceUser, string Message)
        {
            this.checkEmotion(sourceUser, Message);
            if (sourceUser.isTyping)
            {
                this.sendData("Ei" + Holo.Encoding.encodeVL64(sourceUser.roomUID) + "H");
                sourceUser.isTyping = false;
            }
            string data = string.Concat(new object[] { "@X", Holo.Encoding.encodeVL64(sourceUser.roomUID), Message, Convert.ToChar(2) });
            foreach (virtualRoomUser user in this._Users.Values)
            {
                if ((Math.Abs((int) (user.X - sourceUser.X)) < 6) && (Math.Abs((int) (user.Y - sourceUser.Y)) < 6))
                {
                    user.User.sendData(data);
                }
            }
            foreach (virtualBot bot in this._Bots.Values)
            {
                if ((Math.Abs((int) (bot.X - sourceUser.X)) < 6) && (Math.Abs((int) (bot.Y - sourceUser.Y)) < 6))
                {
                    bot.Interact(sourceUser, Message);
                }
            }
        }

        internal void sendShout(virtualBot sourceBot, string Message)
        {
            string data = string.Concat(new object[] { "@Z", Holo.Encoding.encodeVL64(sourceBot.roomUID), Message, Convert.ToChar(2) });
            foreach (virtualRoomUser user in ((Hashtable) this._Users.Clone()).Values)
            {
                user.User.sendData(data);
            }
        }

        internal void sendShout(virtualRoomUser sourceUser, string Message)
        {
            this.checkEmotion(sourceUser, Message);
            if (sourceUser.isTyping)
            {
                this.sendData("Ei" + Holo.Encoding.encodeVL64(sourceUser.roomUID) + "H");
                sourceUser.isTyping = false;
            }
            string data = string.Concat(new object[] { "@Z", Holo.Encoding.encodeVL64(sourceUser.roomUID), Message, Convert.ToChar(2) });
            foreach (virtualRoomUser user in this._Users.Values)
            {
                this._statusUpdates.Append(user.statusString + Convert.ToChar(13));
                user.User.sendData(data);
            }
            foreach (virtualBot bot in this._Bots.Values)
            {
                if (((Math.Abs((int) (bot.X - sourceUser.X)) < 6) && (Math.Abs((int) (bot.Y - sourceUser.Y)) < 6)) && (new Random(DateTime.Now.Millisecond).Next(0, 11) == 0))
                {
                    this.sendSaying(bot, bot.noShoutingMessage);
                }
            }
        }

        internal void sendSpecialCast(string Emitter, string Cast)
        {
            this.sendData("AG" + Emitter + " " + Cast);
        }

        internal void sendWhisper(virtualRoomUser sourceUser, string Receiver, string Message)
        {
            if (sourceUser.isTyping)
            {
                this.sendData("Ei" + Holo.Encoding.encodeVL64(sourceUser.roomUID) + "H");
                sourceUser.isTyping = false;
            }
            string data = string.Concat(new object[] { "@Y", Holo.Encoding.encodeVL64(sourceUser.roomUID), Message, Convert.ToChar(2) });
            foreach (virtualRoomUser user in this._Users.Values)
            {
                if (user.User._Username == Receiver)
                {
                    sourceUser.User.sendData(data);
                    user.User.sendData(data);
                    break;
                }
            }
        }

        internal void setSquareState(int X, int Y, int Length, int Width, squareState State)
        {
            for (int i = X; i < (X + Width); i++)
            {
                for (int j = Y; j < (Y + Length); j++)
                {
                    this.sqSTATE[i, j] = State;
                }
            }
        }

        internal bool squareBlocked(int X, int Y, int Length, int Width)
        {
            for (int i = X; i < (X + Width); i++)
            {
                for (int j = Y; j < (X + Length); j++)
                {
                    if (this.sqUNIT[i, j])
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        internal void unmuteUsers(byte casterRank)
        {
            string data = "BK" + stringManager.getString("scommand_unmuted");
            foreach (virtualRoomUser user in ((Hashtable) this._Users.Clone()).Values)
            {
                if (user.User._isMuted && (user.User._Rank < casterRank))
                {
                    user.User._isMuted = false;
                    user.User.sendData(data);
                }
            }
        }

        internal string dynamicStatuses
        {
            get
            {
                StringBuilder builder = new StringBuilder();
                foreach (virtualBot bot in this._Bots.Values)
                {
                    builder.Append(bot.statusString + Convert.ToChar(13));
                }
                foreach (virtualRoomUser user in this._Users.Values)
                {
                    builder.Append(user.statusString + Convert.ToChar(13));
                }
                return builder.ToString();
            }
        }

        internal string dynamicUnits
        {
            get
            {
                StringBuilder builder = new StringBuilder();
                foreach (virtualBot bot in this._Bots.Values)
                {
                    builder.Append(bot.detailsString);
                }
                foreach (virtualRoomUser user in this._Users.Values)
                {
                    builder.Append(user.detailsString);
                }
                return builder.ToString();
            }
        }

        internal string Flooritems
        {
            get
            {
                if (this.isPublicroom)
                {
                    return "H";
                }
                return this.floorItemManager.Items;
            }
        }

        internal string Groups
        {
            get
            {
                StringBuilder builder = new StringBuilder(Holo.Encoding.encodeVL64(this._activeGroups.Count));
                foreach (int num in this._activeGroups)
                {
                    builder.Append(Holo.Encoding.encodeVL64(num) + DB.runRead("SELECT badge FROM groups_details WHERE id = '" + num + "'") + Convert.ToChar(2));
                }
                return builder.ToString();
            }
        }

        internal string Heightmap
        {
            get
            {
                return this._Heightmap;
            }
        }

        internal string PublicroomItems
        {
            get
            {
                return this._publicroomItems;
            }
        }

        internal string Userlist
        {
            get
            {
                StringBuilder builder = new StringBuilder(Holo.Encoding.encodeVL64(this.roomID) + Holo.Encoding.encodeVL64(this._Users.Count));
                foreach (virtualRoomUser user in this._Users.Values)
                {
                    builder.Append(user.User._Username + Convert.ToChar(2));
                }
                return builder.ToString();
            }
        }

        internal ICollection Users
        {
            get
            {
                return this._Users.Values;
            }
        }

        internal string Wallitems
        {
            get
            {
                if (this.isPublicroom)
                {
                    return "";
                }
                return this.wallItemManager.Items;
            }
        }

        internal class FloorItemManager
        {
            private Hashtable _Items = new Hashtable();
            private virtualRoom _Room;
            internal int soundMachineID;

            public FloorItemManager(virtualRoom Room)
            {
                this._Room = Room;
            }

            internal void addItem(int itemID, int templateID, int X, int Y, int Z, double H, string Var)
            {
                catalogueManager.itemTemplate template = catalogueManager.getTemplate(templateID);
                if (stringManager.getStringPart(template.Sprite, 0, 13) == "sound_machine")
                {
                    this.soundMachineID = itemID;
                }
                int length = 0;
                int width = 0;
                if ((Z == 2) || (Z == 6))
                {
                    length = template.Length;
                    width = template.Width;
                }
                else
                {
                    length = template.Width;
                    width = template.Length;
                }
                for (int i = X; i < (X + width); i++)
                {
                    for (int j = Y; j < (Y + length); j++)
                    {
                        virtualRoom.furnitureStack stack = this._Room.sqSTACK[i, j];
                        if (stack == null)
                        {
                            if ((template.typeID != 2) && (template.typeID != 3))
                            {
                                stack = new virtualRoom.furnitureStack();
                                stack.Add(itemID);
                            }
                        }
                        else
                        {
                            stack.Add(itemID);
                        }
                        this._Room.sqSTATE[i, j] = (virtualRoom.squareState) template.typeID;
                        if ((template.typeID == 2) || (template.typeID == 3))
                        {
                            this._Room.sqITEMHEIGHT[i, j] = H + template.topH;
                            this._Room.sqITEMROT[i, j] = Convert.ToByte(Z);
                        }
                        else if (template.typeID == 4)
                        {
                            this._Room.sqITEMHEIGHT[i, j] = H;
                        }
                        this._Room.sqSTACK[i, j] = stack;
                    }
                }
                floorItem item = new floorItem(itemID, templateID, X, Y, Z, H, Var);
                this._Items.Add(itemID, item);
            }

            internal void Clear()
            {
                try
                {
                    this._Items.Clear();
                }
                catch
                {
                }
                this._Room = null;
                this._Items = null;
            }

            internal bool containsItem(int itemID)
            {
                return this._Items.ContainsKey(itemID);
            }

            internal floorItem getItem(int itemID)
            {
                return (floorItem) this._Items[itemID];
            }

            internal void placeItem(int itemID, int templateID, int X, int Y, byte typeID, byte Z)
            {
                if (!this._Items.ContainsKey(itemID))
                {
                    try
                    {
                        catalogueManager.itemTemplate template = catalogueManager.getTemplate(templateID);
                        bool flag = stringManager.getStringPart(template.Sprite, 0, 13) == "sound_machine";
                        if (!flag || (this.soundMachineID <= 0))
                        {
                            floorItem item;
                            int num5;
                            int num6;
                            int length = 0;
                            int width = 0;
                            if ((Z == 2) || (Z == 6))
                            {
                                length = template.Length;
                                width = template.Width;
                            }
                            else
                            {
                                length = template.Width;
                                width = template.Length;
                            }
                            double num3 = this._Room.sqFLOORHEIGHT[X, Y];
                            double h = num3;
                            if (this._Room.sqSTACK[X, Y] != null)
                            {
                                item = (floorItem) this._Items[this._Room.sqSTACK[X, Y].topItemID()];
                                h = item.H + catalogueManager.getTemplate(item.templateID).topH;
                            }
                            for (num5 = X; num5 < (X + width); num5++)
                            {
                                num6 = Y;
                                while (num6 < (Y + length))
                                {
                                    if (this._Room.sqUNIT[num5, num6])
                                    {
                                        return;
                                    }
                                    virtualRoom.squareState state = this._Room.sqSTATE[num5, num6];
                                    switch (state)
                                    {
                                        case virtualRoom.squareState.Open:
                                            break;

                                        case virtualRoom.squareState.Blocked:
                                        {
                                            if (this._Room.sqSTACK[num5, num6] == null)
                                            {
                                                return;
                                            }
                                            item = (floorItem) this._Items[this._Room.sqSTACK[num5, num6].topItemID()];
                                            catalogueManager.itemTemplate template2 = catalogueManager.getTemplate(item.templateID);
                                            if (((template2.topH == 0.0) || (template2.typeID == 2)) || (template2.typeID == 3))
                                            {
                                                return;
                                            }
                                            if ((item.H + template2.topH) > h)
                                            {
                                                h = item.H + template2.topH;
                                            }
                                            break;
                                        }
                                        default:
                                        {
                                            if ((state != virtualRoom.squareState.Rug) || (this._Room.sqSTACK[num5, num6] == null))
                                            {
                                                return;
                                            }
                                            double num7 = ((floorItem) this._Items[this._Room.sqSTACK[num5, num6].topItemID()]).H + 0.1;
                                            if (num7 > h)
                                            {
                                                h = num7;
                                            }
                                            break;
                                        }
                                    }
                                    num6++;
                                }
                            }
                            if (h > Config.Items_Stacking_maxHeight)
                            {
                                h = Config.Items_Stacking_maxHeight;
                            }
                            for (num5 = X; num5 < (X + width); num5++)
                            {
                                for (num6 = Y; num6 < (Y + length); num6++)
                                {
                                    virtualRoom.furnitureStack stack = null;
                                    if (this._Room.sqSTACK[num5, num6] == null)
                                    {
                                        if (((template.typeID == 1) && (template.topH > 0.0)) || (template.typeID == 4))
                                        {
                                            stack = new virtualRoom.furnitureStack();
                                            stack.Add(itemID);
                                        }
                                    }
                                    else
                                    {
                                        stack = this._Room.sqSTACK[num5, num6];
                                        stack.Add(itemID);
                                    }
                                    this._Room.sqSTATE[num5, num6] = (virtualRoom.squareState) template.typeID;
                                    this._Room.sqSTACK[num5, num6] = stack;
                                    if ((template.typeID == 2) || (template.typeID == 3))
                                    {
                                        this._Room.sqITEMHEIGHT[num5, num6] = h + template.topH;
                                        this._Room.sqITEMROT[num5, num6] = Z;
                                    }
                                    else if (template.typeID == 4)
                                    {
                                        this._Room.sqITEMHEIGHT[num5, num6] = h;
                                    }
                                }
                            }
                            string var = DB.runRead("SELECT var FROM furniture WHERE id = '" + itemID + "'");
                            DB.runQuery(string.Concat(new object[] { "UPDATE furniture SET roomid = '", this._Room.roomID, "',x = '", X, "',y = '", Y, "',z = '", Z, "',h = '", h.ToString().Replace(',', '.'), "' WHERE id = '", itemID, "' LIMIT 1" }));
                            floorItem item2 = new floorItem(itemID, templateID, X, Y, Z, h, var);
                            this._Items.Add(itemID, item2);
                            this._Room.sendData("A]" + item2.ToString());
                            if (flag)
                            {
                                this.soundMachineID = itemID;
                            }
                        }
                    }
                    catch
                    {
                    }
                }
            }

            internal void relocateItem(int itemID, int X, int Y, byte Z)
            {
                try
                {
                    floorItem item2;
                    int y;
                    virtualRoom.furnitureStack stack;
                    floorItem item = (floorItem) this._Items[itemID];
                    catalogueManager.itemTemplate template = catalogueManager.getTemplate(item.templateID);
                    int length = 0;
                    int width = 0;
                    if ((Z == 2) || (Z == 6))
                    {
                        length = template.Length;
                        width = template.Width;
                    }
                    else
                    {
                        length = template.Width;
                        width = template.Length;
                    }
                    double num3 = this._Room.sqFLOORHEIGHT[X, Y];
                    double h = num3;
                    if (this._Room.sqSTACK[X, Y] != null)
                    {
                        item2 = (floorItem) this._Items[this._Room.sqSTACK[X, Y].topItemID()];
                        if (item2 != item)
                        {
                            catalogueManager.itemTemplate template2 = catalogueManager.getTemplate(item2.templateID);
                            if (template2.typeID == 1)
                            {
                                h = item2.H + template2.topH;
                            }
                        }
                        else if (this._Room.sqSTACK[X, Y].Count > 1)
                        {
                            h = item2.H;
                        }
                    }
                    int x = X;
                    while (x < (X + width))
                    {
                        y = Y;
                        while (y < (Y + length))
                        {
                            if ((template.typeID != 2) && this._Room.sqUNIT[x, y])
                            {
                                return;
                            }
                            virtualRoom.squareState state = this._Room.sqSTATE[x, y];
                            stack = this._Room.sqSTACK[x, y];
                            if (state != virtualRoom.squareState.Open)
                            {
                                if (stack == null)
                                {
                                    if ((x != item.X) || (y != item.Y))
                                    {
                                        return;
                                    }
                                }
                                else
                                {
                                    item2 = (floorItem) this._Items[stack.topItemID()];
                                    if (item2 != item)
                                    {
                                        catalogueManager.itemTemplate template3 = catalogueManager.getTemplate(item2.templateID);
                                        if ((template3.typeID == 1) && (template3.topH > 0.0))
                                        {
                                            if ((item2.H + template3.topH) > h)
                                            {
                                                h = item2.H + template3.topH;
                                            }
                                        }
                                        else if (template3.typeID == 2)
                                        {
                                            return;
                                        }
                                    }
                                }
                            }
                            y++;
                        }
                        x++;
                    }
                    int num7 = 1;
                    int num8 = 1;
                    if ((template.Length > 1) || (template.Width > 1))
                    {
                        if ((item.Z == 2) || (item.Z == 6))
                        {
                            num7 = template.Length;
                            num8 = template.Width;
                        }
                        else
                        {
                            num7 = template.Width;
                            num8 = template.Length;
                        }
                    }
                    if (h > Config.Items_Stacking_maxHeight)
                    {
                        h = Config.Items_Stacking_maxHeight;
                    }
                    for (x = item.X; x < (item.X + num8); x++)
                    {
                        y = item.Y;
                        while (y < (item.Y + num7))
                        {
                            stack = this._Room.sqSTACK[x, y];
                            if ((stack != null) && (stack.Count > 1))
                            {
                                if (itemID == stack.bottomItemID())
                                {
                                    if (catalogueManager.getTemplate(((floorItem) this._Items[stack.topItemID()]).templateID).typeID == 2)
                                    {
                                        this._Room.sqSTATE[x, y] = virtualRoom.squareState.Seat;
                                    }
                                    else
                                    {
                                        this._Room.sqSTATE[x, y] = virtualRoom.squareState.Open;
                                    }
                                }
                                else if (itemID == stack.topItemID())
                                {
                                    floorItem item3 = (floorItem) this._Items[stack.getBelowItemID(itemID)];
                                    byte typeID = catalogueManager.getTemplate(item3.templateID).typeID;
                                    this._Room.sqSTATE[x, y] = (virtualRoom.squareState) typeID;
                                    switch (typeID)
                                    {
                                        case 2:
                                        case 3:
                                            this._Room.sqITEMROT[x, y] = item3.Z;
                                            this._Room.sqITEMHEIGHT[x, y] = item3.H + catalogueManager.getTemplate(item3.templateID).topH;
                                            break;

                                        case 4:
                                            this._Room.sqITEMHEIGHT[x, y] = item3.H;
                                            break;
                                    }
                                }
                                stack.Remove(itemID);
                                this._Room.sqSTACK[x, y] = stack;
                            }
                            else
                            {
                                this._Room.sqSTATE[x, y] = virtualRoom.squareState.Open;
                                this._Room.sqITEMHEIGHT[x, y] = 0.0;
                                this._Room.sqITEMROT[x, y] = 0;
                                this._Room.sqSTACK[x, y] = null;
                            }
                            if ((template.typeID == 2) || (template.typeID == 3))
                            {
                                this._Room.refreshCoord(x, y);
                            }
                            y++;
                        }
                    }
                    item.X = X;
                    item.Y = Y;
                    item.Z = Z;
                    item.H = h;
                    this._Room.sendData("A_" + item.ToString());
                    DB.runQuery(string.Concat(new object[] { "UPDATE furniture SET x = '", X, "',y = '", Y, "',z = '", Z, "',h = '", h.ToString().Replace(',', '.'), "' WHERE id = '", itemID, "' LIMIT 1" }));
                    for (x = X; x < (X + width); x++)
                    {
                        for (y = Y; y < (Y + length); y++)
                        {
                            stack = null;
                            if (this._Room.sqSTACK[x, y] == null)
                            {
                                if ((((template.topH > 0.0) && (template.typeID != 2)) && (template.typeID != 3)) && (template.typeID != 4))
                                {
                                    stack = new virtualRoom.furnitureStack();
                                    stack.Add(itemID);
                                }
                            }
                            else
                            {
                                stack = this._Room.sqSTACK[x, y];
                                stack.Add(itemID);
                            }
                            this._Room.sqSTATE[x, y] = (virtualRoom.squareState) template.typeID;
                            this._Room.sqSTACK[x, y] = stack;
                            if ((template.typeID == 2) || (template.typeID == 3))
                            {
                                this._Room.sqITEMHEIGHT[x, y] = h + template.topH;
                                this._Room.sqITEMROT[x, y] = Z;
                                this._Room.refreshCoord(x, y);
                            }
                            else if (template.typeID == 4)
                            {
                                this._Room.sqITEMHEIGHT[x, y] = h;
                            }
                        }
                    }
                }
                catch
                {
                }
            }

            internal void removeItem(int itemID, int ownerID)
            {
                if (this._Items.ContainsKey(itemID))
                {
                    floorItem item = (floorItem) this._Items[itemID];
                    catalogueManager.itemTemplate template = catalogueManager.getTemplate(item.templateID);
                    int length = 0;
                    int width = 0;
                    if ((item.Z == 2) || (item.Z == 6))
                    {
                        length = template.Length;
                        width = template.Width;
                    }
                    else
                    {
                        length = template.Width;
                        width = template.Length;
                    }
                    for (int i = item.X; i < (item.X + width); i++)
                    {
                        for (int j = item.Y; j < (item.Y + length); j++)
                        {
                            virtualRoom.furnitureStack stack = this._Room.sqSTACK[i, j];
                            if ((stack != null) && (stack.Count > 1))
                            {
                                if (itemID == stack.bottomItemID())
                                {
                                    int num5 = stack.topItemID();
                                    floorItem item2 = (floorItem) this._Items[num5];
                                    if (catalogueManager.getTemplate(item2.templateID).typeID == 2)
                                    {
                                        this._Room.sqSTATE[i, j] = virtualRoom.squareState.Seat;
                                    }
                                    else
                                    {
                                        this._Room.sqSTATE[i, j] = virtualRoom.squareState.Open;
                                    }
                                }
                                else if (itemID == stack.topItemID())
                                {
                                    int num6 = stack.getBelowItemID(itemID);
                                    floorItem item3 = (floorItem) this._Items[num6];
                                    byte typeID = catalogueManager.getTemplate(item3.templateID).typeID;
                                    this._Room.sqSTATE[i, j] = (virtualRoom.squareState) typeID;
                                    switch (typeID)
                                    {
                                        case 2:
                                        case 3:
                                            this._Room.sqITEMROT[i, j] = item3.Z;
                                            this._Room.sqITEMHEIGHT[i, j] = item3.H + catalogueManager.getTemplate(item3.templateID).topH;
                                            break;

                                        case 4:
                                            this._Room.sqITEMHEIGHT[i, j] = item3.H;
                                            break;
                                    }
                                }
                                stack.Remove(itemID);
                                this._Room.sqSTACK[i, j] = stack;
                            }
                            else
                            {
                                this._Room.sqSTATE[i, j] = virtualRoom.squareState.Open;
                                this._Room.sqITEMHEIGHT[i, j] = 0.0;
                                this._Room.sqITEMROT[i, j] = 0;
                                this._Room.sqSTACK[i, j] = null;
                            }
                            if ((template.typeID == 2) || (template.typeID == 3))
                            {
                                this._Room.refreshCoord(i, j);
                            }
                        }
                    }
                    if ((this.soundMachineID == 0) && (stringManager.getStringPart(template.Sprite, 0, 13) == "sound_machine"))
                    {
                        this.soundMachineID = 0;
                    }
                    this._Room.sendData("A^" + itemID);
                    this._Items.Remove(itemID);
                    if (ownerID > 0)
                    {
                        DB.runQuery(string.Concat(new object[] { "UPDATE furniture SET x = '0',y = '0',z = '0', h = '0', ownerid = '", ownerID, "',roomid = '0' WHERE id = '", itemID, "' LIMIT 1" }));
                    }
                    else
                    {
                        DB.runQuery("DELETE FROM furniture WHERE id = '" + itemID + "' LIMIT 1");
                    }
                }
            }

            internal void rotateItem(int itemID, byte Z)
            {
                floorItem item = (floorItem) this._Items[itemID];
                catalogueManager.itemTemplate template = catalogueManager.getTemplate(item.templateID);
                int length = 1;
                int width = 1;
                if ((template.Length > 1) && (template.Width > 1))
                {
                    if ((Z == 2) || (Z == 6))
                    {
                        length = template.Length;
                        width = template.Width;
                    }
                    else
                    {
                        length = template.Width;
                        width = template.Length;
                    }
                }
                for (int i = item.X; i < (item.X + width); i++)
                {
                    for (int j = item.Y; j < (item.Y + length); j++)
                    {
                        virtualRoom.furnitureStack stack = this._Room.sqSTACK[i, j];
                        if ((stack != null) && (stack.topItemID() != itemID))
                        {
                        }
                    }
                }
            }

            internal void toggleItemStatus(int itemID, string toStatus, bool hasRights)
            {
                if (this._Items.ContainsKey(itemID))
                {
                    floorItem item = (floorItem) this._Items[itemID];
                    string sprite = item.Sprite;
                    if ((((sprite != "edice") && (sprite != "edicehc")) && (stringManager.getStringPart(sprite, 0, 11) != "prizetrophy")) && (stringManager.getStringPart(sprite, 0, 7) != "present"))
                    {
                        if ((toStatus.ToLower() == "c") || (toStatus.ToLower() == "o"))
                        {
                            if (hasRights)
                            {
                                catalogueManager.itemTemplate template = catalogueManager.getTemplate(item.templateID);
                                if (template.isDoor)
                                {
                                    int length = 1;
                                    int width = 1;
                                    if ((template.Length > 1) || (template.Width > 1))
                                    {
                                        if ((item.Z == 2) || (item.Z == 6))
                                        {
                                            length = template.Length;
                                            width = template.Width;
                                        }
                                        else
                                        {
                                            length = template.Width;
                                            width = template.Length;
                                        }
                                    }
                                    if (toStatus.ToLower() == "c")
                                    {
                                        if (this._Room.squareBlocked(item.X, item.Y, length, width))
                                        {
                                            return;
                                        }
                                        this._Room.setSquareState(item.X, item.Y, length, width, virtualRoom.squareState.Blocked);
                                    }
                                    else
                                    {
                                        this._Room.setSquareState(item.X, item.Y, length, width, virtualRoom.squareState.Open);
                                    }
                                    item.Var = toStatus;
                                    this._Room.sendData(string.Concat(new object[] { "AX", itemID, Convert.ToChar(2), toStatus, Convert.ToChar(2) }));
                                    DB.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", toStatus, "' WHERE id = '", itemID, "' LIMIT 1" }));
                                }
                            }
                        }
                        else
                        {
                            item.Var = toStatus;
                            this._Room.sendData(string.Concat(new object[] { "AX", itemID, Convert.ToChar(2), toStatus, Convert.ToChar(2) }));
                            DB.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", toStatus, "' WHERE id = '", itemID, "' LIMIT 1" }));
                        }
                    }
                }
            }

            internal string Items
            {
                get
                {
                    StringBuilder builder = new StringBuilder(Holo.Encoding.encodeVL64(this._Items.Count));
                    foreach (floorItem item in this._Items.Values)
                    {
                        builder.Append(item.ToString());
                    }
                    return builder.ToString();
                }
            }
        }

        private class furnitureStack
        {
            private int[] _itemIDs = new int[20];

            internal furnitureStack()
            {
            }

            internal void Add(int itemID)
            {
                for (int i = 0; i < 20; i++)
                {
                    if (this._itemIDs[i] == 0)
                    {
                        this._itemIDs[i] = itemID;
                        break;
                    }
                }
            }

            internal int bottomItemID()
            {
                return this._itemIDs[0];
            }

            internal bool Contains(int itemID)
            {
                foreach (int num in this._itemIDs)
                {
                    if (num == itemID)
                    {
                        return true;
                    }
                }
                return false;
            }

            internal int getAboveItemID(int aboveID)
            {
                for (int i = 0; i < 20; i++)
                {
                    if (this._itemIDs[i] == aboveID)
                    {
                        return this._itemIDs[i + 1];
                    }
                }
                return 0;
            }

            internal int getBelowItemID(int belowID)
            {
                for (int i = 0; i < 20; i++)
                {
                    if (this._itemIDs[i] == belowID)
                    {
                        return this._itemIDs[i - 1];
                    }
                }
                return 0;
            }

            internal void Remove(int itemID)
            {
                int num;
                for (num = 0; num < 20; num++)
                {
                    if (this._itemIDs[num] == itemID)
                    {
                        this._itemIDs[num] = 0;
                        break;
                    }
                }
                int index = 0;
                int[] numArray = new int[20];
                for (num = 0; num < 20; num++)
                {
                    if (this._itemIDs[num] > 0)
                    {
                        numArray[index] = this._itemIDs[num];
                        index++;
                    }
                }
                this._itemIDs = numArray;
            }

            internal int topItemID()
            {
                for (int i = 0; i < 20; i++)
                {
                    if (this._itemIDs[i] == 0)
                    {
                        return this._itemIDs[i - 1];
                    }
                }
                return 0;
            }

            internal int Count
            {
                get
                {
                    int num = 0;
                    for (int i = 0; i < 20; i++)
                    {
                        if (this._itemIDs[i] > 0)
                        {
                            num++;
                        }
                        else
                        {
                            return num;
                        }
                    }
                    return num;
                }
            }
        }

        private delegate void sendDataSleep(string Data, int msSleep);

        public enum squareState
        {
            Open,
            Blocked,
            Seat,
            Bed,
            Rug
        }

        internal class squareTrigger
        {
            internal readonly int goalX;
            internal readonly int goalY;
            internal readonly string Object;
            internal readonly int roomID;
            internal bool State;
            internal readonly int stepX;
            internal readonly int stepY;

            internal squareTrigger(string Object, int goalX, int goalY, int stepX, int stepY, bool State, int roomID)
            {
                this.Object = Object;
                this.goalX = goalX;
                this.goalY = goalY;
                this.stepX = stepX;
                this.stepY = stepY;
                this.roomID = roomID;
                this.State = State;
            }
        }

        private delegate void userMover(virtualRoomUser roomUser, int toX, int toY, bool secondRefresh);

        internal class WallItemManager
        {
            private Hashtable _Items = new Hashtable();
            private virtualRoom _Room;

            public WallItemManager(virtualRoom Room)
            {
                this._Room = Room;
            }

            internal void addItem(int itemID, int templateID, string wallPosition, string Var, bool Place)
            {
                if (!this._Items.Contains(itemID))
                {
                    wallItem item = new wallItem(itemID, templateID, wallPosition, Var);
                    this._Items.Add(itemID, item);
                    if (Place)
                    {
                        this._Room.sendData("AS" + item.ToString());
                        DB.runQuery(string.Concat(new object[] { "UPDATE furniture SET roomid = '", this._Room.roomID, "',wallpos = '", wallPosition, "' WHERE id = '", itemID, "' LIMIT 1" }));
                        if (DB.checkExists("SELECT id FROM furniture_moodlight WHERE id = '" + itemID.ToString() + "'"))
                        {
                            DB.runQuery(string.Concat(new object[] { "UPDATE furniture_moodlight SET roomid = '", this._Room.roomID, "' WHERE id = '", itemID, "' LIMIT 1" }));
                        }
                    }
                }
            }

            internal void Clear()
            {
                try
                {
                    this._Items.Clear();
                }
                catch
                {
                }
                this._Room = null;
                this._Items = null;
            }

            internal bool containsItem(int itemID)
            {
                return this._Items.ContainsKey(itemID);
            }

            internal wallItem getItem(int itemID)
            {
                return (wallItem) this._Items[itemID];
            }

            internal void removeItem(int itemID, int ownerID)
            {
                if (this._Items.ContainsKey(itemID))
                {
                    this._Room.sendData("AT" + itemID);
                    this._Items.Remove(itemID);
                    if (ownerID > 0)
                    {
                        DB.runQuery(string.Concat(new object[] { "UPDATE furniture SET ownerid = '", ownerID, "',roomid = '0' WHERE id = '", itemID, "' LIMIT 1" }));
                    }
                    else
                    {
                        DB.runQuery("DELETE FROM furniture WHERE id = '" + itemID + "' LIMIT 1");
                    }
                }
            }

            internal void toggleItemStatus(int itemID, int toStatus)
            {
                if (this._Items.ContainsKey(itemID))
                {
                    wallItem item = (wallItem) this._Items[itemID];
                    string sprite = item.Sprite;
                    if ((((sprite != "roomdimmer") && (sprite != "post.it")) && ((sprite != "post.it.vd") && (sprite != "poster"))) && !(sprite == "habbowheel"))
                    {
                        item.Var = toStatus.ToString();
                        this._Room.sendData(string.Concat(new object[] { "AU", itemID, Convert.ToChar(9), sprite, Convert.ToChar(9), " ", item.wallPosition, Convert.ToChar(9), item.Var }));
                        DB.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", toStatus, "' WHERE id = '", itemID, "' LIMIT 1" }));
                    }
                }
            }

            internal string Items
            {
                get
                {
                    StringBuilder builder = new StringBuilder();
                    foreach (wallItem item in this._Items.Values)
                    {
                        builder.Append(item.ToString() + Convert.ToChar(13));
                    }
                    return builder.ToString();
                }
            }
        }
    }
}