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 byte[,] 00AAA;
        private int 01AAA;
        private byte[,] 10AA1;
        private Thread 11AA1;
        private double[,] 20AAA;
        private bool[,] 30AA1;
        private ᙅ[,] 40AAA;
        private squareTrigger[,] 50AA1;
        private Hashtable 60AAA;
        private Hashtable 70AA1;
        private HashSet<int> 80AAA;
        private Thread 90AA1;
        private string 9AAA1;
        private StringBuilder B0AAA;
        private string BAAAA;
        private byte C0AA1;
        private squareState[,] CAAA1;
        internal bool containsPoll;
        internal int doorX;
        internal int doorY;
        internal FloorItemManager floorItemManager;
        internal bool hasSwimmingPool;
        internal bool isPublicroom;
        internal gameLobby Lobby;
        internal string pollPacket;
        internal int roomID;
        internal WallItemManager wallItemManager;

        public virtualRoom(int roomID, bool isPublicroom)
        {
            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.01AAA = DB.runRead("SELECT door_h FROM room_modeldata WHERE model = '" + parameter + "'", null);
            this.C0AA1 = byte.Parse(DB.runRead("SELECT door_z FROM room_modeldata WHERE model = '" + parameter + "'"));
            this.BAAAA = DB.runRead("SELECT heightmap FROM room_modeldata WHERE model = '" + parameter + "'");
            string[] strArray = this.BAAAA.Split(new char[] { Convert.ToChar(13) });
            int length = strArray[0].Length;
            int num2 = strArray.Length - 1;
            this.CAAA1 = new squareState[length, num2];
            this.10AA1 = new byte[length, num2];
            this.00AAA = new byte[length, num2];
            this.20AAA = new double[length, num2];
            this.30AA1 = new bool[length, num2];
            this.40AAA = new ᙅ[length, num2];
            this.50AA1 = 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.CAAA1[j, i] = squareState.Blocked;
                    }
                    else
                    {
                        this.CAAA1[j, i] = squareState.Open;
                        try
                        {
                            this.10AA1[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 (int k = 0; k < strArray2.Length; k++)
                {
                    string[] strArray3 = strArray2[k].Split(new char[] { ' ' });
                    int num6 = int.Parse(strArray3[2]);
                    int num7 = int.Parse(strArray3[3]);
                    squareState state = (squareState) int.Parse(strArray3[6]);
                    this.CAAA1[num6, num7] = state;
                    if (state == squareState.Seat)
                    {
                        this.00AAA[num6, num7] = byte.Parse(strArray3[5]);
                        this.20AAA[num6, num7] = 1.0;
                    }
                    object obj2 = this.9AAA1;
                    this.9AAA1 = 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 (int m = 0; m < numArray.Length; m++)
                    {
                        string str3 = DB.runRead("SELECT object FROM room_modeldata_triggers WHERE id = '" + numArray[m] + "'");
                        int[] numArray2 = DB.runReadRow("SELECT x,y,goalx,goaly,stepx,stepy,roomid,state FROM room_modeldata_triggers WHERE id = '" + numArray[m] + "'", null);
                        this.50AA1[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.11AA1 = new Thread(new ParameterizedThreadStart(this.handleSpecialCasts));
                    this.11AA1.Priority = ThreadPriority.Lowest;
                    this.11AA1.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 (int n = 0; n < numArray3.Length; n++)
                    {
                        if (strArray7[n] == "")
                        {
                            this.floorItemManager.addItem(numArray3[n], numArray4[n], numArray5[n], numArray6[n], numArray7[n], double.Parse(strArray5[n]), strArray6[n]);
                        }
                        else
                        {
                            this.wallItemManager.addItem(numArray3[n], numArray4[n], strArray7[n], strArray6[n], false);
                        }
                    }
                }
            }
            this.60AAA = new Hashtable();
            this.70AA1 = new Hashtable();
            this.loadBots();
            this.80AAA = new HashSet<int>();
            this.B0AAA = new StringBuilder();
            this.90AA1 = new Thread(new ThreadStart(this.cycleStatuses));
            this.90AA1.Start();
            this.CAAA1[this.doorX, this.doorY] = squareState.Open;
            this.containsPoll = DB.checkExists("SELECT pid FROM poll WHERE rid = '" + roomID + "'");
            if (this.containsPoll)
            {
                this.pollPacket = roomManager.getPoll(roomID);
            }
        }

        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.C0AA1;
                    User.roomUser.Z2 = this.C0AA1;
                    User.roomUser.H = this.01AAA;
                }
                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.60AAA.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.80AAA.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.80AAA.Add(User._groupID);
                }
                roomManager.updateRoomVisitorCount(this.roomID, this.60AAA.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);
                    return;
                }
            }
        }

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

        private void cycleStatuses()
        {
            try
            {
                while (true)
                {
                    foreach (virtualRoomUser user in ((Hashtable) this.60AAA.Clone()).Values)
                    {
                        if (user.goalX == -1)
                        {
                            continue;
                        }
                        squareState[,] stateMap = (squareState[,]) this.CAAA1.Clone();
                        try
                        {
                            if ((stateMap[user.goalX, user.goalY] == squareState.Seat) || (stateMap[user.goalX, user.goalY] == squareState.Bed))
                            {
                                stateMap[user.goalX, user.goalY] = squareState.Open;
                            }
                            if (this.30AA1[user.goalX, user.goalY])
                            {
                                stateMap[user.goalX, user.goalY] = squareState.Blocked;
                            }
                        }
                        catch
                        {
                        }
                        int[] numArray = new Pathfinder(stateMap, this.10AA1, this.30AA1).getNext(user.X, user.Y, user.goalX, user.goalY);
                        user.statusManager.removeStatus("mv");
                        if (numArray == null)
                        {
                            user.goalX = -1;
                            if (this.50AA1[user.X, user.Y] != null)
                            {
                                squareTrigger trigger = this.50AA1[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.60AAA.Count > 1)
                                {
                                    this.removeUser(user.roomUID, true, "");
                                    continue;
                                }
                                this.removeUser(user.roomUID, true, "");
                                return;
                            }
                            this.B0AAA.Append(user.statusString + Convert.ToChar(13));
                            continue;
                        }
                        int num = numArray[0];
                        int num2 = numArray[1];
                        squareState state = this.CAAA1[num, num2];
                        this.30AA1[user.X, user.Y] = false;
                        this.30AA1[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");
                        double num3 = 0.0;
                        if (state == squareState.Rug)
                        {
                            num3 = this.20AAA[num, num2];
                        }
                        else
                        {
                            num3 = this.10AA1[num, num2];
                        }
                        user.statusManager.addStatus("mv", string.Concat(new object[] { num, ",", num2, ",", num3.ToString().Replace(',', '.') }));
                        this.B0AAA.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.00AAA[num, num2];
                                user.Z2 = user.Z1;
                                user.statusManager.addStatus("sit", this.20AAA[num, num2].ToString().Replace(',', '.'));
                                continue;
                            }
                            case squareState.Bed:
                                user.statusManager.removeStatus("dance");
                                user.Z1 = this.00AAA[num, num2];
                                user.Z2 = user.Z1;
                                user.statusManager.addStatus("lay", this.20AAA[num, num2].ToString().Replace(',', '.'));
                                break;
                        }
                    }
                    foreach (virtualBot bot in this.70AA1.Values)
                    {
                        if (bot.goalX == -1)
                        {
                            continue;
                        }
                        squareState[,] stateArray2 = (squareState[,]) this.CAAA1.Clone();
                        try
                        {
                            if (stateArray2[bot.goalX, bot.goalY] == squareState.Seat)
                            {
                                stateArray2[bot.goalX, bot.goalY] = squareState.Open;
                            }
                            if (this.30AA1[bot.goalX, bot.goalY])
                            {
                                stateArray2[bot.goalX, bot.goalY] = squareState.Blocked;
                            }
                        }
                        catch
                        {
                        }
                        int[] numArray2 = new Pathfinder(stateArray2, this.10AA1, this.30AA1).getNext(bot.X, bot.Y, bot.goalX, bot.goalY);
                        bot.removeStatus("mv");
                        if (numArray2 == null)
                        {
                            if ((bot.X == bot.goalX) && (bot.Y == bot.goalY))
                            {
                                bot.checkOrders();
                            }
                            bot.goalX = -1;
                            this.B0AAA.Append(bot.statusString + Convert.ToChar(13));
                            continue;
                        }
                        int num4 = numArray2[0];
                        int num5 = numArray2[1];
                        this.30AA1[bot.X, bot.Y] = false;
                        this.30AA1[num4, num5] = true;
                        bot.Z1 = Rotation.Calculate(bot.X, bot.Y, num4, num5);
                        bot.Z2 = bot.Z1;
                        bot.removeStatus("sit");
                        double num6 = this.10AA1[num4, num5];
                        if (this.CAAA1[num4, num5] == squareState.Rug)
                        {
                            num6 = this.20AAA[num4, num5];
                        }
                        else
                        {
                            num6 = this.10AA1[num4, num5];
                        }
                        bot.addStatus("mv", string.Concat(new object[] { num4, ",", num5, ",", num6.ToString().Replace(',', '.') }));
                        this.B0AAA.Append(bot.statusString + Convert.ToChar(13));
                        bot.X = num4;
                        bot.Y = num5;
                        bot.H = num6;
                        if (this.CAAA1[num4, num5] == squareState.Seat)
                        {
                            bot.removeStatus("dance");
                            bot.Z1 = this.00AAA[num4, num5];
                            bot.Z2 = bot.Z1;
                            bot.addStatus("sit", this.20AAA[num4, num5].ToString().Replace(',', '.'));
                        }
                    }
                    if (this.B0AAA.Length > 0)
                    {
                        this.sendData("@b" + this.B0AAA.ToString());
                        this.B0AAA = new StringBuilder();
                    }
                    Thread.Sleep(410);
                    Out.WriteTrace("Status update loop");
                }
            }
            catch (Exception exception)
            {
                Out.WriteError(exception.Message);
            }
        }

        ~virtualRoom()
        {
        }

        private int getFreeRoomIdentifier()
        {
            int key = 0;
            while (this.70AA1.ContainsKey(key) || this.60AAA.ContainsKey(key))
            {
                key++;
                Out.WriteTrace("Get free room identifier");
            }
            return key;
        }

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

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

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

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

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

        private void handleSpecialCasts(object o)
        {
            try
            {
                string str3;
                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 = "";
            Label_004D:
                str3 = "";
                int num4 = new Random().Next(minValue, num3 + 1);
            Label_0065:
                if (emitter == "cam1")
                {
                    switch (num4)
                    {
                        case 1:
                        {
                            int num5 = this.getRandomRoomIdentifier();
                            if (num5 != -1)
                            {
                                str3 = "targetcamera " + num5;
                            }
                            goto Label_00F9;
                        }
                        case 2:
                            str3 = "setcamera 1";
                            goto Label_00F9;

                        case 3:
                            str3 = "setcamera 2";
                            goto Label_00F9;
                    }
                }
                else if (emitter == "sf")
                {
                    str3 = num4.ToString();
                }
                else if (emitter == "lamp")
                {
                    str3 = "setlamp " + num4;
                }
            Label_00F9:
                if (str3 == "")
                {
                    goto Label_0065;
                }
                if (str3 != str2)
                {
                    this.sendSpecialCast(emitter, str3);
                    str2 = str3;
                }
                Thread.Sleep(millisecondsTimeout);
                Out.WriteTrace("Special cast loop");
            }
            catch
            {
            }
            goto Label_004D;
        }

        internal void kickUsers(byte casterRank, string Message)
        {
            foreach (virtualRoomUser user in ((Hashtable) this.60AAA.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.10AA1[bot.X, bot.Y];
                this.30AA1[bot.X, bot.Y] = true;
                this.70AA1.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 ᙄ(this.MOVEUSER).BeginInvoke(roomUser, toX, toY, secondRefresh, null, null);
        }

        private void MOVEUSER(virtualRoomUser roomUser, int toX, int toY, bool secondRefresh)
        {
            try
            {
                this.30AA1[roomUser.X, roomUser.Y] = false;
                this.30AA1[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.CAAA1[toX, toY] == squareState.Rug)
                {
                    num = this.20AAA[toX, toY];
                }
                else
                {
                    num = this.10AA1[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.CAAA1[toX, toY] == squareState.Seat)
                    {
                        roomUser.statusManager.removeStatus("dance");
                        roomUser.Z1 = this.00AAA[toX, toY];
                        roomUser.Z2 = roomUser.Z1;
                        roomUser.statusManager.addStatus("sit", this.20AAA[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.60AAA.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.B0AAA.Append(roomBot.statusString + Convert.ToChar(13));
                }
            }
            catch
            {
            }
        }

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

        internal void refreshCoord(int X, int Y)
        {
            foreach (virtualRoomUser user in this.60AAA.Values)
            {
                if ((user.X == X) && (user.Y == Y))
                {
                    if (this.CAAA1[X, Y] == squareState.Seat)
                    {
                        if (!user.statusManager.containsStatus("sit"))
                        {
                            user.Z1 = this.00AAA[X, Y];
                            user.Z2 = user.Z1;
                            user.statusManager.addStatus("sit", this.20AAA[X, Y].ToString().Replace(',', '.'));
                            this.Refresh(user);
                        }
                    }
                    else if (this.CAAA1[X, Y] == squareState.Bed)
                    {
                        if (!user.statusManager.containsStatus("bed"))
                        {
                            user.Z1 = this.00AAA[X, Y];
                            user.Z2 = user.Z1;
                            user.statusManager.addStatus("lay", this.20AAA[X, Y].ToString().Replace(',', '.'));
                            this.Refresh(user);
                        }
                    }
                    else
                    {
                        user.statusManager.removeStatus("sit");
                        user.statusManager.removeStatus("lay");
                        user.H = this.10AA1[X, Y];
                        this.Refresh(user);
                    }
                    break;
                }
            }
        }

        internal void removeUser(int roomUID, bool sendKick, string moderatorMessage)
        {
            if (this.60AAA.Contains(roomUID))
            {
                virtualRoomUser user = (virtualRoomUser) this.60AAA[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.30AA1[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.60AAA.Remove(roomUID);
                if (this.60AAA.Count <= 0)
                {
                    this.60AAA.Clear();
                    this.70AA1.Clear();
                    this.B0AAA = null;
                    if (!this.isPublicroom)
                    {
                        this.floorItemManager.Clear();
                        this.wallItemManager.Clear();
                    }
                    try
                    {
                        this.11AA1.Abort();
                    }
                    catch
                    {
                    }
                    roomManager.removeRoom(this.roomID);
                    this.90AA1.Abort();
                }
                else
                {
                    if (user.User._groupID > 0)
                    {
                        bool flag = true;
                        foreach (virtualRoomUser user2 in this.60AAA.Values)
                        {
                            if ((user2.roomUID != user.roomUID) && (user2.User._groupID == user.User._groupID))
                            {
                                flag = false;
                                break;
                            }
                        }
                        if (flag)
                        {
                            this.80AAA.Remove(user.User._groupID);
                        }
                    }
                    this.sendData("@]" + roomUID);
                    roomManager.updateRoomVisitorCount(this.roomID, this.60AAA.Count);
                }
            }
        }

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

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

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

        internal void sendData(string Username, string Data)
        {
            foreach (virtualRoomUser user in this.60AAA.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.60AAA.Values)
            {
                user.User.sendData(Data);
            }
        }

        internal void sendDataToRights(string Data)
        {
            try
            {
                foreach (virtualRoomUser user in this.60AAA.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.60AAA.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.60AAA.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.60AAA.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.70AA1.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.60AAA.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.60AAA.Values)
            {
                this.B0AAA.Append(user.statusString + Convert.ToChar(13));
                user.User.sendData(data);
            }
            foreach (virtualBot bot in this.70AA1.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.60AAA.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.CAAA1[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.30AA1[i, j])
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        internal void unmuteUsers(byte casterRank)
        {
            string data = "BK" + stringManager.getString("scommand_unmuted");
            foreach (virtualRoomUser user in ((Hashtable) this.60AAA.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.70AA1.Values)
                {
                    builder.Append(bot.statusString + Convert.ToChar(13));
                }
                foreach (virtualRoomUser user in this.60AAA.Values)
                {
                    builder.Append(user.statusString + Convert.ToChar(13));
                }
                return builder.ToString();
            }
        }

        internal string dynamicUnits
        {
            get
            {
                StringBuilder builder = new StringBuilder();
                foreach (virtualBot bot in this.70AA1.Values)
                {
                    builder.Append(bot.detailsString);
                }
                foreach (virtualRoomUser user in this.60AAA.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.80AAA.Count));
                foreach (int num in this.80AAA)
                {
                    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.BAAAA;
            }
        }

        internal string PublicroomItems
        {
            get
            {
                return this.9AAA1;
            }
        }

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

        internal ICollection Users
        {
            get
            {
                return this.60AAA.Values;
            }
        }

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

        private class ᙅ
        {
            private int[] 8AAAA = new int[20];

            internal ᙅ()
            {
            }

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

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

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

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

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

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

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

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

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

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

        internal class FloorItemManager
        {
            private virtualRoom 4AAAA;
            private Hashtable 5AAA1 = new Hashtable();
            internal int soundMachineID;

            public FloorItemManager(virtualRoom Room)
            {
                this.4AAAA = 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.ᙅ ᙅ = this.4AAAA.40AAA[i, j];
                        if (ᙅ == null)
                        {
                            if ((template.typeID != 2) && (template.typeID != 3))
                            {
                                ᙅ = new virtualRoom.ᙅ();
                                ᙅ.Add(itemID);
                            }
                        }
                        else
                        {
                            ᙅ.Add(itemID);
                        }
                        this.4AAAA.CAAA1[i, j] = (virtualRoom.squareState) template.typeID;
                        if ((template.typeID == 2) || (template.typeID == 3))
                        {
                            this.4AAAA.20AAA[i, j] = H + template.topH;
                            this.4AAAA.00AAA[i, j] = Convert.ToByte(Z);
                        }
                        else if (template.typeID == 4)
                        {
                            this.4AAAA.20AAA[i, j] = H;
                        }
                        this.4AAAA.40AAA[i, j] = ᙅ;
                    }
                }
                floorItem item = new floorItem(itemID, templateID, X, Y, Z, H, Var);
                this.5AAA1.Add(itemID, item);
            }

            internal void Clear()
            {
                try
                {
                    this.5AAA1.Clear();
                }
                catch
                {
                }
                this.4AAAA = null;
                this.5AAA1 = null;
            }

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

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

            internal void placeItem(int itemID, int templateID, int X, int Y, byte typeID, byte Z)
            {
                if (!this.5AAA1.ContainsKey(itemID))
                {
                    try
                    {
                        catalogueManager.itemTemplate template = catalogueManager.getTemplate(templateID);
                        bool flag = stringManager.getStringPart(template.Sprite, 0, 13) == "sound_machine";
                        if (!flag || (this.soundMachineID <= 0))
                        {
                            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.4AAAA.10AA1[X, Y];
                            double h = num3;
                            if (this.4AAAA.40AAA[X, Y] != null)
                            {
                                floorItem item = (floorItem) this.5AAA1[this.4AAAA.40AAA[X, Y].topItemID()];
                                h = item.H + catalogueManager.getTemplate(item.templateID).topH;
                            }
                            for (int i = X; i < (X + width); i++)
                            {
                                for (int k = Y; k < (Y + length); k++)
                                {
                                    if (this.4AAAA.30AA1[i, k])
                                    {
                                        return;
                                    }
                                    virtualRoom.squareState state = this.4AAAA.CAAA1[i, k];
                                    switch (state)
                                    {
                                        case virtualRoom.squareState.Open:
                                            break;

                                        case virtualRoom.squareState.Blocked:
                                        {
                                            if (this.4AAAA.40AAA[i, k] == null)
                                            {
                                                return;
                                            }
                                            floorItem item2 = (floorItem) this.5AAA1[this.4AAAA.40AAA[i, k].topItemID()];
                                            catalogueManager.itemTemplate template2 = catalogueManager.getTemplate(item2.templateID);
                                            if (((template2.topH == 0.0) || (template2.typeID == 2)) || (template2.typeID == 3))
                                            {
                                                return;
                                            }
                                            if ((item2.H + template2.topH) > h)
                                            {
                                                h = item2.H + template2.topH;
                                            }
                                            break;
                                        }
                                        default:
                                        {
                                            if ((state != virtualRoom.squareState.Rug) || (this.4AAAA.40AAA[i, k] == null))
                                            {
                                                return;
                                            }
                                            double num7 = ((floorItem) this.5AAA1[this.4AAAA.40AAA[i, k].topItemID()]).H + 0.1;
                                            if (num7 > h)
                                            {
                                                h = num7;
                                            }
                                            break;
                                        }
                                    }
                                }
                            }
                            if (h > Config.Items_Stacking_maxHeight)
                            {
                                h = Config.Items_Stacking_maxHeight;
                            }
                            for (int j = X; j < (X + width); j++)
                            {
                                for (int m = Y; m < (Y + length); m++)
                                {
                                    virtualRoom.ᙅ ᙅ = null;
                                    if (this.4AAAA.40AAA[j, m] == null)
                                    {
                                        if (((template.typeID == 1) && (template.topH > 0.0)) || (template.typeID == 4))
                                        {
                                            ᙅ = new virtualRoom.ᙅ();
                                            ᙅ.Add(itemID);
                                        }
                                    }
                                    else
                                    {
                                        ᙅ = this.4AAAA.40AAA[j, m];
                                        ᙅ.Add(itemID);
                                    }
                                    this.4AAAA.CAAA1[j, m] = (virtualRoom.squareState) template.typeID;
                                    this.4AAAA.40AAA[j, m] = ᙅ;
                                    if ((template.typeID == 2) || (template.typeID == 3))
                                    {
                                        this.4AAAA.20AAA[j, m] = h + template.topH;
                                        this.4AAAA.00AAA[j, m] = Z;
                                    }
                                    else if (template.typeID == 4)
                                    {
                                        this.4AAAA.20AAA[j, m] = h;
                                    }
                                }
                            }
                            string var = DB.runRead("SELECT var FROM furniture WHERE id = '" + itemID + "'");
                            DB.runQuery(string.Concat(new object[] { "UPDATE furniture SET roomid = '", this.4AAAA.roomID, "',x = '", X, "',y = '", Y, "',z = '", Z, "',h = '", h.ToString().Replace(',', '.'), "' WHERE id = '", itemID, "' LIMIT 1" }));
                            floorItem item3 = new floorItem(itemID, templateID, X, Y, Z, h, var);
                            this.5AAA1.Add(itemID, item3);
                            this.4AAAA.sendData("A]" + item3.ToString());
                            if (flag)
                            {
                                this.soundMachineID = itemID;
                            }
                        }
                    }
                    catch
                    {
                    }
                }
            }

            internal void relocateItem(int itemID, int X, int Y, byte Z)
            {
                try
                {
                    floorItem item = (floorItem) this.5AAA1[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.4AAAA.10AA1[X, Y];
                    double h = num3;
                    if (this.4AAAA.40AAA[X, Y] != null)
                    {
                        floorItem item2 = (floorItem) this.5AAA1[this.4AAAA.40AAA[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.4AAAA.40AAA[X, Y].Count > 1)
                        {
                            h = item2.H;
                        }
                    }
                    for (int i = X; i < (X + width); i++)
                    {
                        for (int m = Y; m < (Y + length); m++)
                        {
                            if ((template.typeID != 2) && this.4AAAA.30AA1[i, m])
                            {
                                return;
                            }
                            virtualRoom.squareState state = this.4AAAA.CAAA1[i, m];
                            virtualRoom.ᙅ ᙅ = this.4AAAA.40AAA[i, m];
                            if (state != virtualRoom.squareState.Open)
                            {
                                if (ᙅ == null)
                                {
                                    if ((i != item.X) || (m != item.Y))
                                    {
                                        return;
                                    }
                                }
                                else
                                {
                                    floorItem item3 = (floorItem) this.5AAA1[ᙅ.topItemID()];
                                    if (item3 != item)
                                    {
                                        catalogueManager.itemTemplate template3 = catalogueManager.getTemplate(item3.templateID);
                                        if ((template3.typeID == 1) && (template3.topH > 0.0))
                                        {
                                            if ((item3.H + template3.topH) > h)
                                            {
                                                h = item3.H + template3.topH;
                                            }
                                        }
                                        else if (template3.typeID == 2)
                                        {
                                            return;
                                        }
                                    }
                                }
                            }
                        }
                    }
                    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 (int j = item.X; j < (item.X + num8); j++)
                    {
                        for (int n = item.Y; n < (item.Y + num7); n++)
                        {
                            virtualRoom.ᙅ ᙅ2 = this.4AAAA.40AAA[j, n];
                            if ((ᙅ2 == null) || (ᙅ2.Count <= 1))
                            {
                                goto Label_042B;
                            }
                            if (itemID == ᙅ2.bottomItemID())
                            {
                                if (catalogueManager.getTemplate(((floorItem) this.5AAA1[ᙅ2.topItemID()]).templateID).typeID == 2)
                                {
                                    this.4AAAA.CAAA1[j, n] = virtualRoom.squareState.Seat;
                                }
                                else
                                {
                                    this.4AAAA.CAAA1[j, n] = virtualRoom.squareState.Open;
                                }
                            }
                            else if (itemID == ᙅ2.topItemID())
                            {
                                floorItem item4 = (floorItem) this.5AAA1[ᙅ2.getBelowItemID(itemID)];
                                byte typeID = catalogueManager.getTemplate(item4.templateID).typeID;
                                this.4AAAA.CAAA1[j, n] = (virtualRoom.squareState) typeID;
                                switch (typeID)
                                {
                                    case 2:
                                    case 3:
                                        this.4AAAA.00AAA[j, n] = item4.Z;
                                        this.4AAAA.20AAA[j, n] = item4.H + catalogueManager.getTemplate(item4.templateID).topH;
                                        goto Label_040B;
                                }
                                if (typeID == 4)
                                {
                                    this.4AAAA.20AAA[j, n] = item4.H;
                                }
                            }
                        Label_040B:
                            ᙅ2.Remove(itemID);
                            this.4AAAA.40AAA[j, n] = ᙅ2;
                            goto Label_0487;
                        Label_042B:
                            this.4AAAA.CAAA1[j, n] = virtualRoom.squareState.Open;
                            this.4AAAA.20AAA[j, n] = 0.0;
                            this.4AAAA.00AAA[j, n] = 0;
                            this.4AAAA.40AAA[j, n] = null;
                        Label_0487:
                            if ((template.typeID == 2) || (template.typeID == 3))
                            {
                                this.4AAAA.refreshCoord(j, n);
                            }
                        }
                    }
                    item.X = X;
                    item.Y = Y;
                    item.Z = Z;
                    item.H = h;
                    this.4AAAA.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 (int k = X; k < (X + width); k++)
                    {
                        for (int num13 = Y; num13 < (Y + length); num13++)
                        {
                            virtualRoom.ᙅ ᙅ3 = null;
                            if (this.4AAAA.40AAA[k, num13] == null)
                            {
                                if (((template.topH > 0.0) && (template.typeID != 2)) && ((template.typeID != 3) && (template.typeID != 4)))
                                {
                                    ᙅ3 = new virtualRoom.ᙅ();
                                    ᙅ3.Add(itemID);
                                }
                            }
                            else
                            {
                                ᙅ3 = this.4AAAA.40AAA[k, num13];
                                ᙅ3.Add(itemID);
                            }
                            this.4AAAA.CAAA1[k, num13] = (virtualRoom.squareState) template.typeID;
                            this.4AAAA.40AAA[k, num13] = ᙅ3;
                            if ((template.typeID == 2) || (template.typeID == 3))
                            {
                                this.4AAAA.20AAA[k, num13] = h + template.topH;
                                this.4AAAA.00AAA[k, num13] = Z;
                                this.4AAAA.refreshCoord(k, num13);
                            }
                            else if (template.typeID == 4)
                            {
                                this.4AAAA.20AAA[k, num13] = h;
                            }
                        }
                    }
                }
                catch
                {
                }
            }

            internal void removeItem(int itemID, int ownerID)
            {
                if (this.5AAA1.ContainsKey(itemID))
                {
                    floorItem item = (floorItem) this.5AAA1[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.ᙅ ᙅ = this.4AAAA.40AAA[i, j];
                            if ((ᙅ == null) || (ᙅ.Count <= 1))
                            {
                                goto Label_0216;
                            }
                            if (itemID == ᙅ.bottomItemID())
                            {
                                int num5 = ᙅ.topItemID();
                                floorItem item2 = (floorItem) this.5AAA1[num5];
                                if (catalogueManager.getTemplate(item2.templateID).typeID == 2)
                                {
                                    this.4AAAA.CAAA1[i, j] = virtualRoom.squareState.Seat;
                                }
                                else
                                {
                                    this.4AAAA.CAAA1[i, j] = virtualRoom.squareState.Open;
                                }
                            }
                            else if (itemID == ᙅ.topItemID())
                            {
                                int num6 = ᙅ.getBelowItemID(itemID);
                                floorItem item3 = (floorItem) this.5AAA1[num6];
                                byte typeID = catalogueManager.getTemplate(item3.templateID).typeID;
                                this.4AAAA.CAAA1[i, j] = (virtualRoom.squareState) typeID;
                                switch (typeID)
                                {
                                    case 2:
                                    case 3:
                                        this.4AAAA.00AAA[i, j] = item3.Z;
                                        this.4AAAA.20AAA[i, j] = item3.H + catalogueManager.getTemplate(item3.templateID).topH;
                                        goto Label_01F6;
                                }
                                if (typeID == 4)
                                {
                                    this.4AAAA.20AAA[i, j] = item3.H;
                                }
                            }
                        Label_01F6:
                            ᙅ.Remove(itemID);
                            this.4AAAA.40AAA[i, j] = ᙅ;
                            goto Label_0272;
                        Label_0216:
                            this.4AAAA.CAAA1[i, j] = virtualRoom.squareState.Open;
                            this.4AAAA.20AAA[i, j] = 0.0;
                            this.4AAAA.00AAA[i, j] = 0;
                            this.4AAAA.40AAA[i, j] = null;
                        Label_0272:
                            if ((template.typeID == 2) || (template.typeID == 3))
                            {
                                this.4AAAA.refreshCoord(i, j);
                            }
                        }
                    }
                    if ((this.soundMachineID == 0) && (stringManager.getStringPart(template.Sprite, 0, 13) == "sound_machine"))
                    {
                        this.soundMachineID = 0;
                    }
                    this.4AAAA.sendData("A^" + itemID);
                    this.5AAA1.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.5AAA1[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.ᙅ ᙅ = this.4AAAA.40AAA[i, j];
                        if (ᙅ != null)
                        {
                            ᙅ.topItemID();
                        }
                    }
                }
            }

            internal void toggleItemStatus(int itemID, string toStatus, bool hasRights)
            {
                if (this.5AAA1.ContainsKey(itemID))
                {
                    floorItem item = (floorItem) this.5AAA1[itemID];
                    string sprite = item.Sprite;
                    if (((sprite != "edice") && (sprite != "edicehc")) && (((stringManager.getStringPart(sprite, 0, 11) != "prizetrophy") && (stringManager.getStringPart(sprite, 0, 11) != "greektrophy")) && (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.4AAAA.squareBlocked(item.X, item.Y, length, width))
                                        {
                                            return;
                                        }
                                        this.4AAAA.setSquareState(item.X, item.Y, length, width, virtualRoom.squareState.Blocked);
                                    }
                                    else
                                    {
                                        this.4AAAA.setSquareState(item.X, item.Y, length, width, virtualRoom.squareState.Open);
                                    }
                                    item.Var = toStatus;
                                    this.4AAAA.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.4AAAA.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.5AAA1.Count));
                    foreach (floorItem item in this.5AAA1.Values)
                    {
                        builder.Append(item.ToString());
                    }
                    return builder.ToString();
                }
            }
        }

        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;
            }
        }

        internal class WallItemManager
        {
            private virtualRoom 4AAAA;
            private Hashtable 5AAA1 = new Hashtable();

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

            internal void addItem(int itemID, int templateID, string wallPosition, string Var, bool Place)
            {
                if (!this.5AAA1.Contains(itemID))
                {
                    wallItem item = new wallItem(itemID, templateID, wallPosition, Var);
                    this.5AAA1.Add(itemID, item);
                    if (Place)
                    {
                        this.4AAAA.sendData("AS" + item.ToString());
                        DB.runQuery(string.Concat(new object[] { "UPDATE furniture SET roomid = '", this.4AAAA.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.4AAAA.roomID, "' WHERE id = '", itemID, "' LIMIT 1" }));
                        }
                    }
                }
            }

            internal void Clear()
            {
                try
                {
                    this.5AAA1.Clear();
                }
                catch
                {
                }
                this.4AAAA = null;
                this.5AAA1 = null;
            }

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

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

            internal void removeItem(int itemID, int ownerID)
            {
                if (this.5AAA1.ContainsKey(itemID))
                {
                    this.4AAAA.sendData("AT" + itemID);
                    this.5AAA1.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.5AAA1.ContainsKey(itemID))
                {
                    wallItem item = (wallItem) this.5AAA1[itemID];
                    string sprite = item.Sprite;
                    switch (sprite)
                    {
                        case "roomdimmer":
                        case "post.it":
                        case "post.it.vd":
                        case "poster":
                        case "habbowheel":
                            return;
                    }
                    item.Var = toStatus.ToString();
                    this.4AAAA.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.5AAA1.Values)
                    {
                        builder.Append(item.ToString() + Convert.ToChar(13));
                    }
                    return builder.ToString();
                }
            }
        }
    }
}