namespace Holo.Virtual.Rooms
{
    using Holo;
    using Holo.Managers;
    using Holo.Virtual.Rooms.Bots;
    using Holo.Virtual.Rooms.Games;
    using Holo.Virtual.Rooms.Items;
    using Holo.Virtual.Rooms.Pathfinding;
    using Holo.Virtual.Users;
    using 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 string _publicroomItems;
        private Thread _statusHandler;
        private StringBuilder _statusUpdates;
        private Hashtable _Users;
        private int doorH;
        internal int doorX;
        internal int doorY;
        private byte doorZ;
        internal string emitter;
        internal FloorItemManager floorItemManager;
        internal bool hasSwimmingPool;
        internal bool isPublicroom;
        internal gameLobby Lobby;
        internal int roomID;
        private Thread specialCastHandler;
        public byte[,] sqFLOORHEIGHT;
        private double[,] sqITEMHEIGHT;
        private byte[,] sqITEMROT;
        private furnitureStack[,] sqSTACK;
        private squareState[,] sqSTATE;
        private squareTrigger[,] sqTRIGGER;
        internal bool[,] sqUNIT;
        internal WallItemManager wallItemManager;

        public virtualRoom(int roomID, bool isPublicroom)
        {
            string str;
            DataRow row;
            DatabaseClient client;
            DataTable table;
            this.roomID = roomID;
            this.isPublicroom = isPublicroom;
            using (client = Eucalypt.dbManager.GetClient())
            {
                str = client.getString("SELECT model FROM rooms WHERE id = '" + roomID + "'");
                row = client.getRow("SELECT door_x,door_y,door_h,door_z,heightmap,publicroom_items, swimmingpool FROM room_modeldata WHERE model = '" + str + "'");
            }
            this.doorX = Convert.ToInt32(row["door_x"]);
            this.doorY = Convert.ToInt32(row["door_y"]);
            this.doorH = Convert.ToInt32(row["door_h"]);
            this.doorZ = Convert.ToByte(row["door_z"]);
            this._Heightmap = Convert.ToString(row["heightmap"]);
            string[] strArray = this._Heightmap.Split(new char[] { Convert.ToChar(13) });
            int length = strArray[0].Length;
            int num2 = strArray.Length - 1;
            this.sqSTATE = new squareState[length, num2];
            this.sqFLOORHEIGHT = new byte[length, num2];
            this.sqITEMROT = new byte[length, num2];
            this.sqITEMHEIGHT = new double[length, num2];
            this.sqUNIT = new bool[length, num2];
            this.sqSTACK = new furnitureStack[length, num2];
            this.sqTRIGGER = new squareTrigger[length, num2];
            for (int i = 0; i < num2; i++)
            {
                for (int j = 0; j < length; j++)
                {
                    string s = strArray[i].Substring(j, 1).Trim().ToLower();
                    if (s == "x")
                    {
                        this.sqSTATE[j, i] = squareState.Blocked;
                    }
                    else
                    {
                        this.sqSTATE[j, i] = squareState.Open;
                        try
                        {
                            this.sqFLOORHEIGHT[j, i] = byte.Parse(s);
                        }
                        catch
                        {
                        }
                    }
                }
            }
            if (isPublicroom)
            {
                string[] strArray2 = Convert.ToString(row["publicroom_items"]).Split("\n".ToCharArray());
                for (int k = 0; k < strArray2.Length; k++)
                {
                    string[] strArray3 = strArray2[k].Split(new char[] { ' ' });
                    int num6 = int.Parse(strArray3[2]);
                    int num7 = int.Parse(strArray3[3]);
                    squareState state = (squareState) int.Parse(strArray3[6]);
                    this.sqSTATE[num6, num7] = state;
                    if (state == squareState.Seat)
                    {
                        this.sqITEMROT[num6, num7] = byte.Parse(strArray3[5]);
                        this.sqITEMHEIGHT[num6, num7] = 1.0;
                    }
                    object obj2 = this._publicroomItems;
                    this._publicroomItems = string.Concat(new object[] { obj2, strArray3[0], " ", strArray3[1], " ", strArray3[2], " ", strArray3[3], " ", strArray3[4], " ", strArray3[5], Convert.ToChar(13) });
                }
                using (client = Eucalypt.dbManager.GetClient())
                {
                    table = client.getTable("SELECT object,x,y,goalx,goaly,stepx,stepy,roomid,state FROM room_modeldata_triggers WHERE model = '" + str + "'");
                }
                foreach (DataRow row2 in table.Rows)
                {
                    this.sqTRIGGER[Convert.ToInt32(row2["x"]), Convert.ToInt32(row2["y"])] = new squareTrigger(Convert.ToString(row2["object"]), Convert.ToInt32(row2["goalx"]), Convert.ToInt32(row2["goaly"]), Convert.ToInt32(row2["stepx"]), Convert.ToInt32(row2["stepy"]), Convert.ToInt32(row2["state"]) == 1, Convert.ToInt32(row2["roomid"]));
                }
                bool flag = false;
                using (client = Eucalypt.dbManager.GetClient())
                {
                    flag = client.findsResult("SELECT specialcast_interval FROM room_modeldata WHERE model = '" + str + "' AND specialcast_interval > 0");
                }
                if (flag)
                {
                    this.specialCastHandler = new Thread(new ParameterizedThreadStart(this.handleSpecialCasts));
                    this.specialCastHandler.Priority = ThreadPriority.Lowest;
                    this.specialCastHandler.Start(str);
                }
                using (client = Eucalypt.dbManager.GetClient())
                {
                    int num8;
                    this.hasSwimmingPool = int.TryParse(Convert.ToString(row["swimmingpool"]), out num8);
                    flag = client.findsResult("SELECT id FROM games_lobbies WHERE id = '" + roomID + "'");
                }
                if (flag)
                {
                    using (client = Eucalypt.dbManager.GetClient())
                    {
                        row = client.getRow("SELECT type,rank FROM games_lobbies WHERE id = '" + roomID + "'");
                    }
                    this.Lobby = new gameLobby(this, Convert.ToString(row["type"]) == "bb", Convert.ToString(row["rank"]));
                }
            }
            else
            {
                this.floorItemManager = new FloorItemManager(this);
                this.wallItemManager = new WallItemManager(this);
                using (client = Eucalypt.dbManager.GetClient())
                {
                    table = client.getTable("SELECT furniture.id, furniture.tid, furniture.x, furniture.y, furniture.z, furniture.h, furniture.var, furniture.wallpos FROM rooms, furniture WHERE furniture.roomid = rooms.id AND rooms.id = '" + roomID + "' ORDER BY rooms.id ASC");
                }
                foreach (DataRow row2 in table.Rows)
                {
                    if (Convert.ToString(row2["wallpos"]) == "")
                    {
                        this.floorItemManager.addItem(Convert.ToInt32(row2["id"]), Convert.ToInt32(row2["tid"]), Convert.ToInt32(row2["x"]), Convert.ToInt32(row2["y"]), Convert.ToInt32(row2["z"]), Convert.ToDouble(row2["h"]), Convert.ToString(row2["var"]));
                    }
                    else
                    {
                        this.wallItemManager.addItem(Convert.ToInt32(row2["id"]), Convert.ToInt32(row2["tid"]), Convert.ToString(row2["wallpos"]), Convert.ToString(row2["var"]), false);
                    }
                }
            }
            this._Users = new Hashtable();
            this._Bots = new Hashtable();
            this.loadBots();
            this._activeGroups = new HashSet<int>();
            this._statusUpdates = new StringBuilder();
            this._statusHandler = new Thread(new ThreadStart(this.cycleStatuses));
            this._statusHandler.Start();
            this.sqSTATE[this.doorX, this.doorY] = squareState.Open;
        }

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

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

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

        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
                {
                    try
                    {
                        this.specialCastHandler.Abort();
                    }
                    catch
                    {
                    }
                    if (this.Lobby != null)
                    {
                        this.Lobby.Clear();
                    }
                    this.Lobby = null;
                }
                roomManager.removeRoom(this.roomID);
                this._statusHandler.Abort();
            }
            catch
            {
            }
        }

        private void cycleStatuses()
        {
            List<int> list = new List<int>();
            while (true)
            {
                squareState[,] stateArray;
                int[] numArray;
                int num;
                int num2;
                double num3;
                try
                {
                    foreach (virtualRoomUser user in this._Users.Values)
                    {
                        if (user.goalX == -1)
                        {
                            continue;
                        }
                        stateArray = (squareState[,]) this.sqSTATE.Clone();
                        try
                        {
                            if ((stateArray[user.goalX, user.goalY] == squareState.Seat) || (stateArray[user.goalX, user.goalY] == squareState.Bed))
                            {
                                stateArray[user.goalX, user.goalY] = squareState.Open;
                            }
                            if (this.sqUNIT[user.goalX, user.goalY])
                            {
                                stateArray[user.goalX, user.goalY] = squareState.Blocked;
                            }
                        }
                        catch
                        {
                        }
                        numArray = new Pathfinder(stateArray, this.sqFLOORHEIGHT, this.sqUNIT).getNext(user.X, user.Y, user.goalX, user.goalY);
                        user.statusManager.removeStatus("mv");
                        if (numArray == null)
                        {
                            user.goalX = -1;
                            if (this.sqTRIGGER[user.X, user.Y] != null)
                            {
                                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 != "") && trigger.Object.Contains("Splash"))
                                    {
                                        this.sendData("AG" + trigger.Object);
                                        if (trigger.Object.Substring(8) == "enter")
                                        {
                                            user.statusManager.dropCarrydItem();
                                            user.statusManager.addStatus("swim", "");
                                        }
                                        else
                                        {
                                            user.statusManager.removeStatus("swim");
                                        }
                                        this.moveUser(user, trigger.stepX, trigger.stepY, false);
                                        user.goalX = trigger.goalX;
                                        user.goalY = trigger.goalY;
                                    }
                                }
                            }
                            else if (user.walkDoor)
                            {
                                if (this._Users.Count <= 1)
                                {
                                    this.removeUser(user.roomUID, true, "");
                                    return;
                                }
                                this.removeUser(user.roomUID, true, "");
                                continue;
                            }
                            this._statusUpdates.Append(user.statusString + Convert.ToChar(13));
                        }
                        else
                        {
                            num = numArray[0];
                            num2 = numArray[1];
                            squareState state = this.sqSTATE[num, num2];
                            this.sqUNIT[user.X, user.Y] = false;
                            this.sqUNIT[num, num2] = true;
                            user.Z1 = Rotation.Calculate(user.X, user.Y, num, num2);
                            user.Z2 = user.Z1;
                            user.statusManager.removeStatus("sit");
                            user.statusManager.removeStatus("lay");
                            num3 = 0.0;
                            if (state == squareState.Rug)
                            {
                                num3 = this.sqITEMHEIGHT[num, num2];
                            }
                            else
                            {
                                num3 = this.sqFLOORHEIGHT[num, num2];
                            }
                            user.statusManager.addStatus("mv", string.Concat(new object[] { num, ",", num2, ",", num3.ToString().Replace(',', '.') }));
                            this._statusUpdates.Append(user.statusString + Convert.ToChar(13));
                            user.X = num;
                            user.Y = num2;
                            user.H = num3;
                            switch (state)
                            {
                                case squareState.Seat:
                                    user.statusManager.removeStatus("dance");
                                    user.Z1 = this.sqITEMROT[num, num2];
                                    user.Z2 = user.Z1;
                                    user.statusManager.addStatus("sit", this.sqITEMHEIGHT[num, num2].ToString().Replace(',', '.'));
                                    break;

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

        ~virtualRoom()
        {
            Out.WriteLine(".", Out.logFlags.ImportantAction, ConsoleColor.Cyan, ConsoleColor.DarkCyan);
        }

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

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

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

        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;
                string str2;
                bool flag;
                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 = "";
                goto Label_01E4;
            Label_0098:
                str2 = "";
                int num4 = new Random().Next(minValue, num3 + 1);
                if (this.emitter == "cam1")
                {
                    int num5;
                    switch (num4)
                    {
                        case 1:
                            num5 = this.getRandomRoomIdentifier();
                            if (num5 != -1)
                            {
                                str2 = "targetcamera " + num5;
                            }
                            goto Label_019E;

                        case 2:
                            str2 = "setcamera 1";
                            goto Label_019E;

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

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

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

        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 = new virtualBot(numArray[i], this.getFreeRoomIdentifier(), this);
                bot.H = this.sqFLOORHEIGHT[bot.X, bot.Y];
                this.sqUNIT[bot.X, bot.Y] = true;
                this._Bots.Add(bot.roomUID, bot);
                this.sendData(@"@\" + bot.detailsString);
                this.sendData("@b" + bot.statusString);
            }
        }

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

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

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

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

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

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

        internal void removeUser(int roomUID, bool sendKick, string moderatorMessage)
        {
            if (!this._Users.Contains(roomUID))
            {
                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
                {
                    try
                    {
                        this.specialCastHandler.Abort();
                    }
                    catch
                    {
                    }
                    if (this.Lobby != null)
                    {
                        this.Lobby.Clear();
                    }
                    this.Lobby = null;
                }
                roomManager.removeRoom(this.roomID);
                this._statusHandler.Abort();
                return;
            }
            if (user.User._groupID <= 0)
            {
                goto Label_0275;
            }
            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_0254;
                    }
                }
            }
            catch
            {
            }
        Label_0254:
            if (flag)
            {
                this._activeGroups.Remove(user.User._groupID);
            }
        Label_0275:
            this.sendData("@]" + roomUID);
            roomManager.updateRoomVisitorCount(this.roomID, this._Users.Count);
        }

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

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

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

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

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

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

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

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

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

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

        internal void sendShout(virtualRoomUser sourceUser, string Message)
        {
            this.checkEmotion(sourceUser, Message);
            if (sourceUser.isTyping)
            {
                this.sendData("Ei" + Encoding.encodeVL64(sourceUser.roomUID) + "H");
                sourceUser.isTyping = false;
            }
            sourceUser.statusManager.handleStatus("talk", "", Message.Length * 190);
            string data = string.Concat(new object[] { "@Z", Encoding.encodeVL64(sourceUser.roomUID), Message, Convert.ToChar(2) });
            Hashtable hashtable = new Hashtable();
            hashtable = (Hashtable) this._Users.Clone();
            foreach (virtualRoomUser user in hashtable.Values)
            {
                this._statusUpdates.Append(user.statusString + Convert.ToChar(13));
                user.User.sendData(data);
            }
            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);
                    }
                }
            }
        }

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

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

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

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

        internal void unmuteUsers(byte casterRank)
        {
            string data = "BK" + stringManager.getString("scommand_unmuted");
            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(data);
                    }
                }
            }
            catch
            {
            }
        }

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

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

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

        internal string Groups
        {
            get
            {
                DataTable table;
                StringBuilder builder = new StringBuilder(Encoding.encodeVL64(this._activeGroups.Count));
                StringBuilder builder2 = new StringBuilder();
                foreach (int num in this._activeGroups)
                {
                    builder2.Append(" OR id = '" + num + "'");
                }
                builder2.Append(" OR");
                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)
                {
                    builder.Append(Encoding.encodeVL64(Convert.ToInt32(row["id"])) + Convert.ToString(row["badge"]) + Convert.ToChar(2));
                }
                return builder.ToString();
            }
        }

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

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

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

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

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

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

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

            internal void addItem(int itemID, int templateID, int X, int Y, int Z, double H, string Var)
            {
                try
                {
                    catalogueManager.itemTemplate template = catalogueManager.getTemplate(templateID);
                    if (stringManager.getStringPart(template.Sprite, 0, 13) == "sound_machine")
                    {
                        this.soundMachineID = itemID;
                    }
                    int length = 0;
                    int width = 0;
                    if ((Z == 2) || (Z == 6))
                    {
                        length = template.Length;
                        width = template.Width;
                    }
                    else
                    {
                        length = template.Width;
                        width = template.Length;
                    }
                    for (int i = X; i < (X + width); i++)
                    {
                        for (int j = Y; j < (Y + length); j++)
                        {
                            virtualRoom.furnitureStack stack = this._Room.sqSTACK[i, j];
                            if (stack == null)
                            {
                                if ((template.typeID != 2) && (template.typeID != 3))
                                {
                                    stack = new virtualRoom.furnitureStack();
                                    stack.Add(itemID);
                                }
                            }
                            else
                            {
                                stack.Add(itemID);
                            }
                            this._Room.sqSTATE[i, j] = (virtualRoom.squareState) template.typeID;
                            if ((template.typeID == 2) || (template.typeID == 3))
                            {
                                this._Room.sqITEMHEIGHT[i, j] = H + template.topH;
                                this._Room.sqITEMROT[i, j] = Convert.ToByte(Z);
                            }
                            else if (template.typeID == 4)
                            {
                                this._Room.sqITEMHEIGHT[i, j] = H;
                            }
                            this._Room.sqSTACK[i, j] = stack;
                        }
                    }
                    if (template.isDoor)
                    {
                        if (this._Room.squareBlocked(X, Y, length, width))
                        {
                            return;
                        }
                        if (Var.ToLower() == "c")
                        {
                            this._Room.setSquareState(X, Y, length, width, virtualRoom.squareState.Blocked);
                        }
                        else if (Var.ToLower() == "o")
                        {
                            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);
                    this._Items.Add(itemID, item);
                }
                catch (Exception exception)
                {
                    Out.WriteError("[" + exception.Source + "] Exception Error - " + exception.Message);
                }
            }

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

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

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

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

                                        case virtualRoom.squareState.Blocked:
                                        {
                                            if (this._Room.sqSTACK[num5, num6] == null)
                                            {
                                                return;
                                            }
                                            item = (floorItem) this._Items[this._Room.sqSTACK[num5, num6].topItemID()];
                                            catalogueManager.itemTemplate template2 = catalogueManager.getTemplate(item.templateID);
                                            if (((template2.topH == 0.0) || (template2.typeID == 2)) || (template2.typeID == 3))
                                            {
                                                return;
                                            }
                                            if ((item.H + template2.topH) > h)
                                            {
                                                h = item.H + template2.topH;
                                            }
                                            break;
                                        }
                                        default:
                                        {
                                            if ((state != virtualRoom.squareState.Rug) || (this._Room.sqSTACK[num5, num6] == null))
                                            {
                                                return;
                                            }
                                            double num7 = ((floorItem) this._Items[this._Room.sqSTACK[num5, num6].topItemID()]).H + 0.1;
                                            if (num7 > h)
                                            {
                                                h = num7;
                                            }
                                            break;
                                        }
                                    }
                                    num6++;
                                }
                            }
                            if (h > Config.Items_Stacking_maxHeight)
                            {
                                h = Config.Items_Stacking_maxHeight;
                            }
                            for (num5 = X; num5 < (X + width); num5++)
                            {
                                for (num6 = Y; num6 < (Y + length); num6++)
                                {
                                    virtualRoom.furnitureStack stack = null;
                                    if (this._Room.sqSTACK[num5, num6] == null)
                                    {
                                        if (((template.typeID == 1) && (template.topH > 0.0)) || (template.typeID == 4))
                                        {
                                            stack = new virtualRoom.furnitureStack();
                                            stack.Add(itemID);
                                        }
                                    }
                                    else
                                    {
                                        stack = this._Room.sqSTACK[num5, num6];
                                        stack.Add(itemID);
                                    }
                                    this._Room.sqSTATE[num5, num6] = (virtualRoom.squareState) template.typeID;
                                    this._Room.sqSTACK[num5, num6] = stack;
                                    if ((template.typeID == 2) || (template.typeID == 3))
                                    {
                                        this._Room.sqITEMHEIGHT[num5, num6] = h + template.topH;
                                        this._Room.sqITEMROT[num5, num6] = Z;
                                        this._Room.sqITEMROT[num5, num6] = Z;
                                        if ((template.typeID == 3) && ((num5 != X) || (num6 != Y)))
                                        {
                                            if (width == 1)
                                            {
                                                this._Room.sqSTATE[num5, num6] = virtualRoom.squareState.Blocked;
                                            }
                                            else if (((Z == 2) && (num5 != X)) || ((Z == 0) && (num6 != Y)))
                                            {
                                                this._Room.sqSTATE[num5, num6] = virtualRoom.squareState.Blocked;
                                            }
                                        }
                                    }
                                    else if (template.typeID == 4)
                                    {
                                        this._Room.sqITEMHEIGHT[num5, num6] = h;
                                    }
                                }
                            }
                            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" }));
                            }
                            floorItem item2 = new floorItem(itemID, templateID, X, Y, Z, h, str);
                            this._Items.Add(itemID, item2);
                            this._Room.sendData("A]" + item2.ToString());
                            if (flag)
                            {
                                this.soundMachineID = itemID;
                            }
                        }
                    }
                    catch
                    {
                    }
                }
            }

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

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

                                        case 4:
                                            this._Room.sqITEMHEIGHT[i, j] = item3.H;
                                            break;
                                    }
                                }
                                stack.Remove(itemID);
                                this._Room.sqSTACK[i, j] = stack;
                            }
                            else
                            {
                                this._Room.sqSTATE[i, j] = virtualRoom.squareState.Open;
                                this._Room.sqITEMHEIGHT[i, j] = 0.0;
                                this._Room.sqITEMROT[i, j] = 0;
                                this._Room.sqSTACK[i, j] = null;
                            }
                            if ((template.typeID == 2) || (template.typeID == 3))
                            {
                                this._Room.refreshCoord(i, j);
                            }
                        }
                    }
                    if ((this.soundMachineID == 0) && (stringManager.getStringPart(template.Sprite, 0, 13) == "sound_machine"))
                    {
                        this.soundMachineID = 0;
                    }
                    this._Room.sendData("A^" + itemID);
                    this._Items.Remove(itemID);
                    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() != itemID))
                        {
                        }
                    }
                }
            }

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

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

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

            internal furnitureStack()
            {
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            internal void addItem(int itemID, int templateID, string wallPosition, string Var, bool Place)
            {
                if (!this._Items.Contains(itemID))
                {
                    wallItem item = new wallItem(itemID, templateID, wallPosition, Var);
                    this._Items.Add(itemID, item);
                    if (Place)
                    {
                        this._Room.sendData("AS" + item.ToString());
                        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 = Encoding.encodeVL64(3) + 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, Encoding.encodeVL64(i), Encoding.encodeVL64(Convert.ToInt32(strArray2[0])), strArray2[1], Convert.ToChar(2), 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 num;
                DatabaseClient client;
                string str;
                DataRow row;
                using (client = Eucalypt.dbManager.GetClient())
                {
                    num = client.getInt("SELECT id FROM furniture_moodlight WHERE roomid ='" + roomID + "'");
                }
                if (!isEnabled)
                {
                    string str2;
                    using (client = Eucalypt.dbManager.GetClient())
                    {
                        str2 = client.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 (client = Eucalypt.dbManager.GetClient())
                    {
                        client.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", str, "' WHERE id ='", num, "' LIMIT 1" }));
                    }
                }
                else
                {
                    str = string.Concat(new object[] { "2,", presetID, ",", bgState, ",", presetColour, ",", alphaDarkF });
                    using (client = Eucalypt.dbManager.GetClient())
                    {
                        client.runQuery(string.Concat(new object[] { "UPDATE furniture SET var ='", str, "' WHERE id ='", num, "' LIMIT 1" }));
                        client.runQuery(string.Concat(new object[] { "UPDATE furniture_moodlight SET preset_cur ='", presetID, "',preset_", presetID, " ='", bgState, ",", presetColour, ",", alphaDarkF, "' WHERE id = '", num, "' LIMIT 1" }));
                    }
                }
                using (client = Eucalypt.dbManager.GetClient())
                {
                    row = client.getRow("SELECT wallpos,var FROM furniture WHERE id = '" + num + "'");
                }
                string wallPosition = Convert.ToString(row["wallpos"]);
                this.refreshWallitem(num, "roomdimmer", wallPosition, Convert.ToString(row["var"]));
            }

            internal void refreshWallitem(int itemID, string cctName, string wallPosition, string itemVariable)
            {
                this._Room.sendData(string.Concat(new object[] { "AU", itemID, Convert.ToChar(9), cctName, Convert.ToChar(9), " ", wallPosition, Convert.ToChar(9), itemVariable }));
            }

            internal void removeItem(int itemID, int ownerID)
            {
                if (this._Items.ContainsKey(itemID))
                {
                    this._Room.sendData("AT" + itemID);
                    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' 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))
                {
                    wallItem item = (wallItem) this._Items[itemID];
                    string sprite = item.Sprite;
                    if ((((sprite != "roomdimmer") && (sprite != "post.it")) && ((sprite != "post.it.vd") && (sprite != "poster"))) && !(sprite == "habbowheel"))
                    {
                        item.Var = toStatus.ToString();
                        this._Room.sendData(string.Concat(new object[] { "AU", itemID, Convert.ToChar(9), sprite, Convert.ToChar(9), " ", item.wallPosition, Convert.ToChar(9), item.Var }));
                        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();
                    try
                    {
                        foreach (wallItem item in this._Items.Values)
                        {
                            builder.Append(item.ToString() + Convert.ToChar(13));
                        }
                    }
                    catch
                    {
                    }
                    return builder.ToString();
                }
            }
        }
    }
}