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

    public class virtualRoom
    {
        private HashSet<int> _activeGroups;
        private Hashtable _Bots;
        private string _Heightmap;
        private Dictionary<Coord, magicTile> _magicTiles;
        private Hashtable _Pets;
        private string _publicroomItems;
        private StringBuilder _statusUpdates;
        private Hashtable _Users;
        internal bool DiveDoorOpen;
        private int doorH;
        internal int doorX;
        internal int doorY;
        private byte doorZ;
        internal string emitter;
        internal FloorItemManager floorItemManager;
        internal bool HasMoodLight;
        internal bool hasSwimmingPool;
        internal bool isPublicroom;
        internal gameLobby Lobby;
        private string ModelType;
        internal int roomID;
        private int RoomVote;
        private Thread specialCastHandler;
        public byte[,] sqFLOORHEIGHT;
        private double[,] sqITEMHEIGHT;
        private byte[,] sqITEMROT;
        private furnitureStack[,] sqSTACK;
        private squareState[,] sqSTATE;
        private squareTrigger[,] sqTRIGGER;
        public bool[,] sqUNIT;
        private bool StatusThingy;
        private Hashtable ThreadSafeUserTable;
        internal WallItemManager wallItemManager;

        public virtualRoom(int roomID, bool isPublicroom)
        {
            string str;
            this.DiveDoorOpen = true;
            this.StatusThingy = true;
            this._magicTiles = new Dictionary<Coord, magicTile>();
            this.roomID = roomID;
            this.isPublicroom = isPublicroom;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                str = client.getString("SELECT model FROM rooms WHERE id = '" + roomID + "' LIMIT 1");
            }
            this.ModelType = str;
            ModeldataStructure structureInstance = modeldataManager.GetStructureInstance(str);
            this.doorX = structureInstance.DoorX;
            this.doorY = structureInstance.DoorY;
            this.doorH = structureInstance.DoorH;
            this.doorZ = structureInstance.DoorZ;
            this._Heightmap = structureInstance.HeightMap;
            string[] strArray = this._Heightmap.Split("\r".ToCharArray());
            int length = strArray[0].Length;
            int num2 = strArray.Length - 1;
            squareState[,] sQState = structureInstance.GetSQState();
            byte[,] floorgeight = modeldataManager.GetFloorgeight(str);
            this.sqSTATE = sQState;
            this.sqFLOORHEIGHT = floorgeight;
            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];
            if (isPublicroom)
            {
                DataTable table;
                string[] strArray2 = modeldataManager.publicroom_items(str).Split("\r".ToCharArray());
                this._publicroomItems = this._publicroomItems + Holo.Encoding.encodeVL64(strArray2.Length);
                for (int i = 0; i < strArray2.Length; i++)
                {
                    string[] strArray3 = strArray2[i].Split(new char[] { ' ' });
                    int num4 = int.Parse(strArray3[2]);
                    int num5 = int.Parse(strArray3[3]);
                    squareState state = (squareState) int.Parse(strArray3[6]);
                    this.sqSTATE[num4, num5] = state;
                    if (state == squareState.Seat)
                    {
                        this.sqITEMROT[num4, num5] = byte.Parse(strArray3[5]);
                        this.sqITEMHEIGHT[num4, num5] = 1.0;
                    }
                    object obj2 = this._publicroomItems;
                    this._publicroomItems = string.Concat(new object[] { obj2, Holo.Encoding.encodeVL64(0), strArray3[0], Convert.ToChar(2), strArray3[1], Convert.ToChar(2), Holo.Encoding.encodeVL64(int.Parse(strArray3[2])), Holo.Encoding.encodeVL64(int.Parse(strArray3[3])), Holo.Encoding.encodeVL64(int.Parse(strArray3[4])), Holo.Encoding.encodeVL64(int.Parse(strArray3[5])) });
                }
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    table = client2.getTable("SELECT object,x,y,goalx,goaly,stepx,stepy,roomid,state FROM room_modeldata_triggers WHERE model = '" + str + "'");
                }
                foreach (DataRow row in table.Rows)
                {
                    this.sqTRIGGER[Convert.ToInt32(row["x"]), Convert.ToInt32(row["y"])] = new squareTrigger(Convert.ToString(row["object"]), Convert.ToInt32(row["goalx"]), Convert.ToInt32(row["goaly"]), Convert.ToInt32(row["stepx"]), Convert.ToInt32(row["stepy"]), Convert.ToInt32(row["state"]) == 1, Convert.ToInt32(row["roomid"]));
                }
                bool flag = false;
                using (Eucalypt.dbManager.GetClient())
                {
                    flag = modeldataManager.specialcast_interval(str) > 0;
                }
                if (flag)
                {
                    this.specialCastHandler = new Thread(new ParameterizedThreadStart(this.handleSpecialCasts));
                    this.specialCastHandler.Priority = ThreadPriority.Lowest;
                    this.specialCastHandler.Start(str);
                }
                using (DatabaseClient client3 = Eucalypt.dbManager.GetClient())
                {
                    this.hasSwimmingPool = modeldataManager.swimmingpool(str);
                    flag = client3.findsResult("SELECT id FROM games_lobbies WHERE id = '" + roomID + "'");
                }
                if (flag)
                {
                    DataRow row2;
                    using (DatabaseClient client4 = Eucalypt.dbManager.GetClient())
                    {
                        row2 = client4.getRow("SELECT type,rank FROM games_lobbies WHERE id = '" + roomID + "'");
                    }
                    this.Lobby = new gameLobby(this, Convert.ToString(row2["type"]) == "bb", Convert.ToString(row2["rank"]));
                }
                this.InitMagicTiles();
            }
            else
            {
                this.floorItemManager = new FloorItemManager(this);
                this.wallItemManager = new WallItemManager(this);
                using (DatabaseClient client5 = Eucalypt.dbManager.GetClient())
                {
                    foreach (DataRow row3 in client5.getTable("SELECT furniture.id, furniture.tid, furniture.x, furniture.y, furniture.z, furniture.h, furniture.var, furniture.wallpos, furniture.teleportid FROM rooms, furniture WHERE furniture.roomid = rooms.id AND rooms.id = '" + roomID + "' ORDER BY rooms.id ASC").Rows)
                    {
                        int spriteID = client5.getInt("SELECT id FROM furniture_data WHERE sprite = '" + client5.getString("SELECT name_cct FROM catalogue_items WHERE tid = '" + row3["tid"] + "'") + "'");
                        if (Convert.ToString(row3["wallpos"]) == "")
                        {
                            this.floorItemManager.addItem(Convert.ToInt32(row3["id"]), Convert.ToInt32(row3["tid"]), Convert.ToInt32(row3["x"]), Convert.ToInt32(row3["y"]), Convert.ToInt32(row3["z"]), Convert.ToDouble(row3["h"]), Convert.ToString(row3["var"]), Convert.ToInt32(row3["teleportid"]), spriteID);
                        }
                        else
                        {
                            this.wallItemManager.addItem(Convert.ToInt32(row3["id"]), Convert.ToInt32(row3["tid"]), Convert.ToString(row3["wallpos"]), Convert.ToString(row3["var"]), false);
                        }
                    }
                }
            }
            this._Users = new Hashtable();
            this._Bots = new Hashtable();
            this._Pets = new Hashtable();
            this.loadBots();
            this.loadPets();
            this._activeGroups = new HashSet<int>();
            this._statusUpdates = new StringBuilder();
            this.sqSTATE[this.doorX, this.doorY] = squareState.Open;
        }

        internal void addPet(int ID, int X, int Y, bool Broadcast)
        {
            int roomUID = this.getFreeRoomIdentifier();
            virtualPet pet = new virtualPet(ID, roomUID, this, X, Y);
            this.sqUNIT[pet.X, pet.Y] = true;
            this._Pets.Add(roomUID, pet);
            if (Broadcast)
            {
                this.sendData(@"@\I" + pet.detailsString);
                this.sendData("@b" + this.dynamicStatuses);
            }
        }

        internal void addUser(virtualUser User)
        {
            int toX = 0;
            int toY = 0;
            if ((User._teleporterID == 0) && (!User._ROOMACCESS_PRIMARY_OK || !User._ROOMACCESS_SECONDARY_OK))
            {
                return;
            }
            virtualRoomUserStatusManager statusManager = new virtualRoomUserStatusManager(User.userID, this.roomID);
            User.statusManager = statusManager;
            User.roomUser = new virtualRoomUser(User.userID, this.roomID, this.getFreeRoomIdentifier(), 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);
                if (item == null)
                {
                    return;
                }
                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;
                toX = item.X;
                toY = item.Y;
                if (item.Z == 4)
                {
                    toY = item.Y + 1;
                }
                if (item.Z == 2)
                {
                    toX = item.X + 1;
                }
            }
            User.roomUser.goalX = -1;
            this._Users.Add(User.roomUser.roomUID, User.roomUser);
            if (User._teleporterID > 0)
            {
                this.sendData(string.Concat(new object[] { "AX", User._teleporterID, Convert.ToChar(2), 2, Convert.ToChar(2) }), 250);
                this.sendData(string.Concat(new object[] { "AX", User._teleporterID, Convert.ToChar(2), 1, Convert.ToChar(2) }), 450);
                this.sendData(string.Concat(new object[] { "AX", User._teleporterID, Convert.ToChar(2), 0, Convert.ToChar(2) }), 800);
            }
            if (!this.isPublicroom)
            {
                if (User._hasRights && !User._isOwner)
                {
                    User.statusManager.addStatus("flatctrl", "onlyfurniture");
                }
                if (User._isOwner)
                {
                    User.statusManager.addStatus("flatctrl", "useradmin");
                }
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    User.roomUser.hasVoted = client.findsResult(string.Concat(new object[] { "SELECT userid FROM room_votes WHERE userid = '", User.userID, "' AND roomid = '", this.roomID, "'" }));
                    goto Label_04C8;
                }
            }
            if (this.hasSwimmingPool)
            {
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    User.roomUser.swimOutfit = client2.getString("SELECT figure_swim FROM users WHERE id = '" + User.userID + "'");
                }
            }
            if (!this.DiveDoorOpen)
            {
                this.sendSpecialCast("door", "close");
            }
            if (this.Lobby != null)
            {
                using (DatabaseClient client3 = Eucalypt.dbManager.GetClient())
                {
                    User.roomUser.gamePoints = client3.getInt(string.Concat(new object[] { "SELECT ", this.Lobby.Type, "_totalpoints FROM users WHERE id = '", User.userID, "'" }));
                }
                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) }));
            }
        Label_04C8:
            this.sendData(@"@\I" + User.roomUser.detailsString);
            if ((User._groupID > 0) && !this._activeGroups.Contains(User._groupID))
            {
                string str;
                using (DatabaseClient client4 = Eucalypt.dbManager.GetClient())
                {
                    str = client4.getString("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);
            }
            if ((toX > 0) && (toY > 0))
            {
                this.moveUser(User.roomUser, toX, toY, true);
            }
            roomManager.updateRoomVisitorCount(this.roomID, this._Users.Count);
        }

        internal void AddVote(bool Vote, int userID)
        {
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                if (Vote)
                {
                    if (!client.findsResult(string.Concat(new object[] { "SELECT userid FROM room_votes WHERE userid = '", userID, "' AND roomid = '", this.roomID, "'" })))
                    {
                        client.runQuery(string.Concat(new object[] { "INSERT INTO room_votes (userid,roomid,vote) VALUES ('", userID, "','", this.roomID, "','1')" }));
                        this.RoomVote++;
                    }
                }
                else if (!client.findsResult(string.Concat(new object[] { "SELECT userid FROM room_votes WHERE userid = '", userID, "' AND roomid = '", this.roomID, "'" })))
                {
                    client.runQuery(string.Concat(new object[] { "INSERT INTO room_votes (userid,roomid,vote) VALUES ('", userID, "','", this.roomID, "','-1')" }));
                    this.RoomVote--;
                }
                client.runQuery(string.Concat(new object[] { "UPDATE rooms SET votes = '", this.RoomVote, "' WHERE id = '", this.roomID, "'" }));
            }
        }

        internal int 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 0;
        }

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

        internal void Crash()
        {
            try
            {
                try
                {
                    foreach (virtualRoomUser user in this._Users.Values)
                    {
                        user.User.sendData("@R");
                        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;
                        if (user.User._tradePartnerRoomUID != -1)
                        {
                            user.User.abortTrade();
                        }
                        if ((user.User.gamePlayer != null) && !user.User.gamePlayer.enteringGame)
                        {
                            user.User.leaveGame();
                        }
                    }
                }
                catch
                {
                }
                foreach (virtualBot bot in this._Bots.Values)
                {
                    bot.Kill();
                }
                this._Users.Clear();
                this._Bots.Clear();
                this._statusUpdates = null;
                if (!this.isPublicroom)
                {
                    this.floorItemManager.Clear();
                    this.wallItemManager.Clear();
                }
                else
                {
                    if (this.Lobby != null)
                    {
                        this.Lobby.Clear();
                    }
                    this.Lobby = null;
                }
                roomManager.removeRoom(this.roomID);
                this.StatusThingy = false;
            }
            catch
            {
            }
        }

        public void cycleStatuses()
        {
            try
            {
                new List<int>();
                this.RefreshTable();
                foreach (virtualRoomUser user in this.ThreadSafeUserTable.Values)
                {
                    if (user.goalX != -1)
                    {
                        if (user.walkDoor)
                        {
                            this.removeUser(user.roomUID, true, "");
                            goto Label_0845;
                        }
                        squareState[,] stateMap = (squareState[,]) this.sqSTATE.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.sqUNIT[user.goalX, user.goalY])
                            {
                                stateMap[user.goalX, user.goalY] = squareState.Blocked;
                            }
                        }
                        catch
                        {
                        }
                        user.statusManager.removeStatus("mv");
                        int[] numArray2 = new Pathfinder(stateMap, this.sqFLOORHEIGHT, this.sqUNIT).getNext(user.X, user.Y, user.goalX, user.goalY);
                        if (numArray2 != null)
                        {
                            int num4 = numArray2[0];
                            int num5 = numArray2[1];
                            double num6 = 0.0;
                            if (this.sqSTATE[num4, num5] != squareState.Open)
                            {
                                num6 = this.sqITEMHEIGHT[num4, num5];
                            }
                            else
                            {
                                num6 = this.sqFLOORHEIGHT[num4, num5];
                            }
                            if ((Convert.ToInt32(num6) - Convert.ToInt32(user.H)) > 1)
                            {
                                user.goalX = -1;
                                user.goalY = -1;
                                numArray2 = null;
                            }
                        }
                        if (numArray2 == null)
                        {
                            if (((user.X == user.goalX) && (user.Y == user.goalY)) && this._magicTiles.ContainsKey(new Coord(user.X, user.Y)))
                            {
                                magicTile tile = this._magicTiles[new Coord(user.X, user.Y)];
                                user.User.spawnLoc[0].X = tile.toX;
                                user.User.spawnLoc[0].Y = tile.toY;
                                user.User.spawnLoc[1].X = tile.toZ;
                                user.User.spawnLoc[1].Y = tile.toH;
                                user.User.spawnStatus = tile.toStatus;
                                user.User.sendData("D^" + tile.toMode + Holo.Encoding.encodeVL64(tile.toID));
                            }
                            if (this.sqTRIGGER[user.X, user.Y] != null)
                            {
                                squareTrigger 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 == "lidodive")
                                        {
                                            user.walkLock = true;
                                            user.Diving = true;
                                            this.DiveDoorOpen = false;
                                            user.goalX = 0x1a;
                                            user.goalY = 3;
                                            this.moveUser(user, 0x1a, 3, true);
                                            this.sendSpecialCast("door", "close");
                                            this.sqUNIT[0x1a, 4] = true;
                                            user.User.sendData("A}");
                                        }
                                        if (trigger.Object.Contains("Splash"))
                                        {
                                            this.sendData("AG" + trigger.Object);
                                            if (trigger.Object.Substring(8) == "enter")
                                            {
                                                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 (trigger.Object == "bus")
                                {
                                    if (!trigger.State)
                                    {
                                        this.sendData("AQ" + stringManager.getString("room_infobus_closed"));
                                        user.goalX = trigger.goalX;
                                        user.goalY = trigger.goalY;
                                    }
                                    else
                                    {
                                        this.removeUser(user.roomUID, false, "");
                                        user.User._roomID = trigger.roomID;
                                        user.User._ROOMACCESS_PRIMARY_OK = true;
                                        user.User._ROOMACCESS_SECONDARY_OK = true;
                                        user.User.sendData("Bf");
                                        using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                                        {
                                            user.User.sendData(string.Concat(new object[] { "AE", client.getString("SELECT model FROM rooms WHERE id = '" + trigger.roomID + "'"), " ", trigger.roomID }));
                                        }
                                    }
                                }
                            }
                            user.goalX = -1;
                            this._statusUpdates.Append(user.statusString + Convert.ToChar(2));
                        }
                        else
                        {
                            int num7 = numArray2[0];
                            int num8 = numArray2[1];
                            squareState state = this.sqSTATE[num7, num8];
                            this.sqUNIT[user.X, user.Y] = false;
                            this.sqUNIT[num7, num8] = true;
                            user.Z1 = Rotation.Calculate(user.X, user.Y, num7, num8);
                            user.Z2 = user.Z1;
                            user.statusManager.removeStatus("sit");
                            user.statusManager.removeStatus("lay");
                            double num9 = 0.0;
                            if (state == squareState.Rug)
                            {
                                num9 = this.sqITEMHEIGHT[num7, num8];
                            }
                            else
                            {
                                num9 = this.sqFLOORHEIGHT[num7, num8];
                            }
                            user.statusManager.addStatus("mv", string.Concat(new object[] { num7, ",", num8, ",", num9.ToString().Replace(',', '.') }));
                            this._statusUpdates.Append(user.statusString + Convert.ToChar(2));
                            user.X = num7;
                            user.Y = num8;
                            user.H = num9;
                            switch (state)
                            {
                                case squareState.Seat:
                                {
                                    user.Z1 = this.sqITEMROT[num7, num8];
                                    user.Z2 = user.Z1;
                                    user.statusManager.addStatus("sit", this.sqITEMHEIGHT[num7, num8].ToString().Replace(',', '.'));
                                    continue;
                                }
                                case squareState.Bed:
                                {
                                    user.Z1 = this.sqITEMROT[num7, num8];
                                    user.Z2 = user.Z1;
                                    user.statusManager.addStatus("lay", this.sqITEMHEIGHT[num7, num8].ToString().Replace(',', '.'));
                                    continue;
                                }
                            }
                        }
                    }
                }
            }
            catch
            {
            }
        Label_0845:
            foreach (virtualBot bot in this._Bots.Values)
            {
                if (bot.goalX == -1)
                {
                    continue;
                }
                squareState[,] 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
                {
                }
                int[] numArray = new Pathfinder(stateArray, this.sqFLOORHEIGHT, this.sqUNIT).getNext(bot.X, bot.Y, bot.goalX, bot.goalY);
                if (numArray != null)
                {
                    if ((bot.X == bot.goalX) && (bot.Y == bot.goalY))
                    {
                        bot.checkOrders();
                    }
                    bot.goalX = -1;
                    this._statusUpdates.Append(bot.statusString + Convert.ToChar(2));
                    continue;
                }
                int num = numArray[0];
                int 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");
                double 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(2));
                bot.X = num;
                bot.Y = num2;
                bot.H = num3;
                if (this.sqSTATE[num, num2] == squareState.Seat)
                {
                    bot.Z1 = this.sqITEMROT[num, num2];
                    bot.Z2 = bot.Z1;
                    bot.addStatus("sit", this.sqITEMHEIGHT[num, num2].ToString().Replace(',', '.'));
                }
            }
            try
            {
                foreach (virtualPet pet in this._Pets.Values)
                {
                    if (pet.goalX == -1)
                    {
                        continue;
                    }
                    squareState[,] stateArray3 = (squareState[,]) this.sqSTATE.Clone();
                    try
                    {
                        if (stateArray3[pet.goalX, pet.goalY] == squareState.Seat)
                        {
                            stateArray3[pet.goalX, pet.goalY] = squareState.Open;
                        }
                        if (this.sqUNIT[pet.goalX, pet.goalY])
                        {
                            stateArray3[pet.goalX, pet.goalY] = squareState.Blocked;
                        }
                    }
                    catch
                    {
                    }
                    int[] numArray3 = new Pathfinder(stateArray3, this.sqFLOORHEIGHT, this.sqUNIT).getNext(pet.X, pet.Y, pet.goalX, pet.goalY);
                    pet.removeStatus("mv");
                    if (numArray3 == null)
                    {
                        pet.goalX = -1;
                        this._statusUpdates.Append(pet.statusString + Convert.ToChar(2));
                        continue;
                    }
                    int num10 = numArray3[0];
                    int num11 = numArray3[1];
                    this.sqUNIT[pet.X, pet.Y] = false;
                    this.sqUNIT[num10, num11] = true;
                    pet.Z1 = Rotation.Calculate(pet.X, pet.Y, num10, num11);
                    pet.Z2 = pet.Z1;
                    pet.removeStatus("sit");
                    double num12 = this.sqFLOORHEIGHT[num10, num11];
                    if (this.sqSTATE[num10, num11] == squareState.Rug)
                    {
                        num12 = this.sqITEMHEIGHT[num10, num11];
                    }
                    else
                    {
                        num12 = this.sqFLOORHEIGHT[num10, num11];
                    }
                    pet.addStatus("mv", string.Concat(new object[] { num10, ",", num11, ",", num12.ToString().Replace(',', '.') }));
                    this._statusUpdates.Append(pet.statusString + Convert.ToChar(13));
                    pet.X = num10;
                    pet.Y = num11;
                    pet.H = num12;
                    if (this.sqSTATE[num10, num11] == squareState.Seat)
                    {
                        pet.removeStatus("dance");
                        pet.Z1 = this.sqITEMROT[num10, num11];
                        pet.Z2 = pet.Z1;
                        pet.addStatus("sit", this.sqITEMHEIGHT[num10, num11].ToString().Replace(',', '.'));
                    }
                }
            }
            catch (Exception exception)
            {
                Out.WriteError(exception.ToString());
            }
            try
            {
                if (this._statusUpdates.Length > 0)
                {
                    int i = this._statusUpdates.ToString().Split(new char[] { '\x0002' }).Length / 2;
                    this.sendData("@b" + Holo.Encoding.encodeVL64(i) + this._statusUpdates.ToString());
                    this._statusUpdates = new StringBuilder();
                }
                this._statusUpdates = new StringBuilder();
            }
            catch
            {
            }
        }

        ~virtualRoom()
        {
            roomManager.removeRoom(this.roomID);
            GC.Collect();
        }

        private int getFreeRoomIdentifier()
        {
            int key = 0;
            while ((this._Bots.ContainsKey(key) || this._Users.ContainsKey(key)) || this._Pets.ContainsKey(key))
            {
                key++;
            }
            return key;
        }

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

        internal string getPetString(int petID)
        {
            StringBuilder builder = new StringBuilder();
            foreach (virtualPet pet in this._Pets.Values)
            {
                int num;
                int num2;
                int num3;
                int num4;
                int num5;
                int num6;
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    num3 = client.getInt("SELECT owner FROM pets WHERE roomid = '" + this.roomID + "'");
                    num4 = client.getInt("SELECT name FROM users WHERE id = '" + num3 + "'");
                    num2 = client.getInt("SELECT level FROM pets WHERE id = '" + petID + "'");
                    num = client.getInt("SELECT energy FROM pets WHERE id = '" + petID + "'");
                    num5 = client.getInt("SELECT experience FROM pets WHERE id = '" + petID + "'");
                    num6 = client.getInt("SELECT satiety FROM pets WHERE id = '" + petID + "'");
                }
                if (pet.ID == petID)
                {
                    builder.Append(Holo.Encoding.encodeVL64(petID));
                    builder.Append(pet.Name);
                    builder.Append(Convert.ToChar(2));
                    builder.Append(Holo.Encoding.encodeVL64(num2));
                    builder.Append(Holo.Encoding.encodeVL64(20));
                    builder.Append(Holo.Encoding.encodeVL64(num5));
                    builder.Append(Holo.Encoding.encodeVL64(200));
                    builder.Append(Holo.Encoding.encodeVL64(num));
                    builder.Append(Holo.Encoding.encodeVL64(200));
                    builder.Append(Holo.Encoding.encodeVL64(num6));
                    builder.Append(Holo.Encoding.encodeVL64(200));
                    builder.Append(pet.Type);
                    builder.Append(Convert.ToChar(0x20));
                    builder.Append(pet.Race);
                    builder.Append(Convert.ToChar(0x20));
                    builder.Append(pet.Colour);
                    builder.Append(Convert.ToChar(2));
                    builder.Append("I");
                    builder.Append(Holo.Encoding.encodeVL64(num3));
                    builder.Append("I");
                    builder.Append(Holo.Encoding.encodeVL64(num4));
                    builder.Append(Convert.ToChar(2));
                    builder.Append(Convert.ToChar(2));
                    return builder.ToString();
                }
            }
            return null;
        }

        private int getRandomRoomIdentifier()
        {
            int num;
            if (this._Users.Count <= 0)
            {
                return -1;
            }
            do
            {
                num = new Random(DateTime.Now.Millisecond).Next(0, this._Users.Count);
            }
            while (!this._Bots.ContainsKey(num) && !this._Users.ContainsKey(num));
            return num;
        }

        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
            {
                DataRow row;
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    row = client.getRow("SELECT specialcast_emitter,specialcast_interval,specialcast_rnd_min, specialcast_rnd_max FROM room_modeldata WHERE model = '" + ((string) o) + "'");
                }
                this.emitter = Convert.ToString(row["specialcast_emitter"]);
                int millisecondsTimeout = Convert.ToInt32(row["specialcast_interval"]);
                int minValue = Convert.ToInt32(row["specialcast_rnd_min"]);
                int num3 = Convert.ToInt32(row["specialcast_rnd_max"]);
                row = null;
                string str = "";
                while (this.StatusThingy)
                {
                    string cast = "";
                    int num4 = new Random().Next(minValue, num3 + 1);
                    if (this.emitter == "cam1")
                    {
                        int num5;
                        switch (num4)
                        {
                            case 1:
                                num5 = this.getRandomRoomIdentifier();
                                if (num5 != -1)
                                {
                                    cast = "targetcamera " + num5;
                                }
                                goto Label_016B;

                            case 2:
                                cast = "setcamera 1";
                                goto Label_016B;

                            case 3:
                                cast = "setcamera 2";
                                goto Label_016B;
                        }
                        num5 = this.getRandomRoomIdentifier();
                        if (num5 != -1)
                        {
                            cast = "targetcamera " + num5;
                        }
                    }
                    else if (this.emitter == "sf")
                    {
                        cast = num4.ToString();
                    }
                    else if (this.emitter == "lamp")
                    {
                        cast = "setlamp " + num4;
                    }
                Label_016B:
                    if (cast == "")
                    {
                        return;
                    }
                    if (cast != str)
                    {
                        this.sendSpecialCast(this.emitter, cast);
                        str = cast;
                    }
                    Thread.Sleep(millisecondsTimeout);
                }
            }
            catch
            {
            }
        }

        public bool hasSpecialCasts(string emiterValue)
        {
            return ((this.emitter != null) && (this.emitter == emiterValue));
        }

        private void InitMagicTiles()
        {
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                foreach (DataRow row in client.getTable("SELECT toid,fromx,fromy,tox,toy,toh,toz,tostatus,tomode FROM room_magicTiles WHERE fromid = '" + this.roomID + "'").Rows)
                {
                    magicTile tile = new magicTile(Convert.ToString(row["tomode"]), Convert.ToString(row["tostatus"]), Convert.ToInt32(row["toid"]), Convert.ToInt32(row["tox"]), Convert.ToInt32(row["toy"]), Convert.ToByte(row["toz"]), Convert.ToInt32(row["toh"]));
                    this._magicTiles.Add(new Coord(Convert.ToInt32(row["fromx"]), Convert.ToInt32(row["fromy"])), tile);
                }
                foreach (DataRow row2 in client.getTable("SELECT fromid,fromx,fromy,fromh,fromz,tox,toy,fromstatus,frommode FROM room_magicTiles WHERE toid = '" + this.roomID + "'").Rows)
                {
                    Coord key = new Coord(Convert.ToInt32(row2["tox"]), Convert.ToInt32(row2["toy"]));
                    if (!this._magicTiles.ContainsKey(key))
                    {
                        magicTile tile2 = new magicTile(Convert.ToString(row2["frommode"]), Convert.ToString(row2["fromstatus"]), Convert.ToInt32(row2["fromid"]), Convert.ToInt32(row2["fromx"]), Convert.ToInt32(row2["fromy"]), Convert.ToByte(row2["fromz"]), Convert.ToInt32(row2["fromh"]));
                        this._magicTiles.Add(key, tile2);
                    }
                }
            }
        }

        internal void kickUsers(byte casterRank, string Message)
        {
            List<virtualRoomUser> list = new List<virtualRoomUser>();
            Hashtable hashtable = (Hashtable) this._Users.Clone();
            foreach (virtualRoomUser user in this._Users.Values)
            {
                if (user.User._Rank < casterRank)
                {
                    list.Add(user);
                }
            }
            foreach (virtualRoomUser user2 in list)
            {
                this.removeUser(user2.roomUID, true, Message);
            }
            hashtable.Clear();
        }

        internal void loadBots()
        {
            DataColumn column;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                column = client.getColumn("SELECT id FROM roombots WHERE roomid = '" + this.roomID + "'");
            }
            int[] numArray = dataHandling.dColToArray(column, null);
            for (int i = 0; i < numArray.Length; i++)
            {
                virtualBot bot;
                bot = new virtualBot(numArray[i], this.getFreeRoomIdentifier(), this) {
                    H = (double) this.sqFLOORHEIGHT[bot.X, bot.Y]
                };
                this.sqUNIT[bot.X, bot.Y] = true;
                this._Bots.Add(bot.roomUID, bot);
                this.sendData(@"@\I" + bot.detailsString);
                this.sendData("@b" + bot.statusString);
            }
        }

        internal void loadPets()
        {
            DataColumn column;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                column = client.getColumn("SELECT id FROM pets WHERE roomid = '" + this.roomID + "'");
            }
            int[] numArray = dataHandling.dColToArray(column, null);
            for (int i = 0; i < numArray.Length; i++)
            {
                virtualPet pet;
                pet = new virtualPet(numArray[i], this.getFreeRoomIdentifier(), this, 0, 0) {
                    H = (double) this.sqFLOORHEIGHT[pet.X, pet.Y]
                };
                this.sqUNIT[pet.X, pet.Y] = true;
                this._Pets.Add(pet.roomUID, pet);
                this.sendData(@"@\I" + pet.detailsString);
                this.sendData("@b" + this.dynamicStatuses);
            }
        }

        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");
                this.Refresh(roomUser);
                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.Refresh(roomUser);
                Thread.Sleep(310);
                roomUser.X = toX;
                roomUser.Y = toY;
                roomUser.H = num;
                roomUser.statusManager.removeStatus("mv");
                this.Refresh(roomUser);
                if (secondRefresh && (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.Refresh(roomUser);
                }
            }
            catch
            {
            }
        }

        internal void muteUsers(byte casterRank, string Message)
        {
            Message = string.Concat(new object[] { "BK", stringManager.getString("scommand_muted"), "\r", Message, Convert.ToChar(2) });
            Hashtable hashtable = (Hashtable) this._Users.Clone();
            foreach (virtualRoomUser user in hashtable.Values)
            {
                if (!user.User._isMuted && (user.User._Rank < casterRank))
                {
                    user.User._isMuted = true;
                    user.User.sendData(Message);
                }
            }
            hashtable.Clear();
        }

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

        internal void Refresh(virtualPet roomPet)
        {
            try
            {
                if (roomPet.goalX == -1)
                {
                    this._statusUpdates.Append(roomPet.statusString + Convert.ToChar(2));
                }
            }
            catch
            {
            }
        }

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

        internal void refreshActions(int roomUID)
        {
            virtualRoomUser user = (virtualRoomUser) this._Users[roomUID];
            foreach (virtualRoomUser user2 in this._Users.Values)
            {
                if (user2.roomUID != roomUID)
                {
                    user.User.sendData(user2.User.statusID + Holo.Encoding.encodeVL64(user2.roomUID) + Holo.Encoding.encodeVL64(user2.User.statusCount));
                }
            }
        }

        internal void refreshCoord(int X, int Y)
        {
            Hashtable hashtable = (Hashtable) this._Users.Clone();
            foreach (virtualRoomUser user in hashtable.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);
                    }
                    return;
                }
            }
            hashtable.Clear();
        }

        private void RefreshTable()
        {
            if (this.ThreadSafeUserTable == null)
            {
                this.ThreadSafeUserTable = new Hashtable();
            }
            if (this.ThreadSafeUserTable.Count != 0)
            {
                this.ThreadSafeUserTable.Clear();
            }
            this.ThreadSafeUserTable = (Hashtable) this._Users.Clone();
        }

        internal void removeUser(int roomUID, bool sendKick, string moderatorMessage)
        {
            if (!this._Users.Contains(roomUID))
            {
                return;
            }
            virtualRoomUser user = (virtualRoomUser) this._Users[roomUID];
            if (sendKick)
            {
                user.User.sendData("@R");
                if (moderatorMessage != "")
                {
                    user.User.sendData(string.Concat(new object[] { "@a", 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;
            if (user.User._tradePartnerRoomUID != -1)
            {
                user.User.abortTrade();
            }
            if ((user.User.gamePlayer != null) && !user.User.gamePlayer.enteringGame)
            {
                user.User.leaveGame();
            }
            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();
                }
                else
                {
                    this.StatusThingy = false;
                    if (this.Lobby != null)
                    {
                        this.Lobby.Clear();
                    }
                    this.Lobby = null;
                }
                roomManager.removeRoom(this.roomID);
                GC.Collect();
                return;
            }
            if (user.User._groupID <= 0)
            {
                goto Label_0287;
            }
            bool flag = true;
            try
            {
                foreach (virtualRoomUser user2 in this._Users.Values)
                {
                    if ((user2.roomUID != user.roomUID) && (user2.User._groupID == user.User._groupID))
                    {
                        flag = false;
                        goto Label_026D;
                    }
                }
            }
            catch
            {
            }
        Label_026D:
            if (flag)
            {
                this._activeGroups.Remove(user.User._groupID);
            }
        Label_0287:
            this.sendData("@]" + roomUID + Convert.ToChar(2));
            roomManager.updateRoomVisitorCount(this.roomID, this._Users.Count);
        }

        internal void RemoveVote()
        {
            this.RoomVote--;
        }

        internal void sendData(string Data)
        {
            try
            {
                Hashtable hashtable = (Hashtable) this._Users.Clone();
                byte[] bytes = System.Text.Encoding.Default.GetBytes(Data + Convert.ToChar(1));
                foreach (virtualRoomUser user in hashtable.Values)
                {
                    user.User.SendByteArray(bytes);
                }
                hashtable.Clear();
            }
            catch
            {
            }
        }

        internal void sendData(int userID, string Data)
        {
            virtualUser user = userManager.getUser(userID);
            if (user.roomUser.roomID == this.roomID)
            {
                user.sendData(Data);
            }
        }

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

        internal void sendData(string Username, string Data)
        {
            virtualUser user = userManager.getUser(Username);
            if (user.roomUser.roomID == this.roomID)
            {
                user.sendData(Data);
            }
        }

        private void SENDDATASLEEP(string Data, int msSleep)
        {
            Thread.Sleep(msSleep);
            this.sendData(Data);
        }

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

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

        internal void sendSaying(virtualBot sourceBot, string Message)
        {
            string text1 = string.Concat(new object[] { "@X", Holo.Encoding.encodeVL64(sourceBot.roomUID), Message, Convert.ToChar(2), Holo.Encoding.encodeVL64(0) });
            Hashtable hashtable = (Hashtable) this._Users.Clone();
            foreach (virtualRoomUser user in hashtable.Values)
            {
                if ((Math.Abs((int) (user.X - sourceBot.X)) < 6) && (Math.Abs((int) (user.Y - sourceBot.Y)) < 6))
                {
                    user.Z1 = Rotation.headRotation(user.Z2, user.X, user.Y, sourceBot.X, sourceBot.Y);
                    this._statusUpdates.Append(user.statusString + Convert.ToChar(2));
                }
            }
            hashtable.Clear();
        }

        internal void sendSaying(virtualPet sourcePet, string Message)
        {
            string text1 = string.Concat(new object[] { "@X", Holo.Encoding.encodeVL64(sourcePet.roomUID), Message, Convert.ToChar(2), Holo.Encoding.encodeVL64(0) });
            Hashtable hashtable = (Hashtable) this._Users.Clone();
            foreach (virtualRoomUser user in hashtable.Values)
            {
                if ((Math.Abs((int) (user.X - sourcePet.X)) < 6) && (Math.Abs((int) (user.Y - sourcePet.Y)) < 6))
                {
                    user.Z1 = Rotation.headRotation(user.Z2, user.X, user.Y, sourcePet.X, sourcePet.Y);
                    this._statusUpdates.Append(user.statusString + Convert.ToChar(2));
                }
            }
            hashtable.Clear();
        }

        internal void sendSaying(virtualRoomUser sourceUser, string Message)
        {
            int i = this.checkEmotion(sourceUser, Message);
            if (sourceUser.isTyping)
            {
                this.sendData("Ei" + Holo.Encoding.encodeVL64(sourceUser.roomUID) + "H");
                sourceUser.isTyping = false;
            }
            string packet = string.Concat(new object[] { "@X", Holo.Encoding.encodeVL64(sourceUser.roomUID), Message, Convert.ToChar(2), Holo.Encoding.encodeVL64(i) });
            Hashtable hashtable = (Hashtable) this._Users.Clone();
            foreach (virtualRoomUser user in hashtable.Values)
            {
                if ((Math.Abs((int) (user.X - sourceUser.X)) < 6) && (Math.Abs((int) (user.Y - sourceUser.Y)) < 6))
                {
                    if ((user.roomUID != sourceUser.roomUID) && (user.goalX == -1))
                    {
                        user.Z1 = Rotation.headRotation(user.Z2, user.X, user.Y, sourceUser.X, sourceUser.Y);
                        this._statusUpdates.Append(user.statusString + Convert.ToChar(2));
                    }
                    string str2 = user.User._mutedIDs ?? "";
                    if (!str2.Contains("<" + sourceUser.userID + ">"))
                    {
                        user.User.sendData(packet);
                    }
                }
            }
            hashtable.Clear();
            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 packet = string.Concat(new object[] { "@Z", Holo.Encoding.encodeVL64(sourceBot.roomUID), Message, Convert.ToChar(2), Holo.Encoding.encodeVL64(0) });
            Hashtable hashtable = (Hashtable) this._Users.Clone();
            foreach (virtualRoomUser user in hashtable.Values)
            {
                if ((user.roomUID != sourceBot.roomUID) && (user.goalX == -1))
                {
                    this._statusUpdates.Append(user.statusString + Convert.ToChar(2));
                }
                user.User.sendData(packet);
            }
            hashtable.Clear();
        }

        internal void sendShout(virtualPet sourceBot, string Message)
        {
            string packet = string.Concat(new object[] { "@Z", Holo.Encoding.encodeVL64(sourceBot.roomUID), Message, Convert.ToChar(2), Holo.Encoding.encodeVL64(0) });
            Hashtable hashtable = (Hashtable) this._Users.Clone();
            foreach (virtualRoomUser user in hashtable.Values)
            {
                if ((user.roomUID != sourceBot.roomUID) && (user.goalX == -1))
                {
                    this._statusUpdates.Append(user.statusString + Convert.ToChar(2));
                }
                user.User.sendData(packet);
            }
            hashtable.Clear();
        }

        internal void sendShout(virtualRoomUser sourceUser, string Message)
        {
            int i = this.checkEmotion(sourceUser, Message);
            if (sourceUser.isTyping)
            {
                this.sendData("Ei" + Holo.Encoding.encodeVL64(sourceUser.roomUID) + "H");
                sourceUser.isTyping = false;
            }
            string packet = string.Concat(new object[] { "@Z", Holo.Encoding.encodeVL64(sourceUser.roomUID), Message, Convert.ToChar(2), Holo.Encoding.encodeVL64(i) });
            Hashtable hashtable = new Hashtable();
            hashtable = (Hashtable) this._Users.Clone();
            foreach (virtualRoomUser user in this._Users.Values)
            {
                if ((user.roomUID != sourceUser.roomUID) && (user.goalX == -1))
                {
                    user.Z1 = Rotation.headRotation(user.Z2, user.X, user.Y, sourceUser.X, sourceUser.Y);
                    this._statusUpdates.Append(user.statusString + Convert.ToChar(2));
                }
                string str2 = user.User._mutedIDs ?? "";
                if (!str2.Contains("<" + sourceUser.userID + ">"))
                {
                    user.User.sendData(packet);
                }
            }
            lock (this._Bots)
            {
                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);
                    }
                }
            }
            hashtable.Clear();
        }

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

        internal void sendWhisper(virtualRoomUser sourceUser, string Receiver, string Message)
        {
            int i = this.checkEmotion(sourceUser, Message);
            if (sourceUser.isTyping)
            {
                this.sendData("Ei" + Holo.Encoding.encodeVL64(sourceUser.roomUID) + "H");
                sourceUser.isTyping = false;
            }
            string packet = string.Concat(new object[] { "@Y", Holo.Encoding.encodeVL64(sourceUser.roomUID), Message, Convert.ToChar(2), Holo.Encoding.encodeVL64(i) });
            Hashtable hashtable = new Hashtable();
            hashtable = (Hashtable) this._Users.Clone();
            foreach (virtualRoomUser user in this._Users.Values)
            {
                if (user.User._Username == Receiver)
                {
                    sourceUser.User.sendData(packet);
                    string str2 = user.User._mutedIDs ?? "";
                    if (!str2.Contains("<" + sourceUser.userID + ">"))
                    {
                        user.User.sendData(packet);
                    }
                    return;
                }
            }
            hashtable.Clear();
        }

        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 packet = "BK" + stringManager.getString("scommand_unmuted") + Convert.ToChar(2);
            Hashtable hashtable = new Hashtable();
            hashtable = (Hashtable) this._Users.Clone();
            try
            {
                foreach (virtualRoomUser user in hashtable.Values)
                {
                    if (user.User._isMuted && (user.User._Rank < casterRank))
                    {
                        user.User._isMuted = false;
                        user.User.sendData(packet);
                    }
                }
            }
            catch
            {
            }
            hashtable.Clear();
        }

        internal int VoteCount()
        {
            return this.RoomVote;
        }

        internal string dynamicStatuses
        {
            get
            {
                int i = 0;
                StringBuilder builder = new StringBuilder();
                foreach (virtualPet pet in this._Pets.Values)
                {
                    i++;
                    builder.Append(pet.statusString);
                }
                foreach (virtualBot bot in this._Bots.Values)
                {
                    i++;
                    builder.Append(bot.statusString + Convert.ToChar(2));
                }
                Hashtable hashtable = (Hashtable) this._Users.Clone();
                foreach (virtualRoomUser user in hashtable.Values)
                {
                    i++;
                    builder.Append(user.statusString);
                }
                hashtable.Clear();
                return (Holo.Encoding.encodeVL64(i) + builder.ToString());
            }
        }

        internal string dynamicUnits
        {
            get
            {
                int i = 0;
                StringBuilder builder = new StringBuilder();
                foreach (virtualPet pet in this._Pets.Values)
                {
                    i++;
                    builder.Append(pet.detailsString);
                }
                foreach (virtualBot bot in this._Bots.Values)
                {
                    i++;
                    builder.Append(bot.detailsString);
                }
                Hashtable hashtable = (Hashtable) this._Users.Clone();
                foreach (virtualRoomUser user in hashtable.Values)
                {
                    i++;
                    builder.Append(user.detailsString);
                }
                hashtable.Clear();
                return (Holo.Encoding.encodeVL64(i) + builder.ToString());
            }
        }

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

        internal string Groups
        {
            get
            {
                DataTable table;
                StringBuilder builder = new StringBuilder(Holo.Encoding.encodeVL64(this._activeGroups.Count));
                StringBuilder builder2 = new StringBuilder();
                foreach (int num in this._activeGroups)
                {
                    builder2.Append(" OR id = '" + num + "'");
                }
                builder2.Append(" OR");
                int i = 0;
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    client.AddParamWithValue("tablename", builder2.ToString().Substring(3));
                    table = client.getTable("SELECT id,badge FROM groups_details WHERE @tablename 'a' = 'b'");
                }
                foreach (DataRow row in table.Rows)
                {
                    i++;
                    builder.Append(Holo.Encoding.encodeVL64(Convert.ToInt32(row["id"])) + Convert.ToString(row["badge"]) + Convert.ToChar(2));
                }
                return (Holo.Encoding.encodeVL64(i) + 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));
                Hashtable hashtable = (Hashtable) this._Users.Clone();
                foreach (virtualRoomUser user in hashtable.Values)
                {
                    builder.Append(user.User._Username + Convert.ToChar(2));
                }
                hashtable.Clear();
                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, int remoteID, int spriteID)
            {
                try
                {
                    catalogueManager.itemTemplate template = catalogueManager.getTemplate(templateID);
                    if (((stringManager.getStringPart(template.Sprite, 0, 13) == "sound_machine") || (stringManager.getStringPart(template.Sprite, 0, 13) == "ads_idol_trax")) || (stringManager.getStringPart(template.Sprite, 0, 13) == "nouvelle_trax"))
                    {
                        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 + template.topH;
                            }
                            this._Room.sqSTACK[i, j] = stack;
                        }
                    }
                    if (template.isDoor)
                    {
                        if (this._Room.squareBlocked(X, Y, length, width))
                        {
                            return;
                        }
                        if (Var.ToLower() == "0")
                        {
                            this._Room.setSquareState(X, Y, length, width, virtualRoom.squareState.Blocked);
                        }
                        else if (Var.ToLower() == "1")
                        {
                            this._Room.setSquareState(X, Y, length, width, virtualRoom.squareState.Open);
                        }
                        else
                        {
                            this._Room.setSquareState(X, Y, length, width, virtualRoom.squareState.Blocked);
                        }
                    }
                    floorItem item = new floorItem(itemID, templateID, X, Y, Z, H, Var, remoteID);
                    this._Items.Add(itemID, item);
                }
                catch
                {
                }
            }

            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, int spriteID)
            {
                if (!this._Items.ContainsKey(itemID))
                {
                    try
                    {
                        catalogueManager.itemTemplate template = catalogueManager.getTemplate(templateID);
                        bool flag = ((stringManager.getStringPart(template.Sprite, 0, 13) == "sound_machine") || (stringManager.getStringPart(template.Sprite, 0, 13) == "ads_idol_trax")) || (stringManager.getStringPart(template.Sprite, 0, 13) == "nouvelle_trax");
                        if (!flag || (this.soundMachineID <= 0))
                        {
                            string str;
                            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)
                            {
                                floorItem item = (floorItem) this._Items[this._Room.sqSTACK[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._Room.sqUNIT[i, k])
                                    {
                                        return;
                                    }
                                    virtualRoom.squareState state = this._Room.sqSTATE[i, k];
                                    switch (state)
                                    {
                                        case virtualRoom.squareState.Open:
                                        {
                                            continue;
                                        }
                                        case virtualRoom.squareState.Blocked:
                                            if (this._Room.sqSTACK[i, k] != null)
                                            {
                                                break;
                                            }
                                            return;

                                        default:
                                            goto Label_022F;
                                    }
                                    floorItem item2 = (floorItem) this._Items[this._Room.sqSTACK[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;
                                    }
                                    continue;
                                Label_022F:
                                    if ((state != virtualRoom.squareState.Rug) || (this._Room.sqSTACK[i, k] == null))
                                    {
                                        return;
                                    }
                                    double num7 = ((floorItem) this._Items[this._Room.sqSTACK[i, k].topItemID()]).H + template.topH;
                                    if (num7 > h)
                                    {
                                        h = num7;
                                    }
                                }
                            }
                            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.furnitureStack stack = null;
                                    if (this._Room.sqSTACK[j, m] == null)
                                    {
                                        if (((template.typeID == 1) && (template.topH > 0.0)) || (template.typeID == 4))
                                        {
                                            stack = new virtualRoom.furnitureStack();
                                            stack.Add(itemID);
                                        }
                                    }
                                    else
                                    {
                                        stack = this._Room.sqSTACK[j, m];
                                        stack.Add(itemID);
                                    }
                                    this._Room.sqSTATE[j, m] = (virtualRoom.squareState) template.typeID;
                                    this._Room.sqSTACK[j, m] = stack;
                                    if ((template.typeID == 2) || (template.typeID == 3))
                                    {
                                        this._Room.sqITEMHEIGHT[j, m] = template.topH;
                                        this._Room.sqITEMROT[j, m] = Z;
                                        this._Room.sqITEMROT[j, m] = Z;
                                        if ((template.typeID == 3) && ((j != X) || (m != Y)))
                                        {
                                            if (width == 1)
                                            {
                                                this._Room.sqSTATE[j, m] = virtualRoom.squareState.Blocked;
                                            }
                                            else if (((Z == 2) && (j != X)) || ((Z == 0) && (m != Y)))
                                            {
                                                this._Room.sqSTATE[j, m] = virtualRoom.squareState.Blocked;
                                            }
                                        }
                                    }
                                    else if (template.typeID == 4)
                                    {
                                        this._Room.sqITEMHEIGHT[j, m] = h + template.topH;
                                    }
                                }
                            }
                            int remoteID = 0;
                            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                            {
                                str = client.getString("SELECT var FROM furniture WHERE id = '" + itemID + "'");
                                client.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" }));
                                remoteID = client.getInt("SELECT teleportid FROM furniture WHERE id = '" + itemID + "'");
                            }
                            floorItem item3 = new floorItem(itemID, templateID, X, Y, Z, h, str, remoteID);
                            this._Items.Add(itemID, item3);
                            this._Room.sendData(string.Concat(new object[] { "A]", item3.ToString(), Convert.ToChar(2), Convert.ToChar(1), "C[!;0" }));
                            if (flag)
                            {
                                this.soundMachineID = itemID;
                            }
                        }
                    }
                    catch
                    {
                    }
                }
            }

            internal void relocateItem(int itemID, int X, int Y, byte Z)
            {
                try
                {
                    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)
                    {
                        floorItem 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;
                        }
                    }
                    for (int i = X; i < (X + width); i++)
                    {
                        for (int m = Y; m < (Y + length); m++)
                        {
                            if ((template.typeID != 2) && this._Room.sqUNIT[i, m])
                            {
                                return;
                            }
                            virtualRoom.squareState state = this._Room.sqSTATE[i, m];
                            virtualRoom.furnitureStack stack = this._Room.sqSTACK[i, m];
                            if (state != virtualRoom.squareState.Open)
                            {
                                if (stack == null)
                                {
                                    if ((i != item.X) || (m != item.Y))
                                    {
                                        return;
                                    }
                                }
                                else
                                {
                                    floorItem item3 = (floorItem) this._Items[stack.topItemID()];
                                    floorItem item4 = (floorItem) this._Items[stack.bottomItemID()];
                                    if (catalogueManager.getTemplate(item4.templateID).typeID == 4)
                                    {
                                        return;
                                    }
                                    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.furnitureStack stack2 = this._Room.sqSTACK[j, n];
                            if ((stack2 == null) || (stack2.Count <= 1))
                            {
                                goto Label_05A4;
                            }
                            if (itemID == stack2.bottomItemID())
                            {
                                if (catalogueManager.getTemplate(((floorItem) this._Items[stack2.topItemID()]).templateID).typeID == 2)
                                {
                                    this._Room.sqSTATE[j, n] = virtualRoom.squareState.Seat;
                                }
                                else if (catalogueManager.getTemplate(((floorItem) this._Items[stack2.topItemID()]).templateID).typeID == 4)
                                {
                                    this._Room.sqSTATE[j, n] = virtualRoom.squareState.Rug;
                                }
                                else if (catalogueManager.getTemplate(((floorItem) this._Items[stack2.topItemID()]).templateID).typeID == 3)
                                {
                                    this._Room.sqSTATE[j, n] = virtualRoom.squareState.Bed;
                                }
                                else if (catalogueManager.getTemplate(((floorItem) this._Items[stack2.topItemID()]).templateID).typeID == 1)
                                {
                                    this._Room.sqSTATE[j, n] = virtualRoom.squareState.Blocked;
                                }
                                else
                                {
                                    this._Room.sqSTATE[j, n] = virtualRoom.squareState.Open;
                                }
                            }
                            else if (itemID == stack2.topItemID())
                            {
                                floorItem item5 = (floorItem) this._Items[stack2.getBelowItemID(itemID)];
                                byte typeID = catalogueManager.getTemplate(item5.templateID).typeID;
                                this._Room.sqSTATE[j, n] = (virtualRoom.squareState) typeID;
                                switch (typeID)
                                {
                                    case 2:
                                    case 3:
                                        this._Room.sqITEMROT[j, n] = item5.Z;
                                        this._Room.sqITEMHEIGHT[j, n] = item5.H + catalogueManager.getTemplate(item5.templateID).topH;
                                        if ((template.typeID == 3) && ((j != X) || (n != Y)))
                                        {
                                            if (width == 1)
                                            {
                                                this._Room.sqSTATE[j, n] = virtualRoom.squareState.Blocked;
                                            }
                                            else if (((Z == 2) && (j != X)) || ((Z == 0) && (n != Y)))
                                            {
                                                this._Room.sqSTATE[j, n] = virtualRoom.squareState.Blocked;
                                            }
                                        }
                                        goto Label_0584;
                                }
                                if (typeID == 4)
                                {
                                    this._Room.sqITEMHEIGHT[j, n] = item5.H;
                                }
                            }
                        Label_0584:
                            stack2.Remove(itemID);
                            this._Room.sqSTACK[j, n] = stack2;
                            goto Label_0600;
                        Label_05A4:
                            this._Room.sqSTATE[j, n] = virtualRoom.squareState.Open;
                            this._Room.sqITEMHEIGHT[j, n] = 0.0;
                            this._Room.sqITEMROT[j, n] = 0;
                            this._Room.sqSTACK[j, n] = null;
                        Label_0600:
                            if ((template.typeID == 2) || (template.typeID == 3))
                            {
                                this._Room.refreshCoord(j, n);
                            }
                        }
                    }
                    item.X = X;
                    item.Y = Y;
                    item.Z = Z;
                    item.H = h;
                    this._Room.sendData(string.Concat(new object[] { "A_", item.ToString(), Convert.ToChar(2), "H", Convert.ToChar(1), "C[!;0" }));
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        client.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.furnitureStack stack3 = null;
                            if (this._Room.sqSTACK[k, num13] == null)
                            {
                                if (((template.topH > 0.0) && (template.typeID != 2)) && ((template.typeID != 3) && (template.typeID != 4)))
                                {
                                    stack3 = new virtualRoom.furnitureStack();
                                    stack3.Add(itemID);
                                }
                            }
                            else
                            {
                                stack3 = this._Room.sqSTACK[k, num13];
                                stack3.Add(itemID);
                            }
                            this._Room.sqSTATE[k, num13] = (virtualRoom.squareState) template.typeID;
                            this._Room.sqSTACK[k, num13] = stack3;
                            if ((template.typeID == 2) || (template.typeID == 3))
                            {
                                this._Room.sqITEMHEIGHT[k, num13] = template.topH;
                                this._Room.sqITEMROT[k, num13] = Z;
                                this._Room.refreshCoord(k, num13);
                            }
                            else if (template.typeID == 4)
                            {
                                this._Room.sqITEMHEIGHT[k, num13] = h + template.topH;
                            }
                        }
                    }
                }
                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))
                            {
                                goto Label_0223;
                            }
                            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;
                                        goto Label_0203;
                                }
                                if (typeID == 4)
                                {
                                    this._Room.sqITEMHEIGHT[i, j] = item3.H;
                                }
                            }
                        Label_0203:
                            stack.Remove(itemID);
                            this._Room.sqSTACK[i, j] = stack;
                            goto Label_027F;
                        Label_0223:
                            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;
                        Label_027F:
                            if ((template.typeID == 2) || (template.typeID == 3))
                            {
                                this._Room.refreshCoord(i, j);
                            }
                        }
                    }
                    if ((this.soundMachineID == 0) && (((stringManager.getStringPart(template.Sprite, 0, 13) == "sound_machine") || (stringManager.getStringPart(template.Sprite, 0, 13) == "ads_idol_trax")) || (stringManager.getStringPart(template.Sprite, 0, 13) == "nouvelle_trax")))
                    {
                        this.soundMachineID = 0;
                    }
                    this._Room.sendData("A^" + itemID + Convert.ToChar(2));
                    this._Items.Remove(itemID);
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        if (ownerID > 0)
                        {
                            client.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
                        {
                            client.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();
                        }
                    }
                }
            }

            internal void toggleItemStatus(int itemID, string toStatus, bool hasRights)
            {
                string s = "";
                int num = Holo.Encoding.decodeVL64(toStatus);
                toStatus = Convert.ToString(Holo.Encoding.decodeVL64(toStatus));
                if (int.Parse(toStatus) == 0)
                {
                    toStatus = "";
                }
                if (this._Items.ContainsKey(itemID))
                {
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        s = client.getString("SELECT var FROM furniture WHERE id = " + itemID + " LIMIT 1");
                    }
                    floorItem item = (floorItem) this._Items[itemID];
                    catalogueManager.itemTemplate template = catalogueManager.getTemplate(item.templateID);
                    int maxStatus = 0;
                    if (s == "")
                    {
                        s = Convert.ToString(0);
                    }
                    if (template.drinkIDs != "")
                    {
                        toStatus = Convert.ToString(1);
                    }
                    else
                    {
                        maxStatus = int.Parse(s);
                        if ((int.Parse(s) == template.maxStatus) || (int.Parse(s) >= template.maxStatus))
                        {
                            maxStatus = 0;
                        }
                        else
                        {
                            switch (num)
                            {
                                case 1:
                                    maxStatus--;
                                    break;

                                case 2:
                                    maxStatus++;
                                    break;
                            }
                            if (maxStatus == -1)
                            {
                                maxStatus = template.maxStatus;
                            }
                            if (num == 0)
                            {
                                maxStatus++;
                                if (template.maxStatus > 9)
                                {
                                    if (int.Parse(s) == -1)
                                    {
                                        maxStatus = 0;
                                    }
                                    else
                                    {
                                        maxStatus = -1;
                                    }
                                }
                            }
                        }
                        toStatus = Convert.ToString(maxStatus);
                    }
                    string sprite = item.Sprite;
                    if (((!sprite.Contains("present_gen") && !sprite.Contains("prizetrophy")) && (!sprite.Contains("greektrophy") && (sprite != "edice"))) && (((sprite != "edicehc") && (stringManager.getStringPart(sprite, 0, 11) != "prizetrophy")) && (stringManager.getStringPart(sprite, 0, 7) != "present")))
                    {
                        using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                        {
                            client2.AddParamWithValue("var", toStatus);
                            if (template.isDoor)
                            {
                                if (hasRights)
                                {
                                    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 (int.Parse(toStatus.ToLower()) == 0)
                                    {
                                        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) }));
                                    client2.runQuery("UPDATE furniture SET var = @var WHERE id = " + itemID + " LIMIT 1");
                                }
                            }
                            else if (toStatus.Replace(Convert.ToChar(2), Convert.ToChar(0x20)) == toStatus)
                            {
                                item.Var = toStatus;
                                this._Room.sendData(string.Concat(new object[] { "AX", itemID, Convert.ToChar(2), toStatus, Convert.ToChar(2) }));
                                client2.runQuery("UPDATE furniture SET var = @var 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;
                        return;
                    }
                }
            }

            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)
            {
                for (int i = 0; i < 20; i++)
                {
                    if (this._itemIDs[i] == itemID)
                    {
                        this._itemIDs[i] = 0;
                        break;
                    }
                }
                int index = 0;
                int[] numArray = new int[20];
                for (int j = 0; j < 20; j++)
                {
                    if (this._itemIDs[j] > 0)
                    {
                        numArray[index] = this._itemIDs[j];
                        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 class magicTile
        {
            internal int toH;
            internal int toID;
            internal string toMode;
            internal string toStatus;
            internal int toX;
            internal int toY;
            internal byte toZ;

            internal magicTile(string s4, string s5, int i6, int i7, int i8, byte b9, int i10)
            {
                this.toMode = s4;
                this.toStatus = s5;
                this.toID = i6;
                this.toX = i7;
                this.toY = i8;
                this.toZ = b9;
                this.toH = i10;
            }
        }

        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() + Convert.ToChar(2));
                        using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                        {
                            client.runQuery(string.Concat(new object[] { "UPDATE furniture SET roomid = '", this._Room.roomID, "',wallpos = '", wallPosition, "' WHERE id = '", itemID, "' LIMIT 1" }));
                            if (templateID == 0x3ea)
                            {
                                if (!client.findsResult("SELECT roomid FROM furniture_moodlight WHERE id='" + itemID + "'"))
                                {
                                    client.runQuery(string.Concat(new object[] { "INSERT INTO furniture_moodlight VALUES ('", itemID, "','", this._Room.roomID, "','1','1,#000000,225','1,#000000,200','1,#000000,175')" }));
                                }
                                else
                                {
                                    client.runQuery(string.Concat(new object[] { "UPDATE furniture_moodlight SET roomid = '", this._Room.roomID, "' WHERE id= '", itemID, "'" }));
                                }
                            }
                        }
                    }
                }
            }

            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 string moodLight_GetSettings(int roomID)
            {
                try
                {
                    string[] itemArray;
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        itemArray = (string[]) client.getRow("SELECT preset_cur,preset_1,preset_2,preset_3 FROM furniture_moodlight WHERE roomid ='" + roomID + "'").ItemArray;
                    }
                    string str = Holo.Encoding.encodeVL64(3) + Holo.Encoding.encodeVL64(Convert.ToInt32(itemArray[0]));
                    for (int i = 1; i <= 3; i++)
                    {
                        string[] strArray2 = itemArray[i].Split(new char[] { ',' });
                        str = string.Concat(new object[] { str, Holo.Encoding.encodeVL64(i), Holo.Encoding.encodeVL64(Convert.ToInt32(strArray2[0])), strArray2[1], Convert.ToChar(2), Holo.Encoding.encodeVL64(Convert.ToInt32(strArray2[2])) });
                    }
                    return str;
                }
                catch
                {
                    return "";
                }
            }

            internal void moodLight_SetSettings(bool isEnabled, int presetID, int bgState, string presetColour, int alphaDarkF, int roomID, int templateID)
            {
                int num;
                string str;
                DataRow row;
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    num = client.getInt("SELECT id FROM furniture_moodlight WHERE roomid ='" + roomID + "'");
                }
                if (!isEnabled)
                {
                    string str2;
                    using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                    {
                        str2 = client2.getString("SELECT var FROM furniture WHERE id ='" + num + "'");
                    }
                    if (str2.Substring(0, 1) == "2")
                    {
                        str = "1" + str2.Substring(1);
                    }
                    else
                    {
                        str = "2" + str2.Substring(1);
                    }
                    using (DatabaseClient client3 = Eucalypt.dbManager.GetClient())
                    {
                        client3.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", str, "' WHERE id ='", num, "' LIMIT 1" }));
                        goto Label_0252;
                    }
                }
                str = string.Concat(new object[] { "2,", presetID, ",", bgState, ",", presetColour, ",", alphaDarkF });
                using (DatabaseClient client4 = Eucalypt.dbManager.GetClient())
                {
                    client4.runQuery(string.Concat(new object[] { "UPDATE furniture SET var ='", str, "' WHERE id ='", num, "' LIMIT 1" }));
                    client4.runQuery(string.Concat(new object[] { "UPDATE furniture_moodlight SET preset_cur ='", presetID, "',preset_", presetID, " ='", bgState, ",", presetColour, ",", alphaDarkF, "' WHERE id = '", num, "' LIMIT 1" }));
                }
            Label_0252:
                using (DatabaseClient client5 = Eucalypt.dbManager.GetClient())
                {
                    row = client5.getRow("SELECT wallpos,var FROM furniture WHERE id = '" + num + "'");
                }
                string wallPosition = Convert.ToString(row["wallpos"]);
                this.refreshWallitem(num, "roomdimmer", wallPosition, Convert.ToString(row["var"]), templateID);
            }

            internal void refreshWallitem(int itemID, string cctName, string wallPosition, string itemVariable, int templateID)
            {
                templateID = 0x3ea;
                this._Room.sendData(string.Concat(new object[] { "AU", itemID, Convert.ToChar(2), Holo.Encoding.encodeVL64(templateID), wallPosition, Convert.ToChar(2), itemVariable, Convert.ToChar(2) }));
            }

            internal void removeItem(int itemID, int ownerID)
            {
                if (this._Items.ContainsKey(itemID))
                {
                    this._Room.sendData("AT" + itemID + Convert.ToChar(2));
                    this._Items.Remove(itemID);
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        if (ownerID > 0)
                        {
                            client.runQuery(string.Concat(new object[] { "UPDATE furniture SET ownerid = '", ownerID, "',roomid = '0',pickedup = '", Convert.ToString(DateTime.Now), "' WHERE id = '", itemID, "' LIMIT 1" }));
                        }
                        else
                        {
                            client.runQuery("DELETE FROM furniture WHERE id = '" + itemID + "' LIMIT 1");
                        }
                    }
                }
            }

            internal void toggleItemStatus(int itemID, int toStatus)
            {
                if (this._Items.ContainsKey(itemID))
                {
                    string str;
                    wallItem item = (wallItem) this._Items[itemID];
                    if (((str = item.Sprite) == null) || ((((str != "roomdimmer") && (str != "post.it")) && ((str != "post.it.vd") && (str != "poster"))) && ((str != "habbowheel") && (str != "ads_lin_wh_c"))))
                    {
                        item.Var = toStatus.ToString();
                        this._Room.sendData(string.Concat(new object[] { "AU", itemID, Convert.ToChar(2), Holo.Encoding.encodeVL64(item.templateID), item.wallPosition, Convert.ToChar(2), item.Var, Convert.ToChar(2) }));
                        using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                        {
                            client.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", toStatus, "' WHERE id = '", itemID, "' LIMIT 1" }));
                        }
                    }
                }
            }

            internal string Items
            {
                get
                {
                    StringBuilder builder = new StringBuilder();
                    builder.Append(Holo.Encoding.encodeVL64(this._Items.Count));
                    try
                    {
                        foreach (wallItem item in this._Items.Values)
                        {
                            builder.Append(item.ToString() + Convert.ToChar(2));
                        }
                    }
                    catch
                    {
                    }
                    return builder.ToString();
                }
            }
        }
    }
}