namespace Holo.Virtual.Users
{
    using Holo;
    using Holo.Catalogue.Marketplace;
    using Holo.Managers;
    using Holo.marketManager;
    using Holo.Source.GameConnectionSystem;
    using Holo.Source.Managers;
    using Holo.Source.Managers.User;
    using Holo.Source.Socket_servers.Game_Socketsystem;
    using Holo.Virtual.Rooms;
    using Holo.Virtual.Rooms.Games;
    using Holo.Virtual.Rooms.Items;
    using Holo.Virtual.Rooms.Pathfinding;
    using Holo.Virtual.Users.Items;
    using Holo.Virtual.Users.Messenger;
    using Ion.Storage;
    using Microsoft.VisualBasic;
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Data;
    using System.Globalization;
    using System.Runtime.CompilerServices;
    using System.Text;
    using System.Threading;
    using Holo.Virtual.Rooms.Pets;

    public class virtualUser
    {
        internal bool _activateBuy;
        internal List<string> _Badges = new List<string>();
        internal List<int> _badgeSlotIDs = new List<int>();
        internal bool _blockCFH;
        internal bool _clean;
        internal bool _clubMember;
        private gameConnection _ConnectionManager;
        internal int _Credits;
        internal string _Figure;
        internal List<string> _fuserights;
        internal int _groupID;
        internal int _groupMemberRank;
        internal int _guideCount = -1;
        internal int _guideFinish = -1;
        internal int _guideRequest = -1;
        internal int _guideRoom = -1;
        internal bool _guideSearch;
        private int _handPage;
        internal bool _hasRights;
        internal bool _hostsEvent;
        internal bool _inPublicroom;
        internal bool _isDisconnected;
        internal bool _isGuide;
        public bool _isLoggedIn;
        internal bool _isMuted;
        internal bool _isOwner;
        internal bool _isOwner2;
        internal bool _stackRugs;
        internal int _Minuteperiod;
        internal string _Mission;
        internal string _mutedIDs;
        internal int _Pixels;
        internal byte _Rank;
        private bool _receivedSpriteIndex;
        internal bool _ROOMACCESS_PRIMARY_OK;
        internal bool _ROOMACCESS_SECONDARY_OK;
        internal int _roomID;
        internal char _Sex;
        internal int _teleporterID;
        private Hashtable Statuses;
        internal int _teleporterRoomID;
        internal int _Tickets;
        internal string _TotalGamePoints;
        internal bool _tradeAccept;
        internal bool _noHeightLimit;
        internal bool _tradeConfirm;
        internal int _tradeItemCount;
        internal int[] _tradeItems = new int[0x41];
        internal int _tradePartnerRoomUID = -1;
        internal int _tradePartnerUID = -1;
        internal string _Username;
        private int BVPacketOverload;
        internal string currentPacket;
        internal Holo.Virtual.Rooms.Games.gamePlayer gamePlayer;
        //internal bool generatedOwnRooms;
        private messageHandler Handler;
        internal string Ipaddress = "";
        private bool IsPwnwd;
        internal virtualMessenger Messenger;
        internal bool ownRoomsUpdated = true;
        internal bool pingOK;
        private Thread PwnerThread;
        internal int Respect;
        internal virtualRoom Room;
        internal virtualPet Pet;
        internal virtualRoomUser roomUser;
        private string ShockwaveID;
        private virtualSongEditor songEditor;
        internal Coord[] spawnLoc = new Coord[] { new Coord(-1, -1), new Coord(-1, -1) };
        internal string spawnStatus = "";
        internal int statusCount;
        internal string statusID;
        internal virtualRoomUserStatusManager statusManager;
        internal int userID;
        internal int petID;
        internal int UserSearchID;

        public virtualUser(gameConnection ConnectionManager)
        {
            this._ConnectionManager = ConnectionManager;
        }

        internal void abortTrade()
        {
            if (((this.Room != null) && this.Room.containsUser(this._tradePartnerRoomUID)) && (this.roomUser != null))
            {
                virtualUser user = this.Room.getUser(this._tradePartnerRoomUID);
                this.sendData("An");
                this.refreshHand("update");
                user.sendData("An");
                user.refreshHand("update");
                this._tradePartnerRoomUID = -1;
                this._tradeAccept = false;
                this._tradeItems = new int[0x41];
                this._tradeItemCount = 0;
                this.statusManager.removeStatus("trd");
                this.roomUser.Refresh();
                user._tradePartnerRoomUID = -1;
                user._tradeAccept = false;
                user._tradeItems = new int[0x41];
                user._tradeItemCount = 0;
                user.statusManager.removeStatus("trd");
                user.roomUser.Refresh();
            }
        }

        private void cleanhand()
        {
            if (this._clean)
            {
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    client.runQuery("DELETE FROM furniture WHERE ownerid = '" + this.userID + "' AND roomid = '" + _roomID +"'");
                }
                this.refreshHand("update");
                this._clean = false;
            }
            else
            {
                this.sendData(string.Concat(new object[] { "BKIf you want to clear your whole hand please type the command again,", Convert.ToChar(13), "this command will remove every item from your inventory.", Convert.ToChar(13), Convert.ToChar(13), "WARNING: You are unable to restore or cancel the process!", Convert.ToChar(2) }));
                this._clean = true;
            }
        }

        private void delDisconnectTimed(int ms)
        {
            Thread.Sleep(ms);
            this.Disconnect();
        }

        internal void Disconnect()
        {
            this._ConnectionManager.Close();
        }

        internal void Disconnect(int ms)
        {
            new timedDisconnector(this.delDisconnectTimed).BeginInvoke(ms, null, null);
        }

        internal void GetAllRooms(int UserSearchID)
        {
            int RoomCount;
            DataTable dTable;
            DataColumn UsersInRoom;
            int FriendCount = 0;
            int CategoryID;
            int Trading;
            int RoomVote;
            int Icon;
            StringBuilder NavigatorContent = new StringBuilder();

            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
            {
                RoomCount = dbClient.getInt("SELECT count(id) FROM rooms WHERE level = '1'");
                dTable = dbClient.getTable("SELECT id,level,name,owner,state,visitors_now,visitors_max,description FROM rooms WHERE level = '1' ORDER BY id ASC");
                //dTable = dbClient.getTable("SELECT id,level,name,owner,state,visitors_now,visitors_max,description FROM rooms WHERE level = '1' ORDER BY visitors_now LIMIT 20");
                //RoomCount = dbClient.getInt("SELECT count(id) FROM rooms WHERE level = '1' LIMIT 50");

            }
            NavigatorContent.Append(Holo.Encoding.encodeVL64(UserSearchID));
            NavigatorContent.Append(Holo.Encoding.encodeVL64(5) + Convert.ToChar(2));
            NavigatorContent.Append(Holo.Encoding.encodeVL64(RoomCount));
            if (dTable.Rows.Count > 0)
            {
                foreach (DataRow dRow in dTable.Rows)
                {
                    NavigatorContent.Append(Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["id"])) + Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["level"])) + Convert.ToString(dRow["name"]) + Convert.ToChar(2) + Convert.ToString(dRow["owner"]) + Convert.ToChar(2) + Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["state"])) + Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["visitors_now"])) + Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["visitors_max"])) + Convert.ToString(dRow["description"]) + Convert.ToChar(2));

                    using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                    {
                        UsersInRoom = dbClient.getColumn("SELECT id FROM users WHERE roomid = '" + dRow["id"] + "' ORDER BY id ASC");
                        CategoryID = dbClient.getInt("SELECT category FROM rooms WHERE id = '" + dRow["id"] + "'");
                        Trading = dbClient.getInt("SELECT trading FROM room_categories WHERE id = '" + CategoryID + "'");
                        RoomVote = dbClient.getInt("SELECT count(vote)from room_votes WHERE id = '" + dRow["id"] + "'");
                        Icon = dbClient.getInt("SELECT room_icon FROM rooms WHERE id = '" + dRow["id"] + "'");
                    }

                    System.Collections.Hashtable deletedIDs = new System.Collections.Hashtable(UsersInRoom.Table.Rows.Count);
                    string FriendIDs = "";

                    foreach (DataRow FriendsRow in UsersInRoom.Table.Rows)
                    {
                        deletedIDs.Add(Convert.ToInt32(FriendsRow["id"]), Convert.ToInt32(FriendsRow["id"]));
                        FriendIDs += Convert.ToString(FriendsRow["id"]);

                        FriendIDs = FriendIDs.Substring(0, FriendIDs.Length);
                        if (FriendIDs.Length > 0)
                        {
                            if (Messenger.hasFriendship(Convert.ToInt32(FriendIDs)))
                            {
                                deletedIDs.Remove(Convert.ToInt32(FriendsRow["id"]));
                                FriendCount++;
                            }
                        }
                    }
                    NavigatorContent.Append(Holo.Encoding.encodeVL64(FriendCount));
                    if (Convert.ToString(Trading) == "10")
                    {
                        NavigatorContent.Append(Holo.Encoding.encodeVL64(1));
                    }
                    else
                    {
                        NavigatorContent.Append(Holo.Encoding.encodeVL64(UserSearchID));
                        NavigatorContent.Append(Holo.Encoding.encodeVL64(5) + Convert.ToChar(2));
                        NavigatorContent.Append(Holo.Encoding.encodeVL64(RoomVote) + Holo.Encoding.encodeVL64(0) + Holo.Encoding.encodeVL64(Icon) + Holo.Encoding.encodeVL64(0) + Convert.ToChar(2));
                    }
                        NavigatorContent.Append(Holo.Encoding.encodeVL64(RoomVote) + Holo.Encoding.encodeVL64(0) + Holo.Encoding.encodeVL64(Icon) + Holo.Encoding.encodeVL64(0) + Convert.ToChar(2));
                }
            }
            else
            {
                NavigatorContent.Append(Holo.Encoding.encodeVL64(0));
            }
            sendData("GC" + NavigatorContent);
        }

        internal void ProcessPacketFu()
        {
            string[] strArray;
            string packet = "@D";
            string str2 = "";
            string str3 = "";
            string str4 = "";
            int i = 0;
            int num2 = 0;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                string val = this.currentPacket.Substring(4).Replace(@"\", @"\").Replace("'", @"\'");
                client.AddParamWithValue("search", val);
                strArray = dataHandling.dColToArray(client.getColumn("SELECT id FROM rooms WHERE name LIKE '" + val + "%' LIMIT 20 "));
            }
            for (int j = 0; j < strArray.Length; j++)
            {
                DataRow row;
                int userID = Convert.ToInt32(strArray[j]);
                bool flag = userManager.containsUser(userID);
                string str6 = flag ? "I" : "H";
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    row = client2.getRow("SELECT name FROM rooms WHERE id = " + userID.ToString());
                }
                str4 = string.Concat(new object[] { Holo.Encoding.encodeVL64(userID), row[0], "\x0002", row[1], "\x0002", str6, str6, "\x0002", str6, flag ? row[3] : "", "\x0002", flag ? "" : row[2], "\x0002" });
                if (this.Messenger.hasFriendship(userID))
                {
                    i++;
                    str2 = str2 + str4;
                }
                else
                {
                    num2++;
                    str3 = str3 + str4;
                }
            }
            str2 = Holo.Encoding.encodeVL64(i) + str2;
            str3 = Holo.Encoding.encodeVL64(num2) + str3;
            packet = packet + str2 + str3;
            this.sendData(packet);
        }

        internal void GetFavourites(int UserSearchID)
        {
            int RoomCount;
            DataTable dTable;
            DataColumn UsersInRoom;
            int FriendCount = 0;
            int CategoryID;
            int Trading;
            int RoomVote;
            int Icon;

            StringBuilder NavigatorContent = new StringBuilder();

            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
            {
                //RoomCount = dbClient.getInt("SELECT count(id) FROM rooms WHERE level = '1'");
                //dTable = dbClient.getTable("SELECT id,level,name,owner,state,visitors_now,visitors_max,description FROM rooms WHERE level = '1' ORDER BY id ASC");
                //dTable = dbClient.getTable("SELECT id,level,name,owner,state,visitors_now,visitors_max,description FROM rooms WHERE level = '1' ORDER BY visitors_now LIMIT 20");
                //RoomCount = dbClient.getInt("SELECT count(id) FROM rooms WHERE level = '1' LIMIT 50");
                RoomCount = dbClient.getInt("SELECT roomid FROM users_favourites WHERE userid = '" + this.userID + "'");
                dTable = dbClient.getTable("SELECT count(roomid) FROM users_favourites WHERE userid = '" + this.userID + "'");

            }
            NavigatorContent.Append(Holo.Encoding.encodeVL64(UserSearchID));
            NavigatorContent.Append(Holo.Encoding.encodeVL64(5) + Convert.ToChar(2));
            NavigatorContent.Append(Holo.Encoding.encodeVL64(RoomCount));
            if (dTable.Rows.Count > 0)
            {
                foreach (DataRow dRow in dTable.Rows)
                {
                    NavigatorContent.Append(Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["id"])) + Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["level"])) + Convert.ToString(dRow["name"]) + Convert.ToChar(2) + Convert.ToString(dRow["owner"]) + Convert.ToChar(2) + Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["state"])) + Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["visitors_now"])) + Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["visitors_max"])) + Convert.ToString(dRow["description"]) + Convert.ToChar(2));

                    using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                    {
                        UsersInRoom = dbClient.getColumn("SELECT id FROM users WHERE roomid = '" + dRow["id"] + "' ORDER BY id ASC");
                        CategoryID = dbClient.getInt("SELECT category FROM rooms WHERE id = '" + dRow["id"] + "'");
                        Trading = dbClient.getInt("SELECT trading FROM room_categories WHERE id = '" + CategoryID + "'");
                        RoomVote = dbClient.getInt("SELECT count(vote)from room_votes WHERE id = '" + dRow["id"] + "'");
                        Icon = dbClient.getInt("SELECT room_icon FROM rooms WHERE id = '" + dRow["id"] + "'");
                    }

                    System.Collections.Hashtable deletedIDs = new System.Collections.Hashtable(UsersInRoom.Table.Rows.Count);
                    string FriendIDs = "";

                    foreach (DataRow FriendsRow in UsersInRoom.Table.Rows)
                    {
                        deletedIDs.Add(Convert.ToInt32(FriendsRow["id"]), Convert.ToInt32(FriendsRow["id"]));
                        FriendIDs += Convert.ToString(FriendsRow["id"]);

                        FriendIDs = FriendIDs.Substring(0, FriendIDs.Length);
                        if (FriendIDs.Length > 0)
                        {
                            if (Messenger.hasFriendship(Convert.ToInt32(FriendIDs)))
                            {
                                deletedIDs.Remove(Convert.ToInt32(FriendsRow["id"]));
                                FriendCount++;
                            }
                        }
                    }
                    NavigatorContent.Append(Holo.Encoding.encodeVL64(FriendCount));
                    if (Convert.ToString(Trading) == "10")
                    {
                        NavigatorContent.Append(Holo.Encoding.encodeVL64(1));
                    }
                    else
                    {
                        NavigatorContent.Append(Holo.Encoding.encodeVL64(UserSearchID));
                        NavigatorContent.Append(Holo.Encoding.encodeVL64(5) + Convert.ToChar(2));
                        NavigatorContent.Append(Holo.Encoding.encodeVL64(RoomVote) + Holo.Encoding.encodeVL64(0) + Holo.Encoding.encodeVL64(Icon) + Holo.Encoding.encodeVL64(0) + Convert.ToChar(2));
                    }
                    NavigatorContent.Append(Holo.Encoding.encodeVL64(RoomVote) + Holo.Encoding.encodeVL64(0) + Holo.Encoding.encodeVL64(Icon) + Holo.Encoding.encodeVL64(0) + Convert.ToChar(2));
                }
            }
            else
            {
                NavigatorContent.Append(Holo.Encoding.encodeVL64(0));
            }
            sendData("GC" + NavigatorContent);
        }


        internal static string GetGuestRoomCategories(byte userRank)
        {
            DataTable table;
            StringBuilder builder = new StringBuilder();
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                table = client.getTable("SELECT id,name FROM room_categories WHERE type = '2' AND parent > 0 AND access_rank_min <= " + userRank);
            }
            builder.Append(Holo.Encoding.encodeVL64(table.Rows.Count));
            foreach (DataRow row in table.Rows)
            {
                builder.Append(Holo.Encoding.encodeVL64(Convert.ToInt32(row["id"])) + row["name"] + Convert.ToChar(2));
            }
            return builder.ToString();
        }

        internal void GetHighestRated(int UserSearchID)
        {
            int num;
            int num2;
            int num3;
            DataTable table;
            int num9;
            StringBuilder builder = new StringBuilder();
            int i = 0;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                num = client.getInt("SELECT min(id) FROM rooms where publicroom = 0");
                num2 = client.getInt("SELECT max(id) FROM rooms where publicroom = 0");
                num3 = num;
            }
            do
            {
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    int num8 = client2.getInt("SELECT count(vote) FROM room_votes WHERE roomid = '" + num3 + "'");
                    client2.runQuery(string.Concat(new object[] { "UPDATE rooms SET votes = '", num8, "' WHERE id = '", num3, "'" }));
                }
                num3++;
            }
            while ((num3 >= num) && (num3 <= num2));
            using (DatabaseClient client3 = Eucalypt.dbManager.GetClient())
            {
                table = client3.getTable("SELECT id,level,name,owner,state,visitors_now,visitors_max,description,votes FROM rooms where publicroom = 0 ORDER BY votes DESC LIMIT 20");
                num9 = client3.getInt("SELECT count(id) FROM rooms where publicroom = 0");
            }
            builder.Append(Holo.Encoding.encodeVL64(UserSearchID) + Holo.Encoding.encodeVL64(2) + Convert.ToChar(2));
            builder.Append(Holo.Encoding.encodeVL64(num9));
            if (table.Rows.Count > 0)
            {
                foreach (DataRow row in table.Rows)
                {
                    DataColumn column;
                    int num5;
                    string str;
                    int num6;
                    builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(Convert.ToInt32(row["id"])), Holo.Encoding.encodeVL64(Convert.ToInt32(row["level"])), Convert.ToString(row["name"]), Convert.ToChar(2), Convert.ToString(row["owner"]), Convert.ToChar(2), Holo.Encoding.encodeVL64(Convert.ToInt32(row["state"])), Holo.Encoding.encodeVL64(Convert.ToInt32(row["visitors_now"])), Holo.Encoding.encodeVL64(Convert.ToInt32(row["visitors_max"])), Convert.ToString(row["description"]), Convert.ToChar(2) }));
                    using (DatabaseClient client4 = Eucalypt.dbManager.GetClient())
                    {
                        column = client4.getColumn("SELECT id FROM users WHERE roomid = '" + row["id"] + "'");
                        int num4 = client4.getInt("SELECT category FROM rooms WHERE id = '" + row["id"] + "'");
                        num5 = client4.getInt("SELECT trading FROM room_categories WHERE id = '" + num4 + "'");
                        str = client4.getString("SELECT name FROM room_categories WHERE id = '" + num4 + "'");
                        client4.getInt("SELECT count(vote)from room_votes WHERE id = '" + row["id"] + "'");
                        num6 = client4.getInt("SELECT icon FROM rooms WHERE id = '" + row["id"] + "'");
                    }
                    Hashtable hashtable = new Hashtable(column.Table.Rows.Count);
                    string str2 = "";
                    foreach (DataRow row2 in column.Table.Rows)
                    {
                        hashtable.Add(Convert.ToInt32(row2["id"]), Convert.ToInt32(row2["id"]));
                        str2 = str2 + Convert.ToString(row2["id"]);
                        str2 = str2.Substring(0, str2.Length);
                        if ((str2.Length > 0) && this.Messenger.hasFriendship(Convert.ToInt32(str2)))
                        {
                            hashtable.Remove(Convert.ToInt32(row2["id"]));
                            i++;
                        }
                    }
                    builder.Append(Holo.Encoding.encodeVL64(i));
                    if (Convert.ToString(num5) == "1")
                    {
                        builder.Append(Holo.Encoding.encodeVL64(1));
                    }
                    else
                    {
                        builder.Append(Holo.Encoding.encodeVL64(0));
                    }
                    builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(Convert.ToInt32(row["votes"])), "I", str, Convert.ToChar(2), Holo.Encoding.encodeVL64(num6), "HH" }));
                }
            }
            else
            {
                builder.Append(Holo.Encoding.encodeVL64(0));
            }
            this.sendData("GC" + builder);
        }
        private void whosonline()
        {
            //sendData(userManager.generateWhosOnline(rankManager.containsRight(ref _fuserights, _Rank, "fuse_administrator_access", userID)));
        }

        internal void GetOwnRooms(int UserSearchID)
        {
            int RoomCount;
            DataTable dTable;
            DataColumn UsersInRoom;
            int FriendCount = 0;
            int CategoryID;
            int Trading;
            int RoomVote;
            int Icon;

            StringBuilder NavigatorContent = new StringBuilder();

            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
            {
                RoomCount = dbClient.getInt("SELECT count(id) FROM rooms WHERE owner = '" + _Username + "'");
                dTable = dbClient.getTable("SELECT id,level,name,owner,state,visitors_now,visitors_max,description FROM rooms WHERE owner = '" + _Username + "' ORDER BY id ASC");
            }
            NavigatorContent.Append(Holo.Encoding.encodeVL64(UserSearchID));
            NavigatorContent.Append(Holo.Encoding.encodeVL64(5) + Convert.ToChar(2));
            NavigatorContent.Append(Holo.Encoding.encodeVL64(RoomCount));
            if (dTable.Rows.Count > 0)
            {
                foreach (DataRow dRow in dTable.Rows)
                {
                    NavigatorContent.Append(Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["id"])) + Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["level"])) + Convert.ToString(dRow["name"]) + Convert.ToChar(2) + Convert.ToString(dRow["owner"]) + Convert.ToChar(2) + Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["state"])) + Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["visitors_now"])) + Holo.Encoding.encodeVL64(Convert.ToInt32(dRow["visitors_max"])) + Convert.ToString(dRow["description"]) + Convert.ToChar(2));

                    using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                    {
                        UsersInRoom = dbClient.getColumn("SELECT id FROM users WHERE roomid = '" + dRow["id"] + "' ORDER BY id ASC");
                        CategoryID = dbClient.getInt("SELECT category FROM rooms WHERE id = '" + dRow["id"] + "'");
                        Trading = dbClient.getInt("SELECT trading FROM room_categories WHERE id = '" + CategoryID + "'");
                        RoomVote = dbClient.getInt("SELECT count(vote)from room_votes WHERE id = '" + dRow["id"] + "'");
                        Icon = dbClient.getInt("SELECT room_icon FROM rooms WHERE id = '" + dRow["id"] + "'");
                    }

                    System.Collections.Hashtable deletedIDs = new System.Collections.Hashtable(UsersInRoom.Table.Rows.Count);
                    string FriendIDs = "";

                    foreach (DataRow FriendsRow in UsersInRoom.Table.Rows)
                    {
                        deletedIDs.Add(Convert.ToInt32(FriendsRow["id"]), Convert.ToInt32(FriendsRow["id"]));
                        FriendIDs += Convert.ToString(FriendsRow["id"]);

                        FriendIDs = FriendIDs.Substring(0, FriendIDs.Length);
                        if (FriendIDs.Length > 0)
                        {
                            if (Messenger.hasFriendship(Convert.ToInt32(FriendIDs)))
                            {
                                deletedIDs.Remove(Convert.ToInt32(FriendsRow["id"]));
                                FriendCount++;
                            }
                        }
                    }
                    NavigatorContent.Append(Holo.Encoding.encodeVL64(FriendCount));
                    if (Convert.ToString(Trading) == "10")
                    {
                        NavigatorContent.Append(Holo.Encoding.encodeVL64(1));
                    }
                    else
                    {
                        NavigatorContent.Append(Holo.Encoding.encodeVL64(UserSearchID));
                        NavigatorContent.Append(Holo.Encoding.encodeVL64(5) + Convert.ToChar(2));
                        NavigatorContent.Append(Holo.Encoding.encodeVL64(RoomVote) + Holo.Encoding.encodeVL64(0) + Holo.Encoding.encodeVL64(Icon) + Holo.Encoding.encodeVL64(0) + Convert.ToChar(2));
                    }
                        NavigatorContent.Append(Holo.Encoding.encodeVL64(RoomVote) + Holo.Encoding.encodeVL64(0) + Holo.Encoding.encodeVL64(Icon) + Holo.Encoding.encodeVL64(0) + Holo.Encoding.encodeVL64(2));
                }
            }
            else
            {
                NavigatorContent.Append(Holo.Encoding.encodeVL64(0));
            }
            sendData("GC" + NavigatorContent);
        }

        internal void GotShockwaveID()
        {
            this.ShockwaveID = "";
        }

        private bool isSpeechCommand(string Text)
        {
            string[] args = Text.Split(' ');
            try // Try/catch, on error (eg, target user offline, parameters incorrect etc) then failure message will be sent
            {
                switch (args[0].ToLower()) // arg[0] = command itself
                {
                    #region Public commands
                    #region :comandi
                    case "comandi": //lista comandi utenti
                        {
                            sendData("BK" + "Ciao " + _Username + " Benvenuto nella lista comandi pubblici dell' hotel !\r" +
                            " \r" +
                            ":info (per vedere le info del server in uso)\r" +
                            " \r" +
                            ":nudo (per diventare nudo)\r" +
                            " \r" +
                            ":babbonatale (per diventare Babbo Natale)\r" +
                            " \r" +
                            ":invisibile (per diventare invisibile)\r" +
                            " \r" +
                            ":personeonline (visualizza le persone online)\r" +
                            " \r" +
                            ":puliscimano (elimina i furni nella tua mano)\r" +
                            " \r" +
                            ":pixel (ricarica di 5000 pixel)\r" +
                            " \r" +
                            ":pets (per i comandi per gli animali)\r" +
                            " \r" +
                            "Buon proseguimento e cordiali saluti dal Meethar Team!" + Convert.ToChar(2));


                            break;
                        }
                    #endregion
                    #region :info
                    case "info": // Display information about the emulator
                        {
                            sendData("BK" + "Meethar Emulator V46\r" +
                                "Il server e' stato codato da Kemix, Crax e Shinil35" + Convert.ToChar(2));

                            break;
                        }
                    #endregion
                    #region :personeonline
                    case "personeonline": // Generates a list of users connected
                        sendData(userManager.generateWhosOnline(rankManager.containsRight(this, "fuse_administrator_access", userID)));
                        break;
                    #endregion
                    #region :nudo
                    case "nudo": // ora sei nudo :O
                        {
                            using (DatabaseClient HuBBixDB = Eucalypt.dbManager.GetClient())
                            {
                                HuBBixDB.runQuery("UPDATE users SET figure = 'hd-180-4.hr-831-61' WHERE id = '" + userID + "'");
                                refreshAppearance(true, true, true, true);
                            }
                        }
                        break;
                    #endregion
                    #region :invisibile
                    case "invisibile": // ora sei invisibile :O
                        {
                            using (DatabaseClient HuBBixDB = Eucalypt.dbManager.GetClient())
                            {
                                HuBBixDB.runQuery("UPDATE users SET figure = 'fa-120' WHERE id = '" + userID + "'");
                                refreshAppearance(true, true, true, true);
                            }
                        }
                        break;
                    #endregion
                    #region :babbonatale
                    case "babbonatale": // Ohohohoh...
                        {
                            using (DatabaseClient frmfrm = Eucalypt.dbManager.GetClient())
                            {
                                frmfrm.runQuery("UPDATE users SET figure = 'hd-180-4.hr-828-61.ha-1006-.fa-1205-92.ch-255-96.lg-285-92.sh-300-96' WHERE id = '" + userID + "'");
                                refreshAppearance(true, true, true, true);
                            }
                        }
                        break;
                    #endregion
                    #region :puliscimano
                    case "puliscimano": // Deletes everything from the senders hand
                        {
                            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                            {
                                dbClient.runQuery("DELETE FROM furniture WHERE ownerid = '" + userID + "' AND roomid = '0'");
                            }
                            refreshHand("update");
                            break;
                        }
                    #endregion
                    #region :pixel
                    case "pixel":
                        {

                            _Pixels = _Pixels + 5000;
                            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                            {
                                dbClient.runQuery("UPDATE users SET pixels = '" + _Pixels + "' WHERE id = '" + userID + "' LIMIT 1");
                            }

                            sendData("Fv" + Holo.Encoding.encodeVL64(_Pixels) + "I");
                            sendData("You got 5000 pixels extra :O don't tell this secret command");
                            break;
                        }
                    #endregion
                    #region :energia
                    case "energia":
                        {                            
                            string nome = args[1];
                            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                            {
                                dbClient.runQuery("update users set credits = credits -10 where id = " + userID + "");
                                dbClient.runQuery("UPDATE pets SET energy = energy + 10 WHERE name = '" + nome + "' LIMIT 1");
                                refreshValueables(true, false);
                                sendData("BK" + "L'animale " + nome + " ha ricevuto 10 di energia" + Convert.ToChar(2));
                            }

                            break;
                        }
                    #endregion
                    #region :livello
                    case "livello":
                        {
                            string nome = args[1];
                            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                            {
                                dbClient.runQuery("update users set credits = credits -10 where id = " + userID + "");
                                dbClient.runQuery("UPDATE pets SET level = level + 1 WHERE name = '" + nome + "' LIMIT 1");
                                refreshValueables(true, false);
                                sendData("BK" + "L'animale " + nome + " ha ricevuto 1 di livello" + Convert.ToChar(2));
                            }

                            break;
                        }
                    #endregion
                    #region :nutrizione
                    case "nutrizione":
                        {
                            string nome = args[1];
                            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                            {
                                dbClient.runQuery("update users set credits = credits -10 where id = " + userID + "");
                                dbClient.runQuery("UPDATE pets SET satiety = satiety + 10 WHERE name = '" + nome + "' LIMIT 1");
                                refreshValueables(true, false);
                                sendData("BK" + "L'animale " + nome + " ha ricevuto 10 di sazietà" + Convert.ToChar(2));
                            }

                            break;
                        }
                    #endregion
                    #region :esperienza
                    case "esperienza":
                        {
                            string nome = args[1];
                            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                            {
                                dbClient.runQuery("update users set credits = credits -10 where id = " + userID + "");
                                dbClient.runQuery("UPDATE pets SET experience = experience + 10 WHERE name = '" + nome + "' LIMIT 1");
                                refreshValueables(true, false);
                                sendData("BK" + "L'animale " + nome + " ha ricevuto 10 di esperienza" + Convert.ToChar(2));
                            }

                            break;
                        }
                    #endregion
                    #region :pets
                    case "pets": //lista comandi Animale
                        {
                            sendData("BK" + "Ciao " + _Username + " Ecco la lista dei comandi per gli Animali!\r" +
                            " \r" +
                            ":livello (nome) (per aumentare il livello dell' animale)\r" +
                            " \r" +
                            ":energia (nome) (per aumentare l'energia dell' animale)\r" +
                            " \r" +
                            ":esperienza (nome) (per aumentare l'esperienza dell' animale)\r" +
                            " \r" +
                            ":nutrizione (nome) (per aumentare la sazietà dell' animale)\r" +
                            " \r" +
                            "Buon proseguimento e cordiali saluti dal Meethar Team!" + Convert.ToChar(2));
                            break;
                        }
                    #endregion
                    #region comportamenti pets
                    case "hopp":
                        {
                            Statuses.Remove("sit");
                            Statuses.Remove("ded");
                            Pet.addStatus("jmp", "");
                            break;
                        }
                    #endregion

                    #endregion
                    #region Moderacy commands
                    #region :alert
                    case "alert": // Alert a virtual user
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_alert", userID) == false)
                                return false;
                            else
                            {
                                int _userID = userManager.getUserID(args[1]);
                                virtualUser Target = userManager.getUser(_userID);
                                string Message = stringManager.wrapParameters(args, 2);

                                Target.sendData("B!" + Message + Convert.ToChar(2));
                                sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                                staffManager.addStaffMessage("alert", userID, Target.userID, args[2], "");
                            }
                            break;
                        }
                    #endregion
                    #region :roomalert
                    case "roomalert": // Alert all virtual users in current virtual room
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_room_alert", userID) == false)
                                return false;
                            else
                            {
                                string Message = Text.Substring(10);
                                Room.sendData("B!" + Message + Convert.ToChar(2));
                                staffManager.addStaffMessage("ralert", userID, Room.roomID, Message, "");
                            }
                            break;
                        }
                    #endregion
                    #region :kick
                    case "kick": // Kicks a virtual user from room
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_kick", userID) == false)
                                return false;
                            else
                            {
                                int _userID = userManager.getUserID(args[1]);
                                virtualUser Target = userManager.getUser(_userID);
                                if (Target._Rank < this._Rank)
                                {
                                    string Message = "";
                                    if (args.Length > 2) // Reason supplied
                                        Message = stringManager.wrapParameters(args, 2);

                                    Target.Room.removeUser(Target.roomUser.roomUID, true, Message);
                                    sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                                    staffManager.addStaffMessage("kick", userID, Target.userID, Message, "");
                                }
                                else
                                    sendData("BK" + stringManager.getString("scommand_failed") + Convert.ToChar(2));
                            }
                            break;
                        }
                    #endregion
                    #region :roomkick
                    case "roomkick": // Kicks all virtual users below rank from virtual room
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_room_kick", userID) == false)
                                return false;
                            else
                            {
                                string Message = stringManager.wrapParameters(args, 1);
                                Room.kickUsers(_Rank, Message);
                                sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                                staffManager.addStaffMessage("rkick", userID, Room.roomID, Message, "");
                            }
                            break;
                        }
                    #endregion
                    #region :shutup/:unmute
                    case "shutup": // Mutes a virtual user (disabling it from chat)
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_mute", userID) == false)
                                return false;
                            else
                            {
                                int _userID = userManager.getUserID(args[1]);
                                virtualUser Target = userManager.getUser(_userID);
                                if (Target._Rank < _Rank && Target._isMuted == false)
                                {
                                    string Message = stringManager.wrapParameters(args, 2);
                                    Target._isMuted = true;
                                    Target.sendData("BK" + stringManager.getString("scommand_muted") + "\r" + Message + Convert.ToChar(2));
                                    sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                                    staffManager.addStaffMessage("mute", userID, Target.userID, Message, "");
                                }
                                else
                                    sendData("BK" + stringManager.getString("scommand_failed") + Convert.ToChar(2));
                            }
                            break;
                        }

                    case "unmute": // Unmutes a virtual user (enabling it to chat again)
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_mute", userID) == false)
                                return false;
                            else
                            {
                                int _userID = userManager.getUserID(args[1]);
                                virtualUser Target = userManager.getUser(_userID);
                                if (Target._Rank < _Rank && Target._isMuted)
                                {
                                    Target._isMuted = false;
                                    Target.sendData("BK" + stringManager.getString("scommand_unmuted") + Convert.ToChar(2));
                                    sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                                    staffManager.addStaffMessage("unmute", userID, Target.userID, "", "");
                                }
                                else
                                    sendData("BK" + stringManager.getString("scommand_failed") + Convert.ToChar(2));
                            }
                            break;
                        }
                    #endregion
                    #region :roomshutup/:roomunmute
                    case "roomshutup": // Mutes all virtual users in the current room from chat. Only user's that have a lower rank than this user are affected.
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_room_mute", userID) == false)
                                return false;
                            else
                            {
                                string Message = stringManager.wrapParameters(args, 1);
                                Room.muteUsers(_Rank, Message);
                                sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                                staffManager.addStaffMessage("rmute", userID, Room.roomID, Message, "");
                            }
                            break;
                        }

                    case "roomunmute": // Unmutes all the muted virtual users in this room (who's rank is lower than this user's rank), making them able to chat again
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_room_mute", userID) == false)
                                return false;
                            else
                            {
                                Room.unmuteUsers(_Rank);
                                sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                                staffManager.addStaffMessage("runmute", userID, Room.roomID, "", "");
                            }
                            break;
                        }
                    #endregion
                    #region :ban/:superban
                    case "ban": // Bans a virtual user from server (no IP ban)
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_ban", userID) == false)
                                return false;
                            else
                            {
                                DataRow dRow;
                                using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                                {
                                    dbClient.AddParamWithValue("name", args[1]);
                                    dRow = dbClient.getRow("SELECT id,rank FROM users WHERE name = @name");
                                }
                                if (dRow.Table.Rows.Count == 0)
                                    sendData("BK" + stringManager.getString("modtool_actionfailed") + "\r" + stringManager.getString("modtool_usernotfound") + Convert.ToChar(2));
                                else if (Convert.ToByte(dRow["rank"]) > _Rank)
                                    sendData("BK" + stringManager.getString("modtool_actionfailed") + "\r" + stringManager.getString("modtool_rankerror") + Convert.ToChar(2));
                                else
                                {
                                    int banHours = int.Parse(args[2]);
                                    string Reason = stringManager.wrapParameters(args, 3);
                                    if (banHours == 0 || Reason == "")
                                        sendData("BK" + stringManager.getString("scommand_failed") + Convert.ToChar(2));
                                    else
                                    {
                                        staffManager.addStaffMessage("ban", userID, Convert.ToInt32(dRow["id"]), Reason, "");
                                        userManager.setBan(Convert.ToInt32(dRow["id"]), banHours, Reason);
                                        sendData("BK" + userManager.generateBanReport(Convert.ToInt32(dRow["id"])) + Convert.ToChar(2));
                                    }
                                }
                            }
                            break;
                        }

                    case "superban": // Bans an IP address and all virtual user's that used this IP address for their last access from the system
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_superban", userID) == false)
                                return false;
                            else
                            {
                                DataRow dRow;
                                using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                                {
                                    dbClient.AddParamWithValue("name", args[1]);
                                    dRow = dbClient.getRow("SELECT id,rank,ipaddress_last FROM users WHERE name = @name");
                                }
                                if (dRow.Table.Rows.Count == 0)
                                    sendData("BK" + stringManager.getString("modtool_actionfailed") + "\r" + stringManager.getString("modtool_usernotfound") + Convert.ToChar(2));
                                else if (Convert.ToByte(dRow["rank"]) > _Rank)
                                    sendData("BK" + stringManager.getString("modtool_actionfailed") + "\r" + stringManager.getString("modtool_rankerror") + Convert.ToChar(2));
                                else
                                {
                                    int banHours = int.Parse(args[2]);
                                    string Reason = stringManager.wrapParameters(args, 3);
                                    if (banHours == 0 || Reason == "")
                                        sendData("BK" + stringManager.getString("scommand_failed") + Convert.ToChar(2));
                                    else
                                    {
                                        string IP = Convert.ToString(dRow["ipaddress_last"]);
                                        staffManager.addStaffMessage("superban", userID, Convert.ToInt32(dRow["id"]), Reason, "");
                                        userManager.setBan(Convert.ToInt32(dRow["id"]), banHours, Reason);
                                        sendData("BK" + userManager.generateBanReport(IP) + Convert.ToChar(2));
                                    }
                                }
                            }
                            break;
                        }
                    #endregion
                    #endregion
                    #region Special staff commands
                    #region Message broadcoasting
                    #region :ha
                    case "ha": // Broadcoasts a message to all virtual users (hotel alert)
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_administrator_access", userID) == false)
                                return false;
                            else
                            {
                                string Message = Text.Substring(3);
                                userManager.sendData("BK" + stringManager.getString("scommand_hotelalert") + "\r" + Message + Convert.ToChar(2));
                                staffManager.addStaffMessage("halert", userID, 0, Message, "");
                            }
                        }
                        break;
                    #endregion
                    #region :offline
                    case "offline": // Broadcoasts a message that the server will shutdown in xx minutes
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_administrator_access", userID) == false)
                                return false;
                            else
                            {
                                int Minutes = int.Parse(args[1]);
                                userManager.sendData("Dc" + Holo.Encoding.encodeVL64(Minutes));
                                staffManager.addStaffMessage("offline", userID, 0, "mm=" + Minutes, "");
                            }
                            break;
                        }
                    #endregion
                    #endregion
                    #region Commands
                    #region :teleport/:warp
                    case "teleport": // Toggles the user's teleport ability on/off
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_administrator_access", userID) == false)
                                return false;
                            else
                            {
                                roomUser.SPECIAL_TELEPORTABLE = (roomUser.SPECIAL_TELEPORTABLE != true); // Reverse the bool
                                refreshAppearance(false, false, true, true); // Use the poof animation
                            }
                            break;
                        }

                    case "warp": // Warps the virtual user to a certain X,Y coordinate
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_administrator_access", userID) == false)
                                return false;
                            else
                            {
                                int X = int.Parse(args[1]);
                                int Y = int.Parse(args[2]);
                                roomUser.X = X;
                                roomUser.Y = Y;
                                roomUser.goalX = -1;
                                Room.Refresh(roomUser);
                                refreshAppearance(false, false, true, true); // Use the poof animation
                            }
                            break;
                        }

                    #endregion
                    #region :userinfo
                    case "userinfo": // Generates a list of information about a certain virtual user
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_moderator_access", userID) == false)
                                return false;
                            else
                                sendData("BK" + userManager.generateUserInfo(userManager.getUserID(args[1]), _Rank) + Convert.ToChar(2));
                            break;
                        }
                    #endregion
                    //#region :cords
                    //case "cords": // Returns the cords of the user
                    //    {
                    //        if (rankManager.containsRight(ref _fuserights, _Rank,"fuse_administrator_access", userID) == false)
                    //            return false;
                    //        else
                    //            sendData("BK" + "X: " + roomUser.X + "\rY: " + roomUser.Y + "\rH: " + roomUser.H + Convert.ToChar(2));
                    //        break;
                    //    }
                    //#endregion
                    #region :freeze / :unfreeze
                    case "freeze": // Freeze the specified user
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_kick", userID) == false)
                                return false;
                            else
                            {
                                string userName = args[1]; // Get the username
                                virtualUser _User = userManager.getUser(userName); // Get the user

                                _User.roomUser.walkLock = true; // Freeze the user
                            }
                            break;
                        }
                    case "unfreeze": // Unfreeze the specified user
                        {
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_kick", userID) == false)
                                return false;
                            else
                            {
                                string userName = args[1]; // Get the username
                                virtualUser _User = userManager.getUser(userName); // Get the user

                                _User.roomUser.walkLock = false; // Unfreeze the user
                            }

                            break;
                        }

                    #endregion
                    #region :refresh
                    case "refresh": // Updates certain parts of the server.
                        {
                            bool returnNow = false;
                            if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_administrator_access", userID) == false)
                                return false;
                            else
                            {
                                try
                                {
                                    Thread Refresher;
                                    ThreadStart tStarter = null;
                                    switch (args[1])
                                    {
                                        case "catalogue": // Refresh the catalogue
                                            {
                                                tStarter = new ThreadStart(refresh_cat);
                                                userManager.sendData("Fy" + Convert.ToChar(1) + "A~" + "HHHM" + Convert.ToChar(2));// Holo.Habbo_Hotel.Requests.Catalogue.GetCatalogIndex(this);
                                                returnNow = true;
                                                break;
                                            }
                                        case "strings": // Refresh the strings
                                            {
                                                tStarter = new ThreadStart(refresh_strings);
                                                break;
                                            }
                                        case "config": // Refresh the config
                                            {
                                                tStarter = new ThreadStart(refresh_config);
                                                break;
                                            }
                                        case "filter": // Refresh the filters
                                            {
                                                tStarter = new ThreadStart(refresh_filter);
                                                break;
                                            }
                                        case "fuse": // Refresh the fuse_rights
                                            {
                                                tStarter = new ThreadStart(refresh_fuse);
                                                break;
                                            }
                                        case "ecotron": // Refresh the ecotron
                                            {
                                                tStarter = new ThreadStart(refresh_eco);
                                                break;
                                            }
                                        case "model": // Refresh the ecotron
                                            {
                                                tStarter = new ThreadStart(refresh_modeldata);
                                                break;
                                            }
                                        default:
                                            sendData("BK" + stringManager.getString("scommand_failed") + Convert.ToChar(2));
                                            return true;
                                    }
                                    Refresher = new Thread(tStarter);
                                    Refresher.Priority = ThreadPriority.BelowNormal;
                                    Refresher.Start();
                                    if (returnNow == false)
                                        sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                                }
                                catch
                                {
                                    sendData("BK" + ":refresh catalogue\r" +
                                        ":refresh eco\r" +
                                        ":refresh strings\r" +
                                        ":refresh config\r" +
                                        ":refresh filter\r" +
                                        ":refresh model\r" +
                                        ":refresh fuse\r" + Convert.ToChar(2));
                                }
                                break;
                            }
                        }
                    #endregion
                    
                    //#region :infobus
                    //case "infobus":
                    //    {
                    //        if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_administrator_access", userID) == false)
                    //            return false;
                    //        else
                    //            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                    //            {
                    //                Room.sendData("BK" + "Infobus has started");
                    //                dbClient.runQuery("update infobus set risp1tot = 0");
                    //                dbClient.runQuery("update infobus set risp2tot = 0");

                    //                string domanda = dbClient.getString("select domanda from infobus");
                    //                string risp1 = dbClient.getString("select risp1 from infobus");
                    //                string risp2 = dbClient.getString("select risp2 from infobus");
                    //                Room.sendData("AO" + domanda + Convert.ToChar(13) + "1:" + risp1 + Convert.ToChar(13) + "2:" + risp2 + Convert.ToChar(2));
                    //                break;

                    //            }
                    //    }

                    //case "domanda":
                    //    if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_administrator_access", userID) == false)
                    //        return false;
                    //    else
                    //        using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                    //        {
                    //            string domanda = Text.Substring(7);

                    //            dbClient.runQuery("UPDATE infobus SET domanda = '" + domanda + "'");
                    //            sendData("BK" + "This is the question' " + domanda);
                    //        }
                    //    break;

                    //case "answ1":
                    //    if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_administrator_access", userID) == false)
                    //        return false;
                    //    else
                    //        using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                    //        {
                    //            string risp = Text.Substring(5);
                    //            dbClient.runQuery("UPDATE infobus SET risp1 = '" + risp + "'");
                    //            sendData("BK" + "The answer number 1 is: " + risp);
                    //        }
                    //    break;

                    //case "answ2":
                    //    if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_administrator_access", userID) == false)
                    //        return false;
                    //    else
                    //        using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                    //        {
                    //            string risp2 = Text.Substring(5);
                    //            dbClient.runQuery("UPDATE infobus SET risp2 = '" + risp2 + "'");
                    //            sendData("BK" + "The answer number 2 is: " + risp2);
                    //        }
                    //    break;

                    //case "results":
                    //    {
                    //        if (rankManager.containsRight(ref _fuserights, _Rank, "fuse_administrator_access", userID) == false)
                    //            return false;
                    //        else
                    //        {
                    //            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                    //            {

                    //                int risp1 = dbClient.getInt("select risp1tot from infobus");
                    //                int risp2 = dbClient.getInt("select risp2tot from infobus");
                    //                int risptot = risp1 + risp2;
                    //                userManager.sendData("AP" + "/" + risptot + "/" + risp1 + "/" + risp2); break;
                    //            }
                    //        }
                    //    }
                    //#endregion
                    //#region :happyhour
                    //case "happyhour": // Turn on/off Happy Hour
                    //    {
                    //        Thread Refresher;
                    //        ThreadStart tStarter = null;
                    //        if (rankManager.containsRight(ref _fuserights, _Rank,"fuse_administrator_access", userID) == false)
                    //            return false;
                    //        else
                    //            Config.enableHappyHour = false;
                    //        switch (args[1])
                    //        {
                    //            case "on": // Turn on HappyHour
                    //                Config.enableHappyHour = true;
                    //                break;
                    //        }
                    //        tStarter = new ThreadStart(refresh_cat);
                    //        Refresher = new Thread(tStarter);
                    //        Refresher.Priority = ThreadPriority.BelowNormal;
                    //        Refresher.Start();
                    //        userManager.sendData("Fy" + Convert.ToChar(1) + "A~" + "HHHM" + Convert.ToChar(2) + catalogueManager.getPageIndex(Convert.ToInt16(_Rank)));
                    //    }
                    //    break;
                    //#endregion
                    #endregion
                    #endregion
                    default:
                        return false;
                }
            }
            catch { sendData("BK" + stringManager.getString("scommand_failed") + Convert.ToChar(2)); }
            return true;
        }

        public void leaveCurrentRoom(string message, bool kick)
        {
            if ((this._guideRoom > 0) && !this._guideSearch)
            {
                this.sendData("Fh" + Holo.Encoding.encodeVL64(this._guideRoom));
            }
            if ((this.Room != null) && (this.roomUser != null))
            {
                this.Room.removeUser(this.roomUser.roomUID, kick, message);
            }
            this.leaveGame();
            this.abortTrade();
            this._roomID = 0;
            this._inPublicroom = false;
            this._ROOMACCESS_PRIMARY_OK = false;
            this._ROOMACCESS_SECONDARY_OK = false;
            this._isOwner = false;
            this._isOwner2 = false;
            this._hasRights = false;
            this.Room = null;
            if (this.statusManager != null)
            {
                this.statusManager.Clear();
                this.statusManager = null;
            }
            this.roomUser = null;
        }

        internal void leaveGame()
        {
            if ((this.gamePlayer != null) && (this.gamePlayer.Game != null))
            {
                if (this.gamePlayer.Game.Owner == this.gamePlayer)
                {
                    try
                    {
                        this.gamePlayer.Game.Lobby.Games.Remove(this.gamePlayer.Game.ID);
                    }
                    catch
                    {
                    }
                    this.gamePlayer.Game.Abort();
                    this.sendData("FS");
                }
                else if (this.gamePlayer.teamID != -1)
                {
                    this.gamePlayer.Game.movePlayer(this.gamePlayer, this.gamePlayer.teamID, -1);
                }
                else
                {
                    this.gamePlayer.Game.Subviewers.Remove(this.gamePlayer);
                    this.sendData("CmH");
                    this.sendData("FS");
                }
            }
            this.gamePlayer = null;
        }

        internal void NavigatorSearch(int UserSearchID)
        {
            DataColumn column;
            int num;
            StringBuilder builder = new StringBuilder();
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                column = client.getColumn("SELECT id FROM room_categories WHERE access_rank_hideforlower <= '" + this._Rank + "'");
                num = client.getInt("SELECT count(id) FROM room_categories WHERE access_rank_hideforlower <= '" + this._Rank + "'");
            }
            Hashtable hashtable = new Hashtable(column.Table.Rows.Count);
            string str = "";
            builder.Append(Holo.Encoding.encodeVL64(UserSearchID) + Holo.Encoding.encodeVL64(num));
            foreach (DataRow row in column.Table.Rows)
            {
                string str2;
                DataColumn column2;
                int num2;
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    str2 = client2.getString("SELECT name FROM room_categories WHERE id = '" + row["id"] + "'");
                    column2 = client2.getColumn("SELECT id FROM rooms");
                    num2 = client2.getInt("SELECT userscount FROM room_categories WHERE id = '" + row["id"] + "'");
                }
                Hashtable hashtable2 = new Hashtable(column2.Table.Rows.Count);
                string str3 = "";
                hashtable.Add(Convert.ToInt32(row["id"]), Convert.ToInt32(row["id"]));
                str = str + Convert.ToString(row["id"]);
                str = str.Substring(0, str.Length);
                if (str.Length > 0)
                {
                    builder.Append(str2 + Convert.ToChar(2));
                    foreach (DataRow row2 in column2.Table.Rows)
                    {
                        hashtable2.Add(Convert.ToInt32(row2["id"]), Convert.ToInt32(row2["id"]));
                        str3 = str3 + Convert.ToString(row2["id"]);
                        str3 = str3.Substring(0, str3.Length);
                        if (str3.Length > 0)
                        {
                            using (DatabaseClient client3 = Eucalypt.dbManager.GetClient())
                            {
                                client3.runQuery("UPDATE room_categories set userscount = userscount + '" + client3.getInt("SELECT count(id) FROM users WHERE roomid = '" + row2["id"] + "'") + "'");
                            }
                            hashtable2.Remove(Convert.ToInt32(row2["id"]));
                        }
                    }
                    builder.Append(Holo.Encoding.encodeVL64(num2));
                }
            }
            this.sendData("GDRL" + builder);
            this.sendData("GCPB");
        }

        internal void ProcessPacket_b()
        {
            if (((this.Room != null) && (this.roomUser != null)) && ((this.Room.Lobby != null) && (this.gamePlayer == null)))
            {
                if (this.Room.Lobby.validGamerank(this.roomUser.gamePoints))
                {
                    if (this.Room.Lobby.isBattleBall)
                    {
                        this.sendData("Ck" + this.Room.Lobby.getCreateGameSettings());
                    }
                    else
                    {
                        this.sendData(string.Concat(new object[] { "CkRAsecondsUntilRestart", Convert.ToChar(2), "HIRGIHHfieldType", Convert.ToChar(2), "HKIIIISAnumTeams", Convert.ToChar(2), "HJJIIIPAgameLengthChoice", Convert.ToChar(2), "HJIIIIKname", Convert.ToChar(2), "IJ", Convert.ToChar(2), "HsecondsUntilStart", Convert.ToChar(2), "HIRBIHH" }));
                    }
                }
                else
                {
                    this.sendData("ClK");
                }
            }
        }

        internal void ProcessPacket_B()
        {
            if ((this.Room != null) && (this.Room.Lobby != null))
            {
                this.sendData("Ch" + this.Room.Lobby.gameList());
            }
        }

        internal void ProcessPacket_c()
        {
            if (((this.Room != null) && (this.roomUser != null)) && ((this.Room.Lobby != null) && (this.gamePlayer == null)))
            {
                if (this.Room.Lobby.validGamerank(this.roomUser.gamePoints))
                {
                    try
                    {
                        int mapID = -1;
                        int teamAmount = -1;
                        int[] enabledPowerups = null;
                        string name = "";
                        int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                        this.currentPacket = this.currentPacket.Substring(Holo.Encoding.encodeVL64(i).Length + 2);
                        for (int j = 0; j < i; j++)
                        {
                            int num7;
                            int num8;
                            int length = Holo.Encoding.decodeB64(this.currentPacket.Substring(0, 2));
                            string str2 = this.currentPacket.Substring(2, length);
                            if (!(this.currentPacket.Substring(length + 2, 1) == "H"))
                            {
                                goto Label_0145;
                            }
                            int num6 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(length + 3));
                            string str4 = str2;
                            if (str4 != null)
                            {
                                if (!(str4 == "fieldType"))
                                {
                                    if (str4 == "numTeams")
                                    {
                                        goto Label_0117;
                                    }
                                }
                                else
                                {
                                    mapID = num6;
                                }
                            }
                            goto Label_011A;
                        Label_0117:
                            teamAmount = num6;
                        Label_011A:
                            num7 = Holo.Encoding.encodeVL64(num6).Length;
                            this.currentPacket = this.currentPacket.Substring((length + num7) + 3);
                            continue;
                        Label_0145:
                            num8 = Holo.Encoding.decodeB64(this.currentPacket.Substring(length + 3, 2));
                            string text = this.currentPacket.Substring(length + 5, num8);
                            string str5 = str2;
                            if (str5 != null)
                            {
                                if (!(str5 == "allowedPowerups"))
                                {
                                    if (str5 == "name")
                                    {
                                        goto Label_01FC;
                                    }
                                }
                                else
                                {
                                    string[] strArray = text.Split(new char[] { ',' });
                                    enabledPowerups = new int[strArray.Length];
                                    for (int k = 0; k < strArray.Length; k++)
                                    {
                                        int iD = int.Parse(strArray[k]);
                                        if (!this.Room.Lobby.allowsPowerup(iD))
                                        {
                                            return;
                                        }
                                        enabledPowerups[k] = iD;
                                    }
                                }
                            }
                            goto Label_0204;
                        Label_01FC:
                            name = stringManager.filterSwearwords(text);
                        Label_0204:
                            this.currentPacket = this.currentPacket.Substring((length + num8) + 5);
                        }
                        if (((mapID != -1) && (teamAmount != -1)) && (name != ""))
                        {
                            this.gamePlayer = new Holo.Virtual.Rooms.Games.gamePlayer(this, this.roomUser.roomUID, null);
                            this.Room.Lobby.createGame(this.gamePlayer, name, mapID, teamAmount, enabledPowerups);
                        }
                    }
                    catch
                    {
                    }
                }
                else
                {
                    this.sendData("ClK");
                }
            }
        }

        internal void ProcessPacket_e()
        {
            if (((this.Room != null) && (this.Room.Lobby != null)) && ((this.gamePlayer != null) && (this.gamePlayer.Game.State == Game.gameState.Waiting)))
            {
                if (this.Room.Lobby.validGamerank(this.roomUser.gamePoints))
                {
                    int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                    int teamID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(Holo.Encoding.encodeVL64(i).Length + 2));
                    if ((teamID != this.gamePlayer.teamID) && this.gamePlayer.Game.teamHasSpace(teamID))
                    {
                        if (this.gamePlayer.teamID == -1)
                        {
                            this.gamePlayer.Game.Subviewers.Remove(this.gamePlayer);
                        }
                        this.gamePlayer.Game.movePlayer(this.gamePlayer, this.gamePlayer.teamID, teamID);
                    }
                    else
                    {
                        this.sendData("ClH");
                    }
                }
                else
                {
                    this.sendData("ClK");
                }
            }
        }

        internal void ProcessPacket_g()
        {
            this.leaveGame();
        }

        internal void ProcessPacket_h()
        {
            if ((((this.Room != null) && (this.Room.Lobby != null)) && ((this.gamePlayer != null) && (this.gamePlayer.Game != null))) && (this.gamePlayer == this.gamePlayer.Game.Owner))
            {
                int num = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                for (int i = 0; i < this.gamePlayer.Game.Teams.Length; i++)
                {
                    foreach (Holo.Virtual.Rooms.Games.gamePlayer player in this.gamePlayer.Game.Teams[i])
                    {
                        if (player.roomUID == num)
                        {
                            player.sendData("ClRA");
                            this.gamePlayer.Game.movePlayer(player, i, -1);
                            return;
                        }
                    }
                }
            }
        }

        internal void ProcessPacket_j()
        {
            if (((this.Room != null) && (this.Room.Lobby != null)) && ((this.gamePlayer != null) && (this.gamePlayer == this.gamePlayer.Game.Owner)))
            {
                this.gamePlayer.Game.startGame();
            }
        }

        internal void ProcessPacket_k()
        {
            if (((this.gamePlayer != null) && (this.gamePlayer.Game.State == Game.gameState.Started)) && (this.gamePlayer.teamID != -1))
            {
                this.gamePlayer.goalX = Holo.Encoding.decodeVL64(this.currentPacket.Substring(3));
                this.gamePlayer.goalY = Holo.Encoding.decodeVL64(this.currentPacket.Substring(Holo.Encoding.encodeVL64(this.gamePlayer.goalX).Length + 3));
            }
        }

        internal void ProcessPacket_l()
        {
            if (((this.gamePlayer != null) && (this.gamePlayer.Game.State == Game.gameState.Ended)) && (this.gamePlayer.teamID != -1))
            {
                this.gamePlayer.Game.sendData(string.Concat(new object[] { "BK", this._Username, " wants to replay!", Convert.ToChar(2) }));
            }
        }

        internal void ProcessPacket_TH()
        {
            if (((this.Room != null) && (this.roomUser != null)) && ((this.Room.Lobby != null) && (this.gamePlayer == null)))
            {
                int key = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (this.Room.Lobby.Games.ContainsKey(key))
                {
                    this.gamePlayer = new Holo.Virtual.Rooms.Games.gamePlayer(this, this.roomUser.roomUID, (Game)this.Room.Lobby.Games[key]);
                    this.gamePlayer.Game.Subviewers.Add(this.gamePlayer);
                    this.sendData("Ci" + this.gamePlayer.Game.Sub);
                }
            }
        }

        internal void ProcessPacket_V()
        {
         
        }

        internal void ProcessPacketAa()
        {
            if (((this.Room != null) && (this.roomUser != null)) && (!this._inPublicroom && this._isOwner))
            {
                virtualUser user = userManager.getUser(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2)));
                if (((user._roomID == this._roomID) && user._hasRights) && !user._isOwner)
                {
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        client.runQuery(string.Concat(new object[] { "DELETE FROM room_rights WHERE roomid = '", this._roomID, "' AND userid = '", user.userID, "' LIMIT 1" }));
                    }
                    user._hasRights = false;
                    user.statusManager.removeStatus("flatctrl");
                    user.roomUser.Refresh();
                    user.sendData("@k");
                }
            }
        }

        internal void ProcessPacketAAFQ()
        {
            int num2;
            int i = 0;
            i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            string val = "";
            string text = "";
            string str3 = "";
            string str4 = "";
            string str5 = "";
            string str6 = "";
            string str7 = "";
            string str8 = "";
            string str9 = "";
            string str10 = "";
            string str11 = "";
            string str13 = "";
            string str14 = "";
            val = this.currentPacket.Substring(Strings.Len(Holo.Encoding.encodeVL64(i)) + 2, 2);
            text = stringManager.filterSwearwords(this.currentPacket.Substring(Strings.Len(Holo.Encoding.encodeVL64(i)) + 4, Holo.Encoding.decodeB64(val)));
            str3 = this.currentPacket.Substring((Strings.Len(Holo.Encoding.encodeVL64(i)) + Holo.Encoding.decodeB64(val)) + 4, 2);
            str4 = this.currentPacket.Substring((Strings.Len(Holo.Encoding.encodeVL64(i)) + 6) + Holo.Encoding.decodeB64(val), Holo.Encoding.decodeB64(str3));
            str5 = this.currentPacket.Substring(((Strings.Len(Holo.Encoding.encodeVL64(i)) + 6) + Holo.Encoding.decodeB64(val)) + Holo.Encoding.decodeB64(str3));
            str6 = Convert.ToString(Holo.Encoding.decodeVL64(str5.Substring(0, 1)));
            str7 = Convert.ToString(Holo.Encoding.decodeB64(str5.Substring(1, 2)));
            str8 = str5.Substring(1 + Strings.Len(Holo.Encoding.encodeB64(str7)), Convert.ToInt16(str7));
            str9 = Convert.ToString(Holo.Encoding.decodeVL64(str5.Substring((1 + Strings.Len(Holo.Encoding.encodeB64(str7))) + Convert.ToInt16(str7), 2)));
            str11 = str5.Substring((1 + Strings.Len(Holo.Encoding.encodeB64(str7))) + Convert.ToInt16(str7));
            str10 = Convert.ToString(Holo.Encoding.decodeVL64(str11.Substring(5, 2)));
            switch (Convert.ToString(Holo.Encoding.decodeVL64(str11.Substring(7, 1))))
            {
                case "0":
                    str13 = "";
                    str14 = "";
                    break;

                case "1":
                    num2 = Holo.Encoding.decodeB64(str11.Substring(8, 2));
                    str13 = Convert.ToString(str11.Substring(10, num2));
                    str14 = "";
                    break;

                case "2":
                    {
                        num2 = Holo.Encoding.decodeB64(str11.Substring(8, 2));
                        str13 = Convert.ToString(str11.Substring(10, num2));
                        int length = Holo.Encoding.decodeB64(str11.Substring(10 + num2, 2));
                        str14 = Convert.ToString(str11.Substring(12 + num2, length));
                        break;
                    }
            }
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                client.AddParamWithValue("name", stringManager.filterSwearwords(text));
                client.AddParamWithValue("description", stringManager.filterSwearwords(str4));
                client.AddParamWithValue("id", i);
                client.AddParamWithValue("owner", this._Username);
                client.AddParamWithValue("state", str6);
                client.AddParamWithValue("password", str8);
                client.AddParamWithValue("visitors_max", str9);
                client.AddParamWithValue("tag1", str13);
                client.AddParamWithValue("tag2", str14);
                client.AddParamWithValue("category", str10);
                client.runQuery("UPDATE rooms SET category = @category,tag1 = @tag1,tag2 = @tag2,visitors_max = @visitors_max,state = @state,password = @password,name = @name,description = @description,showname = '1',level = '1' WHERE id = @id AND owner = @owner LIMIT 1");
                DataRow row = client.getRow("SELECT name,description,owner,superusers,visitors_now,visitors_max,tag1,tag2,room_icon FROM rooms WHERE id = '" + this._roomID + "'");
                string str15 = Convert.ToString(row["tag1"]);
                string str16 = Convert.ToString(row["tag2"]);
                StringBuilder builder = new StringBuilder("");
                if ((str15 == "") && (str16 == ""))
                {
                    builder.Append("H");
                }
                else if ((str15 == "") || (str16 == ""))
                {
                    if (str15 == "")
                    {
                        builder.Append("I" + str16 + Convert.ToChar(2));
                    }
                    else
                    {
                        builder.Append("I" + str15 + Convert.ToChar(2));
                    }
                }
                else if ((str15 != "") && (str16 != ""))
                {
                    builder.Append(string.Concat(new object[] { "J", str15, Convert.ToChar(2), str16, Convert.ToChar(2) }));
                }
                this.sendData("GS" + Holo.Encoding.encodeVL64(this._roomID));
                this.Room.sendData("GH" + Holo.Encoding.encodeVL64(this._roomID));
                this.Room.sendData(string.Concat(new object[] { "GFH", Holo.Encoding.encodeVL64(this._roomID), "H", Convert.ToString(row["name"]), Convert.ToChar(2), Convert.ToString(row["owner"]), Convert.ToChar(2), Holo.Encoding.encodeVL64(Convert.ToInt16(row["superusers"])), Holo.Encoding.encodeVL64(Convert.ToInt16(row["visitors_now"])), Holo.Encoding.encodeVL64(Convert.ToInt16(row["visitors_max"])), Convert.ToString(row["description"]), Convert.ToChar(2), "HHHH", Convert.ToChar(2), builder, Convert.ToString(row["room_icon"]) }));
            }
        }

        internal void ProcessPacketAb()
        {
            if (this._hasRights || !rankManager.containsRight(ref this.roomUser.User._fuserights, this.roomUser.User._Rank, "fuse_enter_locked_rooms", this.userID))
            {
                string userName = this.currentPacket.Substring(4, Holo.Encoding.decodeB64(this.currentPacket.Substring(2, 2)));
                int num = Holo.Encoding.decodeVL64(this.currentPacket.Substring(this.currentPacket.Length - 1));
                virtualUser user = userManager.getUser(userName);
                if ((user != null) && (user._roomID == this._roomID))
                {
                    if (num == 1)
                    {
                        user._ROOMACCESS_SECONDARY_OK = true;
                        this.Room.sendDataToRights("@i" + userName + Convert.ToChar(2));
                        user.sendData("@i");
                    }
                    else
                    {
                        user.sendData("BC");
                        user._roomID = 0;
                        user._inPublicroom = false;
                        user._ROOMACCESS_PRIMARY_OK = false;
                        user._ROOMACCESS_SECONDARY_OK = false;
                        user._isOwner = false;
                        user._isOwner2 = false;
                        user._hasRights = false;
                        user.Room = null;
                        user.roomUser = null;
                    }
                }
            }
        }

        internal void ProcessPacketAB()
        {
            if ((this._hasRights && !this._inPublicroom) && ((this.Room != null) && (this.roomUser != null)))
            {
                int num = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    string str = catalogueManager.getTemplate(client.getInt(string.Concat(new object[] { "SELECT tid FROM furniture WHERE id = '", num, "' AND ownerid = '", this.userID, "' AND roomid = '0'" }))).Sprite.Split(new char[] { ' ' })[0];
                    switch (str)
                    {
                        case "wallpaper":
                        case "floor":
                        case "landscape":
                            {
                                string str2 = client.getString("SELECT var FROM furniture WHERE id = '" + num + "'");
                                this.Room.sendData(string.Concat(new object[] { "@n", str, Convert.ToChar(2), str2, Convert.ToChar(2) }));
                                client.runQuery(string.Concat(new object[] { "UPDATE rooms SET ", str, " = '", str2, "' WHERE id = '", this._roomID, "' LIMIT 1" }));
                                client.runQuery("DELETE FROM furniture WHERE id = '" + num + "' LIMIT 1");
                                break;
                            }
                    }
                }
            }
        }

        internal void ProcessPacketnl()
        {
            sendData("RM");
        }

        internal void ProcessPacketnCG()
        {
                            StringBuilder builder = new StringBuilder();
            {
                int prendis;
            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
            {

                dbClient.AddParamWithValue("@ownerid", userID);
                dbClient.AddParamWithValue("@id", petID);
                prendis = dbClient.getInt("UPDATE @id FROM pets WHERE owner = @ownerid AND roomid = 0");
            }
            builder.Append(Holo.Encoding.encodeVL64(prendis));

            }
            sendData("BK" + "Pets preso con successo! Rientra in hotel e lo vedrai nella tua mano!");
        }

        internal void ProcessPacketAC()
        {
            if ((this._isOwner && !this._inPublicroom) && ((this.Room != null) && (this.roomUser != null)))
            {
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                int itemID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2 + Holo.Encoding.encodeVL64(i).Length));
                if (this.Room.floorItemManager.containsItem(itemID))
                {
                    this.Room.floorItemManager.removeItem(itemID, this.userID);
                }
                else if (this.Room.wallItemManager.containsItem(itemID) && (stringManager.getStringPart(this.Room.wallItemManager.getItem(itemID).Sprite, 0, 7) != "post.it"))
                {
                    this.Room.wallItemManager.removeItem(itemID, this.userID);
                }
                else
                {
                    return;
                }
                this.refreshHand("last");
            }
        }

        internal void ProcessPacketACA()
        {
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                if (this._inPublicroom && client.findsResult("SELECT roomid FROM room_ads WHERE roomid = '" + this._roomID + "'"))
                {
                    DataRow row = client.getRow("SELECT img, uri FROM room_ads WHERE roomid = '" + this._roomID + "'");
                    string str = Convert.ToString(row["img"]);
                    string str2 = Convert.ToString(row["uri"]);
                    this.sendData(string.Concat(new object[] { "CP", str, Convert.ToChar(9), str2 }));
                }
                else
                {
                    this.sendData("CP0");
                }
                if (!this._inPublicroom)
                {
                    DataRow row2 = client.getRow("SELECT name, state, visitors_now, visitors_max FROM rooms WHERE id = '" + this._roomID + "'");
                    this.sendData(string.Concat(new object[] { "GFI", Holo.Encoding.encodeVL64(this._roomID), "H", row2["name"], "\x0002-\x0002", Holo.Encoding.encodeVL64(Convert.ToInt32(row2["state"])), Holo.Encoding.encodeVL64(Convert.ToInt32(row2["visitors_now"])), Holo.Encoding.encodeVL64(Convert.ToInt32(row2["visitors_max"])), Convert.ToChar(2), "HHKHHHHH" }));
                }

                if ((this._ROOMACCESS_SECONDARY_OK && (this.Room != null)) && (this.roomUser == null))
                {
                    this.Room.addUser(this);
                    this.roomUser.Z1 = Rotation.Calculate(this.roomUser.X, this.roomUser.Y, this.roomUser.X, this.roomUser.Y);
                    this.roomUser.Z2 = this.roomUser.Z1;
                    this.roomUser.Refresh();
                    if (this.Room.hasSpecialCasts("cam1"))
                    {
                        this.sendData("AGcam1 targetcamera " + this.roomUser.roomUID);
                    }
                }

                this.Handler.ProcessPacket("D{");
                this.Handler.ProcessPacket("FA");

            }
        }

        internal void ProcessPacketAd()
        {
            if (this.currentPacket.Contains("\x0003"))
            {
                this.currentPacket = this.currentPacket.Replace(Convert.ToChar(3).ToString(), Convert.ToChar(13).ToString());
            }
            int i = 0;
            int num2 = 0;
            i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            num2 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2 + Holo.Encoding.encodeVL64(i).Length));
            int length = 0;
            string text = "";
            length = Holo.Encoding.decodeB64(this.currentPacket.Substring((2 + Holo.Encoding.encodeVL64(num2).Length) + Holo.Encoding.encodeVL64(i).Length, 2));
            text = this.currentPacket.Substring((4 + Holo.Encoding.encodeVL64(num2).Length) + Holo.Encoding.encodeVL64(i).Length, length);
            int num4 = 0;
            //num4 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(((4 + Holo.Encoding.encodeVL64(num2).Length) + Holo.Encoding.encodeVL64(i).Length) + length, 1));
            int num5 = 0;
            string val = "";
            int num6 = 0;
            string str3 = "";
            if (num4 == 1)
            {
                num5 = Holo.Encoding.decodeB64(this.currentPacket.Substring(((5 + Holo.Encoding.encodeVL64(num2).Length) + Holo.Encoding.encodeVL64(i).Length) + length, 2));
                val = this.currentPacket.Substring(((7 + Holo.Encoding.encodeVL64(num2).Length) + Holo.Encoding.encodeVL64(i).Length) + length, num5);
                num6 = Holo.Encoding.decodeB64(this.currentPacket.Substring((((7 + num5) + Holo.Encoding.encodeVL64(num2).Length) + Holo.Encoding.encodeVL64(i).Length) + length, 2));
                str3 = this.currentPacket.Substring((((9 + Holo.Encoding.encodeVL64(num2).Length) + num5) + Holo.Encoding.encodeVL64(i).Length) + length, num6);
            }
            string input = "";
            int num7 = 0;
            int num8 = 0;
            int num9 = 0;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                client.AddParamWithValue("indexid", i);
                client.AddParamWithValue("tid", num2);
                num7 = client.getInt("SELECT indexid FROM catalogue_pages WHERE indexid = @indexid AND minrank <= " + this._Rank);
                input = client.getString("SELECT name_cct FROM catalogue_items WHERE tid = @tid");
                num8 = client.getInt(string.Concat(new object[] { "SELECT catalogue_cost_credits FROM catalogue_items WHERE catalogue_id_page = '", num7, "' AND tid = '", num2, "'" }));
                num9 = client.getInt(string.Concat(new object[] { "SELECT catalogue_cost_pixels FROM catalogue_items WHERE catalogue_id_page = '", num7, "' AND tid = '", num2, "'" }));
                if (Config.enableHappyHour)
                {
                    num8 = 0;
                    if (num9 > 0)
                    {
                        num8 = 1;
                    }
                    num9 /= 2;
                }
            }
            if (((num7 == 0) || (num8 > this._Credits)) || (num9 > this._Pixels))
            {
                this.sendData("AD" + Convert.ToChar(2));
                return;
            }
            bool flag = false;
            int userID = this.userID;
            int presentBoxID = 0;
            int roomID = 0;
            if (num9 > 0)
            {
                num4 = 0;
            }
            if (num4 == 1)
            {
                flag = true;
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    client2.AddParamWithValue("name", val);
                    if (val != this._Username)
                    {
                        int num13 = client2.getInt("SELECT id FROM users WHERE name = @name LIMIT 1");
                        if (num13 > 0)
                        {
                            userID = num13;
                        }
                        else
                        {
                            this.sendData("AL" + val);
                            return;
                        }
                    }
                }
                string str5 = "present_gen" + new Random().Next(1, 7);
                using (DatabaseClient client3 = Eucalypt.dbManager.GetClient())
                {
                    string str6 = client3.getString("SELECT tid FROM catalogue_items WHERE name_cct = '" + str5 + "'");
                    client3.AddParamWithValue("tid", str6);
                    client3.AddParamWithValue("ownerid", userID);
                    client3.AddParamWithValue("var", "!" + stringManager.filterSwearwords(str3));
                    client3.runQuery("INSERT INTO furniture(tid,ownerid,var) VALUES (@tid,@ownerid,@var)");
                    presentBoxID = client3.getInt("SELECT MAX(id) FROM furniture");
                }
                roomID = -1;
            }
            this._Credits -= num8;
            this._Pixels -= num9;
            this.sendData("@F" + this._Credits);
            this.sendData("Fv" + Holo.Encoding.encodeVL64(this._Pixels) + "H");
            using (DatabaseClient client4 = Eucalypt.dbManager.GetClient())
            {
                client4.runQuery(string.Concat(new object[] { "UPDATE users SET credits = '", this._Credits, "' WHERE id = '", this.userID, "' LIMIT 1" }));
                client4.runQuery(string.Concat(new object[] { "UPDATE users SET pixels = '", this._Pixels, "' WHERE id = '", this.userID, "' LIMIT 1" }));
            }
            if (!(stringManager.getStringPart(input, 0, 13) == "avatar_effect"))
            {
                if (stringManager.getStringPart(input, 0, 4) != "deal")
                {
                    int lastItemID = 0;
                    using (DatabaseClient client6 = Eucalypt.dbManager.GetClient())
                    {
                        client6.runQuery(string.Concat(new object[] { "INSERT INTO furniture(tid,ownerid,roomid) VALUES ('", num2, "','", userID, "','", roomID, "' )" }));
                        lastItemID = catalogueManager.lastItemID;
                    }
                    if (((catalogueManager.getTemplate(num2).Sprite == "wallpaper") || (catalogueManager.getTemplate(num2).Sprite == "floor")) || catalogueManager.getTemplate(num2).Sprite.Contains("landscape"))
                    {
                        string decorID = text;
                        catalogueManager.handlePurchase(num2, userID, 0, decorID, presentBoxID, 0);
                    }
                    if (catalogueManager.getTemplate(num2).Sprite.Substring(0, 3) == "pet")
                    {
                        string[] Props = text.Split("\n".ToCharArray());
                        string Name = Props[0];
                        string Race = Props[1];
                        string Colour = Props[2];
                        using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                        {
                            int lastPetID = dbClient.getInt("SELECT MAX (id) FROM pets");
                            string Message = Holo.Encoding.encodeVL64(lastPetID) + Name + Convert.ToChar(2) + catalogueManager.getTemplate(num2).typeID + Convert.ToChar(32) + Race + Convert.ToChar(32) + Colour + Convert.ToChar(2) + Holo.Encoding.encodeVL64(catalogueManager.getTemplate(num2).typeID);
                            sendData("I_" + Message);
                            //sendData("I[" + Message.Substring(1));
                            dbClient.AddParamWithValue("@ownerid", userID);
                            dbClient.AddParamWithValue("@petname", Name);
                            dbClient.AddParamWithValue("@petrace", Race);
                            dbClient.AddParamWithValue("@petcolour", Colour);
                            dbClient.AddParamWithValue("@pettype", catalogueManager.getTemplate(num2).typeID);
                            dbClient.AddParamWithValue("@bought", DateTime.Now);
                            dbClient.runQuery("INSERT INTO pets(owner,name,race,colour,type,bought,roomid) VALUES (@ownerid,@petname,@petrace,@petcolour,@pettype,@bought,'0')");
                            ProcessPacketnx();
                            return;
                        }
                    }
                    else
                    {
                        if ((stringManager.getStringPart(input, 0, 11) == "greektrophy") || (stringManager.getStringPart(input, 0, 11) == "prizetrophy"))
                        {
                            if (!flag)
                            {
                                using (DatabaseClient client7 = Eucalypt.dbManager.GetClient())
                                {
                                    string str8 = (this._Username + "\t" + DateTime.Today.ToShortDateString() + "\t" + stringManager.filterSwearwords(text)).Replace(@"\", @"\").Replace("'", @"\'");
                                    client7.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", str8, "' WHERE id = '", catalogueManager.lastItemID, "' LIMIT 1" }));
                                    goto Label_0B4C;
                                }
                            }
                            using (DatabaseClient client8 = Eucalypt.dbManager.GetClient())
                            {
                                string str9 = (this._Username + "\t" + DateTime.Today.ToShortDateString() + "\t" + stringManager.filterSwearwords(text)).Replace(@"\", @"\").Replace("'", @"\'");
                                client8.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", str9, "' WHERE id = '", catalogueManager.lastItemID, "' LIMIT 1" }));
                                client8.runQuery(string.Concat(new object[] { "INSERT INTO furniture_presents(id,itemid) VALUES ('", presentBoxID, "','", lastItemID, "')" }));
                                this.refreshHand("last");
                                return;
                            }
                        }
                        if (stringManager.getStringPart(input, 0, 3) == "pet")
                        {
                            string[] strArray = text.Split("\n".ToCharArray());
                            string str10 = strArray[0];
                            string str11 = strArray[1];
                            string str12 = strArray[2];
                            int lastPetID = catalogueManager.lastPetID;
                            using (DatabaseClient client9 = Eucalypt.dbManager.GetClient())
                            {
                                client9.runQuery(string.Concat(new object[] { "INSERT INTO pets (id,owner,name,race,colour,roomid) VALUES ('", lastPetID, "', '", this.userID, "', '", str10, "', '", str11, "', '", str12, "', '", roomID, "')" }));
                            }
                            this.sendData(string.Concat(new object[] { "I_", Holo.Encoding.encodeVL64(lastPetID), str10, Convert.ToChar(2), "0", Convert.ToChar(0x20), str11, Convert.ToChar(0x20), str12, Convert.ToChar(2), "H" }));
                        }
                        else
                        {
                            catalogueManager.handlePurchase(num2, userID, roomID, "0", presentBoxID, lastItemID);
                        }
                    }
                }
            }
            else
            {
                int Cost = 0;
                int Cost_Pixels = 0;
                int spriteID = 0;

                    int effectID = int.Parse(input.Replace("avatar_effect", ""));
                    using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                    {
                        //int effectDuration = dbClient.getInt("SELECT duration FROM system_effects WHERE effectid = " + effectID + " LIMIT 1");
                        dbClient.runQuery("INSERT INTO users_effects(userid,effect_id,effect_activated,effect_timemax,effect_timeleft) VALUES ('" + userID + "','" + effectID + "','" + 0 + "','3600','3600' )");
                        //refreshEffect();
                        //if (_activateBuy == true)
                        //{
                        //_activateBuy = false;
                        //sendData("Eu" + Encoding.encodeVL64(effectID));
                        //sendData("Et" + Encoding.encodeVL64(effectID));
                        int TypeID;
                        sendData("GM" + Holo.Encoding.encodeVL64(effectID) + Holo.Encoding.encodeVL64(3600));
                        StringBuilder Builder = new StringBuilder(Holo.Encoding.encodeVL64(spriteID) + input + Convert.ToChar(2) + Holo.Encoding.encodeVL64(Cost) + Holo.Encoding.encodeVL64(Cost_Pixels) + "I"); // Yey! Buying Successful
                        using (DatabaseClient dbClient5 = Eucalypt.dbManager.GetClient())
                        {
                            TypeID = dbClient5.getInt("SELECT typeid FROM catalogue_items WHERE name_cct = '" + input + "'");
                        }
                        if (TypeID == 0)
                            Builder.Append("i");
                        else if (input.Contains("avatar_effect") == true)
                            Builder.Append("e");
                        else
                            Builder.Append("s");
                        if (input.Contains("avatar_effect") == true)
                        {
                            Builder.Append(Convert.ToChar(2) + Holo.Encoding.encodeVL64(int.Parse(input.Replace("avatar_effect", ""))) + Convert.ToChar(2) + "IPO");
                        }
                        else
                        {
                            string custInformation = "";
                            if (input.Contains(" "))
                                custInformation = input.Split(' ')[1];
                            Builder.Append(Convert.ToChar(2) + Holo.Encoding.encodeVL64(spriteID) + custInformation + Convert.ToChar(2) + "IM");
                        }
                        sendData("AC" + Builder);
                        //}
                    }
                    return;
                }
        Label_0B4C:
            if (userID == this.userID)
            {
                this.refreshHand("last");
            }
            else if (userManager.containsUser(userID))
            {
                userManager.getUser(userID).refreshHand("last");
            }
            this.sendData("AC");
        }

        internal void ProcessPacketoV()
        {
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                int itemID = Holo.Encoding.decodeVL64(currentPacket.Substring(2));
                int trade = client.getInt("SELECT tradeable FROM catalogue_item WHERE tid = '" + itemID + "'");
                this.sendData("In" + Holo.Encoding.encodeVL64(itemID) + Holo.Encoding.encodeVL64(trade));
            }
        }
        internal void ProcessPacketAD()
        {
            if (((this.Room != null) && (this.roomUser != null)) && ((this._tradePartnerRoomUID != -1) && this.Room.containsUser(this._tradePartnerRoomUID)))
            {
                virtualUser user = this.Room.getUser(this._tradePartnerRoomUID);
                this._tradeAccept = false;
                user._tradeAccept = false;
                this.refreshTradeBoxes();
                user.refreshTradeBoxes();
                this.abortTrade();
                this.sendData("Am" + Holo.Encoding.encodeVL64(this.userID) + "H");
                user.sendData("Am" + Holo.Encoding.encodeVL64(this.userID) + "H");
            }
        }

        internal void ProcessPacketAe()
        {
            this.sendData("A~HHHM" + Convert.ToChar(2) + catalogueManager.getPageIndex(this._Rank));
        }

        internal void ProcessPacketAE()
        {
            if (((this.Room != null) && (this.roomUser != null)) && ((this._tradePartnerRoomUID != -1) && this.Room.containsUser(this._tradePartnerRoomUID)))
            {
                virtualUser user = this.Room.getUser(this._tradePartnerRoomUID);
                this._tradeAccept = true;
                this.sendData("Am" + Holo.Encoding.encodeVL64(this.userID) + "I");
                user.sendData("Am" + Holo.Encoding.encodeVL64(this.userID) + "I");
                if (user._tradeAccept)
                {
                    this._tradeConfirm = false;
                    user._tradeConfirm = false;
                    this.sendData("Ao");
                    user.sendData("Ao");
                }
            }
        }

        internal void ProcessPacketAf()
        {
            string pageName = this.currentPacket.Substring(2);
            bool flag1 = pageName == "M";
            this.sendData("A\x007f" + this.currentPacket.Substring(2) + catalogueManager.getPage(pageName, this._Rank));
            if (!this._receivedSpriteIndex)
            {
                this.sendData("DiH" + Convert.ToChar(1) + "DuH");
                this._receivedSpriteIndex = true;
            }
        }

        internal void ProcessPacketAF()
        {
            if (((this.Room != null) && (this.roomUser != null)) && ((this._tradePartnerRoomUID != -1) && this.Room.containsUser(this._tradePartnerRoomUID)))
            {
                this.abortTrade();
                this.refreshHand("update");
            }
        }

        internal void ProcessPacketAG()
        {
            if (((this.Room != null) || (this.roomUser != null)) || (this._tradePartnerRoomUID == -1))
            {
                if (!Config.enableTrading)
                {
                    this.sendData("BK" + stringManager.getString("trading_disabled") + Convert.ToChar(2));
                }
                else
                {
                    int roomUID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                    if (this.Room.containsUser(roomUID))
                    {
                        virtualUser user = this.Room.getUser(roomUID);
                        if (!user.statusManager.containsStatus("trd"))
                        {
                            this._tradePartnerRoomUID = roomUID;
                            this.statusManager.addStatus("trd", "");
                            this.roomUser.Refresh();
                            user._tradePartnerRoomUID = this.roomUser.roomUID;
                            user.statusManager.addStatus("trd", "");
                            user.roomUser.Refresh();
                            user.sendData("Ah" + Holo.Encoding.encodeVL64(this.userID) + "I" + Holo.Encoding.encodeVL64(user.userID) + "I");
                            this.sendData("Ah" + Holo.Encoding.encodeVL64(user.userID) + "I" + Holo.Encoding.encodeVL64(this.userID) + "I");
                        }
                    }
                }
            }
        }

        internal void ProcessPacketAGa()
        {
            if (this.Messenger != null)
            {
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                string str = stringManager.filterSwearwords(this.currentPacket.Substring(Holo.Encoding.encodeVL64(i).Length + 4));
                if (this.Messenger.containsOnlineBuddy(i))
                {
                    userManager.getUser(i).sendData(string.Concat(new object[] { "BF", Holo.Encoding.encodeVL64(this.userID), str, Convert.ToChar(2) }));
                }
                else
                {
                    this.sendData("DE" + Holo.Encoding.encodeVL64(5) + Holo.Encoding.encodeVL64(this.userID));
                }
            }
        }

        internal void ProcessPacketAGb()
        {
            try
            {
                if ((this.Messenger != null) && (this.roomUser != null))
                {
                    int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                    int[] numArray = new int[i];
                    this.currentPacket = this.currentPacket.Substring(Holo.Encoding.encodeVL64(i).Length + 2);
                    for (int j = 0; j < i; j++)
                    {
                        if (this.currentPacket == "")
                        {
                            return;
                        }
                        int userID = Holo.Encoding.decodeVL64(this.currentPacket);
                        if (this.Messenger.hasFriendship(userID) && userManager.containsUser(userID))
                        {
                            numArray[j] = userID;
                        }
                        this.currentPacket = this.currentPacket.Substring(Holo.Encoding.encodeVL64(userID).Length);
                    }
                    string str = this.currentPacket.Substring(2);
                    string packet = string.Concat(new object[] { "BG", Holo.Encoding.encodeVL64(this.userID), str, Convert.ToChar(2) });
                    for (int k = 0; k < i; k++)
                    {
                        if (userManager.containsUser(numArray[k]))
                        {
                            userManager.getUser(numArray[k]).sendData(packet);
                        }
                    }
                }
            }
            catch
            {
                this.sendData("BKSorry something went wrong during sending the invites.");
            }
        }
        internal void ProcessPacketAGB()
        {
            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2, this.currentPacket.Length - 2));
            bool flag = this.currentPacket.Substring(2, 1) == "I";
            this.sendData("@S");
            this.sendData("Bf - HydroHabbo");
            if ((this.Room != null) && (this.roomUser != null))
            {
                this.Room.removeUser(this.roomUser.roomUID, false, "");
            }
            this._roomID = i;
            this._inPublicroom = flag;
            this._ROOMACCESS_PRIMARY_OK = true;
            if (flag)
            {
                string str;
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    str = client.getString("SELECT model FROM rooms WHERE id = '" + i + "'");
                }
                this.sendData(string.Concat(new object[] { "AE", str, Convert.ToChar(2), Holo.Encoding.encodeVL64(i) }));
                this._ROOMACCESS_SECONDARY_OK = true;
                if (roomManager.containsRoom(this._roomID))
                {
                    this.Room = roomManager.getRoom(this._roomID);
                }
                else
                {
                    this.Room = new virtualRoom(this._roomID, this._inPublicroom);
                    roomManager.addRoom(this._roomID, this.Room);
                }
            }
        }

        internal void ProcessPacketAGBL()
        {
            if (this._ROOMACCESS_SECONDARY_OK && !this._inPublicroom)
            {
                DataRow row;
                string str;
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    row = client.getRow("SELECT model, wallpaper, floor FROM rooms WHERE id = '" + this._roomID + "'");
                    str = client.getString("SELECT landscape FROM rooms WHERE id = '" + this._roomID + "'");
                }
                string str2 = "model_" + Convert.ToString(row["model"]);
                this.sendData(string.Concat(new object[] { "AE", str2, Convert.ToChar(2), Holo.Encoding.encodeVL64(this._roomID) }));
                int num = Convert.ToInt32(row["wallpaper"]);
                int num2 = Convert.ToInt32(row["floor"]);
                this.sendData(string.Concat(new object[] { "@nlandscape", Convert.ToChar(2), str.Replace(",", "."), Convert.ToChar(2) }));
                if (num > 0)
                {
                    this.sendData(string.Concat(new object[] { "@nwallpaper", Convert.ToChar(2), num, Convert.ToChar(2) }));
                }
                if (num2 > 0)
                {
                    this.sendData(string.Concat(new object[] { "@nfloor", Convert.ToChar(2), num2, Convert.ToChar(2) }));
                }
                if (!this._isOwner)
                {
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        this._isOwner = client.findsResult(string.Concat(new object[] { "SELECT id FROM rooms WHERE id = '", this._roomID, "' AND owner = '", this._Username, "'" }));/*rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_any_room_controller", this.userID)*/
                    } 
                }
                if (!this._isOwner2)
                {
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        this._isOwner2 = rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_any_room_controller", this.userID);
                    }
                }
                if (this._isOwner)
                {
                    this._hasRights = true;
                    this.sendData("@o");
                }
                if (this._isOwner2)
                {
                    this._hasRights = true;
                    this.sendData("@o");
                }
                if (this._hasRights)
                {
                    this.sendData("@j");
                }
                int i = -1;
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    if (client2.findsResult(string.Concat(new object[] { "SELECT userid FROM room_votes WHERE userid = '", this.userID, "' AND roomid = '", this._roomID, "'" })) | this._isOwner)
                    {
                        i = client2.getInt("SELECT SUM(vote) FROM room_votes WHERE roomid = '" + this._roomID + "'");
                        if (i < 0)
                        {
                            i = 0;
                        }
                    }
                }
                this.sendData("EY" + Holo.Encoding.encodeVL64(i));
                this.sendData("Er" + eventManager.getEvent(this._roomID));
            }
        }

        internal void ProcessPacketAGe()
        {
            if (this.Messenger != null)
            {
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                this.currentPacket = this.currentPacket.Substring(Holo.Encoding.encodeVL64(i).Length + 2);
                int num2 = 0;
                StringBuilder builder = new StringBuilder();
                virtualBuddy buddy = new virtualBuddy(this.userID);
                for (int j = 0; j < i; j++)
                {
                    int num5;
                    if (this.currentPacket == "")
                    {
                        return;
                    }
                    int num4 = Holo.Encoding.decodeVL64(this.currentPacket);
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        num5 = client.getInt(string.Concat(new object[] { "SELECT userid_from FROM messenger_friendrequests WHERE userid_to = '", this.userID, "' AND requestid = '", num4, "'" }));
                    }
                    if (num5 == 0)
                    {
                        return;
                    }
                    virtualBuddy buddy2 = new virtualBuddy(num5);
                    builder.Append(buddy2.ToString(true));
                    num2++;
                    this.Messenger.addBuddy(buddy2, false);
                    if (userManager.containsUser(num5))
                    {
                        userManager.getUser(num5).Messenger.addBuddy(buddy, true);
                    }
                    using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                    {
                        client2.runQuery(string.Concat(new object[] { "INSERT INTO messenger_friendships(userid,friendid) VALUES ('", num5, "','", this.userID, "')" }));
                        client2.runQuery(string.Concat(new object[] { "DELETE FROM messenger_friendrequests WHERE userid_to = '", this.userID, "' AND requestid = '", num4, "' LIMIT 1" }));
                    }
                    this.currentPacket = this.currentPacket.Substring(Holo.Encoding.encodeVL64(num4).Length);
                }
                if (num2 > 0)
                {
                    this.sendData("@MHI" + Holo.Encoding.encodeVL64(num2) + builder.ToString());
                }
            }
        }

        internal void ProcessPacketAGf()
        {
            if (this.Messenger != null)
            {
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(3));
                this.currentPacket = this.currentPacket.Substring(Holo.Encoding.encodeVL64(i).Length + 3);
                for (int j = 0; j < i; j++)
                {
                    if (this.currentPacket == "")
                    {
                        return;
                    }
                    int num3 = Holo.Encoding.decodeVL64(this.currentPacket);
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        client.runQuery(string.Concat(new object[] { "DELETE FROM messenger_friendrequests WHERE userid_to = '", this.userID, "' AND requestid = '", num3, "' LIMIT 1" }));
                    }
                    this.currentPacket = this.currentPacket.Substring(Holo.Encoding.encodeVL64(num3).Length);
                }
            }
        }

        internal void ProcessPacketAGg()
        {
            if (this.Messenger != null)
            {
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    client.AddParamWithValue("username", this.currentPacket.Substring(4));
                    int userID = client.getInt("SELECT id FROM users WHERE name = @username");
                    if (((userID > 0) && !this.Messenger.hasFriendRequests(userID)) && !this.Messenger.hasFriendship(userID))
                    {
                        int num2 = client.getInt("SELECT MAX(requestid) FROM messenger_friendrequests WHERE userid_to = '" + userID + "'") + 1;
                        client.runQuery(string.Concat(new object[] { "INSERT INTO messenger_friendrequests(userid_to,userid_from,requestid) VALUES ('", userID, "','", this.userID, "','", num2, "')" }));
                        if (userManager.getUser(userID) != null)
                        {
                            userManager.getUser(userID).sendData(string.Concat(new object[] { "BDI", this._Username, Convert.ToChar(2), this.userID, Convert.ToChar(2) }));
                        }
                    }
                }
            }
        }

        internal void ProcessPacketAGG()
        {
            this.refreshAppearance(false, true, false, true);
        }

        internal void ProcessPacketAGh()
        {
            if (this.Messenger != null)
            {
                int iD = Holo.Encoding.decodeVL64(this.currentPacket.Substring(3));
                this.Messenger.removeBuddy(iD);
                if (userManager.containsUser(iD) && (userManager.getUser(iD).Messenger != null))
                {
                    userManager.getUser(iD).Messenger.removeBuddy(this.userID);
                }
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    client.runQuery(string.Concat(new object[] { "DELETE FROM messenger_friendships WHERE (userid = '", this.userID, "' AND friendid = '", iD, "') OR (userid = '", iD, "' AND friendid = '", this.userID, "') LIMIT 1" }));
                }
            }
        }

        internal void ProcessPacketAGH()
        {
            this.refreshValueables(true, true);
        }

        internal void ProcessPacketAGi()
        {
            string[] strArray;
            string packet = "Fs";
            string str2 = "";
            string str3 = "";
            string str4 = "";
            int i = 0;
            int num2 = 0;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                string val = this.currentPacket.Substring(4).Replace(@"\", @"\").Replace("'", @"\'");
                client.AddParamWithValue("search", val);
                strArray = dataHandling.dColToArray(client.getColumn("SELECT id FROM users WHERE name LIKE '" + val + "%' LIMIT 20 "));
            }
            for (int j = 0; j < strArray.Length; j++)
            {
                DataRow row;
                int userID = Convert.ToInt32(strArray[j]);
                bool flag = userManager.containsUser(userID);
                string str6 = flag ? "I" : "H";
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    row = client2.getRow("SELECT name, mission, lastvisit, figure FROM users WHERE id = " + userID.ToString());
                }
                str4 = string.Concat(new object[] { Holo.Encoding.encodeVL64(userID), row[0], "\x0002", row[1], "\x0002", str6, str6, "\x0002", str6, flag ? row[3] : "", "\x0002", flag ? "" : row[2], "\x0002" });
                if (this.Messenger.hasFriendship(userID))
                {
                    i++;
                    str2 = str2 + str4;
                }
                else
                {
                    num2++;
                    str3 = str3 + str4;
                }
            }
            str2 = Holo.Encoding.encodeVL64(i) + str2;
            str3 = Holo.Encoding.encodeVL64(num2) + str3;
            packet = packet + str2 + str3;
            this.sendData(packet);
        }

        internal void ProcessPacketAGl()
        {
            string str = Convert.ToString(this.currentPacket.Substring(7));
            if (str != "")
            {
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    client.runQuery(string.Concat(new object[] { "UPDATE users SET figure = '", str, "' WHERE id = '", this.userID, "' LIMIT 1" }));
                }
                this._Figure = str;
                this.sendData(string.Concat(new object[] { "DJM", this._Figure, Convert.ToChar(2), this._Sex, Convert.ToChar(2), this._Mission, Convert.ToChar(2) }));
                if (userManager.containsUser(this.userID))
                {
                    userManager.getUser(this.userID).refreshAppearance(true, false, true, true);
                }
            }
        }

        internal void ProcessPacketAGL()
        {
            this.refreshMessenger();
        }

        internal void ProcessPacketAGO()
        {
            if (this.Messenger != null)
            {
                this.sendData("@M" + this.Messenger.getUpdates());
            }
        }

        internal void ProcessPacketAGp()
        {
            bool flag;
            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(4));
            int num2 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(Holo.Encoding.encodeVL64(i).Length + 4));
            string userName = "";
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                userName = client.getString("SELECT username FROM cms_help WHERE id = '" + i + "'");
                flag = client.findsResult("SELECT id FROM cms_help WHERE id = '" + i + "'");
            }
            if (!flag)
            {
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    client2.runQuery("DELETE FROM cms_help WHERE id = '" + i + "' LIMIT 1");
                }
                userManager.sendToRank(Config.Minimum_CFH_Rank, true, "DQ" + Holo.Encoding.encodeVL64(i) + Convert.ToChar(2));
            }
            else if (num2 == 1)
            {
                virtualUser user = userManager.getUser(userManager.getUserID(userName));
                if (user._isLoggedIn)
                {
                    user._blockCFH = true;
                }
                using (DatabaseClient client3 = Eucalypt.dbManager.GetClient())
                {
                    client3.runQuery("DELETE FROM cms_help WHERE id = '" + i + "' LIMIT 1");
                }
                userManager.sendToRank(Config.Minimum_CFH_Rank, true, "DQ" + Holo.Encoding.encodeVL64(i) + Convert.ToChar(2));
            }
            else
            {
                DataRow row;
                string str2;
                using (DatabaseClient client4 = Eucalypt.dbManager.GetClient())
                {
                    row = client4.getRow("SELECT picked_up,username,message,roomid FROM cms_help WHERE id = '" + i + "'");
                    str2 = client4.getString("SELECT name FROM rooms WHERE id = '" + Convert.ToString(row[3]) + "'");
                }
                userManager.sendToRank(Config.Minimum_CFH_Rank, true, string.Concat(new object[] { 
                    "BT", Holo.Encoding.encodeVL64(i), Convert.ToChar(2), "IPicked up by ", this._Username, " at ", DateTime.Now.ToLongTimeString(), "!", Convert.ToChar(2), Convert.ToString(row[1]), Convert.ToChar(2), Convert.ToString(row[2]), Convert.ToChar(2), Holo.Encoding.encodeVL64(Convert.ToInt32(row[3])), Convert.ToChar(2), str2, 
                    Convert.ToChar(2), "I", Convert.ToChar(2), Holo.Encoding.encodeVL64(Convert.ToInt32(row[3]))
                 }));
                using (DatabaseClient client5 = Eucalypt.dbManager.GetClient())
                {
                    client5.runQuery("UPDATE cms_help SET picked_up = '1' WHERE id = '" + i + "' LIMIT 1");
                }
            }
        }

        internal void ProcessPacketAGq()
        {
            this.sendData("Bc" + DateTime.Today.ToShortDateString());
        }

        internal void ProcessPacketAGQ()
        {
            this.NavigatorSearch(this.UserSearchID);
            this.UserSearchID++;
        }
        internal void ProcessPacketAGS()
        {
            int roomID = Holo.Encoding.decodeVL64(currentPacket.Substring(3));
            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
            {
                dbClient.runQuery("INSERT INTO users_favourites (userid,roomid) VALUES ('" + userID + "','" + roomID + "')");
            }
            sendData("GK" + Holo.Encoding.encodeVL64(roomID) + "I" + Convert.ToChar(2));
            GetFavourites(UserSearchID);

        }
        internal void ProcessPacketAGT()
        {
            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(3));
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                client.runQuery(string.Concat(new object[] { "DELETE FROM users_favourites WHERE userid = '", this.userID, "' AND roomid = '", i, "' LIMIT 1" }));
            }
            this.sendData(string.Concat(new object[] { "GK", Holo.Encoding.encodeVL64(i), "H", Convert.ToChar(2) }));
        }

        internal void ProcessPacketAGu()
        {
            this.Room.removeUser(this.roomUser.roomUID, false, "");
            roomManager.removeRoom(this._roomID);
            this.leaveCurrentRoom("", false);
        }

        internal void ProcessPacketAGU()
        {
            DataRow row;
            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                row = client.getRow("SELECT name,owner,description,model,state,superusers,showname,category,visitors_now,visitors_max FROM rooms WHERE id = '" + i + "' AND NOT(owner IS NULL)");
            }
            if (row.Table.Rows.Count > 0)
            {
                StringBuilder builder = new StringBuilder(Holo.Encoding.encodeVL64(Convert.ToInt32(row[5])) + Holo.Encoding.encodeVL64(Convert.ToInt32(row[4])) + Holo.Encoding.encodeVL64(i));
                if (((Convert.ToString(row[1]) != this._Username) && (Convert.ToString(row[6]) == "0")) && rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_see_all_roomowners", this.userID))
                {
                    builder.Append("-");
                }
                else
                {
                    builder.Append(Convert.ToString(row[1]));
                }
                builder.Append(string.Concat(new object[] { Convert.ToChar(2), "model_", Convert.ToString(row[3]), Convert.ToChar(2), Convert.ToString(row[0]), Convert.ToChar(2), Convert.ToString(row[2]), Convert.ToChar(2), Holo.Encoding.encodeVL64(Convert.ToInt32(row[6])) }));
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    if (client2.findsResult("SELECT id FROM room_categories WHERE id = '" + Convert.ToString(row[7]) + "' AND trading = '1'"))
                    {
                        builder.Append("I");
                    }
                    else
                    {
                        builder.Append("H");
                    }
                }
                builder.Append(Holo.Encoding.encodeVL64(Convert.ToInt32(row[8])) + Holo.Encoding.encodeVL64(Convert.ToInt32(row[9])));
                this.sendData("@v" + builder.ToString());
            }
        }

        internal void ProcessPacketAGv()
        {
            this.sendData("@S");
        }

        internal void ProcessPacketAGw()
        {
            try
            {
                if ((!this._isMuted && (this.Room != null)) && (this.roomUser != null))
                {
                    string message = this.currentPacket.Substring(4);
                    userManager.addChatMessage(this._Username, this._roomID, message);
                    message = stringManager.filterSwearwords(message);
                    if ((message.Substring(0, 1) == ":") && this.isSpeechCommand(message.Substring(1)))
                    {
                        if (this.roomUser.isTyping)
                        {
                            this.Room.sendData("Ei" + Holo.Encoding.encodeVL64(this.roomUser.roomUID) + "H");
                            this.roomUser.isTyping = false;
                        }
                    }
                    else if (this.currentPacket.Substring(1, 1) == "w")
                    {
                        this.Room.sendShout(this.roomUser, message);
                    }
                    else
                    {
                        this.Room.sendSaying(this.roomUser, message);
                    }
                }
            }
            catch (Exception)
            {
            }
        }

        internal void ProcessPacketAGW()
        {
            int roomID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                if (client.findsResult(string.Concat(new object[] { "SELECT id FROM rooms WHERE id = '", roomID, "' AND owner = '", this._Username, "'" })))
                {
                    client.runQuery("DELETE FROM room_rights WHERE roomid = '" + roomID + "'");
                    client.runQuery("DELETE FROM rooms WHERE id = '" + roomID + "' LIMIT 1");
                    client.runQuery("DELETE FROM users_favourites WHERE roomid = '" + this._roomID + "'");
                    client.runQuery("DELETE FROM room_votes WHERE roomid = '" + roomID + "'");
                    client.runQuery("DELETE FROM room_bans WHERE roomid = '" + roomID + "' LIMIT 1");
                    client.runQuery("DELETE FROM furniture WHERE roomid = '" + roomID + "'");
                    client.runQuery("DELETE FROM furniture_moodlight WHERE roomid = '" + roomID + "'");
                }
            }
            if (roomManager.containsRoom(roomID))
            {
                roomManager.getRoom(roomID).kickUsers(byte.Parse("9"), "This room has been deleted");
            }
        }

        internal void ProcessPacketAGx()
        {
            if ((!this._isMuted && (this.Room != null)) && (this.roomUser != null))
            {
                string receiver = this.currentPacket.Substring(4).Split(new char[] { ' ' })[0];
                string message = this.currentPacket.Substring(receiver.Length + 5);
                userManager.addChatMessage(this._Username, this._roomID, message);
                message = stringManager.filterSwearwords(message);
                this.Room.sendWhisper(this.roomUser, receiver, message);
            }
        }

        internal void ProcessPacketAGy()
        {
            if (!this._inPublicroom)
            {
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    this._isOwner = client.findsResult(string.Concat(new object[] { "SELECT id FROM rooms WHERE id = '", this._roomID, "' AND owner = '", this._Username, "'" }));
                    if (!this._isOwner)
                    {
                        this._hasRights = client.findsResult(string.Concat(new object[] { "SELECT userid FROM room_rights WHERE roomid = '", this._roomID, "' AND userid = '", this.userID, "'" }));
                    }
                    this._isOwner2 = client.findsResult(string.Concat(new object[] { "SELECT id FROM rooms WHERE id = '", this._roomID, "' AND owner = '", this._Username, "'" }));
                    if (!this._isOwner2)
                    {
                        this._hasRights = client.findsResult(string.Concat(new object[] { "SELECT userid FROM room_rights WHERE roomid = '", this._roomID, "' AND userid = '", this.userID, "'" }));
                    }
                    if (!this._hasRights)
                    {
                        this._hasRights = client.findsResult("SELECT id FROM rooms WHERE id = '" + this._roomID + "' AND superusers = '1'");
                    }
                    if (((this._teleporterID == 0) && !this._isOwner) && !rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_enter_locked_rooms", this.userID))
                    {
                        int num = client.getInt("SELECT state FROM rooms WHERE id = '" + this._roomID + "'");
                        if (!this._ROOMACCESS_PRIMARY_OK && (num != 2))
                        {
                            return;
                        }
                        if (client.findsResult(string.Concat(new object[] { "SELECT roomid FROM room_bans WHERE roomid = '", this._roomID, "' AND userid = '", this.userID, "'" })))
                        {
                            if (DateTime.Compare(DateTime.Parse(client.getString(string.Concat(new object[] { "SELECT ban_expire FROM room_bans WHERE roomid = '", this._roomID, "' AND userid = '", this.userID, "'" }))), DateTime.Now) > 0)
                            {
                                this.sendData("C`PA");
                                this.sendData("@R");
                                return;
                            }
                            client.runQuery(string.Concat(new object[] { "DELETE FROM room_bans WHERE roomid = '", this._roomID, "' AND userid = '", this.userID, "' LIMIT 1" }));
                        }
                        switch (num)
                        {
                            case 1:
                                if (!roomManager.containsRoom(this._roomID))
                                {
                                    this.sendData("BC");
                                }
                                else
                                {
                                    roomManager.getRoom(this._roomID).sendDataToRights("A[" + this._Username + Convert.ToChar(2));
                                    this.sendData("A[" + Convert.ToChar(2));
                                }
                                return;

                            case 2:
                                {
                                    string str = "";
                                    try
                                    {
                                        str = this.currentPacket.Substring(Holo.Encoding.encodeVL64(this._roomID).Length + 4);
                                    }
                                    catch
                                    {
                                    }
                                    string str2 = client.getString("SELECT password FROM rooms WHERE id = '" + this._roomID + "' LIMIT 1");
                                    if (str != str2)
                                    {
                                        this.sendData("@afhFF" + Convert.ToChar(2));
                                        return;
                                    }
                                    break;
                                }
                        }
                    }
                    this._ROOMACCESS_SECONDARY_OK = true;
                    this.sendData("@i");
                }
            }
        }
        
        internal void ProcessPacketAGY()
        {
            int num;
            string str = this.currentPacket.Substring(4, Holo.Encoding.decodeB64(currentPacket.Substring(2, 2)));
            string str2 = this.currentPacket.Substring(12 + str.Length);
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                num = client.getInt("SELECT max(id) FROM rooms WHERE publicroom = 0");
            }
            num++;
            using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
            {
                client2.runQuery(string.Concat(new object[] { "INSERT INTO rooms (id, name, owner, model, state, showname) VALUES ('", num, "', '", str, "', '", this._Username, "', '", str2, "', 0, 1)" }));
            }
            this.sendData(string.Concat(new object[] { "@{", Holo.Encoding.encodeVL64(num), str, Convert.ToChar(2) }));
        }
        
        internal void ProcessPacketAGZ()
        {
            this.refreshClub();
        }

        internal void ProcessPacketAh()
        {
            if ((((this.Room != null) && (this.roomUser != null)) && (!this.statusManager.containsStatus("swim") && !this.statusManager.containsStatus("sit"))) && !this.statusManager.containsStatus("lay"))
            {
                int num = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                this.statusManager.handleStatus("sign", Convert.ToString(num), Config.Statuses_Wave_waveDuration);
                this.statusManager.Refresh();
            }
        }

        internal void ProcessPacketAH()
        {
            if (((this.Room != null) && (this.roomUser != null)) && ((this._tradePartnerRoomUID != -1) && this.Room.containsUser(this._tradePartnerRoomUID)))
            {
                int num2;
                int num = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    num2 = client.getInt(string.Concat(new object[] { "SELECT tid FROM furniture WHERE id = '", num, "' AND ownerid = '", this.userID, "' AND roomid = '0'" }));
                }
                if (num2 != 0)
                {
                    this._tradeItems[this._tradeItemCount] = num;
                    this._tradeItemCount++;
                    virtualUser user = this.Room.getUser(this._tradePartnerRoomUID);
                    this._tradeAccept = false;
                    user._tradeAccept = false;
                    this.refreshTradeBoxes();
                    user.refreshTradeBoxes();
                }
            }
        }

        internal void ProcessPacketAI()
        {
            if ((this._hasRights && !this._inPublicroom) && ((this.Room != null) && (this.roomUser != null)))
            {
                int itemID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (this.Room.floorItemManager.containsItem(itemID))
                {
                    int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2 + Holo.Encoding.encodeVL64(itemID).Length));
                    int num3 = Holo.Encoding.decodeVL64(this.currentPacket.Substring((2 + Holo.Encoding.encodeVL64(itemID).Length) + Holo.Encoding.encodeVL64(i).Length));
                    byte z = Convert.ToByte(Holo.Encoding.decodeVL64(this.currentPacket.Substring(((2 + Holo.Encoding.encodeVL64(itemID).Length) + Holo.Encoding.encodeVL64(i).Length) + Holo.Encoding.encodeVL64(num3).Length)));
                    this.Room.floorItemManager.relocateItem(itemID, i, num3, z);
                }
            }
        }

        internal void ProcessPacketAj()
        {
            if ((this.Room != null) && this.roomUser.Diving)
            {
                string str = this.currentPacket.Substring(2);
                this.Room.sendData(string.Concat(new object[] { "AJ", this.roomUser.roomUID, Convert.ToChar(13), str }));
            }
        }

        internal void ProcessPacketAk()
        {
            if ((this.Room != null) && this.roomUser.Diving)
            {
                this.Room.DiveDoorOpen = true;
                this.roomUser.walkLock = false;
                string[] strArray = this.currentPacket.Substring(2).Split(",".ToCharArray());
                this.Room.sendData("AGBIGSPLASH position " + strArray[0] + "," + strArray[1]);
                this.Room.sendData("AGdoor open");
                this.Room.sendSpecialCast("cam1", "targetcamera " + this.roomUser.roomUID);
                this.Room.sqUNIT[this.roomUser.X, this.roomUser.Y] = false;
                this.Room.sqUNIT[0x1a, 3] = false;
                this.Room.sqUNIT[0x1a, 4] = false;
                this.roomUser.X = int.Parse(strArray[0]);
                this.roomUser.Y = int.Parse(strArray[1]);
                this.roomUser.Diving = false;
                this.roomUser.InQueue = false;
                this.roomUser.H = this.Room.sqFLOORHEIGHT[int.Parse(strArray[0]), int.Parse(strArray[1])];
                if (this.roomUser.H <= 7.0)
                {
                    this.statusManager.addStatus("swim", "");
                }
                this.roomUser.goalX = 20;
                this.roomUser.goalY = 0x13;
            }
        }

        internal void ProcessPacketAK() // Room - walk to a new square
        {
            if (Room != null && roomUser != null && roomUser.walkLock == false)
            {
                int goalX = Holo.Encoding.decodeVL64(currentPacket.Substring(2));
                int goalY = Holo.Encoding.decodeVL64(currentPacket.Substring(2 + Holo.Encoding.encodeVL64(goalX).Length));

                if (goalX == Room.doorX && Room.doorY == goalY)
                {
                    sendData("@R");
                    Handler.ProcessPacket("@u");
                    return;
                }
                if (roomUser.SPECIAL_TELEPORTABLE) //wat is hier mee? P
                {
                    int oldX = roomUser.X;
                    int oldY = roomUser.Y;

                    roomUser.X = goalX;
                    roomUser.Y = goalY;
                    roomUser.goalX = -1;
                    Room.refreshCoord(goalX, goalY);

                    Room.sqUNIT[oldX, oldY] = false;
                    Room.setSquareState(oldX, oldY, 1, 1, virtualRoom.squareState.Open);
                    refreshAppearance(false, false, true, true);
                }
                else
                {
                    roomUser.goalX = goalX;
                    roomUser.goalY = goalY;
                }
            }
            return;
        }

        internal void ProcessPacketAL()
        {
            if (((this.Room != null) && (this.roomUser != null)) && !this._inPublicroom)
            {
                int itemID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (this.Room.floorItemManager.containsItem(itemID))
                {
                    floorItem item = this.Room.floorItemManager.getItem(itemID);
                    string sprite = item.Sprite;
                    if ((((sprite == "edice") || (sprite == "edicehc")) || (sprite == "bottle")) && (((Math.Abs((int)(this.roomUser.X - item.X)) <= 1) && (Math.Abs((int)(this.roomUser.Y - item.Y)) <= 1)) || (sprite == "bottle")))
                    {
                        this.Room.sendData("AZ" + Holo.Encoding.encodeVL64(itemID) + "M");
                        int i = new Random(DateTime.Now.Millisecond).Next(1, 7);
                        this.Room.sendData("AZ" + Holo.Encoding.encodeVL64(itemID) + Holo.Encoding.encodeVL64(i), 0x7d0);
                        item.Var = i.ToString();
                        using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                        {
                            client.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", i, "' WHERE id = '", itemID, "' LIMIT 1" }));
                        }
                    }
                }
            }
        }

        internal void ProcessPacketAM()
        {
            if (((this.Room != null) && (this.roomUser != null)) && !this._inPublicroom)
            {
                int itemID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (this.Room.floorItemManager.containsItem(itemID))
                {
                    floorItem item = this.Room.floorItemManager.getItem(itemID);
                    string sprite = item.Sprite;
                    if (((sprite == "edice") || (sprite == "edicehc")) && ((Math.Abs((int)(this.roomUser.X - item.X)) <= 1) && (Math.Abs((int)(this.roomUser.Y - item.Y)) <= 1)))
                    {
                        item.Var = "0";
                        this.Room.sendData("AZ" + Holo.Encoding.encodeVL64(itemID) + Holo.Encoding.encodeVL64(0));
                        using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                        {
                            client.runQuery("UPDATE furniture SET var = '0' WHERE id = '" + itemID + "' LIMIT 1");
                        }
                    }
                }
            }
        }

        internal void ProcessPacketAN()
        {
            string str = "s";
            if ((this._isOwner && !this._inPublicroom) && ((this.Room != null) && (this.roomUser != null)))
            {
                int itemID = Holo.Encoding.decodeVL64(Convert.ToString(this.currentPacket.Substring(2)));
                if (this.Room.floorItemManager.containsItem(itemID))
                {
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        DataColumn column = client.getColumn("SELECT itemid FROM furniture_presents WHERE id = '" + itemID + "'");
                        if (column.Table.Rows.Count > 0)
                        {
                            StringBuilder builder = new StringBuilder();
                            int num2 = 0;
                            foreach (DataRow row in column.Table.Rows)
                            {
                                builder.Append(" OR id = '" + Convert.ToString(row["itemid"]) + "'");
                                num2 = Convert.ToInt32(row["itemid"]);
                            }
                            client.runQuery("UPDATE furniture SET roomid = '-' WHERE " + builder.ToString().Substring(4));
                            this.Room.floorItemManager.removeItem(itemID, 0);
                            catalogueManager.itemTemplate template = catalogueManager.getTemplate(client.getInt("SELECT tid FROM furniture WHERE id = '" + num2 + "'"));
                            if (template.typeID > 0)
                            {
                                str = "s";
                            }
                            else
                            {
                                str = "i";
                            }
                            if (template.typeID > 0)
                            {
                                this.sendData(string.Concat(new object[] { "BA", str, Convert.ToChar(2), Holo.Encoding.encodeVL64(template.indexID) }));
                            }
                            else
                            {
                                this.sendData(string.Concat(new object[] { "BA", str, Convert.ToChar(2), Holo.Encoding.encodeVL64(template.indexID) }));
                            }
                        }
                        client.runQuery(string.Concat(new object[] { "DELETE FROM furniture_presents WHERE id = '", itemID, "' LIMIT ", column.Table.Rows.Count }));
                        client.runQuery("DELETE FROM furniture WHERE id = '" + itemID + "' LIMIT 1");
                    }
                    this.refreshHand("last");
                }
            }
        }

        internal void ProcessPacketAO() // Room - rotate user
        {
            //if (Room != null && roomUser != null && statusManager.containsStatus("sit") == false && statusManager.containsStatus("lay") == false)
            //{
               // int X = Holo.Encoding.decodeVL64(currentPacket.Substring(2));
               // int Y = Holo.Encoding.decodeVL64(currentPacket.Substring(Holo.Encoding.encodeVL64((X)).Length + 2));
               // roomUser.Z1 = Rooms.Pathfinding.Rotation.Calculate(roomUser.X, roomUser.Y, X, Y);
               // roomUser.Z2 = roomUser.Z1;
                roomUser.Refresh();
            //}
        }

        internal void ProcessPacketA_() // Kick user A_
        {
            if (Room == null || roomUser == null || _inPublicroom || _hasRights == false)
                return;

            int Target = Holo.Encoding.decodeVL64(currentPacket.Substring(2));
            virtualUser _Target = userManager.getUser(Target);
            if (_Target._roomID != _roomID)
                return;

            if (_Target._isOwner && (_Target._Rank > _Rank || rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_kick_immunity", userID)))
                return;

            if (_Target._isOwner && (_Target._Rank > _Rank || rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_any_room_controller", userID)))
                return;

            _Target.roomUser.walkLock = true;
            _Target.roomUser.walkDoor = true;
            _Target.roomUser.goalX = Room.doorX;
            _Target.roomUser.goalY = Room.doorY;
        }


        internal void ProcessPacketAP()
        {
            if (this.currentPacket.Substring(2) != "H")
            {
                this.sendData("@aThere is no drink machine.");
            }
        }

        internal void ProcessPacketAPAR()
        {
            if (((this.Room != null) && (this.roomUser != null)) && (!this.statusManager.containsStatus("sit") && !this.statusManager.containsStatus("lay")))
            {
                int num = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (((num <= 2) || rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_use_club_dance", this.userID)) && ((num >= -1) && (num <= 4)))
                {
                    this.statusID = "G`";
                    this.statusCount = num;
                    this.Room.sendData(this.statusID + Holo.Encoding.encodeVL64(this.roomUser.roomUID) + Holo.Encoding.encodeVL64(this.statusCount));
                    this.statusManager.Refresh();
                }
            }
        }

        internal void ProcessPacketApeJ()
        {
            if (currentPacket.Contains("¬") || currentPacket.Contains(Convert.ToChar(1).ToString()) || currentPacket.Contains(Convert.ToChar(2).ToString()))
                sendData("@d" + "I"); // Name is invalid
            else
            {
                sendData("@d" + "H"); // Name is valid
            }

        }

        internal void ProcessPacketnz()
        {
            int petID = Holo.Encoding.decodeVL64(currentPacket.Substring(2));
            int X = Holo.Encoding.decodeVL64(currentPacket.Substring(2 + Holo.Encoding.encodeVL64(petID).Length));
            int Y = Holo.Encoding.decodeVL64(currentPacket.Substring(2 + Holo.Encoding.encodeVL64(petID).Length + Holo.Encoding.encodeVL64(X).Length));
            Room.addPet(petID, X, Y, true);
            sendData(@"I\" + Holo.Encoding.encodeVL64(petID));
        }
        internal void ProcessPacketny()
        {
            int petID = Holo.Encoding.decodeVL64(currentPacket.Substring(2));
            sendData("IY" + Room.getPetString(petID));
        }
        internal void ProcessPacketnx()
        {
            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
            {
                dbClient.AddParamWithValue("@ownerid", userID);
                DataTable dTable = dbClient.ReadDataTable("SELECT * FROM pets WHERE owner = @ownerid AND roomid = 0");
                StringBuilder Builder = new StringBuilder();
                int count = 0;
                foreach (DataRow dRow in dTable.Rows)
                {
                    count++;
                    Builder.Append(Holo.Encoding.encodeVL64(int.Parse(dRow["id"].ToString())));
                    Builder.Append(dRow["name"].ToString());
                    Builder.Append(Convert.ToChar(2));
                    Builder.Append(int.Parse(dRow["type"].ToString()));
                    Builder.Append(Convert.ToChar(32));
                    Builder.Append(dRow["race"].ToString());
                    Builder.Append(Convert.ToChar(32));
                    Builder.Append(dRow["colour"].ToString());
                    Builder.Append(Convert.ToChar(2));
                    Builder.Append(Holo.Encoding.encodeVL64(int.Parse(dRow["type"].ToString())));
                }
                sendData("IX" + Holo.Encoding.encodeVL64(count) + Builder);
            }
        }

        internal void ProcessPacketApeo()
        {
            if (this.Room == null)
            {
                userManager.sendData(this.currentPacket.Substring(2) + Convert.ToChar(2));
            }
        }

        internal void ProcessPacketapeU()
        {
            this.sendData("@R" + Convert.ToChar(1));
        }

        internal void ProcessPacketAs()
        {
            if (((this.Room != null) && (this.roomUser != null)) && !this.roomUser.walkDoor)
            {
                this.roomUser.walkDoor = true;
                this.roomUser.goalX = this.Room.doorX;
                this.roomUser.goalY = this.Room.doorY;
            }
        }

        internal void ProcessPacketAS() // Item handling - stickies/photo's - open stickie/photo
        {
            if (Room == null || roomUser == null || _inPublicroom)
                return;

            int itemID = Holo.Encoding.decodeVL64(currentPacket.Substring(2));
            if (Room.wallItemManager.containsItem(itemID))
            {
                string Message;
                using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                {
                    Message = dbClient.getString("SELECT text FROM furniture_stickies WHERE id = '" + itemID + "'");
                }
                sendData("@p" + itemID + Convert.ToChar(2) + Room.wallItemManager.getItem(itemID).Var + " " + Message + Convert.ToChar(2));
            }
        }

        internal void ProcessPacketAt()
        {
            if ((this.Room != null) || ((this.roomUser != null) && this.Room.hasSwimmingPool))
            {
                virtualRoom.squareTrigger trigger = this.Room.getTrigger(this.roomUser.X, this.roomUser.Y);
                if ((trigger.Object == "curtains1") || (trigger.Object == "curtains2"))
                {
                    this.roomUser.swimOutfit = this.currentPacket.Substring(2);
                    this.Room.sendData(@"@\I" + this.roomUser.detailsString);
                    this.Room.sendSpecialCast(trigger.Object, "open");
                    this.roomUser.walkLock = false;
                    this.roomUser.goalX = trigger.goalX;
                    this.roomUser.goalY = trigger.goalY;
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        string val = this.currentPacket.Substring(2);
                        if (val != "@@")
                        {
                            val = this.currentPacket.Substring(4);
                        }
                        else
                        {
                            this.refreshAppearance(true, true, true, true);
                        }
                        client.AddParamWithValue("figure_swim", val);
                        client.AddParamWithValue("id", this.userID);
                        client.runQuery("UPDATE users SET figure_swim = @figure_swim WHERE id = @id LIMIT 1");
                    }
                }
            }
        }

        internal void ProcessPacketAT()
        {
            if (this.currentPacket.Contains("\x0003"))
            {
                this.currentPacket = this.currentPacket.Replace(Convert.ToChar(3).ToString(), Convert.ToChar(13).ToString());
            }
            if ((this._hasRights && (this.Room != null)) && ((this.roomUser != null) && !this._inPublicroom))
            {
                int itemID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (this.Room.wallItemManager.containsItem(itemID))
                {
                    wallItem item = this.Room.wallItemManager.getItem(itemID);
                    string sprite = item.Sprite;
                    switch (sprite)
                    {
                        case "post.it":
                        case "post.it.vd":
                            {
                                string str2 = "FFFFFF";
                                if (sprite == "post.it")
                                {
                                    str2 = this.currentPacket.Substring(4 + Holo.Encoding.encodeVL64(itemID).Length, 6);
                                    if (((str2 != "FFFF33") && (str2 != "FF9CFF")) && ((str2 != "9CFF9C") && (str2 != "9CCEFF")))
                                    {
                                        return;
                                    }
                                }
                                string text = this.currentPacket.Substring((4 + Holo.Encoding.encodeVL64(itemID).Length) + 7);
                                if (text.Length <= 0x2ac)
                                {
                                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                                    {
                                        client.AddParamWithValue("text", stringManager.filterSwearwords(text).Replace("/r", Convert.ToChar(13).ToString()));
                                        if (str2 != item.Var)
                                        {
                                            client.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", str2, "' WHERE id = '", itemID, "' LIMIT 1" }));
                                        }
                                        item.Var = str2;
                                        client.runQuery("UPDATE furniture_stickies SET text = @text WHERE id = '" + itemID + "' LIMIT 1");
                                    }
                                    catalogueManager.itemTemplate template = catalogueManager.getTemplate(item.templateID);
                                    this.Room.sendData(string.Concat(new object[] { "AU", itemID, Convert.ToChar(2), Holo.Encoding.encodeVL64(template.indexID), item.wallPosition, Convert.ToChar(2), str2, Convert.ToChar(2) }));
                                }
                                break;
                            }
                    }
                }
            }
        }

        internal void ProcessPacketATNG()
        {
            if (((this.Room != null) && (this.roomUser != null)) && (!this._inPublicroom && this._isOwner))
            {
                virtualUser user = userManager.getUser(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2)));
                if (((user._roomID == this._roomID) && !user._hasRights) && !user._isOwner)
                {
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        client.runQuery(string.Concat(new object[] { "INSERT INTO room_rights(roomid,userid) VALUES ('", this._roomID, "','", user.userID, "')" }));
                    }
                    user._hasRights = true;
                    user.statusManager.addStatus("flatctrl", "onlyfurniture");
                    user.roomUser.Refresh();
                    user.sendData("@j");
                }
            }
        }

        internal void ProcessPacketAU()
        {
            if ((this._isOwner && (this.Room != null)) && ((this.roomUser != null) && !this._inPublicroom))
            {
                int itemID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (this.Room.wallItemManager.containsItem(itemID) && (stringManager.getStringPart(this.Room.wallItemManager.getItem(itemID).Sprite, 0, 7) == "post.it"))
                {
                    this.Room.wallItemManager.removeItem(itemID, 0);
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        client.runQuery("DELETE FROM furniture_stickies WHERE id = '" + itemID + "' LIMIT 1");
                    }
                }
            }
        }

        internal void ProcessPacketAUL()
        {
            if ((this.Room != null) && (this.roomUser != null))
            {
                this.Room.sendData("Ga" + Holo.Encoding.encodeVL64(this.roomUser.roomUID));
            }
        }



        internal void ProcessPacketAV()
        {
            if (this._blockCFH)
            {
                this.sendData("BKYou have been blocked from Live Help!" + Convert.ToChar(2));
            }
            else
            {
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    if (client.findsResult("SELECT id FROM cms_help WHERE username = '" + this._Username + "' AND picked_up = '0'"))
                    {
                        return;
                    }
                }
                int length = Holo.Encoding.decodeB64(this.currentPacket.Substring(2, 2));
                if (length != 0)
                {
                    int num2;
                    string str2;
                    string val = this.currentPacket.Substring(4, length);
                    using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                    {
                        client2.AddParamWithValue("username", this._Username);
                        client2.AddParamWithValue("ip", this._ConnectionManager.connectionRemoteIP);
                        client2.AddParamWithValue("message", val);
                        client2.AddParamWithValue("date", DateTime.Now);
                        client2.AddParamWithValue("roomid", this._roomID.ToString());
                        client2.runQuery("INSERT INTO cms_help (username,ip,message,date,picked_up,subject,roomid) VALUES (@username,@ip,@message,@date,'0','CFH message [hotel]',@roomid)");
                        num2 = client2.getInt("SELECT id FROM cms_help WHERE username = @username AND picked_up = '0'");
                        str2 = client2.getString("SELECT name FROM rooms WHERE id = @roomid");
                    }
                    this.sendData("EAH");
                    userManager.sendToRank(Config.Minimum_CFH_Rank, true, string.Concat(new object[] { 
                        "BT", Holo.Encoding.encodeVL64(num2), Convert.ToChar(2), "ISent: ", DateTime.Now, Convert.ToChar(2), this._Username, Convert.ToChar(2), val, Convert.ToChar(2), Holo.Encoding.encodeVL64(this._roomID), Convert.ToChar(2), str2, Convert.ToChar(2), "I", Convert.ToChar(2), 
                        Holo.Encoding.encodeVL64(this._roomID)
                     }));
                }
            }
        }

        internal void ProcessPacketAW()
        {
            int i = 20;
            this.sendData("@D" + Holo.Encoding.encodeVL64(i));
        }

        internal void ProcessPacketAZ()
        {
            if ((this._hasRights && !this._inPublicroom) && ((this.Room != null) && (this.roomUser != null)))
            {
                int result = 0;
                if (int.TryParse(this.currentPacket.Split(new char[] { ' ' })[0].Substring(5), out result))
                {
                    int num2;
                    int num3;
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        num2 = client.getInt(string.Concat(new object[] { "SELECT tid FROM furniture WHERE id = '", result, "' AND ownerid = '", this.userID, "' AND roomid = '0'" }));
                        num3 = client.getInt("SELECT id FROM furniture_data WHERE sprite = '" + client.getString("SELECT name_cct FROM catalogue_items WHERE tid = '" + num2 + "'") + "'");
                    }
                    if (num2 != 0)
                    {
                        if (catalogueManager.getTemplate(num2).typeID == 0)
                        {
                            string wallPosition = this.currentPacket.Substring(result.ToString().Length + 5);
                            string str3 = catalogueManager.wallPositionOK(wallPosition);
                            if (str3 != wallPosition)
                            {
                                return;
                            }
                            int num4 = 0;
                            using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                            {
                                string s = client2.getString("SELECT var FROM furniture WHERE id = '" + result + "'");
                                int.TryParse(s, out num4);
                                if (stringManager.getStringPart(catalogueManager.getTemplate(num2).Sprite, 0, 7) == "post.it")
                                {
                                    if (num4 > 1)
                                    {
                                        client2.runQuery("UPDATE furniture SET var = var - 1 WHERE id = '" + result + "' LIMIT 1");
                                    }
                                    else
                                    {
                                        client2.runQuery("DELETE FROM furniture WHERE id = '" + result + "' LIMIT 1");
                                    }
                                    client2.runQuery(string.Concat(new object[] { "INSERT INTO furniture(tid,ownerid) VALUES ('", num2, "','", this.userID, "')" }));
                                    result = catalogueManager.lastItemID;
                                    client2.runQuery("INSERT INTO furniture_stickies(id) VALUES ('" + result + "')");
                                    s = "FFFF33";
                                    client2.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", s, "' WHERE id = '", result, "' LIMIT 1" }));
                                }
                                else if (stringManager.getStringPart(catalogueManager.getTemplate(num2).Sprite, 0, 10) == "roomdimmer")
                                {
                                    client2.runQuery(string.Concat(new object[] { "UPDATE furniture_moodlight SET roomid = '", this._roomID, "' WHERE id = '", result, "' LIMIT 1" }));
                                }
                                this.Room.wallItemManager.addItem(result, num2, str3, s, true);
                            }
                            string[] locDetails = currentPacket.Split(' ');
                            int X = int.Parse(locDetails[1]);
                            int Y = int.Parse(locDetails[2]);
                            byte Z = byte.Parse(locDetails[3]);
                            byte typeID = catalogueManager.getTemplate(num2).typeID;
                            Room.floorItemManager.placeItem(result, num2, X, Y, typeID, Z, num3);

                        }
                        string[] strArray = this.currentPacket.Split(new char[] { ' ' });
                        int x = int.Parse(strArray[1]);
                        int y = int.Parse(strArray[2]);
                        byte z = byte.Parse(strArray[3]);
                        byte typeID2 = catalogueManager.getTemplate(num2).typeID;
                        this.sendData("Ac" + Holo.Encoding.encodeVL64(-num2));
                        this.Room.floorItemManager.placeItem(result, num2, x, y, typeID2, z, num3);
                        this.sendData("C[!nB");
                        this.refreshHand("last");
                    }
                }
            }

            if ((this._hasRights && !this._inPublicroom) && ((this.Room != null) && (this.roomUser != null)))
            {
                int result = 0;
                if (int.TryParse(this.currentPacket.Split(new char[] { ' ' })[0].Substring(4), out result))
                {
                    int num2;
                    int num3;
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        num2 = client.getInt(string.Concat(new object[] { "SELECT tid FROM furniture WHERE id = '", result, "' AND ownerid = '", this.userID, "' AND roomid = '0'" }));
                        num3 = client.getInt("SELECT id FROM furniture_data WHERE sprite = '" + client.getString("SELECT name_cct FROM catalogue_items WHERE tid = '" + num2 + "'") + "'");
                    }
                    if (num2 != 0)
                    {
                        if (catalogueManager.getTemplate(num2).typeID == 0)
                        {
                            string wallPosition = this.currentPacket.Substring(result.ToString().Length + 5);
                            string str3 = catalogueManager.wallPositionOK(wallPosition);
                            if (str3 != wallPosition)
                            {
                                return;
                            }
                            int num4 = 0;
                            using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                            {
                                string s = client2.getString("SELECT var FROM furniture WHERE id = '" + result + "'");
                                int.TryParse(s, out num4);
                                if (stringManager.getStringPart(catalogueManager.getTemplate(num2).Sprite, 0, 7) == "post.it")
                                {
                                    if (num4 > 1)
                                    {
                                        client2.runQuery("UPDATE furniture SET var = var - 1 WHERE id = '" + result + "' LIMIT 1");
                                    }
                                    else
                                    {
                                        client2.runQuery("DELETE FROM furniture WHERE id = '" + result + "' LIMIT 1");
                                    }
                                    client2.runQuery(string.Concat(new object[] { "INSERT INTO furniture(tid,ownerid) VALUES ('", num2, "','", this.userID, "')" }));
                                    result = catalogueManager.lastItemID;
                                    client2.runQuery("INSERT INTO furniture_stickies(id) VALUES ('" + result + "')");
                                    s = "FFFF33";
                                    client2.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", s, "' WHERE id = '", result, "' LIMIT 1" }));
                                }
                                else if (stringManager.getStringPart(catalogueManager.getTemplate(num2).Sprite, 0, 10) == "roomdimmer")
                                {
                                    client2.runQuery(string.Concat(new object[] { "UPDATE furniture_moodlight SET roomid = '", this._roomID, "' WHERE id = '", result, "' LIMIT 1" }));
                                }
                                this.Room.wallItemManager.addItem(result, num2, str3, s, true);
                            }
                            string[] locDetails = currentPacket.Split(' ');
                            int X = int.Parse(locDetails[1]);
                            int Y = int.Parse(locDetails[2]);
                            byte Z = byte.Parse(locDetails[3]);
                            byte typeID = catalogueManager.getTemplate(num2).typeID;
                            Room.floorItemManager.placeItem(result, num2, X, Y, typeID, Z, num3);

                        }
                        string[] strArray = this.currentPacket.Split(new char[] { ' ' });
                        int x = int.Parse(strArray[1]);
                        int y = int.Parse(strArray[2]);
                        byte z = byte.Parse(strArray[3]);
                        byte typeID2 = catalogueManager.getTemplate(num2).typeID;
                        this.sendData("Ac" + Holo.Encoding.encodeVL64(-num2));
                        this.Room.floorItemManager.placeItem(result, num2, x, y, typeID2, z, num3);
                        this.sendData("C[!nB");
                        this.refreshHand("last");
                    }
                }
            }
        }

        internal void ProcessPacketB_()
        {
            if ((this.Room != null) && (this.Room.Lobby != null))
            {
                this.sendData("Ch" + this.Room.Lobby.gameList());
            }
        }

        internal void ProcessPacketB__()
        {
            string str = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2)).ToString();
            if ((this.Room != null) && (this.roomUser != null))
            {
                DataColumn column;
                DataColumn column2;
                int i = 0;
                string str2 = "";
                List<string> list = new List<string>();
                List<int> list2 = new List<int>();
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    column = client.getColumn("SELECT badgeid FROM users_badges WHERE userid = '" + str + "' ORDER BY slotid ASC");
                    column2 = client.getColumn("SELECT slotid FROM users_badges WHERE userid = '" + str + "' ORDER BY slotid ASC");
                }
                string[] strArray = dataHandling.dColToArray(column);
                string[] strArray2 = dataHandling.dColToArray(column2);
                for (int j = 0; j < strArray.Length; j++)
                {
                    list.Add(strArray[j]);
                }
                for (int k = 0; k < strArray.Length; k++)
                {
                    if (Convert.ToInt32(strArray2[k]) > 0)
                    {
                        list2.Add(Convert.ToInt32(strArray2[k]));
                    }
                    else
                    {
                        list2.Add(0);
                    }
                }
                for (int m = 0; m < list.Count; m++)
                {
                    if (list2[m] > 0)
                    {
                        str2 = (str2 + Holo.Encoding.encodeVL64(list2[m])) + list[m] + Convert.ToChar(2);
                        i++;
                    }
                }
                this.sendData("Cd" + Holo.Encoding.encodeVL64(this.userID) + Holo.Encoding.encodeVL64(i) + str2);
            }
        }

        internal void ProcessPacketBA()
        {
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                client.AddParamWithValue("code", this.currentPacket.Substring(4));
                if (client.findsResult("SELECT credits FROM vouchers WHERE voucher = @code"))
                {
                    int num = client.getInt("SELECT credits FROM vouchers WHERE voucher = @code");
                    client.runQuery("DELETE FROM vouchers WHERE voucher = @code LIMIT 1");
                    this._Credits += num;
                    this.sendData("@F" + this._Credits);
                    this.sendData("CT");
                    client.runQuery(string.Concat(new object[] { "UPDATE users SET credits = '", num, "' WHERE id = '", this.userID, "' LIMIT 1" }));
                }
                else
                {
                    this.sendData("CU1" + Convert.ToChar(2));
                }
            }
        }

        internal void ProcessPacketBb()
        {
            if (((this.Room != null) && (this.roomUser != null)) && ((this.Room.Lobby != null) && (this.gamePlayer == null)))
            {
                if (this._Tickets > 1)
                {
                    if (this.Room.Lobby.validGamerank(this.roomUser.gamePoints))
                    {
                        if (this.Room.Lobby.isBattleBall)
                        {
                            this.sendData("Ck" + this.Room.Lobby.getCreateGameSettings());
                        }
                        else
                        {
                            this.sendData(string.Concat(new object[] { "CkRAsecondsUntilRestart", Convert.ToChar(2), "HIRGIHHfieldType", Convert.ToChar(2), "HKIIIISAnumTeams", Convert.ToChar(2), "HJJIIIPAgameLengthChoice", Convert.ToChar(2), "HJIIIIKname", Convert.ToChar(2), "IJ", Convert.ToChar(2), "HsecondsUntilStart", Convert.ToChar(2), "HIRBIHH" }));
                        }
                    }
                    else
                    {
                        this.sendData("ClK");
                    }
                }
                else
                {
                    this.sendData("ClJ");
                }
            }
        }

        internal void ProcessPacketBc()
        {
            if (((this.Room != null) && (this.roomUser != null)) && ((this.Room.Lobby != null) && (this.gamePlayer == null)))
            {
                if (this._Tickets > 1)
                {
                    if (!this.Room.Lobby.validGamerank(this.roomUser.gamePoints))
                    {
                        this.sendData("ClK");
                    }
                    else
                    {
                        try
                        {
                            int mapID = -1;
                            int teamAmount = -1;
                            int[] enabledPowerups = null;
                            string name = "";
                            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                            this.currentPacket = this.currentPacket.Substring(Holo.Encoding.encodeVL64(i).Length + 2);
                            for (int j = 0; j < i; j++)
                            {
                                int num7;
                                int num8;
                                int length = Holo.Encoding.decodeB64(this.currentPacket.Substring(0, 2));
                                string str2 = this.currentPacket.Substring(2, length);
                                if (!(this.currentPacket.Substring(length + 2, 1) == "H"))
                                {
                                    goto Label_0151;
                                }
                                int num6 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(length + 3));
                                string str4 = str2;
                                if (str4 != null)
                                {
                                    if (!(str4 == "fieldType"))
                                    {
                                        if (str4 == "numTeams")
                                        {
                                            goto Label_0123;
                                        }
                                    }
                                    else
                                    {
                                        mapID = num6;
                                    }
                                }
                                goto Label_0126;
                            Label_0123:
                                teamAmount = num6;
                            Label_0126:
                                num7 = Holo.Encoding.encodeVL64(num6).Length;
                                this.currentPacket = this.currentPacket.Substring((length + num7) + 3);
                                continue;
                            Label_0151:
                                num8 = Holo.Encoding.decodeB64(this.currentPacket.Substring(length + 3, 2));
                                string text = this.currentPacket.Substring(length + 5, num8);
                                string str5 = str2;
                                if (str5 != null)
                                {
                                    if (!(str5 == "allowedPowerups"))
                                    {
                                        if (str5 == "name")
                                        {
                                            goto Label_0208;
                                        }
                                    }
                                    else
                                    {
                                        string[] strArray = text.Split(new char[] { ',' });
                                        enabledPowerups = new int[strArray.Length];
                                        for (int k = 0; k < strArray.Length; k++)
                                        {
                                            int iD = int.Parse(strArray[k]);
                                            if (!this.Room.Lobby.allowsPowerup(iD))
                                            {
                                                return;
                                            }
                                            enabledPowerups[k] = iD;
                                        }
                                    }
                                }
                                goto Label_0210;
                            Label_0208:
                                name = stringManager.filterSwearwords(text);
                            Label_0210:
                                this.currentPacket = this.currentPacket.Substring((length + num8) + 5);
                            }
                            if (((mapID != -1) && (teamAmount != -1)) && (name != ""))
                            {
                                this.gamePlayer = new Holo.Virtual.Rooms.Games.gamePlayer(this, this.roomUser.roomUID, null);
                                this.Room.Lobby.createGame(this.gamePlayer, name, mapID, teamAmount, enabledPowerups);
                            }
                        }
                        catch
                        {
                        }
                    }
                }
                else
                {
                    this.sendData("ClJ");
                }
            }
        }

        internal void ProcessPacketBe()
        {
            if (((this.Room != null) && (this.Room.Lobby != null)) && ((this.gamePlayer != null) && (this.gamePlayer.Game.State == Game.gameState.Waiting)))
            {
                if (this._Tickets > 1)
                {
                    if (this.Room.Lobby.validGamerank(this.roomUser.gamePoints))
                    {
                        int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                        int teamID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(Holo.Encoding.encodeVL64(i).Length + 2));
                        if ((teamID != this.gamePlayer.teamID) && this.gamePlayer.Game.teamHasSpace(teamID))
                        {
                            if (this.gamePlayer.teamID == -1)
                            {
                                this.gamePlayer.Game.Subviewers.Remove(this.gamePlayer);
                            }
                            this.gamePlayer.Game.movePlayer(this.gamePlayer, this.gamePlayer.teamID, teamID);
                        }
                        else
                        {
                            this.sendData("ClH");
                        }
                    }
                    else
                    {
                        this.sendData("ClK");
                    }
                }
                else
                {
                    this.sendData("ClJ");
                }
            }
        }

        internal void ProcessPacketBg()
        {
            this.leaveGame();
        }

        internal void ProcessPacketBh()
        {
            if ((((this.Room != null) && (this.Room.Lobby != null)) && ((this.gamePlayer != null) && (this.gamePlayer.Game != null))) && (this.gamePlayer == this.gamePlayer.Game.Owner))
            {
                int num = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                for (int i = 0; i < this.gamePlayer.Game.Teams.Length; i++)
                {
                    foreach (Holo.Virtual.Rooms.Games.gamePlayer player in this.gamePlayer.Game.Teams[i])
                    {
                        if (player.roomUID == num)
                        {
                            player.sendData("ClRA");
                            this.gamePlayer.Game.movePlayer(player, i, -1);
                            return;
                        }
                    }
                }
            }
        }

        internal void ProcessPacketBj()
        {
            if (((this.Room != null) && (this.Room.Lobby != null)) && ((this.gamePlayer != null) && (this.gamePlayer == this.gamePlayer.Game.Owner)))
            {
                this.gamePlayer.Game.startGame();
            }
        }

        internal void ProcessPacketBk()
        {
            if (((this.gamePlayer != null) && (this.gamePlayer.Game.State == Game.gameState.Started)) && (this.gamePlayer.teamID != -1))
            {
                this.gamePlayer.goalX = Holo.Encoding.decodeVL64(this.currentPacket.Substring(3));
                this.gamePlayer.goalY = Holo.Encoding.decodeVL64(this.currentPacket.Substring(Holo.Encoding.encodeVL64(this.gamePlayer.goalX).Length + 3));
            }
        }

        internal void ProcessPacketBl()
        {
            if (((this.gamePlayer != null) && (this.gamePlayer.Game.State == Game.gameState.Ended)) && (this.gamePlayer.teamID != -1))
            {
                this.gamePlayer.Game.sendData("BK" + this._Username + " wants to replay!");
            }
        }

        internal void ProcessPacketBS9()
        {
            this.refreshBadges();
        }

        internal void ProcessPacketBUL()
        {
            if ((this.Room != null) && (this.roomUser != null))
            {
                int num3;
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    client.runQuery("UPDATE users_badges SET slotid = '0' WHERE userid = '" + this.userID + "'");
                }
                int i = 0;
                for (string str = this.currentPacket.Substring(2); str != ""; str = str.Substring(num3 + 2))
                {
                    int num2 = Holo.Encoding.decodeVL64(str);
                    str = str.Substring(Holo.Encoding.encodeVL64(num2).Length);
                    num3 = Holo.Encoding.decodeB64(str.Substring(0, 2));
                    if (num3 > 0)
                    {
                        string str2 = str.Substring(2, num3);
                        using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                        {
                            client2.runQuery(string.Concat(new object[] { "UPDATE users_badges SET slotid = '", num2, "' WHERE userid = '", this.userID, "' AND badgeid = '", str2, "' LIMIT 1" }));
                        }
                        i++;
                    }
                }
                this.refreshBadges();
                string str3 = Holo.Encoding.encodeVL64(this.userID) + Holo.Encoding.encodeVL64(i);
                for (int j = 0; j < this._Badges.Count; j++)
                {
                    if (this._badgeSlotIDs[j] > 0)
                    {
                        str3 = (str3 + Holo.Encoding.encodeVL64(this._badgeSlotIDs[j])) + this._Badges[j] + Convert.ToChar(2);
                    }
                }
                this.Room.sendData("Cd" + str3);
            }
        }

        internal void ProcessPacketBUT()
        {
            if (((this.Room != null) && (this.roomUser != null)) && ((this.Room.Lobby != null) && (this.gamePlayer == null)))
            {
                int key = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (this.Room.Lobby.Games.ContainsKey(key))
                {
                    this.gamePlayer = new Holo.Virtual.Rooms.Games.gamePlayer(this, this.roomUser.roomUID, (Game)this.Room.Lobby.Games[key]);
                    this.gamePlayer.Game.Subviewers.Add(this.gamePlayer);
                    this.sendData("Ci" + this.gamePlayer.Game.Sub);
                }
            }
        }

        internal void ProcessPacketBv()
        {
            if ((this._guideRoom > 0) && this._guideSearch)
            {
                this.sendData("Fh" + Holo.Encoding.encodeVL64(this._guideRoom));
            }
            Config.Rooms_LoadAvertisement_img = "";
            if (Config.Rooms_LoadAvertisement_img == "")
            {
                this.sendData("DB0");
            }
            else
            {
                this.sendData(string.Concat(new object[] { "DB", Config.Rooms_LoadAvertisement_img, Convert.ToChar(2), Config.Rooms_LoadAvertisement_uri }));
            }
        }

        internal void ProcessPacketBV()
        {
            if (this.BVPacketOverload <= 100)
            {
                this.BVPacketOverload++;
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2, 1));
                int id = Holo.Encoding.decodeVL64(this.currentPacket.Substring(3));
                string str = navigatorManager.getNameAcces(this._Rank, id);
                if (str != "")
                {
                    DataTable table;
                    int num3 = navigatorManager.getType(id);
                    int num4 = navigatorManager.getParent(id);
                    StringBuilder builder = new StringBuilder(string.Concat(new object[] { @"C\", Holo.Encoding.encodeVL64(i), Holo.Encoding.encodeVL64(id), Holo.Encoding.encodeVL64(num3), str, Convert.ToChar(2), Holo.Encoding.encodeVL64(0), Holo.Encoding.encodeVL64(0x2710), Holo.Encoding.encodeVL64(num4) }));
                    string str2 = "";
                    if (num3 == 0)
                    {
                        if (i == 1)
                        {
                            str2 = "AND visitors_now < visitors_max ORDER BY id ASC";
                        }
                        else
                        {
                            str2 = "ORDER BY id ASC";
                        }
                    }
                    else if (i == 1)
                    {
                        str2 = "AND visitors_now < visitors_max ORDER BY visitors_now DESC LIMIT 30";
                    }
                    else
                    {
                        str2 = "ORDER BY visitors_now DESC LIMIT " + Config.Navigator_openCategory_maxResults;
                    }
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        table = client.getTable(string.Concat(new object[] { "SELECT id,state,showname,visitors_now,visitors_max,name,description,owner,ccts FROM rooms WHERE category = '", id, "' ", str2 }));
                    }
                    if (num3 == 2)
                    {
                        builder.Append(Holo.Encoding.encodeVL64(table.Rows.Count));
                    }
                    bool flag = false;
                    if (num3 != 0)
                    {
                        flag = rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_enter_locked_rooms", this.userID);
                    }
                    foreach (DataRow row in table.Rows)
                    {
                        if (num3 == 0)
                        {
                            builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(Convert.ToInt32(row["id"])), "I", Convert.ToString(row["name"]), Convert.ToChar(2), Holo.Encoding.encodeVL64(Convert.ToInt32(row["visitors_now"])), Holo.Encoding.encodeVL64(Convert.ToInt32(row["visitors_max"])), Holo.Encoding.encodeVL64(id), Convert.ToString(row["description"]), Convert.ToChar(2), Holo.Encoding.encodeVL64(Convert.ToInt32(row["id"])), "H", Convert.ToString(row["ccts"]), Convert.ToChar(2), "HI" }));
                        }
                        else if ((Convert.ToInt32(row["showname"]) != 0) || flag)
                        {
                            builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(Convert.ToInt32(row["id"])), Convert.ToString(row["name"]), Convert.ToChar(2), Convert.ToString(row["owner"]), Convert.ToChar(2), roomManager.getRoomState(Convert.ToInt32(row["state"])), Convert.ToChar(2), Holo.Encoding.encodeVL64(Convert.ToInt32(row["visitors_now"])), Holo.Encoding.encodeVL64(Convert.ToInt32(row["visitors_max"])), Convert.ToString(row["description"]), Convert.ToChar(2) }));
                        }
                    }
                    DataColumn column = navigatorManager.getAccesParent(this._Rank, id);
                    if (column.Table.Rows.Count > 0)
                    {
                        StringBuilder builder2 = new StringBuilder();
                        List<int> list = new List<int>();
                        foreach (DataRow row2 in column.Table.Rows)
                        {
                            builder2.Append(" OR category = '" + Convert.ToString(row2[0]) + "'");
                            list.Add(Convert.ToInt32(row2[0]));
                        }
                        foreach (DataRow row3 in navigatorManager.getGuestroomQuery("SELECT SUM(visitors_now),SUM(visitors_max),category FROM rooms WHERE" + builder2.ToString().Substring(3) + " GROUP BY category", false).Rows)
                        {
                            if (((Convert.ToInt32(row3[1]) <= 0) || (i != 1)) || (Convert.ToInt32(row3[0]) < Convert.ToInt32(row3[1])))
                            {
                                builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(Convert.ToInt32(row3[2])), "H", navigatorManager.getName(Convert.ToInt32(row3[2])), Convert.ToChar(2), Holo.Encoding.encodeVL64(Convert.ToInt32(row3[0])), Holo.Encoding.encodeVL64(Convert.ToInt32(row3[1])), Holo.Encoding.encodeVL64(id) }));
                                list.Remove(Convert.ToInt32(row3[2]));
                            }
                        }
                        foreach (int num5 in list)
                        {
                            builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(num5), "H", navigatorManager.getName(num5), Convert.ToChar(2), "HH", Holo.Encoding.encodeVL64(id) }));
                        }
                    }
                    this.sendData(builder.ToString());
                }
            }
        }

        internal void ProcessPacketBw()
        {
            if ((this._isOwner && !this._inPublicroom) && ((this.Room != null) && (this.roomUser != null)))
            {
                int itemID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (this.Room.floorItemManager.containsItem(itemID))
                {
                    string sprite = this.Room.floorItemManager.getItem(itemID).Sprite;
                    if ((sprite.Substring(0, 3).ToLower() == "cf_") || (sprite.Substring(0, 4).ToLower() == "cfc_"))
                    {
                        int num2 = 0;
                        try
                        {
                            num2 = int.Parse(sprite.Split(new char[] { '_' })[1]);
                        }
                        catch
                        {
                            return;
                        }
                        this.Room.floorItemManager.removeItem(itemID, 0);
                        this._Credits += num2;
                        this.sendData("@F" + this._Credits);
                        using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                        {
                            client.runQuery(string.Concat(new object[] { "UPDATE users SET credits = '", this._Credits, "' WHERE id = '", this.userID, "' LIMIT 1" }));
                        }
                    }
                }
            }
        }

        internal void ProcessPacketBW()
        {
            int num;
            DataTable table;
            StringBuilder builder = new StringBuilder();
            int i = 0;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                num = client.getInt("SELECT count(id) FROM events LIMIT 20");
                table = client.getTable("SELECT id,name,description,userid,roomid,category,date FROM events ORDER BY id ASC LIMIT 20");
            }
            builder.Append(Holo.Encoding.encodeVL64(num) + "-1" + Convert.ToChar(2));
            if (table.Rows.Count > 0)
            {
                foreach (DataRow row in table.Rows)
                {
                    DataRow row2;
                    int num4;
                    DataColumn column;
                    int num5;
                    int num6;
                    using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                    {
                        row2 = client2.getRow("SELECT id,level,name,owner,state,visitors_now,visitors_max,description FROM rooms WHERE id = '" + row["roomid"] + "'");
                        num4 = client2.getInt("SELECT trading FROM room_categories WHERE id = '" + client2.getInt("SELECT category FROM rooms WHERE id = '" + row["roomid"] + "'") + "'");
                        column = client2.getColumn("SELECT id FROM users WHERE roomid = '" + row["roomid"] + "' ORDER BY id ASC");
                        num5 = client2.getInt("SELECT count(vote)from room_votes WHERE id = '" + row["roomid"] + "'");
                        num6 = client2.getInt("SELECT icon FROM rooms WHERE id = '" + row["roomid"] + "'");
                    }
                    builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(Convert.ToInt32(row["category"])), Holo.Encoding.encodeVL64(Convert.ToInt32(row2["id"])), "I", Convert.ToString(row2["name"]), Convert.ToChar(2), Convert.ToString(row2["owner"]), Convert.ToChar(2), Holo.Encoding.encodeVL64(Convert.ToInt32(row2["state"])), Holo.Encoding.encodeVL64(Convert.ToInt32(row2["visitors_now"])), Holo.Encoding.encodeVL64(Convert.ToInt32(row2["visitors_max"])), Convert.ToString(row2["description"]), Convert.ToChar(2) }));
                    Hashtable hashtable = new Hashtable(column.Table.Rows.Count);
                    string str = "";
                    foreach (DataRow row3 in column.Table.Rows)
                    {
                        hashtable.Add(Convert.ToInt32(row3["id"]), Convert.ToInt32(row3["id"]));
                        str = str + Convert.ToString(row3["id"]);
                        str = str.Substring(0, str.Length);
                        if ((str.Length > 0) && this.Messenger.hasFriendship(Convert.ToInt32(str)))
                        {
                            hashtable.Remove(Convert.ToInt32(row3["id"]));
                            i++;
                        }
                    }
                    builder.Append(Holo.Encoding.encodeVL64(i));
                    if (Convert.ToString(num4) == "1")
                    {
                        builder.Append(Holo.Encoding.encodeVL64(1));
                    }
                    else
                    {
                        builder.Append(Holo.Encoding.encodeVL64(0));
                    }
                    builder.Append(Holo.Encoding.encodeVL64(num5) + Holo.Encoding.encodeVL64(num6) + Convert.ToString(row["date"]));
                }
            }
            else
            {
                builder.Append(Holo.Encoding.encodeVL64(0));
            }
            this.sendData("GC" + builder);
            this.sendData("C]" + GetGuestRoomCategories(this._Rank));
        }

        internal void ProcessPacketBX()
        {
            string str;
            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                str = client.getString(string.Concat(new object[] { "SELECT category FROM rooms WHERE id = '", i, "' AND owner = '", this._Username, "'" }));
            }
            if (str != "")
            {
                this.sendData("C^" + Holo.Encoding.encodeVL64(i) + Holo.Encoding.encodeVL64(int.Parse(str)));
            }
        }

        internal void ProcessPacketBY()
        {
            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            int num2 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(Holo.Encoding.encodeVL64(i).Length + 2));
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                if (client.findsResult(string.Concat(new object[] { "SELECT id FROM room_categories WHERE id = '", num2, "' AND type = '2' AND parent > 0 AND access_rank_min <= ", this._Rank })))
                {
                    client.runQuery(string.Concat(new object[] { "UPDATE rooms SET category = '", num2, "' WHERE id = '", i, "' AND owner = '", this._Username, "' LIMIT 1" }));
                }
            }
        }

        internal void ProcessPacketBZ()
        {
            int roomID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            if (roomManager.containsRoom(roomID))
            {
                this.sendData("C_" + roomManager.getRoom(roomID).Userlist);
            }
            else
            {
                this.sendData("C_");
            }
        }

        internal void ProcessPacketCCA()
        {
            if ((this._isOwner && (this.Room != null)) && (this.Room.floorItemManager.soundMachineID > 0))
            {
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                bool flag = false;
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    flag = client.findsResult(string.Concat(new object[] { "SELECT id FROM soundmachine_songs WHERE id = '", i, "' AND userid = '", this.userID, "' AND machineid = '", this.Room.floorItemManager.soundMachineID, "'" }));
                }
                if ((this._Credits > 0) && flag)
                {
                    using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                    {
                        DataRow row = client2.getRow("SELECT title, length FROM soundmachine_songs WHERE id = '" + i + "'");
                        string val = string.Concat(new object[] { Holo.Encoding.encodeVL64(i), this._Username, "\n", DateTime.Today.Day, "\n", DateTime.Today.Month, "\n", DateTime.Today.Year, "\n", Convert.ToString(row["length"]), "\n", Convert.ToString(row["title"]) });
                        client2.AddParamWithValue("tid", Config.Soundmachine_burnToDisk_diskTemplateID);
                        client2.AddParamWithValue("ownerid", this.userID);
                        client2.AddParamWithValue("var", val);
                        client2.runQuery("INSERT INTO furniture(tid,ownerid,var) VALUES (@tid,@ownerid,@var)");
                        client2.runQuery("UPDATE soundmachine_songs SET burnt = '1' WHERE id = '" + i + "' LIMIT 1");
                        client2.runQuery("UPDATE users SET credits = credits - 1 WHERE id = '" + this.userID + "' LIMIT 1");
                    }
                    this._Credits--;
                    this.sendData("@F" + this._Credits);
                    this.sendData("EB" + soundMachineManager.getMachineSongList(this.Room.floorItemManager.soundMachineID));
                    this.refreshHand("last");
                }
                else
                {
                    this.sendData("AD");
                }
            }
        }

        internal void ProcessPacketCd()
        {
            this.refreshGroupStatus();
        }

        internal void ProcessPacketCD()
        {
            this.pingOK = true;
        }

        internal void ProcessPacketCD21()
        {
            if (this._guideFinish > -1)
            {
                this._guideFinish++;
                if (this._guideFinish == 2)
                {
                    if (this._guideCount > 0)
                    {
                        this.sendData("EeI");
                    }
                    else
                    {
                        this.sendData("Ee");
                    }
                    this.Handler.ProcessPacket("Eg");
                }
            }
            this.pingOK = true;
        }

        internal void ProcessPacketCf()
        {
            StringBuilder builder = new StringBuilder();
            builder.Append(Convert.ToChar(2));
            builder.Append("igor_seat");
            builder.Append(Convert.ToChar(2));
            builder.Append("igor_seatcmp");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_cltele");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_cltele_cmp");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_cllava2");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_cllava");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_frankb");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_frankbcmp");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_cl_jukeb");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_cl_jukeb_camp");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_clcake");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_cl_jukeb_camp");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_clcake");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_clcake_cm");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_cl_sofa");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_cl_sofa_cmp");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_calip_lava");
            builder.Append(Convert.ToChar(2));
            builder.Append("ads_calip_lava2");
            builder.Append(Convert.ToChar(2));
            this.sendData("Di" + builder);
            this.sendData("Du" + this.Room.Groups);
            if (this.Room.Lobby != null)
            {
                this.sendData(string.Concat(new object[] { "CgH", this.Room.Lobby.Rank.Title, Convert.ToChar(2), Holo.Encoding.encodeVL64(this.Room.Lobby.Rank.minPoints), Holo.Encoding.encodeVL64(this.Room.Lobby.Rank.maxPoints) }));
                this.sendData("Cz" + this.Room.Lobby.playerRanks);
            }
        }

        internal void ProcessPacketCF()
        {
            if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_receive_calls_for_help", this.userID))
            {
                DataRow row;
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(4, Holo.Encoding.decodeB64(this.currentPacket.Substring(2, 2))));
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    row = client.getRow("SELECT picked_up FROM cms_help WHERE id = '" + i + "'");
                }
                if (row.Table.Columns.Count != 0)
                {
                    using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                    {
                        client2.runQuery("DELETE FROM cms_help WHERE id = '" + i + "' LIMIT 1");
                    }
                    userManager.sendToRank(Config.Minimum_CFH_Rank, true, string.Concat(new object[] { "BT", Holo.Encoding.encodeVL64(i), Convert.ToChar(2), "HStaff Deleted!", Convert.ToChar(2), "Staff Deleted!", Convert.ToChar(2), "Staff Deleted!", Convert.ToChar(2), "H", Convert.ToChar(2), Convert.ToChar(2), "H", Convert.ToChar(2), "H" }));
                }
            }
        }

        internal void ProcessPacketCg()
        {
            DataRow row;
            string str2;
            if ((this.Room == null) || (this.roomUser == null))
            {
                return;
            }
            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                row = client.getRow("SELECT name,description,roomid FROM groups_details WHERE id = '" + i + "'");
            }
            if (row.Table.Rows.Count != 1)
            {
                return;
            }
            string str = "";
            int num2 = Convert.ToInt32(row["roomid"]);
            if (num2 > 0)
            {
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    str = client2.getString("SELECT name FROM rooms WHERE id = '" + num2 + "'");
                    goto Label_00C9;
                }
            }
            num2 = -1;
        Label_00C9:
            if (str == "")
            {
                str2 = "M";
            }
            else
            {
                str2 = Holo.Encoding.encodeVL64(Convert.ToInt32(row["roomid"]));
            }
            this.sendData(string.Concat(new object[] { "Dw", Holo.Encoding.encodeVL64(i), Convert.ToString(row["name"]), Convert.ToChar(2), Convert.ToString(row["description"]), Convert.ToChar(2), str2, str, Convert.ToChar(2) }));
        }

        internal void ProcessPacketCG()
        {
            if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_receive_calls_for_help", this.userID))
            {
                string str2;
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(4, Holo.Encoding.decodeB64(this.currentPacket.Substring(2, 2))));
                string str = this.currentPacket.Substring(Holo.Encoding.decodeB64(this.currentPacket.Substring(2, 2)) + 6);
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    str2 = client.getString("SELECT username FROM cms_help WHERE id = '" + i + "'");
                }
                if (str2 == null)
                {
                    this.sendData("BK" + stringManager.getString("cfh_fail") + Convert.ToChar(2));
                }
                else
                {
                    virtualUser user = userManager.getUser(userManager.getUserID(str2));
                    if (user._isLoggedIn)
                    {
                        user.sendData("DR" + str + Convert.ToChar(2));
                        using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                        {
                            client2.runQuery("DELETE FROM cms_help WHERE id = '" + i + "' LIMIT 1");
                        }
                        userManager.sendToRank(Config.Minimum_CFH_Rank, true, "DQ" + Holo.Encoding.encodeVL64(i) + Convert.ToChar(2));
                        using (DatabaseClient client3 = Eucalypt.dbManager.GetClient())
                        {
                            client3.runQuery(string.Concat(new object[] { "UPDATE cms_help SET picked_up = '", this._Username, "' WHERE id = '", i, "' LIMIT 1" }));
                        }
                    }
                }
            }
        }

        internal void ProcessPacketCh()
        {
            if (Holo.Encoding.decodeVL64(this.currentPacket.Substring(2)) >= 0)
            {
                this.Room.sendData("Dx" + this.currentPacket.Substring(2) + "IH");
                this.roomUser.goalX = -1;
                int num = 0;
                int x = this.roomUser.X;
                if (x == (this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).X + 1))
                {
                    num = 1;
                }
                if (x == (this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).X - 1))
                {
                    num = 2;
                }
                int y = this.roomUser.Y;
                if (y == (this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).Y + 1))
                {
                    num = 4;
                }
                if (y == (this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).Y - 1))
                {
                    num = 3;
                }
                this.Room.moveUser(this.roomUser, this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).X, this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).Y, true);
                Thread.Sleep(500);
                if (this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).Sprite.Contains("one_way_door*"))
                {
                    switch (num)
                    {
                        case 1:
                            this.Room.moveUser(this.roomUser, this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).X - 1, this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).Y, true);
                            break;

                        case 2:
                            this.Room.moveUser(this.roomUser, this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).X + 1, this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).Y, true);
                            break;

                        case 3:
                            this.Room.moveUser(this.roomUser, this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).X, this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).Y + 1, true);
                            break;

                        case 4:
                            this.Room.moveUser(this.roomUser, this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).X, this.Room.floorItemManager.getItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2))).Y - 1, true);
                            break;
                    }
                    this.Room.sendData("Dx" + this.currentPacket.Substring(2) + "HH", 500);
                }
            }
        }

        internal void ProcessPacketChrispl0x()
        {
            int num;
            DataColumn column;
            StringBuilder builder = new StringBuilder();
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                num = client.getInt("SELECT count(id) FROM rooms WHERE publicroom = 1");
                column = client.getColumn("SELECT id FROM rooms WHERE publicroom = 1");
            }
            builder.Append("H" + Holo.Encoding.encodeVL64(num));
            Hashtable hashtable = new Hashtable(column.Table.Rows.Count);
            string str = "";
            foreach (DataRow row in column.Table.Rows)
            {
                string str2;
                string str3;
                string str4;
                int num2;
                string str5;
                string str6;
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    str2 = client2.getString("SELECT name FROM rooms WHERE id = '" + row["id"] + "'");
                    str3 = client2.getString("SELECT description FROM rooms WHERE id = '" + row["id"] + "'");
                    str4 = client2.getString("SELECT subdescription FROM rooms WHERE id = '" + row["id"] + "'");
                    num2 = client2.getInt("SELECT visitors_now FROM rooms WHERE id = '" + row["id"] + "'");
                    str5 = client2.getString("SELECT model FROM rooms WHERE id = '" + row["id"] + "'");
                    str6 = client2.getString("SELECT ccts FROM rooms WHERE id = '" + row["id"] + "'");
                }
                hashtable.Add(Convert.ToInt32(row["id"]), Convert.ToInt32(row["id"]));
                str = str + Convert.ToString(row["id"]);
                str = str.Substring(0, str.Length);
                if (str.Length > 0)
                {
                    builder.Append(string.Concat(new object[] { str2, Convert.ToChar(2), str3, Convert.ToChar(2), "J", str4, Convert.ToChar(2), Convert.ToChar(2) }));
                    builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(num2), "K", str5, Convert.ToChar(2) }));
                    builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(Convert.ToInt32(row["id"])), "H", str6, Convert.ToChar(2) }));
                    hashtable.Remove(Convert.ToInt32(row["id"]));
                }
            }
            //this.sendData("GB" + builder);
            this.sendData(@"GBISalotto Di BenvenutoRIcevi un caloroso benvenuto!HSalotto di BenvenutoHPHKnewbie_lobbyYTwHhh_room_nlobby
");

        }

        internal void ProcessPacketCj()
        {
        }

        internal void ProcessPacketCl()
        {
            if ((this.Room != null) && (this.roomUser != null))
            {
                int startIndex = 2;
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(startIndex));
                    if (!client.findsResult(string.Concat(new object[] { "SELECT aid FROM poll_results WHERE uid = '", this.userID, "' AND pid = '", i, "'" })))
                    {
                        startIndex += Holo.Encoding.encodeVL64(i).Length;
                        int num3 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(startIndex));
                        startIndex += Holo.Encoding.encodeVL64(num3).Length;
                        if (client.findsResult("SELECT type FROM poll_questions WHERE qid = '" + num3 + "' AND type = '3'"))
                        {
                            int length = Holo.Encoding.decodeB64(this.currentPacket.Substring(startIndex, 2));
                            startIndex += 2;
                            string str = client.getString(this.currentPacket.Substring(startIndex, length));
                            client.getString(string.Concat(new object[] { "INSERT INTO poll_results (pid,qid,aid,answers,uid) VALUES ('", i, "','", num3, "','0','", str, "','", this.userID, "')" }));
                        }
                        else
                        {
                            int num5 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(startIndex));
                            startIndex += Holo.Encoding.encodeVL64(num5).Length;
                            int[] numArray = new int[num5];
                            for (int j = 0; j < num5; j++)
                            {
                                numArray[j] = Holo.Encoding.decodeVL64(this.currentPacket.Substring(startIndex));
                                startIndex += Holo.Encoding.encodeVL64(numArray[j]).Length;
                            }
                            foreach (int num7 in numArray)
                            {
                                client.getString(string.Concat(new object[] { "INSERT INTO poll_results (pid,qid,aid,answers,uid) VALUES ('", i, "','", num3, "','", num7, "',' ','", this.userID, "')" }));
                            }
                        }
                    }
                }
            }
        }

        internal void ProcessPacketCm()
        {
            DataRow row;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                row = client.getRow("SELECT id, date, message FROM cms_help WHERE username = '" + this._Username + "' AND picked_up = '0'");
            }
            if (row.Table.Rows.Count == 0)
            {
                this.sendData("D\x007fH");
            }
            else
            {
                this.sendData(string.Concat(new object[] { "D\x007fI", Convert.ToString(row[0]), Convert.ToChar(2), Convert.ToString(row[1]), Convert.ToChar(2), Convert.ToString(row[2]), Convert.ToChar(2) }));
            }
        }

        internal void ProcessPacketCn()
        {
            int num;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                num = client.getInt("SELECT id FROM cms_help WHERE username = '" + this._Username + "' AND picked_up = '0'");
                client.runQuery("DELETE FROM cms_help WHERE picked_up = '0' AND username = '" + this._Username + "' LIMIT 1");
            }
            this.sendData("D\x007fH");
            userManager.sendToRank(Config.Minimum_CFH_Rank, true, "DQ" + Holo.Encoding.encodeVL64(num) + Convert.ToChar(2));
        }

        internal void ProcessPacketCN()
        {
            StringBuilder builder = new StringBuilder();
            builder.Append(Holo.Encoding.encodeVL64(9));
            builder.Append(Holo.Encoding.encodeVL64(0));
            builder.Append(Holo.Encoding.encodeVL64(0));
            builder.Append(Holo.Encoding.encodeVL64(1));
            builder.Append(Holo.Encoding.encodeVL64(1));
            builder.Append(Holo.Encoding.encodeVL64(3));
            builder.Append(Holo.Encoding.encodeVL64(0));
            builder.Append(Holo.Encoding.encodeVL64(2));
            builder.Append(Holo.Encoding.encodeVL64(1));
            builder.Append(Holo.Encoding.encodeVL64(4));
            builder.Append(Holo.Encoding.encodeVL64(0));
            builder.Append(Holo.Encoding.encodeVL64(5));
            builder.Append("dd-MM-yyyy");
            builder.Append(Holo.Encoding.encodeVL64(7));
            builder.Append(Convert.ToChar(2));
            builder.Append(Holo.Encoding.encodeVL64(8));
            builder.Append("hotel-co.uk");
            builder.Append(Holo.Encoding.encodeVL64(9));
            builder.Append(Convert.ToChar(2));
            this.sendData("DA" + builder);
        }

        internal void ProcessPacketCo()
        {
            if ((this._isOwner && (this.Room != null)) && (this.Room.floorItemManager.soundMachineID > 0))
            {
                this.songEditor = new virtualSongEditor(this.Room.floorItemManager.soundMachineID, this.userID);
                this.songEditor.loadSoundsets();
                this.sendData("Dm" + this.songEditor.getSoundsets());
                this.sendData("Dn" + soundMachineManager.getHandSoundsets(this.userID));
            }
        }

        internal void ProcessPacketCp()
        {
            if (((this.songEditor != null) && this._isOwner) && ((this.Room != null) && (this.Room.floorItemManager.soundMachineID > 0)))
            {
                int length = Holo.Encoding.decodeB64(this.currentPacket.Substring(2, 2));
                string text = this.currentPacket.Substring(4, length);
                string data = this.currentPacket.Substring(length + 6);
                int val = soundMachineManager.calculateSongLength(data);
                if (val != -1)
                {
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        client.AddParamWithValue("userid", this.userID);
                        client.AddParamWithValue("machineid", this.Room.floorItemManager.soundMachineID);
                        client.AddParamWithValue("title", stringManager.filterSwearwords(text));
                        client.AddParamWithValue("length", val);
                        client.AddParamWithValue("data", data);
                        client.runQuery("INSERT INTO soundmachine_songs (userid,machineid,title,length,data) VALUES (@userid,@machineid,@title,@length,@data)");
                    }
                    this.sendData("EB" + soundMachineManager.getMachineSongList(this.Room.floorItemManager.soundMachineID));
                    this.sendData(string.Concat(new object[] { "EK", Holo.Encoding.encodeVL64(this.Room.floorItemManager.soundMachineID), text, Convert.ToChar(2) }));
                }
            }
        }

        internal void ProcessPacketCPAR()
        {
            if ((this.Room != null) && (this.Room.floorItemManager.soundMachineID > 0))
            {
                int songID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                this.sendData("Dl" + soundMachineManager.getSong(songID));
            }
        }

        internal void ProcessPacketCPAR21()
        {
            if (((this.songEditor != null) && this._isOwner) && ((this.Room != null) && (this.Room.floorItemManager.soundMachineID > 0)))
            {
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                int slotID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(Holo.Encoding.encodeVL64(i).Length + 2));
                if (((slotID > 0) && (slotID < 5)) && this.songEditor.slotFree(slotID))
                {
                    this.songEditor.addSoundset(i, slotID);
                    this.sendData("Dn" + soundMachineManager.getHandSoundsets(this.userID));
                    this.sendData("Dm" + this.songEditor.getSoundsets());
                }
            }
        }

        internal void ProcessPacketCq()
        {
            if ((this._isOwner && (this.Room != null)) && (this.Room.floorItemManager.soundMachineID > 0))
            {
                int songID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                this.sendData("Dl" + soundMachineManager.getSong(songID));
                this.songEditor = new virtualSongEditor(this.Room.floorItemManager.soundMachineID, this.userID);
                this.sendData("Dm" + this.songEditor.getSoundsets());
                this.sendData("Dn" + soundMachineManager.getHandSoundsets(this.userID));
            }
        }

        internal void ProcessPacketCr()
        {
            if (((this.songEditor != null) && this._isOwner) && ((this.Room != null) && (this.Room.floorItemManager.soundMachineID > 0)))
            {
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    if (client.findsResult(string.Concat(new object[] { "SELECT id FROM soundmachine_songs WHERE id = '", i, "' AND userid = '", this.userID, "' AND machineid = '", this.Room.floorItemManager.soundMachineID, "'" })))
                    {
                        int length = Holo.Encoding.encodeVL64(i).Length;
                        int num3 = Holo.Encoding.decodeB64(this.currentPacket.Substring(length + 2, 2));
                        string text = this.currentPacket.Substring(length + 4, num3);
                        string data = this.currentPacket.Substring((length + num3) + 6);
                        int val = soundMachineManager.calculateSongLength(data);
                        if (val != -1)
                        {
                            client.AddParamWithValue("id", i);
                            client.AddParamWithValue("title", stringManager.filterSwearwords(text));
                            client.AddParamWithValue("length", val);
                            client.AddParamWithValue("data", data);
                            client.runQuery("UPDATE soundmachine_songs SET title = @title,data = @data,length = @length WHERE id = @id LIMIT 1");
                            this.sendData("ES");
                            this.sendData("EB" + soundMachineManager.getMachineSongList(this.Room.floorItemManager.soundMachineID));
                            this.Room.sendData("EC" + soundMachineManager.getMachinePlaylist(this.Room.floorItemManager.soundMachineID));
                        }
                    }
                }
            }
        }

        internal void ProcessPacketCs()
        {
            if ((this._isOwner && (this.Room != null)) && (this.Room.floorItemManager.soundMachineID > 0))
            {
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (i < 6)
                {
                    this.currentPacket = this.currentPacket.Substring(Holo.Encoding.encodeVL64(i).Length + 2);
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        client.runQuery("DELETE FROM soundmachine_playlists WHERE machineid = '" + this.Room.floorItemManager.soundMachineID + "'");
                    }
                    StringBuilder builder = new StringBuilder();
                    for (int j = 0; j < i; j++)
                    {
                        int num3 = Holo.Encoding.decodeVL64(this.currentPacket);
                        builder.Append(string.Concat(new object[] { " ,('", this.Room.floorItemManager.soundMachineID, "','", num3, "','", j, "')" }));
                        this.currentPacket = this.currentPacket.Substring(Holo.Encoding.encodeVL64(num3).Length);
                    }
                    if (builder.Length != 0)
                    {
                        using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                        {
                            client2.runQuery("INSERT INTO soundmachine_playlists(machineid,songid,pos) VALUES " + builder.ToString().Substring(2));
                        }
                    }
                    this.Room.sendData("EC" + soundMachineManager.getMachinePlaylist(this.Room.floorItemManager.soundMachineID));
                }
            }
        }

        internal void ProcessPacketCSL()
        {
            if (((this.songEditor != null) && this._isOwner) && ((this.Room != null) && (this.Room.floorItemManager.soundMachineID > 0)))
            {
                int slotID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (!this.songEditor.slotFree(slotID))
                {
                    this.songEditor.removeSoundset(slotID);
                    this.sendData("Dm" + this.songEditor.getSoundsets());
                    this.sendData("Dn" + soundMachineManager.getHandSoundsets(this.userID));
                }
            }
        }

        internal void ProcessPacketCt()
        {
            if ((this._isOwner && (this.Room != null)) && (this.Room.floorItemManager.soundMachineID > 0))
            {
                this.sendData("EB" + soundMachineManager.getMachineSongList(this.Room.floorItemManager.soundMachineID));
            }
        }

        internal void ProcessPacketCu()
        {
            if ((this.Room != null) && (this.Room.floorItemManager.soundMachineID > 0))
            {
                this.sendData("EC" + soundMachineManager.getMachinePlaylist(this.Room.floorItemManager.soundMachineID));
            }
        }


        internal void ProcessPacketCw() // Item handling - spin Wheel of fortune
        {
            if (_hasRights == false || Room == null || roomUser == null || _inPublicroom)
                return;

            int itemID = Holo.Encoding.decodeVL64(currentPacket.Substring(2));
            if (Room.wallItemManager.containsItem(itemID))
            {
                Rooms.Items.wallItem Item = Room.wallItemManager.getItem(itemID);
                if (Item.Sprite == "habbowheel" || Item.Sprite == "ads_lin_wh_c")
                {
                    int rndNum = new Random(DateTime.Now.Millisecond).Next(0, 10);

                    catalogueManager.itemTemplate Template = catalogueManager.getTemplate(Item.templateID);
                    Room.sendData("AU" + itemID + Convert.ToChar(2) + Holo.Encoding.encodeVL64(Template.indexID) + Item.wallPosition + Convert.ToChar(2) + "-1" + Convert.ToChar(2));
                    Room.sendData("AU" + itemID + Convert.ToChar(2) + Holo.Encoding.encodeVL64(Template.indexID) + Item.wallPosition + Convert.ToChar(2) + rndNum + Convert.ToChar(2));
                    using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                    {
                        dbClient.runQuery("UPDATE furniture SET var = '" + rndNum + "' WHERE id = '" + itemID + "' LIMIT 1");
                    }
                }
            }
        }
        
        internal void ProcessPacketCW()
        {
            if (this._ROOMACCESS_SECONDARY_OK && (this.Room != null))
            {
                StringBuilder builder = new StringBuilder();
                this.sendData("@_" + this.Room.Heightmap + Convert.ToChar(2));
                this.sendData("GV" + this.Room.Heightmap + Convert.ToChar(2));
                this.sendData(@"@\" + this.Room.dynamicUnits);
                this.sendData("@^" + this.Room.PublicroomItems);
                this.sendData("@`" + this.Room.Flooritems);
                this.sendData("@m" + this.Room.Wallitems);
                this.sendData(@"@\" + this.Room.dynamicStatuses);
                builder.Append(Holo.Encoding.encodeVL64(1));
                builder.Append(Holo.Encoding.encodeVL64(this.Room.roomID));
                builder.Append(Holo.Encoding.encodeVL64(1));
                this.sendData("GW" + builder);
                this.sendData("@b" + this.Room.dynamicStatuses);
            }

        }
        
                                internal void ProcessPacketAGGO() // Item handling - teleporters - flash teleporter
                            {
                                if (_inPublicroom || Room == null || roomUser == null)
                                    return;

                                int itemID = int.Parse(currentPacket.Substring(2));
                                if (Room.floorItemManager.containsItem(itemID))
                                {
                                    Rooms.Items.floorItem Teleporter1 = Room.floorItemManager.getItem(itemID);
                                    if (roomUser.X != Teleporter1.X && roomUser.Y != Teleporter1.Y)
                                        return;
                                    //Database dbClient = new Database (true, false, 114);
                                    int roomIDTeleporter2;
                                    int idTeleporter2;
                                    using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                                    {
                                        idTeleporter2 = dbClient.getInt("SELECT teleportid FROM furniture WHERE id = '" + itemID + "'");
                                        roomIDTeleporter2 = dbClient.getInt("SELECT roomid FROM furniture WHERE id = '" + idTeleporter2 + "'");
                                    }
                                    if (roomIDTeleporter2 > 0)
                                        new TeleporterUsageSleep(useTeleporter).BeginInvoke(Teleporter1, idTeleporter2, roomIDTeleporter2, null, null);
                                }
                            }

         internal void ProcessPacketAQ() // Item handling - teleporters - enter teleporter
                            {
                                if (_inPublicroom || Room == null || roomUser == null)
                                    return;

                                int itemID = int.Parse(currentPacket.Substring(2));
                                if (Room.floorItemManager.containsItem(itemID))
                                {
                                    Rooms.Items.floorItem Teleporter = Room.floorItemManager.getItem(itemID);
                                    // Prevent clientside 'jumps' to teleporter, check if user is removed one coord from teleporter entrance
                                    if (Teleporter.Z == 2 && roomUser.X != Teleporter.X + 1 && roomUser.Y != Teleporter.Y)
                                        return;
                                    else if (Teleporter.Z == 4 && roomUser.X != Teleporter.X && roomUser.Y != Teleporter.Y + 1)
                                        return;
                                    roomUser.goalX = -1;
                                    Room.moveUser(this.roomUser, Teleporter.X, Teleporter.Y, true);
                                }
                            }

        internal void ProcessPacketCx()
        {
            if ((this._isOwner && (this.Room != null)) && (this.Room.floorItemManager.soundMachineID > 0))
            {
                int num = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                bool flag = false;
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    flag = client.findsResult(string.Concat(new object[] { "SELECT id FROM soundmachine_songs WHERE id = '", num, "' AND machineid = '", this.Room.floorItemManager.soundMachineID, "'" }));
                }
                if (flag)
                {
                    using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                    {
                        client2.runQuery("UPDATE soundmachine_songs SET machineid = '0' WHERE id = '" + num + "' AND burnt = '1'");
                        client2.runQuery("DELETE FROM soundmachine_songs WHERE id = '" + num + "' AND burnt = '0' LIMIT 1");
                        client2.runQuery(string.Concat(new object[] { "DELETE FROM soundmachine_playlists WHERE machineid = '", this.Room.floorItemManager.soundMachineID, "' AND songid = '", num, "'" }));
                    }
                    this.Room.sendData("EC" + soundMachineManager.getMachinePlaylist(this.Room.floorItemManager.soundMachineID));
                }
            }
        }

        internal void ProcessPacketDa()
        {
            if ((this.Room != null) && (this.roomUser != null))
            {
                this.statusManager.addStatus("joingame", "3 1/");
            }
        }

        internal void ProcessPacketDBL()
        {
            int categoryID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            if (eventManager.categoryOK(categoryID))
            {
                this.sendData("Eb" + Holo.Encoding.encodeVL64(categoryID));
            }
        }

        internal void ProcessPacketDBL21()
        {
            if ((!this._isMuted && (this.Room != null)) && (this.roomUser != null))
            {
                this.Room.sendData("Ei" + Holo.Encoding.encodeVL64(this.roomUser.roomUID) + "I");
                this.roomUser.isTyping = true;
            }
        }

        internal void ProcessPacketDc()
        {
            this.sendData("DcFG");
        }

        internal void ProcessPacketDCA()
        {
            if ((this.Room != null) && (this.roomUser != null))
            {
                this.Room.sendData("Ei" + Holo.Encoding.encodeVL64(this.roomUser.roomUID) + "H");
                this.roomUser.isTyping = false;
            }
        }

        internal void ProcessPacketDE()
        {
            if ((!this._inPublicroom && (this.Room != null)) && !((this.roomUser == null) | this._isOwner))
            {
                int num = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    if (((num == 1) || (num == -1)) && !client.findsResult(string.Concat(new object[] { "SELECT userid FROM room_votes WHERE userid = '", this.userID, "' AND roomid = '", this._roomID, "'" })))
                    {
                        client.runQuery(string.Concat(new object[] { "INSERT INTO room_votes (userid,roomid,vote) VALUES ('", this.userID, "','", this._roomID, "','", num, "')" }));
                        int voteAmount = client.getInt("SELECT SUM(vote) FROM room_votes WHERE roomid = '" + this._roomID + "'");
                        if (voteAmount < 0)
                        {
                            voteAmount = 0;
                        }
                        this.roomUser.hasVoted = true;
                        this.roomUser.Room.sendNewVoteAmount(voteAmount);
                    }
                }
            }
        }

        internal void ProcessPacketDF()
        {
            if (this.Messenger != null)
            {
                int userID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                int i = -1;
                if (this.Messenger.hasFriendship(userID))
                {
                    if (userManager.containsUser(userID))
                    {
                        virtualUser user = userManager.getUser(userID);
                        if (user._roomID > 0)
                        {
                            if (user._inPublicroom)
                            {
                                this.sendData("D^I" + Holo.Encoding.encodeVL64(user._roomID));
                            }
                            else
                            {
                                this.sendData("D^H" + Holo.Encoding.encodeVL64(user._roomID));
                            }
                        }
                        else
                        {
                            i = 2;
                        }
                    }
                    else
                    {
                        i = 1;
                    }
                }
                else
                {
                    i = 0;
                }
                if (i != -1)
                {
                    this.sendData("E]" + Holo.Encoding.encodeVL64(i));
                }
            }
        }

        internal void ProcessPacketDG()
        {
            DataColumn column;
            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                column = client.getColumn("SELECT tag FROM cms_tags WHERE ownerid = '" + i + "' LIMIT 20");
            }
            StringBuilder builder = new StringBuilder(Holo.Encoding.encodeVL64(i) + Holo.Encoding.encodeVL64(column.Table.Rows.Count + 1));
            foreach (DataRow row in column.Table.Rows)
            {
                builder.Append(Convert.ToString(row["tag"]) + Convert.ToChar(2));
            }
            this.sendData("E^" + builder.ToString());
        }

        internal void ProcessPacketDH()
        {
            this.sendData("E_" + Holo.Encoding.encodeVL64(3) + navigatorManager.getRandomRooms());
        }

        internal void ProcessPacketDJ()
        {
            this.sendData(string.Concat(new object[] { "H", this._Figure, Convert.ToChar(2), this._Sex, Convert.ToChar(2), this._Mission, Convert.ToChar(2) }));
        }

        internal void ProcessPacketDl()
        {
            this.sendData("FIRA");
        }

        internal void ProcessPacketDm()
        {
            this.refreshwelcomerstatus();
        }

        internal void ProcessPacketDn()
        {
            this.sendData("FYQA1\x0002Bouncing Ball level 1\x0002III2\x0002Bouncing Ball level 2\x0002IJI3\x0002Bouncing Ball level 3\x0002IKI4\x0002Bouncing Ball level 4\x0002IPAI5\x0002Bouncing Ball level 5\x0002IQAH\x0001FYQA1\x0002Bouncing Ball level 1\x0002III2\x0002Bouncing Ball level 2\x0002IJI3\x0002Bouncing Ball level 3\x0002IKI4\x0002Bouncing Ball level 4\x0002IPAI5\x0002Bouncing Ball level 5\x0002IQAH");
        }

        internal void ProcessPacketDr()
        {
            this.sendData("BrDa");
        }

        internal void ProcessPacketDThingy()
        {
            string userName = this.currentPacket.Substring(4);
            DatabaseClient client = Eucalypt.dbManager.GetClient();
            try
            {
                virtualUser user = userManager.getUser(userName);
                if (user._Rank <= 3)
                {
                    object obj2 = this._mutedIDs;
                    this._mutedIDs = string.Concat(new object[] { obj2, "<", user.userID, ">" });
                    this.sendData("FcI");
                }
            }
            catch
            {
            }
            finally
            {
                if (client != null)
                {
                    client.Dispose();
                }
            }
        }

        internal void ProcessPacketDu()
        {
            this.sendData("FLPBH");
        }

        internal void ProcessPacketDv()
        {
            this.sendData("DvBKDv");
        }

        internal void ProcessPacketDw()
        {
            this.sendData("DwFL");
        }

        internal void ProcessPacketDx()
        {
            this.sendData("DxQA");
        }

        internal void ProcessPacketDy()
        {
            if (this.currentPacket.Substring(2) == "PB")
            {
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    if (client.getInt("SELECT guide_allowed FROM users WHERE id = " + this.userID) == 1)
                    {
                        client.runQuery("UPDATE users SET guide_allowed = '0' WHERE id = '" + this.userID + "' LIMIT 1");
                        this.sendData("EdI");
                    }
                }
            }
        }

        internal void ProcessPacketDz()
        {
            if (((this.Room != null) && (this.roomUser != null)) && !this._inPublicroom)
            {
                int itemID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (this.Room.floorItemManager.containsItem(itemID) && (this.Room.floorItemManager.getItem(itemID).Sprite == "val_randomizer"))
                {
                    int num2 = new Random(DateTime.Now.Millisecond).Next(1, 5);
                    this.Room.sendData(string.Concat(new object[] { "AX", itemID, Convert.ToChar(2), "123456789", Convert.ToChar(2) }));
                    this.Room.sendData(string.Concat(new object[] { "AX", itemID, Convert.ToChar(2), num2, Convert.ToChar(2) }), 0x1388);
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        client.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", num2, "' WHERE id = '", itemID, "' LIMIT 1" }));
                    }
                }
            }
        }

        internal void ProcessPacketEA()
        {
            this.sendData("Ep" + Holo.Encoding.encodeVL64(eventManager.categoryAmount));
        }

        internal void ProcessPacketEAT()
        {
            if ((this._hasRights && !this._inPublicroom) && ((this.Room != null) && (this.roomUser != null)))
            {
                virtualUser user = userManager.getUser(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2)));
                if ((user._roomID == this._roomID) && ((!user._isOwner || (((user._Rank - 1) <= this._Rank) && !rankManager.containsRight(ref user._fuserights, user._Rank, "fuse_any_room_controller", this.userID))) && !rankManager.containsRight(ref user._fuserights, user._Rank, "fuse_kick_immunity", this.userID)))
                {
                    string str = DateTime.Now.AddMinutes((double)Config.Rooms_roomBan_banDuration).ToString();
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        client.runQuery(string.Concat(new object[] { "INSERT INTO room_bans (roomid,userid,ban_expire) VALUES ('", this._roomID, "','", user.userID, "','", str, "')" }));
                    }
                    user.roomUser.walkLock = true;
                    user.roomUser.walkDoor = true;
                    user.roomUser.goalX = this.Room.doorX;
                    user.roomUser.goalY = this.Room.doorY;
                }
            }
        }

        internal void ProcessPacketEB()
        {
            string userName = this.currentPacket.Substring(4);
            DatabaseClient client = Eucalypt.dbManager.GetClient();
            try
            {
                virtualUser user = userManager.getUser(userName);
                if (user._Rank <= 3)
                {
                    this._mutedIDs = this._mutedIDs.Replace("<" + user.userID + ">", "");
                    this.sendData("FcK");
                }
            }
            catch
            {
            }
            finally
            {
                if (client != null)
                {
                    client.Dispose();
                }
            }
        }

        internal void ProcessPacketEC()
        {
            if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_receive_calls_for_help", this.userID))
            {
                int num3;
                int length = Holo.Encoding.decodeB64(this.currentPacket.Substring(2, 2));
                int num2 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(4, length));
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    num3 = client.getInt("SELECT roomid FROM cms_help WHERE id = '" + num2 + "'");
                }
                if (num3 != 0)
                {
                    if (roomManager.getRoom(num3).isPublicroom)
                    {
                        this.sendData("D^I" + Holo.Encoding.encodeVL64(num3));
                    }
                    else
                    {
                        this.sendData("D^H" + Holo.Encoding.encodeVL64(num3));
                    }
                }
            }
        }

        internal void ProcessPacketEd()
        {
            if (!this._inPublicroom)
            {
                this._guideCount = 0;
                this._guideRoom = this.Room.roomID;
                this._guideSearch = true;
                this._guideFinish = 0;
                userManager.sendToGuides(this.userID, this.Room.roomID, string.Concat(new object[] { "Ec", this.userID, Convert.ToChar(2), this._Username, Convert.ToChar(2) }));
                this.sendData("Fe");
            }
        }

        internal void ProcessPacketEe()
        {
            this._guideCount = 0;
            virtualUser user = userManager.getUser(this._guideRequest);
            if (user._isLoggedIn && (this._guideRoom > 0))
            {
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    client.runQuery("UPDATE users SET guide_points = guide_points + 1 WHERE id = " + this.userID);
                }
                user.sendData("Fg" + Holo.Encoding.encodeVL64(this.userID));
                this.sendData("D^H" + Holo.Encoding.encodeVL64(this._guideRoom) + Convert.ToChar(2));
            }
        }

        internal void ProcessPacketEg()
        {
            if (!this._inPublicroom)
            {
                this._guideFinish = -1;
                this._guideCount = 0;
                this._guideRoom = 0;
                this._guideSearch = false;
                userManager.sendToGuides(this.userID, 0, "Eh" + this.userID + Convert.ToChar(2));
            }
        }

        internal void ProcessPacketEj()
        {
            this._guideRequest = 0;
        }

        internal void ProcessPacketEk()
        {
            this._guideRequest = -1;
        }

        internal void ProcessPacketEPAR()
        {
            if ((this._hostsEvent && this._isOwner) && (!this._inPublicroom && (this.roomUser != null)))
            {
                this._hostsEvent = false;
                eventManager.removeEvent(this._roomID);
                this.Room.sendData("Er-1");
            }
        }

        internal void ProcessPacketEr()
        {
            this.refreshEffect();
        }

        internal void ProcessPacketEs()
        {
            if (this.Respect != 0)
            {
                int userID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                virtualUser user = userManager.getUser(userID);
                if ((user != null) && (user.roomUser.roomID == this.roomUser.roomID))
                {
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        if (client.getInt(string.Concat(new object[] { "SELECT userid FROM users_respected WHERE userid = ", this.userID, " AND respectedid = ", user.userID, " LIMIT 1" })) != this.userID)
                        {
                            client.runQuery(string.Concat(new object[] { "INSERT INTO users_respected (userid,respectedid) VALUES ('", this.userID, "','", user.userID, "')" }));
                            client.runQuery("UPDATE users SET respect_received = respect_received + 1 WHERE id = " + userID + " LIMIT 1");
                            client.runQuery("UPDATE users SET respect_given = respect_given + 1 WHERE id = " + this.userID + " LIMIT 1");
                        }
                    }
                    this.Room.sendData("Fx" + Holo.Encoding.encodeVL64(userID) + Holo.Encoding.encodeVL64(this.Respect));
                    this.Respect--;
                }
            }
        }

        internal void ProcessPacketESL()
        {
            if ((this._hostsEvent && this._isOwner) && (!this._inPublicroom && (this.roomUser != null)))
            {
                int categoryID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (eventManager.categoryOK(categoryID))
                {
                    int length = Holo.Encoding.encodeVL64(categoryID).Length;
                    int num3 = Holo.Encoding.decodeB64(this.currentPacket.Substring(length + 2, 2));
                    string name = this.currentPacket.Substring(length + 4, num3);
                    string description = this.currentPacket.Substring((length + num3) + 6);
                    eventManager.editEvent(categoryID, this._roomID, name, description);
                    this.Room.sendData("Er" + eventManager.getEvent(this._roomID));
                }
            }
        }

        internal void ProcessPacketEt()
        {
            int effectID = Holo.Encoding.decodeVL64(currentPacket.Substring(2));
            if (Room != null && roomUser != null)
            {
                statusID = "Ge";
                statusCount = effectID;
                Room.sendData(statusID + Holo.Encoding.encodeVL64(roomUser.roomUID) + Holo.Encoding.encodeVL64(statusCount));
                return;
            }
        }

        internal void ProcessPacketEu()
        {
            int effectID = Holo.Encoding.decodeVL64(currentPacket.Substring(2));
            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
            {

                if (dbClient.getInt("SELECT effect_timemax FROM users_effects WHERE userid = '" + this.userID + "' AND effect_id = '" + effectID + "' AND effect_activated = '0' LIMIT 1") < 1)
                    return;
                if (dbClient.getInt("SELECT effect_timemax FROM users_effects WHERE userid = '" + this.userID + "' AND effect_id = '" + effectID + "' AND effect_activated = '1' LIMIT 1") > 0)
                    return;
                if (dbClient.getInt("DELETE num FROM users_effects WHERE effect_timeleft = '0' LIMIT 1") > 0)
                    return;
                dbClient.runQuery("UPDATE users_effects SET effect_activated = '1' WHERE userid = '" + this.userID + "' AND effect_id = " + effectID + " LIMIT 1");
                sendData("GN" + Holo.Encoding.encodeVL64(effectID) + Holo.Encoding.encodeVL64(dbClient.getInt("SELECT effect_timemax FROM users_effects WHERE userid = '" + userID + "' AND effect_id = '" + effectID + "' AND effect_activated = '1' LIMIT 1")));
            }
        }

        internal void ProcessPacketEU()
        {
            if (this._isOwner || this._hasRights)
            {
                string str = roomManager.moodlight.getSettings(this._roomID);
                if (str != null)
                {
                    this.sendData("Em" + str);
                }
            }
        }

        internal void ProcessPacketEUT()
        {
            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            if ((i >= 1) && (i <= 11))
            {
                this.sendData("Eq" + Holo.Encoding.encodeVL64(i) + eventManager.getEvents(i));
            }
        }

        internal void ProcessPacketEv()
        {
            _activateBuy = true;
            Handler.ProcessPacket("Ad" + currentPacket.Substring(2) + "@@H");
        }

        internal void ProcessPacketEV()
        {
            if (this._isOwner || this._hasRights)
            {
                int presetID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2, 1));
                int bgState = Holo.Encoding.decodeVL64(this.currentPacket.Substring(3, 1));
                string presetColour = this.currentPacket.Substring(6, Holo.Encoding.decodeB64(this.currentPacket.Substring(4, 2)));
                int alphaDarkF = Holo.Encoding.decodeVL64(this.currentPacket.Substring(presetColour.Length + 6));
                if (alphaDarkF > 0xff)
                {
                    alphaDarkF = 0xff;
                }
                if (alphaDarkF < 0x9b)
                {
                    alphaDarkF = 0x55;
                }
                if ((!((presetID < 1) | (presetID > 3)) && !((bgState > 2) | (bgState < 1))) && ((((presetColour == "#000000") || (presetColour == "#82F349")) || ((presetColour == "#F2F851") || (presetColour == "#EA4532"))) || (((presetColour == "#E759DE") || (presetColour == "#0053F7")) || (presetColour == "#74F5F5"))))
                {
                    roomManager.moodlight.setSettings(this._roomID, true, presetID, bgState, presetColour, alphaDarkF, this.Room);
                }
            }
        }

        internal void ProcessPacketEW()
        {
            if (this._isOwner || this._hasRights)
            {
                roomManager.moodlight.setSettings(this._roomID, false, 0, 0, null, 0, this.Room);
            }
        }



        internal void ProcessPacketEY()
        {
            if ((this._inPublicroom || (this.roomUser == null)) || this._hostsEvent)
            {
                this.sendData("EoH");
            }
            else
            {
                this.sendData("EoI");
            }
        }

        internal void ProcessPacketEZ()
        {
            if ((this._isOwner && !this._hostsEvent) && (!this._inPublicroom && (this.roomUser != null)))
            {
                int categoryID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (eventManager.categoryOK(categoryID))
                {
                    int length = Holo.Encoding.encodeVL64(categoryID).Length;
                    int num3 = Holo.Encoding.decodeB64(this.currentPacket.Substring(length + 2, 2));
                    string name = this.currentPacket.Substring(length + 4, num3);
                    string description = this.currentPacket.Substring((length + num3) + 6);
                    this._hostsEvent = true;
                    eventManager.createEvent(categoryID, this.userID, this._roomID, name, description);
                    this.Room.sendData("Er" + eventManager.getEvent(this._roomID));
                }
            }
        }

        internal void ProcessPacketF_()
        {
            int myID = 0;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                client.AddParamWithValue("sso", this.currentPacket.Substring(4));
                this.userID = client.getInt("SELECT id FROM users WHERE ticket_sso = @sso AND ipaddress_last = '" + this.IP + "' LIMIT 1");
            }
            if (this.userID == 0)
            {
                this.sendData("BKNo user found with your session ticket (SSO ticket).\rPlease try aggain or clear your SSO ticket." + Convert.ToChar(2));
            }
            else
            {
                string str = userManager.getBanReason(this.userID);
                if (str.Length > 0)
                {
                    this.sendData("@c" + str);
                    this.Disconnect(0x3e8);
                }
                else
                {
                    DataRow row;
                    using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                    {
                        row = client2.getRow("SELECT name,figure,sex,mission,rank,guide,dailyrespect,respect_left,totalpoints FROM users WHERE id = '" + this.userID + "'");
                    }
                    this._Username = Convert.ToString(row[0]);
                    this._Figure = Convert.ToString(row[1]);
                    this._Sex = Convert.ToChar(row[2]);
                    this._Mission = Convert.ToString(row[3]);
                    this._Rank = Convert.ToByte(row[4]);
                    int i = Convert.ToInt16(row[5]);
                    this._isGuide = i == 1;
                    string str2 = Convert.ToString(row[6]);
                    this.Respect = Convert.ToInt16(row[7]);
                    this._TotalGamePoints = Convert.ToString(row[8]);
                    string str3 = DateTime.Today.ToString();
                    if (str2 != str3)
                    {
                        using (DatabaseClient client3 = Eucalypt.dbManager.GetClient())
                        {
                            client3.runQuery(string.Concat(new object[] { "UPDATE users SET dailyrespect = '", str3, "' AND respect_left = 3 WHERE id = ", this.userID }));
                        }
                        this.Respect = 3;
                    }
                    FuserightManager.GenerateFuseList(this.userID, ref this._fuserights);
                    StringBuilder builder = new StringBuilder();
                    builder.Append("@B" + rankManager.fuseRights(this._Rank, this._fuserights) + Convert.ToChar(1));
                    builder.Append("Fi" + Holo.Encoding.encodeVL64(i) + Convert.ToChar(1));
                    builder.Append("FdH" + Convert.ToChar(1));
                    builder.Append("DbIH" + Convert.ToChar(1));
                    builder.Append("@C" + Convert.ToChar(1));
                    builder.Append("GGH" + Convert.ToChar(2) + Convert.ToChar(1));
                    if (Config.enableWelcomeMessage)
                    {
                        builder.Append("BK" + stringManager.getString("welcomemessage_text") + Convert.ToChar(2));
                    }
                    if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_moderator_access", this.userID))
                    {
                        this.sendData("HS");
                    }
                    this.Handler.RegisterLoggedInPackets();
                    this.sendData(builder.ToString());
                    //userManager.addUser(this.userID, this.ShockwaveID, this);
                    userManager.addUser(this.userID, this.ShockwaveID, this);
                    this._isLoggedIn = true;
                }
            }
        }

        internal void ProcessPacketF464()
        {
            this.sendData("G{IH");
        }

        internal void ProcessPacketF873()
        {
            this.sendData("Gz" + recyclerManager.rewardString);
        }

        internal void ProcessPacketF893()
        {
            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            int num2 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2 + Holo.Encoding.encodeVL64(i).Length));
            int num3 = Holo.Encoding.decodeVL64(this.currentPacket.Substring((2 + Holo.Encoding.encodeVL64(num2).Length) + Holo.Encoding.encodeVL64(i).Length));
            int num4 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(((2 + Holo.Encoding.encodeVL64(num2).Length) + Holo.Encoding.encodeVL64(num3).Length) + Holo.Encoding.encodeVL64(i).Length));
            int num5 = Holo.Encoding.decodeVL64(this.currentPacket.Substring((((2 + Holo.Encoding.encodeVL64(num2).Length) + Holo.Encoding.encodeVL64(num3).Length) + Holo.Encoding.encodeVL64(num4).Length) + Holo.Encoding.encodeVL64(i).Length));
            int num6 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(((((2 + Holo.Encoding.encodeVL64(num2).Length) + Holo.Encoding.encodeVL64(num3).Length) + Holo.Encoding.encodeVL64(num4).Length) + Holo.Encoding.encodeVL64(num5).Length) + Holo.Encoding.encodeVL64(i).Length));
            if ((((i == 5) && (num2 != num3)) && ((num3 != num4) && (num4 != num5))) && (num5 != num6))
            {
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    if (client.getInt("SELECT ownerid FROM furniture WHERE id = '" + num2 + "'") == this.userID)
                    {
                        client.runQuery("UPDATE furniture SET ownerid = '-1' WHERE id = '" + num2 + "' LIMIT 1");
                        if (client.getInt("SELECT ownerid FROM furniture WHERE id = '" + num3 + "'") == this.userID)
                        {
                            client.runQuery("UPDATE furniture SET ownerid = '-1' WHERE id = '" + num3 + "' LIMIT 1");
                            if (client.getInt("SELECT ownerid FROM furniture WHERE id = '" + num4 + "'") == this.userID)
                            {
                                client.runQuery("UPDATE furniture SET ownerid = '-1' WHERE id = '" + num4 + "' LIMIT 1");
                                if (client.getInt("SELECT ownerid FROM furniture WHERE id = '" + num5 + "'") == this.userID)
                                {
                                    client.runQuery("UPDATE furniture SET ownerid = '-1' WHERE id = '" + num5 + "' LIMIT 1");
                                    if (client.getInt("SELECT ownerid FROM furniture WHERE id = '" + num6 + "'") == this.userID)
                                    {
                                        client.runQuery("UPDATE furniture SET ownerid = '-1' WHERE id = '" + num6 + "' LIMIT 1");
                                        this.sendData("AC");
                                        client.runQuery(string.Concat(new object[] { "INSERT INTO furniture(tid,ownerid,var) VALUES (1627,", this.userID, ",'", DateTime.Now.ToString("yyyy-MM-dd"), "')" }));
                                        int num7 = 0;
                                        int num8 = 0;
                                        num7 = client.getInt("SELECT MAX(id) FROM furniture");
                                        int num9 = 0;
                                        int num10 = new Random().Next(1, 0x2710);
                                        if ((num10 > 0x251c) && (num9 == 0))
                                        {
                                            num9 = 200;
                                        }
                                        if ((num10 > 0x23be) && (num9 == 0))
                                        {
                                            num9 = 0x7d0;
                                        }
                                        if ((num10 > 0x1d4c) && (num9 == 0))
                                        {
                                            num9 = 40;
                                        }
                                        if ((num10 > 0x157c) && (num9 == 0))
                                        {
                                            num9 = 5;
                                        }
                                        int num11 = client.getInt("SELECT rclr_reward FROM system_recycler WHERE chance = '" + num9 + "' ORDER BY RAND() LIMIT 1");
                                        client.runQuery(string.Concat(new object[] { "INSERT INTO furniture(tid,roomid,ownerid) VALUES (", num11, ",'-1','", this.userID, "')" }));
                                        num8 = client.getInt("SELECT MAX(id) FROM furniture");
                                        client.runQuery(string.Concat(new object[] { "INSERT INTO furniture_presents(id,itemid) VALUES ('", num7, "','", num8, "')" }));
                                        this.refreshHand("last");
                                        this.sendData("G{HH");
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        internal void ProcessPacketFB()
        {
            int expression = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                string str = client.getString("SELECT owner FROM rooms WHERE id = '" + expression + "'");
                if (this._Username != str)
                {
                    return;
                }
            }
            int startIndex = Strings.Len(expression);
            string str2 = this.currentPacket.Substring(startIndex);
            using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
            {
                client2.runQuery(string.Concat(new object[] { "UPDATE rooms SET room_icon = '", str2, "' WHERE id = '", expression, "'" }));
                DataRow row = client2.getRow("SELECT name,description,owner,superusers,visitors_now,visitors_max,tag1,tag2,room_icon FROM rooms WHERE id = '" + this._roomID + "'");
                string str3 = Convert.ToString(row["tag1"]);
                string str4 = Convert.ToString(row["tag2"]);
                StringBuilder builder = new StringBuilder("");
                if ((str3 == "") && (str4 == ""))
                {
                    builder.Append("H");
                }
                else if ((str3 == "") || (str4 == ""))
                {
                    if (str3 == "")
                    {
                        builder.Append("I" + str4 + Convert.ToChar(2));
                    }
                    else
                    {
                        builder.Append("I" + str3 + Convert.ToChar(2));
                    }
                }
                else if ((str3 != "") && (str4 != ""))
                {
                    builder.Append(string.Concat(new object[] { "J", str3, Convert.ToChar(2), str4, Convert.ToChar(2) }));
                }
                this.sendData("GI" + Holo.Encoding.encodeVL64(this._roomID) + "H");
                this.Room.sendData("GH" + Holo.Encoding.encodeVL64(this._roomID));
                this.Room.sendData(string.Concat(new object[] { "GFH", Holo.Encoding.encodeVL64(this._roomID), "H", Convert.ToString(row["name"]), Convert.ToChar(2), Convert.ToString(row["owner"]), Convert.ToChar(2), Holo.Encoding.encodeVL64(Convert.ToInt16(row["superusers"])), Holo.Encoding.encodeVL64(Convert.ToInt16(row["visitors_now"])), Holo.Encoding.encodeVL64(Convert.ToInt16(row["visitors_max"])), Convert.ToString(row["description"]), Convert.ToChar(2), "HHHH", Convert.ToChar(2), builder, Convert.ToString(row["room_icon"]) }));
            }
        }

        internal void ProcessPacketFC()
        {
            int num;
            int num2;
            StringBuilder builder = new StringBuilder();
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                num = client.getInt("SELECT sval FROM system_config WHERE skey = 'navigator_createroom_maxrooms'");
                num2 = client.getInt("SELECT count(id) FROM rooms WHERE owner = '" + this._Username + "'");
            }
            if (num2 <= num)
            {
                builder.Append(Holo.Encoding.encodeVL64(0));
            }
            else
            {
                builder.Append(Holo.Encoding.encodeVL64(1));
            }
            builder.Append(Holo.Encoding.encodeVL64(num));
            this.sendData("H@" + builder);
        }

        internal void ProcessPacketFD()
        {
            Out.WriteLine(Convert.ToString(currentPacket.Length));
            //int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(3, 2));
            int i = Holo.Encoding.decodeVL64(currentPacket.Substring(2, currentPacket.Length - 2));
            bool flag = this.currentPacket.Substring(2, 1) == "I";
            using (DatabaseClient cliento = Eucalypt.dbManager.GetClient())
            {
                //int modello;
                //int num = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2, this.currentPacket.Length - 2));
                //this._roomID = num;
                //modello = cliento.getInt("SELECT model FROM rooms WHERE id = '" + _roomID + "'");

                int rowollo;

                rowollo = cliento.getInt("SELECT model FROM rooms WHERE id = '" + i + "'");

                this.sendData("GE" + rowollo);
                this.sendData("@S");
                this.sendData("Bf - HydroHabbo");
                this.sendData("Du");
                //this.sendData("@_" + this.Room.Heightmap + Convert.ToChar(2));
                //this.sendData("GV" + this.Room.Heightmap + Convert.ToChar(2));
                this.Handler.ProcessPacket("CW");
            }
            if ((this.Room != null) && (this.roomUser != null))
            {
                this.Room.removeUser(this.roomUser.roomUID, false, "");
            }
            this._roomID = i;
            this._inPublicroom = flag;
            this._ROOMACCESS_PRIMARY_OK = true;
            if (flag)
            {
                string str;
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    str = client.getString("SELECT ccts FROM rooms WHERE id = '" + i + "'");
                }
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    client2.getString("SELECT model FROM rooms WHERE id = '" + i + "'");
                }
                this.sendData(string.Concat(new object[] { "AE", str, Convert.ToChar(2), Holo.Encoding.encodeVL64(i) }));
                this._ROOMACCESS_SECONDARY_OK = true;
                if (roomManager.containsRoom(this._roomID))
                {
                    this.Room = roomManager.getRoom(this._roomID);
                }
                else
                {
                    this.Room = new virtualRoom(this._roomID, this._inPublicroom);
                    roomManager.addRoom(this._roomID, this.Room);
                }
            }
        }

        internal void ProcessPacketFF() // Enter room - add this user to room A@
        {

            if (_ROOMACCESS_SECONDARY_OK && Room != null && roomUser == null)
            {
                Room.addUser(this);
                statusManager.dropCarrydItem();
                Room.refreshActions(roomUser.roomUID);
                Room.sendData("@b" + Room.dynamicStatuses);
                if (Room.hasSpecialCasts("cam1"))
                {
                    sendData("AGcam1 targetcamera " + roomUser.roomUID);
                }
            }
            return;
        }

        internal void ProcessPacketFG()
        {
            if (Room != null && roomUser != null)
                Room.removeUser(roomUser.roomUID, false, "");

            int num = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2, this.currentPacket.Length - 5));
            this.sendData("@S");
            this.sendData("Bf");
            if ((this.Room != null) && (this.roomUser != null))
            {
                roomManager.removeRoom(this._roomID);
                this.Room.removeUser(this.roomUser.roomUID, false, "");
            }
            else
            {
                this._roomID = num;
                this._inPublicroom = false;
                this._ROOMACCESS_PRIMARY_OK = true;
                this._ROOMACCESS_SECONDARY_OK = true;
                if (this._ROOMACCESS_SECONDARY_OK && !this._inPublicroom)
                {
                    DataRow row;
                    string str;
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        row = client.getRow("SELECT model, wallpaper, floor FROM rooms WHERE id = '" + this._roomID + "'");
                        str = client.getString("SELECT landscape FROM rooms WHERE id = '" + this._roomID + "'");
                    }
                    string str2 = "model_" + Convert.ToString(row["model"]);
                    this.sendData(string.Concat(new object[] { "AE", str2, Convert.ToChar(2), Holo.Encoding.encodeVL64(this._roomID) }));
                    int num2 = Convert.ToInt32(row["wallpaper"]);
                    int num3 = Convert.ToInt32(row["floor"]);
                    this.sendData(string.Concat(new object[] { "@nlandscape", Convert.ToChar(2), str.Replace(",", "."), Convert.ToChar(2) }));
                    if (num2 > 0)
                    {
                        this.sendData(string.Concat(new object[] { "@nwallpaper", Convert.ToChar(2), num2, Convert.ToChar(2) }));
                    }
                    if (num3 > 0)
                    {
                        this.sendData(string.Concat(new object[] { "@nfloor", Convert.ToChar(2), num3, Convert.ToChar(2) }));
                    }

                    if (!this._isOwner)
                    {
                        using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                        {
                            this._isOwner = client.findsResult(string.Concat(new object[] { "SELECT id FROM rooms WHERE id = '", this._roomID, "' AND owner = '", this._Username, "'" }));/*rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_any_room_controller", this.userID)*/
                        }
                    }

                    if (!this._isOwner2)
                    {
                        using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                        {
                            this._isOwner2 = rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_any_room_controller", this.userID);
                        }
                    }

                    if (this._hasRights)
                    {
                        this.sendData("@j" + Convert.ToChar(2));
                        this._hasRights = true;
                    }
                    if (this._isOwner)
                    {
                        this._hasRights = true;
                        this.sendData("@o" + Convert.ToChar(2));
                    }
                    if (this._isOwner2)
                    {
                        this._hasRights = true;
                        this.sendData("@o" + Convert.ToChar(2));
                    }
                    int i = -1;
                    using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                    {
                        if (client2.findsResult(string.Concat(new object[] { "SELECT userid FROM room_votes WHERE userid = '", this.userID, "' AND roomid = '", this._roomID, "'" })))
                        {
                            i = client2.getInt("SELECT SUM(vote) FROM room_votes WHERE roomid = '" + this._roomID + "'");
                            if (i < 0)
                            {
                                i = 0;
                            }
                        }
                    }
                    this.sendData("EY" + Holo.Encoding.encodeVL64(i) + "\x0001");
                    this.sendData(string.Concat(new object[] { "Er", eventManager.getEvent(this._roomID), Convert.ToChar(2), "\x0001" }));
                }
                if (roomManager.containsRoom(this._roomID))
                {
                    this.Room = roomManager.getRoom(this._roomID);
                }
                else
                {
                    this.Room = new virtualRoom(this._roomID, this._inPublicroom);
                    roomManager.addRoom(this._roomID, this.Room);
                }

                this.Handler.ProcessPacket("CW");


            }
        }

        internal void ProcessPacketFH()
        {
            try
            {
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2, 2));
                string data = this.currentPacket.Substring(Holo.Encoding.encodeVL64(i).Length + 2);
                floorItem item = this.Room.floorItemManager.getItem(i);
                catalogueManager.itemTemplate template = catalogueManager.getTemplate(item.templateID);
                if (((Math.Abs((int)(this.roomUser.X - item.X)) <= 1) && (Math.Abs((int)(this.roomUser.Y - item.Y)) <= 1)) || (template.nexttoRequired != 1))
                {
                    if (template.maxStatus == -1)
                    {
                        int num2;
                        int num3;
                        if (item.Z == 2)
                        {
                            if ((this.roomUser.X != (item.X + 1)) || (item.Y != this.roomUser.Y))
                            {
                                return;
                            }
                        }
                        else if (item.Z == 0)
                        {
                            if ((this.roomUser.Y != (item.Y - 1)) || (item.X != this.roomUser.X))
                            {
                                return;
                            }
                        }
                        else if ((item.Z == 4) && ((this.roomUser.Y != (item.Y + 1)) || (item.X != this.roomUser.X)))
                        {
                            return;
                        }
                        this.roomUser.goalX = -1;
                        this.Room.sendData(string.Concat(new object[] { "AX", i, Convert.ToChar(2), 1, Convert.ToChar(2) }));
                        this.Room.moveUser(this.roomUser, item.X, item.Y, true);
                        using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                        {
                            num3 = client.getInt("SELECT teleportid FROM furniture WHERE id = '" + i + "'");
                            num2 = client.getInt("SELECT roomid FROM furniture WHERE id = '" + num3 + "'");
                        }
                        if (num2 > 0)
                        {
                            new TeleporterUsageSleep(this.useTeleporter).BeginInvoke(item, num3, num2, null, null);
                        }
                        else
                        {
                            this.Room.sendData(string.Concat(new object[] { "AX", i, Convert.ToChar(2), 0, Convert.ToChar(2) }), 750);
                        }
                    }
                    else if ((template.rightsRequired != 1) || this._hasRights)
                    {
                        if (template.drinkIDs != "")
                        {
                            this.Room.sendData("G`" + Holo.Encoding.encodeVL64(this.roomUser.roomUID) + Holo.Encoding.encodeVL64(0));
                            if (template.drinkIDs.Contains("\n"))
                            {
                                string s = template.drinkIDs.Split(new char[] { '\r' })[0];
                                s = s.Replace("\n", "");
                                int index = new Random().Next(1, int.Parse(s));
                                s = template.drinkIDs.Split(new char[] { '\r' })[index];
                                s = s.Replace("\n", "");
                                this.statusManager.carryItem(int.Parse(s));
                            }
                            else
                            {
                                this.statusManager.carryItem(int.Parse(template.drinkIDs));
                            }
                        }
                        if ((Holo.Encoding.decodeVL64(data) > 0) | (Holo.Encoding.decodeVL64(data) < 10))
                        {
                            this.Room.floorItemManager.toggleItemStatus(i, data, this._hasRights);
                        }
                    }
                }
            }
            catch
            {
            }
        }

        internal void ProcessPacketFI() // Item handling - toggle wallitem status
        {
            try
            {
                if (_inPublicroom || Room == null || roomUser == null)
                    return;

                int itemID = Holo.Encoding.decodeVL64(currentPacket.Substring(2));
                Rooms.Items.wallItem Item = Room.wallItemManager.getItem(itemID);
                catalogueManager.itemTemplate Template = catalogueManager.getTemplate(Item.templateID);
                int toStatus = 0;

                /* Check if the furniture requires that the user has rights */
                if (Template.rightsRequired == 1)
                    if (_hasRights == false)
                        return;

                using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                {
                    toStatus = dbClient.getInt("SELECT var FROM furniture WHERE id = " + itemID + " LIMIT 1");
                    if (toStatus == 1)
                    {
                        toStatus = 0;
                    }
                    else
                    {
                        toStatus = 1;
                    }
                }
                Room.wallItemManager.toggleItemStatus(itemID, toStatus);
                return;
            }
            catch { }
        }

        internal void ProcessPacketFn()
        {
            this.GetAllRooms(this.UserSearchID);
        }

        internal void ProcessPacketFo()
        {
            this.GetHighestRated(this.UserSearchID);
            this.UserSearchID++;
        }

        internal void ProcessPacketFP()
        {
            DataRow row;
            int num = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                row = client.getRow("SELECT name,owner,state,showname,visitors_now,visitors_max,description,category,ccts,id,tag1,tag2 FROM rooms WHERE id = " + num);
            }
            if (Convert.ToString(row["owner"]) == this._Username)
            {
                string str2 = Convert.ToString(row["tag1"]);
                string str3 = Convert.ToString(row["tag2"]);
                StringBuilder builder = new StringBuilder("");
                if ((str2 == "") && (str3 == ""))
                {
                    builder.Append("H");
                }
                else if ((str2 == "") || (str3 == ""))
                {
                    if (str2 == "")
                    {
                        builder.Append("I" + str3 + Convert.ToChar(2));
                    }
                    else
                    {
                        builder.Append("I" + str2 + Convert.ToChar(2));
                    }
                }
                else if ((str2 != "") && (str3 != ""))
                {
                    builder.Append(string.Concat(new object[] { "J", str2, Convert.ToChar(2), str3, Convert.ToChar(2) }));
                }
                this.sendData(string.Concat(new object[] { "GQ", Holo.Encoding.encodeVL64(Convert.ToInt16(row["id"])), Convert.ToString(row["name"]), Convert.ToChar(2), Convert.ToString(row["description"]), Convert.ToChar(2), Holo.Encoding.encodeVL64(Convert.ToInt16(row["state"])), Holo.Encoding.encodeVL64(Convert.ToInt16(row["category"])), Holo.Encoding.encodeVL64(Convert.ToInt16(row["visitors_max"])), Holo.Encoding.encodeVL64(Convert.ToInt16(row["visitors_max"])), "IHH", builder, "HH" }));
            }
        }

        internal void ProcessPacketFr()
        {
            this.GetOwnRooms(this.UserSearchID);
            this.UserSearchID++;
        }

        internal void ProcessPacketFR()
        {
            if (((this.Room != null) && (this.roomUser != null)) && ((this._tradePartnerRoomUID != -1) && this.Room.containsUser(this._tradePartnerRoomUID)))
            {
                virtualUser user = this.Room.getUser(this._tradePartnerRoomUID);
                this._tradeConfirm = true;
                this.sendData("Am" + Holo.Encoding.encodeVL64(this.userID) + "I");
                user.sendData("Am" + Holo.Encoding.encodeVL64(this.userID) + "I");
                if (user._tradeConfirm)
                {
                    StringBuilder builder = new StringBuilder("'a'='b'");
                    for (int i = 0; i < this._tradeItemCount; i++)
                    {
                        if (this._tradeItems[i] > 0)
                        {
                            builder.Append(" OR id = '" + this._tradeItems[i] + "'");
                        }
                    }
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        client.runQuery(string.Concat(new object[] { "UPDATE furniture SET ownerid = '", user.userID, "',roomid = '0' WHERE", builder.ToString() }));
                    }
                    builder.Remove(7, builder.Length - 7);
                    for (int j = 0; j < user._tradeItemCount; j++)
                    {
                        if (user._tradeItems[j] > 0)
                        {
                            builder.Append(" OR id = '" + user._tradeItems[j] + "'");
                        }
                    }
                    using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                    {
                        client2.runQuery(string.Concat(new object[] { "UPDATE furniture SET ownerid = '", this.userID, "',roomid = '0' WHERE", builder.ToString() }));
                    }
                    this.abortTrade();
                }
            }
        }

        internal void ProcessPacketFs()
        {
            this.GetFavourites(this.UserSearchID);
        }

        internal void ProcessPacketFS()
        {
            this.ProcessPacketAF();
        }

        internal void ProcessPacketFT()
        {
            if ((this.Room != null) && (this.roomUser != null))
            {
                if (!this._receivedSpriteIndex)
                {
                    StringBuilder builder = new StringBuilder();
                    builder.Append(Convert.ToChar(2));
                    builder.Append("igor_seat");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("igor_seatcmp");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_cltele");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_cltele_cmp");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_cllava2");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_cllava");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_frankb");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_frankbcmp");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_cl_jukeb");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_cl_jukeb_camp");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_clcake");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_cl_jukeb_camp");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_clcake");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_clcake_cm");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_cl_sofa");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_cl_sofa_cmp");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_calip_lava");
                    builder.Append(Convert.ToChar(2));
                    builder.Append("ads_calip_lava2");
                    builder.Append(Convert.ToChar(2));
                    this.sendData("Di" + builder);
                    this._receivedSpriteIndex = true;
                }
                string mode = this.currentPacket.Substring(2);
                this.refreshHand(mode);
            }
        }

        internal void ProcessPacketFw()
        {
            int num;
            DataTable table;
            StringBuilder builder = new StringBuilder();
            int i = 0;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                num = client.getInt("SELECT count(id) FROM events");
                table = client.getTable("SELECT id,name,description,userid,roomid,category,date FROM events");
            }
            builder.Append(Holo.Encoding.encodeVL64(num) + "-1" + Convert.ToChar(2));
            if (table.Rows.Count > 0)
            {
                foreach (DataRow row in table.Rows)
                {
                    DataRow row2;
                    int num4;
                    DataColumn column;
                    int num5;
                    int num6;
                    using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                    {
                        row2 = client2.getRow("SELECT id,level,name,owner,state,visitors_now,visitors_max,description FROM rooms WHERE id = '" + row["roomid"] + "'");
                        num4 = client2.getInt("SELECT trading FROM room_categories WHERE id = '" + client2.getInt("SELECT category FROM rooms WHERE id = '" + row["roomid"] + "'") + "'");
                        column = client2.getColumn("SELECT id FROM users WHERE roomid = '" + row["roomid"] + "' ORDER BY id ASC");
                        num5 = client2.getInt("SELECT count(vote)from room_votes WHERE id = '" + row["roomid"] + "'");
                        num6 = client2.getInt("SELECT icon FROM rooms WHERE id = '" + row["roomid"] + "'");
                    }
                    builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(Convert.ToInt32(row["category"])), Holo.Encoding.encodeVL64(Convert.ToInt32(row2["id"])), "I", Convert.ToString(row2["name"]), Convert.ToChar(2), Convert.ToString(row2["owner"]), Convert.ToChar(2), Holo.Encoding.encodeVL64(Convert.ToInt32(row2["state"])), Holo.Encoding.encodeVL64(Convert.ToInt32(row2["visitors_now"])), Holo.Encoding.encodeVL64(Convert.ToInt32(row2["visitors_max"])), Convert.ToString(row2["description"]), Convert.ToChar(2) }));
                    Hashtable hashtable = new Hashtable(column.Table.Rows.Count);
                    string str = "";
                    foreach (DataRow row3 in column.Table.Rows)
                    {
                        hashtable.Add(Convert.ToInt32(row3["id"]), Convert.ToInt32(row3["id"]));
                        str = str + Convert.ToString(row3["id"]);
                        str = str.Substring(0, str.Length);
                        if ((str.Length > 0) && this.Messenger.hasFriendship(Convert.ToInt32(str)))
                        {
                            hashtable.Remove(Convert.ToInt32(row3["id"]));
                            i++;
                        }
                    }
                    builder.Append(Holo.Encoding.encodeVL64(i));
                    if (Convert.ToString(num4) == "1")
                    {
                        builder.Append(Holo.Encoding.encodeVL64(1));
                    }
                    else
                    {
                        builder.Append(Holo.Encoding.encodeVL64(0));
                    }
                    builder.Append(Holo.Encoding.encodeVL64(num5) + Holo.Encoding.encodeVL64(0) + Holo.Encoding.encodeVL64(2) + Holo.Encoding.encodeVL64(num6) + Convert.ToString(row["date"]));
                }
            }
            else
            {
                builder.Append(Holo.Encoding.encodeVL64(0));
            }
            this.sendData("GC" + builder);
        }

        internal void ProcessPacketFx()
        {
            sendData(@"@\IMBot GuidaMissione: aiutarti a conoscere Habbo!hr-836-61.hd-600-2.ch-824-110.lg-695-110.sh-730-110.he-1607-.ca-1813-IKQA0.0HK
");
            sendData("@XIEhi! Benvenuto in Hotel, sono contenta di vederti. Hai bisogno di aiuto?H
");
            sendData("@XIIo sono un Bot Guida e sono qui per rispondere a tutte le tue domande delle prossime 24 ore.H
");
        }

        internal void ProcessPacketFx2()
        {
            sendData(@"@\IMBot GuidaMissione: aiutarti a conoscere Habbo!hr-836-61.hd-600-2.ch-824-110.lg-695-110.sh-730-110.he-1607-.ca-1813-IKQA0.0HK
");
            sendData("@XIEhi! Benvenuto in Hotel, sono contenta di vederti. Hai bisogno di aiuto?H
");
            sendData("@XIIo sono un Bot Guida e sono qui per rispondere a tutte le tue domande delle prossime 24 ore.H
");
        }
        internal void ProcessPacketFy()
        {
            if (this._ROOMACCESS_SECONDARY_OK && (this.Room != null))
            {
                this.sendData("@]1\x0002\x0001");
            }
        }

        internal void ProcessPacketGF()
        {
            sendData("");
        }

        internal void ProcessPacketLB()
        {
            if ((this.Room != null) && (this.roomUser != null))
            {
                string mode = this.currentPacket.Substring(2);
                this.refreshHand(mode);
            }
        }

        internal void ProcessPacketoB()
        {
            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            int num2 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2 + Holo.Encoding.encodeVL64(i).Length));
            MarketManager.AddItem(Holo.Encoding.decodeVL64(this.currentPacket.Substring((2 + Holo.Encoding.encodeVL64(i).Length) + Holo.Encoding.encodeVL64(num2).Length)), this.userID, i);
            this.refreshHand("");
        }

        internal void ProcessPacketoC()
        {
            if ((this.Room != null) && (this.roomUser != null))
            {
                StringBuilder builder = new StringBuilder();
                builder.Append(Holo.Encoding.encodeVL64(4));
                builder.Append(Holo.Encoding.encodeVL64(1));
                builder.Append(Holo.Encoding.encodeVL64(1));
                builder.Append(Holo.Encoding.encodeVL64(5));
                builder.Append(Holo.Encoding.encodeVL64(1));
                builder.Append(Holo.Encoding.encodeVL64(0x2710));
                builder.Append(Holo.Encoding.encodeVL64(0x30));
                this.sendData("Id" + builder);
            }
        }

        internal void ProcessPacketoD()
        {
            this.sendData("IcIJ");
        }

        internal void ProcessPacketOj()
        {
        }

        internal void ProcessPacketoF()
        {
            int furniM = Holo.Encoding.decodeVL64(currentPacket.Substring(2));
            Out.WriteLine(Convert.ToString(furniM));
            MarketManager.BuyItem(furniM, this.userID, this);
            this.sendData("oF");
        }

        internal void ProcessPacketoG()
        {
            MarketManager.RemoveItem(Holo.Encoding.decodeB64(currentPacket.Substring(2, 2)), this.userID);

            this.Handler.ProcessPacket("oK");
            this.refreshHand("");
        }

        internal void ProcessPacketoJ()
        {
            List<Holo.Catalogue.Marketplace.Marketplace> list = MarketManager.MarketItems(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2)));
            StringBuilder builder = new StringBuilder();
            builder.Append(Holo.Encoding.encodeVL64(list.Count));
            foreach (Holo.Catalogue.Marketplace.Marketplace marketplace in list)
            {
                builder.Append(Holo.Encoding.encodeVL64(marketplace.ID));
                builder.Append(Holo.Encoding.encodeVL64(1));
                builder.Append(Holo.Encoding.encodeVL64(1));
                builder.Append(Holo.Encoding.encodeVL64(marketplace.SpriteID));
                builder.Append(Holo.Encoding.encodeVL64(marketplace.Cost_Credits));
                builder.Append(Holo.Encoding.encodeVL64(marketplace.TemplateID));
            }
            this.sendData("Ig" + builder);
        }

        internal void ProcessPacketoK()
        {
            List<Holo.Catalogue.Marketplace.Marketplace> list = MarketManager.MarketItem(this.userID);
            StringBuilder builder = new StringBuilder();
            builder.Append(Holo.Encoding.encodeVL64(list.Count));
            foreach (Holo.Catalogue.Marketplace.Marketplace marketplace in list)
            {
                if (DateTime.Compare(marketplace.ExpiresDate, DateTime.Now) > 0)
                {
                    builder.Append(Holo.Encoding.encodeVL64(marketplace.ID));
                    builder.Append(Holo.Encoding.encodeVL64(1));
                    builder.Append(Holo.Encoding.encodeVL64(1));
                    builder.Append(Holo.Encoding.encodeVL64(marketplace.SpriteID));
                    builder.Append(Holo.Encoding.encodeVL64(marketplace.Cost_Credits));
                    builder.Append(Holo.Encoding.encodeVL64((int)marketplace.ExpiresDate.Subtract(DateTime.Now).TotalMinutes));
                }
            }
            this.sendData("Ih" + builder);
        }

        private void refresh_cat()
        {
            catalogueManager.Init(true);
        }

        private void refresh_config()
        {
            Config.Init(true);
        }

        private void refresh_eco()
        {
            recyclerManager.Init(true);
        }

        private void refresh_filter()
        {
            stringManager.initFilter(true);
        }

        private void refresh_fuse()
        {
            rankManager.Init(true);
        }

        private void refresh_modeldata()
        {
            modeldataManager.Init(true);
        }

        private void refresh_strings()
        {
            stringManager.Init("en", true);
        }

        internal void refreshAppearance(bool Reload, bool refreshSettings, bool refreshRoom, bool refreshBETALooks)
        {
            if (Reload)
            {
                DataRow row;
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    row = client.getRow("SELECT figure,sex,mission FROM users WHERE id = '" + this.userID + "'");
                }
                this._Figure = Convert.ToString(row["figure"]);
                this._Sex = Convert.ToChar(row["sex"]);
                this._Mission = Convert.ToString(row["mission"]);
            }
            if (refreshSettings)
            {
                this.sendData(string.Concat(new object[] { "@E", this.userID, Convert.ToChar(2), this._Username, Convert.ToChar(2), this._Figure, Convert.ToChar(2), this._Sex, Convert.ToChar(2), this._Mission, Convert.ToChar(2), Convert.ToChar(2), "HISCK" }));
            }
            if (refreshRoom && Room != null && roomUser != null)
            {
                Room.sendData("DJ" + Holo.Encoding.encodeVL64(roomUser.roomUID) + _Figure + Convert.ToChar(2) + _Sex + Convert.ToChar(2) + _Mission + Convert.ToChar(2));
            }
            if (refreshBETALooks)
            {
                this.sendData(string.Concat(new object[] { "DJH", this._Figure, Convert.ToChar(2), this._Sex, Convert.ToChar(2), this._Mission, Convert.ToChar(2) }));
            }
        }

        internal void refreshBadges()
        {
            DataColumn column;
            DataColumn column2;
            DataColumn column3;
            DataColumn column4;
            this._Badges.Clear();
            this._badgeSlotIDs.Clear();
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                column = client.getColumn("SELECT badgeid FROM users_badges WHERE userid = '" + this.userID + "' ORDER BY slotid ASC");
                column2 = client.getColumn("SELECT slotid FROM users_badges WHERE userid = '" + this.userID + "' ORDER BY slotid ASC");
            }
            string[] strArray = dataHandling.dColToArray(column);
            string[] strArray2 = dataHandling.dColToArray(column2);
            StringBuilder builder = new StringBuilder();
            builder.Append(Holo.Encoding.encodeVL64(strArray.Length));
            for (int i = 0; i < strArray.Length; i++)
            {
                builder.Append(strArray[i]);
                builder.Append(Convert.ToChar(2));
                this._Badges.Add(strArray[i]);
            }
            for (int j = 0; j < strArray.Length; j++)
            {
                if (Convert.ToInt32(strArray2[j]) > 0)
                {
                    builder.Append(Holo.Encoding.encodeVL64(Convert.ToInt32(strArray2[j])));
                    builder.Append(strArray[j]);
                    builder.Append(Convert.ToChar(2));
                    this._badgeSlotIDs.Add(Convert.ToInt32(strArray2[j]));
                }
                else
                {
                    this._badgeSlotIDs.Add(0);
                }
            }
            this.sendData("Ce" + builder.ToString());
            this.sendData(string.Concat(new object[] { 
                "FtSHJIACH_Graduate1", Convert.ToChar(2), "PAIACH_Login1", Convert.ToChar(2), "PAJACH_Login2", Convert.ToChar(2), "PAKACH_Login3", Convert.ToChar(2), "PAPAACH_Login4", Convert.ToChar(2), "PAQAACH_Login5", Convert.ToChar(2), "PBIACH_RoomEntry1", Convert.ToChar(2), "PBJACH_RoomEntry2", Convert.ToChar(2), 
                "PBKACH_RoomEntry3", Convert.ToChar(2), "SBRAACH_RegistrationDuration6", Convert.ToChar(2), "SBSAACH_RegistrationDuration7", Convert.ToChar(2), "SBPBACH_RegistrationDuration8", Convert.ToChar(2), "SBQBACH_RegistrationDuration9", Convert.ToChar(2), "SBRBACH_RegistrationDuration10", Convert.ToChar(2), "RAIACH_AvatarLooks1", Convert.ToChar(2), "IJGLB", Convert.ToChar(2), 
                "IKGLC", Convert.ToChar(2), "IPAGLD", Convert.ToChar(2), "IQAGLE", Convert.ToChar(2), "IRAGLF", Convert.ToChar(2), "ISAGLG", Convert.ToChar(2), "IPBGLH", Convert.ToChar(2), "IQBGLI", Convert.ToChar(2), "IRBGLJ", Convert.ToChar(2), 
                "SAIACH_Student1", Convert.ToChar(2), "PCIHC1", Convert.ToChar(2), "PCJHC2", Convert.ToChar(2), "PCKHC3", Convert.ToChar(2), "PCPAHC4", Convert.ToChar(2), "PCQAHC5", Convert.ToChar(2), "QAIACH_GamePlayed1", Convert.ToChar(2), "QAJACH_GamePlayed2", Convert.ToChar(2), 
                "QAKACH_GamePlayed3", Convert.ToChar(2), "QAPAACH_GamePlayed4", Convert.ToChar(2), "QAQAACH_GamePlayed5", Convert.ToChar(2)
             }));
            this.sendData("DtIH" + Convert.ToChar(1) + "FCH");
            int num3 = 0;
            string str = "";
            List<string> list = new List<string>();
            List<int> list2 = new List<int>();
            using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
            {
                column3 = client2.getColumn("SELECT badgeid FROM users_badges WHERE userid = '" + this.userID + "' ORDER BY slotid ASC");
                column4 = client2.getColumn("SELECT slotid FROM users_badges WHERE userid = '" + this.userID + "' ORDER BY slotid ASC");
            }
            string[] strArray3 = dataHandling.dColToArray(column3);
            string[] strArray4 = dataHandling.dColToArray(column4);
            for (int k = 0; k < strArray3.Length; k++)
            {
                list.Add(strArray3[k]);
            }
            for (int m = 0; m < strArray3.Length; m++)
            {
                if (Convert.ToInt32(strArray4[m]) > 0)
                {
                    list2.Add(Convert.ToInt32(strArray4[m]));
                }
                else
                {
                    list2.Add(0);
                }
            }
            for (int n = 0; n < list.Count; n++)
            {
                if (list2[n] > 0)
                {
                    str = (str + Holo.Encoding.encodeVL64(list2[n])) + list[n] + Convert.ToChar(2);
                    num3++;
                }
            }
            this.sendData("Cd" + Holo.Encoding.encodeVL64(this.userID) + Holo.Encoding.encodeVL64(num3) + str);
        }

        internal void refreshClub()
        {
            DataRow row;
            int i = 0;
            int num2 = 0;
            int num3 = 0;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                row = client.getRow("SELECT months_expired,months_left,date_monthstarted FROM users_club WHERE userid = '" + this.userID + "' LIMIT 1");
            }
            if (row.Table.Columns.Count > 0)
            {
                num2 = Convert.ToInt32(row["months_expired"]);
                num3 = Convert.ToInt32(row["months_left"]) - 1;
                i = ((int)DateTime.Parse(Convert.ToString(row["date_monthstarted"]), new CultureInfo("en-GB")).Subtract(DateTime.Now).TotalDays) + 0x20;
                this._clubMember = true;
            }
            this.sendData(string.Concat(new object[] { "@Gclub_habbo", Convert.ToChar(2), Holo.Encoding.encodeVL64(i), Holo.Encoding.encodeVL64(num2), Holo.Encoding.encodeVL64(num3), "I" }));
        }

        internal void refreshEffect()
        {
            DataColumn column;
            int i = 0;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                column = client.getColumn("SELECT effect_id FROM users_effects WHERE userid = '" + this.userID + "'");
            }
            string[] strArray = dataHandling.dColToArray(column);
            StringBuilder builder = new StringBuilder();
            if (strArray.Length > 0)
            {
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    for (int j = client2.getInt("SELECT COUNT(*) FROM users_effects WHERE userid = '" + this.userID + "'"); j < 0x1b; j++)
                    {
                        if (client2.getInt(string.Concat(new object[] { "SELECT effect_id FROM users_effects WHERE userid = '", this.userID, "' AND effect_id = ", j, " LIMIT 1" })) != 0)
                        {
                            int num5 = client2.getInt(string.Concat(new object[] { "SELECT effect_id FROM users_effects WHERE userid = '", this.userID, "' AND effect_id = ", j, " AND effect_activated = 1 LIMIT 1" }));
                            int num6 = client2.getInt(string.Concat(new object[] { "SELECT effect_timemax FROM users_effects WHERE userid = '", this.userID, "' AND effect_id = ", j, " ORDER BY effect_timemax DESC LIMIT 1" }));
                            int num7 = client2.getInt(string.Concat(new object[] { "SELECT effect_timeleft FROM users_effects WHERE userid = '", this.userID, "' AND effect_id = ", j, " ORDER BY effect_timeleft DESC LIMIT 1" }));
                            DataRow row = client2.getRow(string.Concat(new object[] { "SELECT effect_id FROM users_effects WHERE userid = '", this.userID, "' AND effect_id = ", j }));
                            i++;
                            if (num5 == j)
                            {
                                builder.Append(Holo.Encoding.encodeVL64(j) + Holo.Encoding.encodeVL64(num6) + Holo.Encoding.encodeVL64(row.Table.Rows.Count) + "M");
                            }
                            else
                            {
                                builder.Append(Holo.Encoding.encodeVL64(j) + Holo.Encoding.encodeVL64(num6) + Holo.Encoding.encodeVL64(row.Table.Rows.Count - 1) + Holo.Encoding.encodeVL64(num7));
                            }
                        }
                    }
                }
            }
            this.sendData("GL" + Holo.Encoding.encodeVL64(i) + builder);
        }

        internal void refreshGroupStatus()
        {
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                this._groupID = client.getInt("SELECT groupid FROM groups_memberships WHERE userid = '" + this.userID + "' AND is_current = '1'");
            }
            if (this._groupID > 0)
            {
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    this._groupMemberRank = client2.getInt(string.Concat(new object[] { "SELECT member_rank FROM groups_memberships WHERE userid = '", this.userID, "' AND groupID = '", this._groupID, "'" }));
                }
            }
        }

        
        internal void refreshHand(string Mode)
        {
            DataTable table;
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                table = client.getTable("SELECT furniture.id,furniture.tid,furniture.var FROM users, furniture WHERE furniture.ownerid = users.id AND furniture.ownerid = '" + this.userID + "' AND furniture.roomid = '0' ORDER BY id ASC");
            }
            StringBuilder builder = new StringBuilder();
            int num2 = 0;
            int count = table.Rows.Count;
            int i = 0;
            switch (Mode)
            {
                case "H":
                case "last":
                    this._handPage = (count - 1) / 9000;
                    break;

                case "I":
                case "next":
                    this._handPage++;
                    break;

                case "J":
                case "prev":
                    this._handPage--;
                    break;

                case "PA":
                case "update":
                    break;

                default:
                    this._handPage = 0;
                    break;
            }
            try
            {
                if (count > 0)
                {
                    while (true)
                    {
                        num2 = this._handPage * 9000;
                        if (count > (num2 + 9000))
                        {
                            count = num2 + 9000;
                        }
                        if ((num2 <= count) && (num2 != count))
                        {
                            break;
                        }
                        this._handPage--;
                    }
                    for (int j = 0; j < count; j++)
                    {
                        int num;
                        DataRow row = table.Rows[j];
                        using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                        {
                            num = client2.getInt("SELECT id FROM furniture_data WHERE sprite = '" + client2.getString("SELECT name_cct FROM catalogue_items WHERE tid = '" + row["tid"] + "'") + "'");
                        }
                        catalogueManager.itemTemplate template = catalogueManager.getTemplate(Convert.ToInt32(row["tid"]));
                        int num6 = 1;
                        if (!template.isRecycleable)
                        {
                            num6 = 0;
                        }
                        int num7 = 1;
                        if (!template.isTradeable)
                        {
                            num7 = 0;
                        }
                        builder.Append(Holo.Encoding.encodeVL64(-int.Parse(row["id"].ToString())));
                        builder.Append("H");
                        if (template.typeID == 0) builder.Append("I");
                        else builder.Append("S");
                        builder.Append(Convert.ToChar(2));
                        builder.Append(Holo.Encoding.encodeVL64(int.Parse(row["id"].ToString())));
                        builder.Append(Holo.Encoding.encodeVL64(num));
                        builder.Append("I");
                        builder.Append(Convert.ToChar(2));
                        builder.Append(Holo.Encoding.encodeVL64(num6));
                        builder.Append(Holo.Encoding.encodeVL64(num7));
                        builder.Append("IIM");
                        if (template.typeID != 0)
                        {
                            builder.Append(Convert.ToChar(2));
                            builder.Append("H");
                        }
                    }
                }
                builder.Append(Holo.Encoding.encodeVL64(table.Rows.Count));
                this.sendData("BL" + Holo.Encoding.encodeVL64(count - num2) + builder.ToString());
            }
            catch
            {
                this.sendData("BLHH" + Convert.ToChar(1) + "C[!;0");
            }
        }
        
        internal void refreshMessenger()
        {
            this.Messenger = new virtualMessenger(this.userID);
            this.sendData("@L" + this.Messenger.friendList());
            this.sendData("Dz" + this.Messenger.friendRequests());
        }

        internal void refreshTradeBoxes()
        {
            if (((this.Room != null) && this.Room.containsUser(this._tradePartnerRoomUID)) && (this.roomUser != null))
            {
                this._tradeAccept = false;
                virtualUser user = this.Room.getUser(this._tradePartnerRoomUID);
                StringBuilder builder = new StringBuilder("Al" + Holo.Encoding.encodeVL64(this.roomUser.userID));
                if (this._tradeItemCount > 0)
                {
                    builder.Append(catalogueManager.tradeItemList(this._tradeItems));
                }
                else
                {
                    builder.Append("H");
                }
                builder.Append(Holo.Encoding.encodeVL64(user.roomUser.userID));
                if (user._tradeItemCount > 0)
                {
                    builder.Append(catalogueManager.tradeItemList(user._tradeItems));
                }
                else
                {
                    builder.Append("H");
                }
                this.sendData(builder.ToString());
            }
        }

        internal void refreshValueables(bool Credits, bool Tickets)
        {
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                this._Credits = client.getInt("SELECT credits FROM users WHERE id = '" + this.userID + "' LIMIT 1");
                this._Pixels = client.getInt("SELECT pixels FROM users WHERE id = '" + this.userID + "' LIMIT 1");
                this.sendData("@F" + this._Credits);
                this._Pixels += 50;
                this.sendData("Fv" + Holo.Encoding.encodeVL64(this._Pixels) + "RL");
                client.runQuery(string.Concat(new object[] { "UPDATE users SET pixels = '", this._Pixels, "' WHERE id = '", this.userID, "' LIMIT 1" }));
            }
        }

        internal void refreshwelcomerstatus()
        {
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                if (client.getInt("SELECT guide_allowed FROM users WHERE id = " + this.userID) == 1)
                {
                    this.sendData("E`PBIJKPAQARASAPB");
                    this.sendData("GJRGK");
                }
            }
        }

        public void Reset()
        {
            if (!this._isDisconnected)
            {
                try
                {
                    this._isDisconnected = true;
                    this.leaveCurrentRoom("", false);
                    if (this.Messenger != null)
                    {
                        this.Messenger.Clear();
                    }
                    userManager.removeUser(this.userID);
                }
                catch (Exception exception)
                {
                    Out.PrimaryErrorWriter("FATAL ERROR DURING DISCONNECTION:\r" + exception.ToString());
                }
            }
        }

        internal void SendByteArray(byte[] Array)
        {
            this._ConnectionManager.SendRawData(Array);
        }

        internal void sendData(string packet)
        {
            this._ConnectionManager.sendData(packet);
        }

        internal void SetHandler(messageHandler _Handler)
        {
            this.Handler = _Handler;
        }

        private void useTeleporter(floorItem Teleporter1, int idTeleporter2, int roomIDTeleporter2)
        {
            try
            {
                Thread.Sleep(500);
                this.roomUser.walkLock = true;
                string sprite = Teleporter1.Sprite;
                if (roomIDTeleporter2 == this._roomID)
                {
                    floorItem item = this.Room.floorItemManager.getItem(idTeleporter2);
                    this.Room.sendData(string.Concat(new object[] { "AX", item.ID, Convert.ToChar(2), 2, Convert.ToChar(2) }), 500);
                    this.Room.sendData(string.Concat(new object[] { "AX", Teleporter1.ID, Convert.ToChar(2), 2, Convert.ToChar(2) }), 500);
                    this.Room.sendData(string.Concat(new object[] { @"A\", Holo.Encoding.encodeVL64(item.ID), this._Username, Convert.ToChar(2) }), 500);
                    this.roomUser.X = item.X;
                    this.roomUser.Y = item.Y;
                    this.roomUser.H = item.H;
                    this.roomUser.Z1 = item.Z;
                    this.roomUser.Z2 = item.Z;
                    this.roomUser.Refresh();
                    this.roomUser.walkLock = false;
                    this.Room.sendData(string.Concat(new object[] { "AX", item.ID, Convert.ToChar(2), 1, Convert.ToChar(2) }), 750);
                    this.Room.sendData(string.Concat(new object[] { "AX", Teleporter1.ID, Convert.ToChar(2), 0, Convert.ToChar(2) }), 750);
                    this.Room.sendData(string.Concat(new object[] { "AX", item.ID, Convert.ToChar(2), 0, Convert.ToChar(2) }), 750);
                    Thread.Sleep(250);
                    int x = item.X;
                    int y = item.Y;
                    if (item.Z == 4)
                    {
                        y = item.Y + 1;
                    }
                    if (item.Z == 2)
                    {
                        x = item.X + 1;
                    }
                    this.Room.moveUser(this.roomUser, x, y, true);
                    this.Room.sendData(string.Concat(new object[] { "AX", Teleporter1.ID, Convert.ToChar(2), 1, Convert.ToChar(2) }));
                }
                else
                {
                    this._teleporterID = idTeleporter2;
                    this._teleporterRoomID = roomIDTeleporter2;
                    this.Room.sendData(string.Concat(new object[] { "AX", Teleporter1.ID, Convert.ToChar(2), 2, Convert.ToChar(2) }));
                    this.Handler.ProcessPacket("@U" + Holo.Encoding.encodeVL64(roomIDTeleporter2));
                    this.Handler.ProcessPacket("@BH" + Holo.Encoding.encodeVL64(roomIDTeleporter2) + "H");
                    this.Room.sendData(string.Concat(new object[] { "AX", Teleporter1.ID, Convert.ToChar(2), 0, Convert.ToChar(2) }), 500);
                }
            }
            catch
            {
            }
        }

        public int ConnectionID
        {
            get
            {
                return this._ConnectionManager.ConnectionID;
            }
        }

        public string IP
        {
            get
            {
                return this._ConnectionManager.connectionRemoteIP;
            }
        }

        private delegate void TeleporterUsageSleep(floorItem Teleporter1, int idTeleporter2, int roomIDTeleporter2);

        private delegate void timedDisconnector(int ms);
    }
}