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.Rooms.Pets;
    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;

    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 int _Minuteperiod;
        internal string _Mission;
        internal string _mutedIDs;
        internal bool _noHeightLimit;
        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 bool _stackRugs;
        internal int _teleporterID;
        internal int _teleporterRoomID;
        internal int _Tickets;
        internal string _TotalGamePoints;
        internal bool _tradeAccept;
        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;
        private messageHandler Handler;
        internal string Ipaddress = "";
        private bool IsPwnwd;
        internal virtualMessenger Messenger;
        internal bool ownRoomsUpdated = true;
        internal virtualPet Pet;
        internal int petID;
        internal bool pingOK;
        private Thread PwnerThread;
        internal int Respect;
        internal virtualRoom Room;
        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;
        private Hashtable Statuses;
        internal string statusID;
        internal virtualRoomUserStatusManager statusManager;
        internal int userID;
        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(string.Concat(new object[] { "DELETE FROM furniture WHERE ownerid = '", this.userID, "' AND roomid = '", this._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 num;
            DataTable table;
            int i = 0;
            StringBuilder builder = new StringBuilder();
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                num = client.getInt("SELECT count(id) FROM rooms WHERE level = '1'");
                table = client.getTable("SELECT id,level,name,owner,state,visitors_now,visitors_max,description FROM rooms WHERE level = '1' ORDER BY id ASC");
            }
            builder.Append(Holo.Encoding.encodeVL64(UserSearchID));
            builder.Append(Holo.Encoding.encodeVL64(5) + Convert.ToChar(2));
            builder.Append(Holo.Encoding.encodeVL64(num));
            if (table.Rows.Count > 0)
            {
                foreach (DataRow row in table.Rows)
                {
                    DataColumn column;
                    int num4;
                    int num5;
                    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 client2 = Eucalypt.dbManager.GetClient())
                    {
                        column = client2.getColumn("SELECT id FROM users WHERE roomid = '" + row["id"] + "' ORDER BY id ASC");
                        num4 = client2.getInt("SELECT trading FROM room_categories WHERE id = '" + client2.getInt("SELECT category FROM rooms WHERE id = '" + row["id"] + "'") + "'");
                        num5 = client2.getInt("SELECT count(vote)from room_votes WHERE id = '" + row["id"] + "'");
                        num6 = client2.getInt("SELECT room_icon FROM rooms WHERE id = '" + row["id"] + "'");
                    }
                    Hashtable hashtable = new Hashtable(column.Table.Rows.Count);
                    string str = "";
                    foreach (DataRow row2 in column.Table.Rows)
                    {
                        hashtable.Add(Convert.ToInt32(row2["id"]), Convert.ToInt32(row2["id"]));
                        str = str + Convert.ToString(row2["id"]);
                        str = str.Substring(0, str.Length);
                        if ((str.Length > 0) && this.Messenger.hasFriendship(Convert.ToInt32(str)))
                        {
                            hashtable.Remove(Convert.ToInt32(row2["id"]));
                            i++;
                        }
                    }
                    builder.Append(Holo.Encoding.encodeVL64(i));
                    if (Convert.ToString(num4) == "10")
                    {
                        builder.Append(Holo.Encoding.encodeVL64(1));
                    }
                    else
                    {
                        builder.Append(Holo.Encoding.encodeVL64(UserSearchID));
                        builder.Append(Holo.Encoding.encodeVL64(5) + Convert.ToChar(2));
                        builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(num5), Holo.Encoding.encodeVL64(0), Holo.Encoding.encodeVL64(num6), Holo.Encoding.encodeVL64(0), Convert.ToChar(2) }));
                    }
                    builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(num5), Holo.Encoding.encodeVL64(0), Holo.Encoding.encodeVL64(num6), Holo.Encoding.encodeVL64(0), Convert.ToChar(2) }));
                }
            }
            else
            {
                builder.Append(Holo.Encoding.encodeVL64(0));
            }
            this.sendData("GC" + builder);
        }

        internal void GetFavourites(int UserSearchID)
        {
            int num;
            DataTable table;
            int i = 0;
            StringBuilder builder = new StringBuilder();
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                num = client.getInt("SELECT roomid FROM users_favourites WHERE userid = '" + this.userID + "'");
                table = client.getTable("SELECT count(roomid) FROM users_favourites WHERE userid = '" + this.userID + "'");
            }
            builder.Append(Holo.Encoding.encodeVL64(UserSearchID));
            builder.Append(Holo.Encoding.encodeVL64(5) + Convert.ToChar(2));
            builder.Append(Holo.Encoding.encodeVL64(num));
            if (table.Rows.Count > 0)
            {
                foreach (DataRow row in table.Rows)
                {
                    DataColumn column;
                    int num4;
                    int num5;
                    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 client2 = Eucalypt.dbManager.GetClient())
                    {
                        column = client2.getColumn("SELECT id FROM users WHERE roomid = '" + row["id"] + "' ORDER BY id ASC");
                        num4 = client2.getInt("SELECT trading FROM room_categories WHERE id = '" + client2.getInt("SELECT category FROM rooms WHERE id = '" + row["id"] + "'") + "'");
                        num5 = client2.getInt("SELECT count(vote)from room_votes WHERE id = '" + row["id"] + "'");
                        num6 = client2.getInt("SELECT room_icon FROM rooms WHERE id = '" + row["id"] + "'");
                    }
                    Hashtable hashtable = new Hashtable(column.Table.Rows.Count);
                    string str = "";
                    foreach (DataRow row2 in column.Table.Rows)
                    {
                        hashtable.Add(Convert.ToInt32(row2["id"]), Convert.ToInt32(row2["id"]));
                        str = str + Convert.ToString(row2["id"]);
                        str = str.Substring(0, str.Length);
                        if ((str.Length > 0) && this.Messenger.hasFriendship(Convert.ToInt32(str)))
                        {
                            hashtable.Remove(Convert.ToInt32(row2["id"]));
                            i++;
                        }
                    }
                    builder.Append(Holo.Encoding.encodeVL64(i));
                    if (Convert.ToString(num4) == "10")
                    {
                        builder.Append(Holo.Encoding.encodeVL64(1));
                    }
                    else
                    {
                        builder.Append(Holo.Encoding.encodeVL64(UserSearchID));
                        builder.Append(Holo.Encoding.encodeVL64(5) + Convert.ToChar(2));
                        builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(num5), Holo.Encoding.encodeVL64(0), Holo.Encoding.encodeVL64(num6), Holo.Encoding.encodeVL64(0), Convert.ToChar(2) }));
                    }
                    builder.Append(string.Concat(new object[] { Holo.Encoding.encodeVL64(num5), Holo.Encoding.encodeVL64(0), Holo.Encoding.encodeVL64(num6), Holo.Encoding.encodeVL64(0), Convert.ToChar(2) }));
                }
            }
            else
            {
                builder.Append(Holo.Encoding.encodeVL64(0));
            }
            this.sendData("GC" + builder);
        }

        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 num4;
            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 num6 = client2.getInt("SELECT count(vote) FROM room_votes WHERE roomid = '" + num3 + "'");
                    client2.runQuery(string.Concat(new object[] { "UPDATE rooms SET votes = '", num6, "' 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");
                num4 = 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(num4));
            if (table.Rows.Count > 0)
            {
                foreach (DataRow row in table.Rows)
                {
                    DataColumn column;
                    int num7;
                    string str;
                    int num8;
                    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 num9 = client4.getInt("SELECT category FROM rooms WHERE id = '" + row["id"] + "'");
                        num7 = client4.getInt("SELECT trading FROM room_categories WHERE id = '" + num9 + "'");
                        str = client4.getString("SELECT name FROM room_categories WHERE id = '" + num9 + "'");
                        client4.getInt("SELECT count(vote)from room_votes WHERE id = '" + row["id"] + "'");
                        num8 = 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(num7) == "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(num8), "HH" }));
                }
            }
            else
            {
                builder.Append(Holo.Encoding.encodeVL64(0));
            }
            this.sendData("GC" + builder);
        }

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

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

        private bool isSpeechCommand(string Text)
        {
            string[] s = Text.Split(new char[] { ' ' });
            try
            {
                virtualUser user;
                string str6;
                virtualUser user2;
                string str8;
                virtualUser user3;
                virtualUser user4;
                string str10;
                DataRow row;
                DataRow row2;
                string str14;
                int num7;
                int num8;
                string str15;
                string str16;
                bool flag;
                switch (s[0].ToLower())
                {
                    case "comandi":
                        this.sendData(string.Concat(new object[] { "BKCiao ", this._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 \rBuon proseguimento e cordiali saluti dal Meethar Team!", Convert.ToChar(2) }));
                        goto Label_1682;

                    case "info":
                        this.sendData("BKMeethar Emulator V46\rIl server e' stato codato da Kemix, Crax e Shinil35" + Convert.ToChar(2));
                        goto Label_1682;

                    case "personeonline":
                        this.sendData(userManager.generateWhosOnline(rankManager.containsRight(this, "fuse_administrator_access", this.userID)));
                        goto Label_1682;

                    case "nudo":
                    {
                        using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                        {
                            client.runQuery("UPDATE users SET figure = 'hd-180-4.hr-831-61' WHERE id = '" + this.userID + "'");
                            this.refreshAppearance(true, true, true, true);
                            goto Label_1682;
                        }
                    }
                    case "invisibile":
                    {
                        using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                        {
                            client2.runQuery("UPDATE users SET figure = 'fa-120' WHERE id = '" + this.userID + "'");
                            this.refreshAppearance(true, true, true, true);
                            goto Label_1682;
                        }
                    }
                    case "babbonatale":
                    {
                        using (DatabaseClient client3 = Eucalypt.dbManager.GetClient())
                        {
                            client3.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 = '" + this.userID + "'");
                            this.refreshAppearance(true, true, true, true);
                            goto Label_1682;
                        }
                    }
                    case "puliscimano":
                        using (DatabaseClient client4 = Eucalypt.dbManager.GetClient())
                        {
                            client4.runQuery("DELETE FROM furniture WHERE ownerid = '" + this.userID + "' AND roomid = '0'");
                        }
                        this.refreshHand("update");
                        goto Label_1682;

                    case "pixel":
                        this._Pixels += 0x1388;
                        using (DatabaseClient client5 = Eucalypt.dbManager.GetClient())
                        {
                            client5.runQuery(string.Concat(new object[] { "UPDATE users SET pixels = '", this._Pixels, "' WHERE id = '", this.userID, "' LIMIT 1" }));
                        }
                        this.sendData("Fv" + Holo.Encoding.encodeVL64(this._Pixels) + "I");
                        this.sendData("You got 5000 pixels extra :O don't tell this secret command");
                        goto Label_1682;

                    case "energia":
                    {
                        string str = s[1];
                        using (DatabaseClient client6 = Eucalypt.dbManager.GetClient())
                        {
                            client6.runQuery("update users set credits = credits -10 where id = " + this.userID);
                            client6.runQuery("UPDATE pets SET energy = energy + 10 WHERE name = '" + str + "' LIMIT 1");
                            this.refreshValueables(true, false);
                            this.sendData(string.Concat(new object[] { "BKL'animale ", str, " ha ricevuto 10 di energia", Convert.ToChar(2) }));
                            goto Label_1682;
                        }
                    }
                    case "livello":
                    {
                        string str2 = s[1];
                        using (DatabaseClient client7 = Eucalypt.dbManager.GetClient())
                        {
                            client7.runQuery("update users set credits = credits -10 where id = " + this.userID);
                            client7.runQuery("UPDATE pets SET level = level + 1 WHERE name = '" + str2 + "' LIMIT 1");
                            this.refreshValueables(true, false);
                            this.sendData(string.Concat(new object[] { "BKL'animale ", str2, " ha ricevuto 1 di livello", Convert.ToChar(2) }));
                            goto Label_1682;
                        }
                    }
                    case "nutrizione":
                    {
                        string str3 = s[1];
                        using (DatabaseClient client8 = Eucalypt.dbManager.GetClient())
                        {
                            client8.runQuery("update users set credits = credits -10 where id = " + this.userID);
                            client8.runQuery("UPDATE pets SET satiety = satiety + 10 WHERE name = '" + str3 + "' LIMIT 1");
                            this.refreshValueables(true, false);
                            this.sendData(string.Concat(new object[] { "BKL'animale ", str3, " ha ricevuto 10 di saziet\x00e0", Convert.ToChar(2) }));
                            goto Label_1682;
                        }
                    }
                    case "esperienza":
                    {
                        string str4 = s[1];
                        using (DatabaseClient client9 = Eucalypt.dbManager.GetClient())
                        {
                            client9.runQuery("update users set credits = credits -10 where id = " + this.userID);
                            client9.runQuery("UPDATE pets SET experience = experience + 10 WHERE name = '" + str4 + "' LIMIT 1");
                            this.refreshValueables(true, false);
                            this.sendData(string.Concat(new object[] { "BKL'animale ", str4, " ha ricevuto 10 di esperienza", Convert.ToChar(2) }));
                            goto Label_1682;
                        }
                    }
                    case "pets":
                        this.sendData(string.Concat(new object[] { "BKCiao ", this._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\x00e0 dell' animale)\r \rBuon proseguimento e cordiali saluti dal Meethar Team!", Convert.ToChar(2) }));
                        goto Label_1682;

                    case "hopp":
                        this.Statuses.Remove("sit");
                        this.Statuses.Remove("ded");
                        this.Pet.addStatus("jmp", "");
                        goto Label_1682;

                    case "alert":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_alert", this.userID))
                        {
                            goto Label_07CE;
                        }
                        return false;

                    case "roomalert":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_room_alert", this.userID))
                        {
                            goto Label_0877;
                        }
                        return false;

                    case "kick":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_kick", this.userID))
                        {
                            goto Label_08F0;
                        }
                        return false;

                    case "roomkick":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_room_kick", this.userID))
                        {
                            goto Label_09DB;
                        }
                        return false;

                    case "shutup":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_mute", this.userID))
                        {
                            goto Label_0A69;
                        }
                        return false;

                    case "unmute":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_mute", this.userID))
                        {
                            goto Label_0B8E;
                        }
                        return false;

                    case "roomshutup":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_room_mute", this.userID))
                        {
                            goto Label_0C85;
                        }
                        return false;

                    case "roomunmute":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_room_mute", this.userID))
                        {
                            goto Label_0D13;
                        }
                        return false;

                    case "ban":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_ban", this.userID))
                        {
                            goto Label_0D99;
                        }
                        return false;

                    case "superban":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_superban", this.userID))
                        {
                            goto Label_0F97;
                        }
                        return false;

                    case "ha":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_administrator_access", this.userID))
                        {
                            goto Label_1199;
                        }
                        return false;

                    case "offline":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_administrator_access", this.userID))
                        {
                            goto Label_122E;
                        }
                        return false;

                    case "teleport":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_administrator_access", this.userID))
                        {
                            goto Label_12A0;
                        }
                        return false;

                    case "warp":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_administrator_access", this.userID))
                        {
                            goto Label_12EE;
                        }
                        return false;

                    case "userinfo":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_moderator_access", this.userID))
                        {
                            goto Label_136E;
                        }
                        return false;

                    case "freeze":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_kick", this.userID))
                        {
                            goto Label_13C7;
                        }
                        return false;

                    case "unfreeze":
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_kick", this.userID))
                        {
                            goto Label_140D;
                        }
                        return false;

                    case "refresh":
                        flag = false;
                        if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_administrator_access", this.userID))
                        {
                            goto Label_1456;
                        }
                        return false;

                    default:
                        return false;
                }
            Label_07CE:
                user = userManager.getUser(userManager.getUserID(s[1]));
                user.sendData("B!" + stringManager.wrapParameters(s, 2) + Convert.ToChar(2));
                this.sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                staffManager.addStaffMessage("alert", this.userID, user.userID, s[2], "");
                goto Label_1682;
            Label_0877:
                str6 = Text.Substring(10);
                this.Room.sendData("B!" + str6 + Convert.ToChar(2));
                staffManager.addStaffMessage("ralert", this.userID, this.Room.roomID, str6, "");
                goto Label_1682;
            Label_08F0:
                user2 = userManager.getUser(userManager.getUserID(s[1]));
                if (user2._Rank < this._Rank)
                {
                    string moderatorMessage = "";
                    if (s.Length > 2)
                    {
                        moderatorMessage = stringManager.wrapParameters(s, 2);
                    }
                    user2.Room.removeUser(user2.roomUser.roomUID, true, moderatorMessage);
                    this.sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                    staffManager.addStaffMessage("kick", this.userID, user2.userID, moderatorMessage, "");
                }
                else
                {
                    this.sendData("BK" + stringManager.getString("scommand_failed") + Convert.ToChar(2));
                }
                goto Label_1682;
            Label_09DB:
                str8 = stringManager.wrapParameters(s, 1);
                this.Room.kickUsers(this._Rank, str8);
                this.sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                staffManager.addStaffMessage("rkick", this.userID, this.Room.roomID, str8, "");
                goto Label_1682;
            Label_0A69:
                user3 = userManager.getUser(userManager.getUserID(s[1]));
                if ((user3._Rank < this._Rank) && !user3._isMuted)
                {
                    string message = stringManager.wrapParameters(s, 2);
                    user3._isMuted = true;
                    user3.sendData(string.Concat(new object[] { "BK", stringManager.getString("scommand_muted"), "\r", message, Convert.ToChar(2) }));
                    this.sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                    staffManager.addStaffMessage("mute", this.userID, user3.userID, message, "");
                }
                else
                {
                    this.sendData("BK" + stringManager.getString("scommand_failed") + Convert.ToChar(2));
                }
                goto Label_1682;
            Label_0B8E:
                user4 = userManager.getUser(userManager.getUserID(s[1]));
                if ((user4._Rank < this._Rank) && user4._isMuted)
                {
                    user4._isMuted = false;
                    user4.sendData("BK" + stringManager.getString("scommand_unmuted") + Convert.ToChar(2));
                    this.sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                    staffManager.addStaffMessage("unmute", this.userID, user4.userID, "", "");
                }
                else
                {
                    this.sendData("BK" + stringManager.getString("scommand_failed") + Convert.ToChar(2));
                }
                goto Label_1682;
            Label_0C85:
                str10 = stringManager.wrapParameters(s, 1);
                this.Room.muteUsers(this._Rank, str10);
                this.sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                staffManager.addStaffMessage("rmute", this.userID, this.Room.roomID, str10, "");
                goto Label_1682;
            Label_0D13:
                this.Room.unmuteUsers(this._Rank);
                this.sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                staffManager.addStaffMessage("runmute", this.userID, this.Room.roomID, "", "");
                goto Label_1682;
            Label_0D99:
                using (DatabaseClient client10 = Eucalypt.dbManager.GetClient())
                {
                    client10.AddParamWithValue("name", s[1]);
                    row = client10.getRow("SELECT id,rank FROM users WHERE name = @name");
                }
                if (row.Table.Rows.Count == 0)
                {
                    this.sendData(string.Concat(new object[] { "BK", stringManager.getString("modtool_actionfailed"), "\r", stringManager.getString("modtool_usernotfound"), Convert.ToChar(2) }));
                }
                else if (Convert.ToByte(row["rank"]) > this._Rank)
                {
                    this.sendData(string.Concat(new object[] { "BK", stringManager.getString("modtool_actionfailed"), "\r", stringManager.getString("modtool_rankerror"), Convert.ToChar(2) }));
                }
                else
                {
                    int hours = int.Parse(s[2]);
                    string str11 = stringManager.wrapParameters(s, 3);
                    if ((hours == 0) || (str11 == ""))
                    {
                        this.sendData("BK" + stringManager.getString("scommand_failed") + Convert.ToChar(2));
                    }
                    else
                    {
                        staffManager.addStaffMessage("ban", this.userID, Convert.ToInt32(row["id"]), str11, "");
                        userManager.setBan(Convert.ToInt32(row["id"]), hours, str11);
                        this.sendData("BK" + userManager.generateBanReport(Convert.ToInt32(row["id"])) + Convert.ToChar(2));
                    }
                }
                goto Label_1682;
            Label_0F97:
                using (DatabaseClient client11 = Eucalypt.dbManager.GetClient())
                {
                    client11.AddParamWithValue("name", s[1]);
                    row2 = client11.getRow("SELECT id,rank,ipaddress_last FROM users WHERE name = @name");
                }
                if (row2.Table.Rows.Count == 0)
                {
                    this.sendData(string.Concat(new object[] { "BK", stringManager.getString("modtool_actionfailed"), "\r", stringManager.getString("modtool_usernotfound"), Convert.ToChar(2) }));
                }
                else if (Convert.ToByte(row2["rank"]) > this._Rank)
                {
                    this.sendData(string.Concat(new object[] { "BK", stringManager.getString("modtool_actionfailed"), "\r", stringManager.getString("modtool_rankerror"), Convert.ToChar(2) }));
                }
                else
                {
                    int num6 = int.Parse(s[2]);
                    string str12 = stringManager.wrapParameters(s, 3);
                    if ((num6 == 0) || (str12 == ""))
                    {
                        this.sendData("BK" + stringManager.getString("scommand_failed") + Convert.ToChar(2));
                    }
                    else
                    {
                        string iP = Convert.ToString(row2["ipaddress_last"]);
                        staffManager.addStaffMessage("superban", this.userID, Convert.ToInt32(row2["id"]), str12, "");
                        userManager.setBan(Convert.ToInt32(row2["id"]), num6, str12);
                        this.sendData("BK" + userManager.generateBanReport(iP) + Convert.ToChar(2));
                    }
                }
                goto Label_1682;
            Label_1199:
                str14 = Text.Substring(3);
                userManager.sendData(string.Concat(new object[] { "BK", stringManager.getString("scommand_hotelalert"), "\r", str14, Convert.ToChar(2) }));
                staffManager.addStaffMessage("halert", this.userID, 0, str14, "");
                goto Label_1682;
            Label_122E:
                num7 = int.Parse(s[1]);
                userManager.sendData("Dc" + Holo.Encoding.encodeVL64(num7));
                staffManager.addStaffMessage("offline", this.userID, 0, "mm=" + num7, "");
                goto Label_1682;
            Label_12A0:
                this.roomUser.SPECIAL_TELEPORTABLE = !this.roomUser.SPECIAL_TELEPORTABLE;
                this.refreshAppearance(false, false, true, true);
                goto Label_1682;
            Label_12EE:
                num8 = int.Parse(s[1]);
                int num9 = int.Parse(s[2]);
                this.roomUser.X = num8;
                this.roomUser.Y = num9;
                this.roomUser.goalX = -1;
                this.Room.Refresh(this.roomUser);
                this.refreshAppearance(false, false, true, true);
                goto Label_1682;
            Label_136E:
                this.sendData("BK" + userManager.generateUserInfo(userManager.getUserID(s[1]), this._Rank) + Convert.ToChar(2));
                goto Label_1682;
            Label_13C7:
                str15 = s[1];
                userManager.getUser(str15).roomUser.walkLock = true;
                goto Label_1682;
            Label_140D:
                str16 = s[1];
                userManager.getUser(str16).roomUser.walkLock = false;
                goto Label_1682;
            Label_1456:
                try
                {
                    ThreadStart start = null;
                    switch (s[1])
                    {
                        case "catalogue":
                            start = new ThreadStart(this.refresh_cat);
                            userManager.sendData(string.Concat(new object[] { "Fy", Convert.ToChar(1), "A~HHHM", Convert.ToChar(2) }));
                            flag = true;
                            break;

                        case "strings":
                            start = new ThreadStart(this.refresh_strings);
                            break;

                        case "config":
                            start = new ThreadStart(this.refresh_config);
                            break;

                        case "filter":
                            start = new ThreadStart(this.refresh_filter);
                            break;

                        case "fuse":
                            start = new ThreadStart(this.refresh_fuse);
                            break;

                        case "ecotron":
                            start = new ThreadStart(this.refresh_eco);
                            break;

                        case "model":
                            start = new ThreadStart(this.refresh_modeldata);
                            break;

                        default:
                            this.sendData("BK" + stringManager.getString("scommand_failed") + Convert.ToChar(2));
                            return true;
                    }
                    new Thread(start) { Priority = ThreadPriority.BelowNormal }.Start();
                    if (!flag)
                    {
                        this.sendData("BK" + stringManager.getString("scommand_success") + Convert.ToChar(2));
                    }
                }
                catch
                {
                    this.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));
                }
            }
            catch
            {
                this.sendData("BK" + stringManager.getString("scommand_failed") + Convert.ToChar(2));
            }
        Label_1682:
            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 num5;
                            int num6;
                            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_0146;
                            }
                            int num8 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(length + 3));
                            string str3 = str2;
                            if (str3 != null)
                            {
                                if (!(str3 == "fieldType"))
                                {
                                    if (!(str3 == "numTeams"))
                                    {
                                        goto Label_011B;
                                    }
                                    goto Label_0118;
                                }
                                mapID = num8;
                            }
                            goto Label_011B;
                        Label_0118:
                            teamAmount = num8;
                        Label_011B:
                            num5 = Holo.Encoding.encodeVL64(num8).Length;
                            this.currentPacket = this.currentPacket.Substring((length + num5) + 3);
                            continue;
                        Label_0146:
                            num6 = Holo.Encoding.decodeB64(this.currentPacket.Substring(length + 3, 2));
                            string text = this.currentPacket.Substring(length + 5, num6);
                            string str5 = str2;
                            if (str5 != null)
                            {
                                if (!(str5 == "allowedPowerups"))
                                {
                                    if (!(str5 == "name"))
                                    {
                                        goto Label_0204;
                                    }
                                    goto Label_01FC;
                                }
                                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 + num6) + 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 ProcessPacketA_()
        {
            if (((this.Room != null) && (this.roomUser != null)) && (!this._inPublicroom && this._hasRights))
            {
                virtualUser user = userManager.getUser(Holo.Encoding.decodeVL64(this.currentPacket.Substring(2)));
                if (((user._roomID == this._roomID) && (!user._isOwner || ((user._Rank <= this._Rank) && !rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_kick_immunity", this.userID)))) && (!user._isOwner || ((user._Rank <= this._Rank) && !rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_any_room_controller", this.userID))))
                {
                    user.roomUser.walkLock = true;
                    user.roomUser.walkDoor = true;
                    user.roomUser.goalX = this.Room.doorX;
                    user.roomUser.goalY = this.Room.doorY;
                }
            }
        }

        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 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 str12 = "";
            string str13 = "";
            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)));
            string str16 = Convert.ToString(Holo.Encoding.decodeVL64(str11.Substring(7, 1)));
            if (str16 != null)
            {
                if (!(str16 == "0"))
                {
                    int num;
                    if (str16 == "1")
                    {
                        num = Holo.Encoding.decodeB64(str11.Substring(8, 2));
                        str12 = Convert.ToString(str11.Substring(10, num));
                        str13 = "";
                    }
                    else if (str16 == "2")
                    {
                        num = Holo.Encoding.decodeB64(str11.Substring(8, 2));
                        str12 = Convert.ToString(str11.Substring(10, num));
                        int length = Holo.Encoding.decodeB64(str11.Substring(10 + num, 2));
                        str13 = Convert.ToString(str11.Substring(12 + num, length));
                    }
                }
                else
                {
                    str12 = "";
                    str13 = "";
                }
            }
            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", str12);
                client.AddParamWithValue("tag2", str13);
                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 str14 = Convert.ToString(row["tag1"]);
                string str15 = Convert.ToString(row["tag2"]);
                StringBuilder builder = new StringBuilder("");
                if ((str14 == "") && (str15 == ""))
                {
                    builder.Append("H");
                }
                else if ((str14 == "") || (str15 == ""))
                {
                    if (str14 == "")
                    {
                        builder.Append("I" + str15 + Convert.ToChar(2));
                    }
                    else
                    {
                        builder.Append("I" + str14 + Convert.ToChar(2));
                    }
                }
                else if ((str14 != "") && (str15 != ""))
                {
                    builder.Append(string.Concat(new object[] { "J", str14, Convert.ToChar(2), str15, 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 str3;
                    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];
                    if (((str3 = str) != null) && (((str3 == "wallpaper") || (str3 == "floor")) || (str3 == "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");
                    }
                }
            }
        }

        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;
            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 client5 = Eucalypt.dbManager.GetClient())
                    {
                        client5.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[] strArray = text.Split("\n".ToCharArray());
                        string str8 = strArray[0];
                        string str9 = strArray[1];
                        string str10 = strArray[2];
                        using (DatabaseClient client6 = Eucalypt.dbManager.GetClient())
                        {
                            int num15 = client6.getInt("SELECT MAX (id) FROM pets");
                            this.sendData("I_" + string.Concat(new object[] { Holo.Encoding.encodeVL64(num15), str8, Convert.ToChar(2), catalogueManager.getTemplate(num2).typeID, Convert.ToChar(0x20), str9, Convert.ToChar(0x20), str10, Convert.ToChar(2), Holo.Encoding.encodeVL64(catalogueManager.getTemplate(num2).typeID) }));
                            client6.AddParamWithValue("@ownerid", userID);
                            client6.AddParamWithValue("@petname", str8);
                            client6.AddParamWithValue("@petrace", str9);
                            client6.AddParamWithValue("@petcolour", str10);
                            client6.AddParamWithValue("@pettype", catalogueManager.getTemplate(num2).typeID);
                            client6.AddParamWithValue("@bought", DateTime.Now);
                            client6.runQuery("INSERT INTO pets(owner,name,race,colour,type,bought,roomid) VALUES (@ownerid,@petname,@petrace,@petcolour,@pettype,@bought,'0')");
                            this.ProcessPacketnx();
                            return;
                        }
                    }
                    if ((stringManager.getStringPart(input, 0, 11) == "greektrophy") || (stringManager.getStringPart(input, 0, 11) == "prizetrophy"))
                    {
                        if (!flag)
                        {
                            using (DatabaseClient client7 = Eucalypt.dbManager.GetClient())
                            {
                                string str12 = (this._Username + "\t" + DateTime.Today.ToShortDateString() + "\t" + stringManager.filterSwearwords(text)).Replace(@"\", @"\").Replace("'", @"\'");
                                client7.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", str12, "' WHERE id = '", catalogueManager.lastItemID, "' LIMIT 1" }));
                                goto Label_0E1F;
                            }
                        }
                        using (DatabaseClient client8 = Eucalypt.dbManager.GetClient())
                        {
                            string str13 = (this._Username + "\t" + DateTime.Today.ToShortDateString() + "\t" + stringManager.filterSwearwords(text)).Replace(@"\", @"\").Replace("'", @"\'");
                            client8.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", str13, "' 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[] strArray2 = text.Split("\n".ToCharArray());
                        string str14 = strArray2[0];
                        string str15 = strArray2[1];
                        string str16 = strArray2[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, "', '", str14, "', '", str15, "', '", str16, "', '", roomID, "')" }));
                        }
                        this.sendData(string.Concat(new object[] { "I_", Holo.Encoding.encodeVL64(lastPetID), str14, Convert.ToChar(2), "0", Convert.ToChar(0x20), str15, Convert.ToChar(0x20), str16, Convert.ToChar(2), "H" }));
                    }
                    else
                    {
                        catalogueManager.handlePurchase(num2, userID, roomID, "0", presentBoxID, lastItemID);
                    }
                }
            }
            else
            {
                int num17 = 0;
                int num18 = 0;
                int num19 = 0;
                int num20 = int.Parse(input.Replace("avatar_effect", ""));
                using (DatabaseClient client10 = Eucalypt.dbManager.GetClient())
                {
                    int num21;
                    client10.runQuery(string.Concat(new object[] { "INSERT INTO users_effects(userid,effect_id,effect_activated,effect_timemax,effect_timeleft) VALUES ('", userID, "','", num20, "','", 0, "','3600','3600' )" }));
                    this.sendData("GM" + Holo.Encoding.encodeVL64(num20) + Holo.Encoding.encodeVL64(0xe10));
                    StringBuilder builder = new StringBuilder(string.Concat(new object[] { Holo.Encoding.encodeVL64(num19), input, Convert.ToChar(2), Holo.Encoding.encodeVL64(num17), Holo.Encoding.encodeVL64(num18), "I" }));
                    using (DatabaseClient client11 = Eucalypt.dbManager.GetClient())
                    {
                        num21 = client11.getInt("SELECT typeid FROM catalogue_items WHERE name_cct = '" + input + "'");
                    }
                    if (num21 == 0)
                    {
                        builder.Append("i");
                    }
                    else if (input.Contains("avatar_effect"))
                    {
                        builder.Append("e");
                    }
                    else
                    {
                        builder.Append("s");
                    }
                    if (input.Contains("avatar_effect"))
                    {
                        builder.Append(string.Concat(new object[] { Convert.ToChar(2), Holo.Encoding.encodeVL64(int.Parse(input.Replace("avatar_effect", ""))), Convert.ToChar(2), "IPO" }));
                    }
                    else
                    {
                        string str17 = "";
                        if (input.Contains(" "))
                        {
                            str17 = input.Split(new char[] { ' ' })[1];
                        }
                        builder.Append(string.Concat(new object[] { Convert.ToChar(2), Holo.Encoding.encodeVL64(num19), str17, Convert.ToChar(2), "IM" }));
                    }
                    this.sendData("AC" + builder);
                }
                return;
            }
        Label_0E1F:
            if (userID == this.userID)
            {
                this.refreshHand("last");
            }
            else if (userManager.containsUser(userID))
            {
                userManager.getUser(userID).refreshHand("last");
            }
            this.sendData("AC");
        }

        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 client2 = Eucalypt.dbManager.GetClient())
                    {
                        this._isOwner = client2.findsResult(string.Concat(new object[] { "SELECT id FROM rooms WHERE id = '", this._roomID, "' AND owner = '", this._Username, "'" }));
                    }
                }
                if (!this._isOwner2)
                {
                    using (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 client4 = Eucalypt.dbManager.GetClient())
                {
                    if (client4.findsResult(string.Concat(new object[] { "SELECT userid FROM room_votes WHERE userid = '", this.userID, "' AND roomid = '", this._roomID, "'" })) | this._isOwner)
                    {
                        i = client4.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 num4;
                    if (this.currentPacket == "")
                    {
                        return;
                    }
                    int num5 = Holo.Encoding.decodeVL64(this.currentPacket);
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        num4 = client.getInt(string.Concat(new object[] { "SELECT userid_from FROM messenger_friendrequests WHERE userid_to = '", this.userID, "' AND requestid = '", num5, "'" }));
                    }
                    if (num4 == 0)
                    {
                        return;
                    }
                    virtualBuddy buddy2 = new virtualBuddy(num4);
                    builder.Append(buddy2.ToString(true));
                    num2++;
                    this.Messenger.addBuddy(buddy2, false);
                    if (userManager.containsUser(num4))
                    {
                        userManager.getUser(num4).Messenger.addBuddy(buddy, true);
                    }
                    using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                    {
                        client2.runQuery(string.Concat(new object[] { "INSERT INTO messenger_friendships(userid,friendid) VALUES ('", num4, "','", this.userID, "')" }));
                        client2.runQuery(string.Concat(new object[] { "DELETE FROM messenger_friendrequests WHERE userid_to = '", this.userID, "' AND requestid = '", num5, "' LIMIT 1" }));
                    }
                    this.currentPacket = this.currentPacket.Substring(Holo.Encoding.encodeVL64(num5).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 ProcessPacketAGGO()
        {
            if ((!this._inPublicroom && (this.Room != null)) && (this.roomUser != null))
            {
                int itemID = int.Parse(this.currentPacket.Substring(2));
                if (this.Room.floorItemManager.containsItem(itemID))
                {
                    floorItem item = this.Room.floorItemManager.getItem(itemID);
                    if ((this.roomUser.X == item.X) || (this.roomUser.Y == item.Y))
                    {
                        int num2;
                        int num3;
                        using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                        {
                            num3 = client.getInt("SELECT teleportid FROM furniture WHERE id = '" + itemID + "'");
                            num2 = client.getInt("SELECT roomid FROM furniture WHERE id = '" + num3 + "'");
                        }
                        if (num2 > 0)
                        {
                            new TeleporterUsageSleep(this.useTeleporter).BeginInvoke(item, num3, num2, null, null);
                        }
                    }
                }
            }
        }

        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 i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(3));
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                client.runQuery(string.Concat(new object[] { "INSERT INTO users_favourites (userid,roomid) VALUES ('", this.userID, "','", i, "')" }));
            }
            this.sendData(string.Concat(new object[] { "GK", Holo.Encoding.encodeVL64(i), "I", Convert.ToChar(2) }));
            this.GetFavourites(this.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))
                                {
                                    goto Label_0352;
                                }
                                this.sendData("BC");
                                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;
                                }
                                goto Label_040D;
                            }
                        }
                    }
                    goto Label_040D;
                Label_0352:
                    roomManager.getRoom(this._roomID).sendDataToRights("A[" + this._Username + Convert.ToChar(2));
                    this.sendData("A[" + Convert.ToChar(2));
                    return;
                Label_040D:
                    this._ROOMACCESS_SECONDARY_OK = true;
                    this.sendData("@i");
                }
            }
        }

        internal void ProcessPacketAGY()
        {
            int num;
            string str = this.currentPacket.Substring(4, Holo.Encoding.decodeB64(this.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 num;
                int num2 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    num = client.getInt(string.Concat(new object[] { "SELECT tid FROM furniture WHERE id = '", num2, "' AND ownerid = '", this.userID, "' AND roomid = '0'" }));
                }
                if (num != 0)
                {
                    this._tradeItems[this._tradeItemCount] = num2;
                    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()
        {
            if (((this.Room != null) && (this.roomUser != null)) && !this.roomUser.walkLock)
            {
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                int y = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2 + Holo.Encoding.encodeVL64(i).Length));
                if ((i == this.Room.doorX) && (this.Room.doorY == y))
                {
                    this.sendData("@R");
                    this.Handler.ProcessPacket("@u");
                }
                else if (this.roomUser.SPECIAL_TELEPORTABLE)
                {
                    int x = this.roomUser.X;
                    int num4 = this.roomUser.Y;
                    this.roomUser.X = i;
                    this.roomUser.Y = y;
                    this.roomUser.goalX = -1;
                    this.Room.refreshCoord(i, y);
                    this.Room.sqUNIT[x, num4] = false;
                    this.Room.setSquareState(x, num4, 1, 1, virtualRoom.squareState.Open);
                    this.refreshAppearance(false, false, true, true);
                }
                else
                {
                    this.roomUser.goalX = i;
                    this.roomUser.goalY = y;
                }
            }
        }

        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()
        {
            this.roomUser.Refresh();
        }

        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 ((this.currentPacket.Contains("\x00ac") || this.currentPacket.Contains(Convert.ToChar(1).ToString())) || this.currentPacket.Contains(Convert.ToChar(2).ToString()))
            {
                this.sendData("@dI");
            }
            else
            {
                this.sendData("@dH");
            }
        }

        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 ProcessPacketAQ()
        {
            if ((!this._inPublicroom && (this.Room != null)) && (this.roomUser != null))
            {
                int itemID = int.Parse(this.currentPacket.Substring(2));
                if (this.Room.floorItemManager.containsItem(itemID))
                {
                    floorItem item = this.Room.floorItemManager.getItem(itemID);
                    if ((((item.Z != 2) || (this.roomUser.X == (item.X + 1))) || (this.roomUser.Y == item.Y)) && (((item.Z != 4) || (this.roomUser.X == item.X)) || (this.roomUser.Y == (item.Y + 1))))
                    {
                        this.roomUser.goalX = -1;
                        this.Room.moveUser(this.roomUser, item.X, item.Y, true);
                    }
                }
            }
        }

        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()
        {
            if (((this.Room != null) && (this.roomUser != null)) && !this._inPublicroom)
            {
                int itemID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                if (this.Room.wallItemManager.containsItem(itemID))
                {
                    string str;
                    using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                    {
                        str = client.getString("SELECT text FROM furniture_stickies WHERE id = '" + itemID + "'");
                    }
                    this.sendData(string.Concat(new object[] { "@p", itemID, Convert.ToChar(2), this.Room.wallItemManager.getItem(itemID).Var, " ", str, 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))
                {
                    string str4;
                    wallItem item = this.Room.wallItemManager.getItem(itemID);
                    string sprite = item.Sprite;
                    if (((str4 = sprite) != null) && ((str4 == "post.it") || (str4 == "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) }));
                        }
                    }
                }
            }
        }

        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 str;
                    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'");
                        str = 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), str, 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 str2 = catalogueManager.wallPositionOK(wallPosition);
                            if (str2 != 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, str2, s, true);
                            }
                            string[] strArray = this.currentPacket.Split(new char[] { ' ' });
                            int num5 = int.Parse(strArray[1]);
                            int num6 = int.Parse(strArray[2]);
                            byte num7 = byte.Parse(strArray[3]);
                            byte num8 = catalogueManager.getTemplate(num2).typeID;
                            this.Room.floorItemManager.placeItem(result, num2, num5, num6, num8, num7, num3);
                        }
                        string[] strArray2 = this.currentPacket.Split(new char[] { ' ' });
                        int x = int.Parse(strArray2[1]);
                        int y = int.Parse(strArray2[2]);
                        byte z = byte.Parse(strArray2[3]);
                        byte typeID = catalogueManager.getTemplate(num2).typeID;
                        this.sendData("Ac" + Holo.Encoding.encodeVL64(-num2));
                        this.Room.floorItemManager.placeItem(result, num2, x, y, typeID, z, num3);
                        this.sendData("C[!nB");
                        this.refreshHand("last");
                    }
                }
            }
            if ((this._hasRights && !this._inPublicroom) && ((this.Room != null) && (this.roomUser != null)))
            {
                int lastItemID = 0;
                if (int.TryParse(this.currentPacket.Split(new char[] { ' ' })[0].Substring(4), out lastItemID))
                {
                    int num14;
                    int num15;
                    using (DatabaseClient client3 = Eucalypt.dbManager.GetClient())
                    {
                        num14 = client3.getInt(string.Concat(new object[] { "SELECT tid FROM furniture WHERE id = '", lastItemID, "' AND ownerid = '", this.userID, "' AND roomid = '0'" }));
                        num15 = client3.getInt("SELECT id FROM furniture_data WHERE sprite = '" + client3.getString("SELECT name_cct FROM catalogue_items WHERE tid = '" + num14 + "'") + "'");
                    }
                    if (num14 != 0)
                    {
                        if (catalogueManager.getTemplate(num14).typeID == 0)
                        {
                            string str4 = this.currentPacket.Substring(lastItemID.ToString().Length + 5);
                            string str5 = catalogueManager.wallPositionOK(str4);
                            if (str5 != str4)
                            {
                                return;
                            }
                            int num16 = 0;
                            using (DatabaseClient client4 = Eucalypt.dbManager.GetClient())
                            {
                                string str6 = client4.getString("SELECT var FROM furniture WHERE id = '" + lastItemID + "'");
                                int.TryParse(str6, out num16);
                                if (stringManager.getStringPart(catalogueManager.getTemplate(num14).Sprite, 0, 7) == "post.it")
                                {
                                    if (num16 > 1)
                                    {
                                        client4.runQuery("UPDATE furniture SET var = var - 1 WHERE id = '" + lastItemID + "' LIMIT 1");
                                    }
                                    else
                                    {
                                        client4.runQuery("DELETE FROM furniture WHERE id = '" + lastItemID + "' LIMIT 1");
                                    }
                                    client4.runQuery(string.Concat(new object[] { "INSERT INTO furniture(tid,ownerid) VALUES ('", num14, "','", this.userID, "')" }));
                                    lastItemID = catalogueManager.lastItemID;
                                    client4.runQuery("INSERT INTO furniture_stickies(id) VALUES ('" + lastItemID + "')");
                                    str6 = "FFFF33";
                                    client4.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", str6, "' WHERE id = '", lastItemID, "' LIMIT 1" }));
                                }
                                else if (stringManager.getStringPart(catalogueManager.getTemplate(num14).Sprite, 0, 10) == "roomdimmer")
                                {
                                    client4.runQuery(string.Concat(new object[] { "UPDATE furniture_moodlight SET roomid = '", this._roomID, "' WHERE id = '", lastItemID, "' LIMIT 1" }));
                                }
                                this.Room.wallItemManager.addItem(lastItemID, num14, str5, str6, true);
                            }
                            string[] strArray3 = this.currentPacket.Split(new char[] { ' ' });
                            int num17 = int.Parse(strArray3[1]);
                            int num18 = int.Parse(strArray3[2]);
                            byte num19 = byte.Parse(strArray3[3]);
                            byte num20 = catalogueManager.getTemplate(num14).typeID;
                            this.Room.floorItemManager.placeItem(lastItemID, num14, num17, num18, num20, num19, num15);
                        }
                        string[] strArray4 = this.currentPacket.Split(new char[] { ' ' });
                        int num21 = int.Parse(strArray4[1]);
                        int num22 = int.Parse(strArray4[2]);
                        byte num23 = byte.Parse(strArray4[3]);
                        byte num24 = catalogueManager.getTemplate(num14).typeID;
                        this.sendData("Ac" + Holo.Encoding.encodeVL64(-num14));
                        this.Room.floorItemManager.placeItem(lastItemID, num14, num21, num22, num24, num23, num15);
                        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 = string.Concat(new object[] { 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 num5;
                                int num6;
                                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_015B;
                                }
                                int num8 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(length + 3));
                                string str3 = str2;
                                if (str3 != null)
                                {
                                    if (!(str3 == "fieldType"))
                                    {
                                        if (!(str3 == "numTeams"))
                                        {
                                            goto Label_0130;
                                        }
                                        goto Label_012D;
                                    }
                                    mapID = num8;
                                }
                                goto Label_0130;
                            Label_012D:
                                teamAmount = num8;
                            Label_0130:
                                num5 = Holo.Encoding.encodeVL64(num8).Length;
                                this.currentPacket = this.currentPacket.Substring((length + num5) + 3);
                                continue;
                            Label_015B:
                                num6 = Holo.Encoding.decodeB64(this.currentPacket.Substring(length + 3, 2));
                                string text = this.currentPacket.Substring(length + 5, num6);
                                string str5 = str2;
                                if (str5 != null)
                                {
                                    if (!(str5 == "allowedPowerups"))
                                    {
                                        if (!(str5 == "name"))
                                        {
                                            goto Label_0219;
                                        }
                                        goto Label_0211;
                                    }
                                    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_0219;
                            Label_0211:
                                name = stringManager.filterSwearwords(text);
                            Label_0219:
                                this.currentPacket = this.currentPacket.Substring((length + num6) + 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 num;
                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(num + 2))
                {
                    int num3 = Holo.Encoding.decodeVL64(str);
                    str = str.Substring(Holo.Encoding.encodeVL64(num3).Length);
                    num = Holo.Encoding.decodeB64(str.Substring(0, 2));
                    if (num > 0)
                    {
                        string str2 = str.Substring(2, num);
                        using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                        {
                            client2.runQuery(string.Concat(new object[] { "UPDATE users_badges SET slotid = '", num3, "' 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 = string.Concat(new object[] { 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 num3;
                    DataColumn column;
                    int num4;
                    int num5;
                    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"] + "'");
                        num3 = 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");
                        num4 = client2.getInt("SELECT count(vote)from room_votes WHERE id = '" + row["roomid"] + "'");
                        num5 = 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(num3) == "1")
                    {
                        builder.Append(Holo.Encoding.encodeVL64(1));
                    }
                    else
                    {
                        builder.Append(Holo.Encoding.encodeVL64(0));
                    }
                    builder.Append(Holo.Encoding.encodeVL64(num4) + Holo.Encoding.encodeVL64(num5) + 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 str;
            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 str2 = "";
            int num2 = Convert.ToInt32(row["roomid"]);
            if (num2 > 0)
            {
                using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                {
                    str2 = client2.getString("SELECT name FROM rooms WHERE id = '" + num2 + "'");
                    goto Label_00C4;
                }
            }
            num2 = -1;
        Label_00C4:
            if (str2 == "")
            {
                str = "M";
            }
            else
            {
                str = 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), str, str2, Convert.ToChar(2) }));
        }

        internal void ProcessPacketCG()
        {
            if (rankManager.containsRight(ref this._fuserights, this._Rank, "fuse_receive_calls_for_help", this.userID))
            {
                string str;
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(4, Holo.Encoding.decodeB64(this.currentPacket.Substring(2, 2))));
                string str2 = this.currentPacket.Substring(Holo.Encoding.decodeB64(this.currentPacket.Substring(2, 2)) + 6);
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    str = client.getString("SELECT username FROM cms_help WHERE id = '" + i + "'");
                }
                if (str == null)
                {
                    this.sendData("BK" + stringManager.getString("cfh_fail") + Convert.ToChar(2));
                }
                else
                {
                    virtualUser user = userManager.getUser(userManager.getUserID(str));
                    if (user._isLoggedIn)
                    {
                        user.sendData("DR" + str2 + 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("GBISalotto Di Benvenuto\x0002RIcevi un caloroso benvenuto!\x0002HSalotto di Benvenuto\x0002\x0002HPHKnewbie_lobby\x0002YTwHhh_room_nlobby\x0001");
        }

        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()
        {
            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);
                    if ((item.Sprite == "habbowheel") || (item.Sprite == "ads_lin_wh_c"))
                    {
                        int num2 = new Random(DateTime.Now.Millisecond).Next(0, 10);
                        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), "-1", Convert.ToChar(2) }));
                        this.Room.sendData(string.Concat(new object[] { "AU", itemID, Convert.ToChar(2), Holo.Encoding.encodeVL64(template.indexID), item.wallPosition, Convert.ToChar(2), num2, Convert.ToChar(2) }));
                        using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                        {
                            client.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", num2, "' 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 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 num;
                int length = Holo.Encoding.decodeB64(this.currentPacket.Substring(2, 2));
                int num3 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(4, length));
                using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                {
                    num = client.getInt("SELECT roomid FROM cms_help WHERE id = '" + num3 + "'");
                }
                if (num != 0)
                {
                    if (roomManager.getRoom(num).isPublicroom)
                    {
                        this.sendData("D^I" + Holo.Encoding.encodeVL64(num));
                    }
                    else
                    {
                        this.sendData("D^H" + Holo.Encoding.encodeVL64(num));
                    }
                }
            }
        }

        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 num = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            if ((this.Room != null) && (this.roomUser != null))
            {
                this.statusID = "Ge";
                this.statusCount = num;
                this.Room.sendData(this.statusID + Holo.Encoding.encodeVL64(this.roomUser.roomUID) + Holo.Encoding.encodeVL64(this.statusCount));
            }
        }

        internal void ProcessPacketEu()
        {
            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                if (((client.getInt(string.Concat(new object[] { "SELECT effect_timemax FROM users_effects WHERE userid = '", this.userID, "' AND effect_id = '", i, "' AND effect_activated = '0' LIMIT 1" })) >= 1) && (client.getInt(string.Concat(new object[] { "SELECT effect_timemax FROM users_effects WHERE userid = '", this.userID, "' AND effect_id = '", i, "' AND effect_activated = '1' LIMIT 1" })) <= 0)) && (client.getInt("DELETE num FROM users_effects WHERE effect_timeleft = '0' LIMIT 1") <= 0))
                {
                    client.runQuery(string.Concat(new object[] { "UPDATE users_effects SET effect_activated = '1' WHERE userid = '", this.userID, "' AND effect_id = ", i, " LIMIT 1" }));
                    this.sendData("GN" + Holo.Encoding.encodeVL64(i) + Holo.Encoding.encodeVL64(client.getInt(string.Concat(new object[] { "SELECT effect_timemax FROM users_effects WHERE userid = '", this.userID, "' AND effect_id = '", i, "' 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()
        {
            this._activateBuy = true;
            this.Handler.ProcessPacket("Ad" + this.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_()
        {
            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);
                    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(this.currentPacket.Length));
            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2, this.currentPacket.Length - 2));
            bool flag = this.currentPacket.Substring(2, 1) == "I";
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                this.sendData("GE" + client.getInt("SELECT model FROM rooms WHERE id = '" + i + "'"));
                this.sendData("@S");
                this.sendData("Bf - HydroHabbo");
                this.sendData("Du");
                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 client2 = Eucalypt.dbManager.GetClient())
                {
                    str = client2.getString("SELECT ccts FROM rooms WHERE id = '" + i + "'");
                }
                using (DatabaseClient client3 = Eucalypt.dbManager.GetClient())
                {
                    client3.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()
        {
            if ((this._ROOMACCESS_SECONDARY_OK && (this.Room != null)) && (this.roomUser == null))
            {
                this.Room.addUser(this);
                this.statusManager.dropCarrydItem();
                this.Room.refreshActions(this.roomUser.roomUID);
                this.Room.sendData("@b" + this.Room.dynamicStatuses);
                if (this.Room.hasSpecialCasts("cam1"))
                {
                    this.sendData("AGcam1 targetcamera " + this.roomUser.roomUID);
                }
            }
        }

        internal void ProcessPacketFG()
        {
            if ((this.Room != null) && (this.roomUser != null))
            {
                this.Room.removeUser(this.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 client2 = Eucalypt.dbManager.GetClient())
                        {
                            this._isOwner = client2.findsResult(string.Concat(new object[] { "SELECT id FROM rooms WHERE id = '", this._roomID, "' AND owner = '", this._Username, "'" }));
                        }
                    }
                    if (!this._isOwner2)
                    {
                        using (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 client4 = Eucalypt.dbManager.GetClient())
                    {
                        if (client4.findsResult(string.Concat(new object[] { "SELECT userid FROM room_votes WHERE userid = '", this.userID, "' AND roomid = '", this._roomID, "'" })))
                        {
                            i = client4.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()
        {
            try
            {
                if ((!this._inPublicroom && (this.Room != null)) && (this.roomUser != null))
                {
                    int itemID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                    catalogueManager.itemTemplate template = catalogueManager.getTemplate(this.Room.wallItemManager.getItem(itemID).templateID);
                    int toStatus = 0;
                    if ((template.rightsRequired != 1) || this._hasRights)
                    {
                        using (DatabaseClient client = Eucalypt.dbManager.GetClient())
                        {
                            toStatus = client.getInt("SELECT var FROM furniture WHERE id = " + itemID + " LIMIT 1");
                            if (toStatus == 1)
                            {
                                toStatus = 0;
                            }
                            else
                            {
                                toStatus = 1;
                            }
                        }
                        this.Room.wallItemManager.toggleItemStatus(itemID, toStatus);
                    }
                }
            }
            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 str = Convert.ToString(row["tag1"]);
                string str2 = Convert.ToString(row["tag2"]);
                StringBuilder builder = new StringBuilder("");
                if ((str == "") && (str2 == ""))
                {
                    builder.Append("H");
                }
                else if ((str == "") || (str2 == ""))
                {
                    if (str == "")
                    {
                        builder.Append("I" + str2 + Convert.ToChar(2));
                    }
                    else
                    {
                        builder.Append("I" + str + Convert.ToChar(2));
                    }
                }
                else if ((str != "") && (str2 != ""))
                {
                    builder.Append(string.Concat(new object[] { "J", str, Convert.ToChar(2), str2, 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 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 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 num3;
                    DataColumn column;
                    int num4;
                    int num5;
                    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"] + "'");
                        num3 = 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");
                        num4 = client2.getInt("SELECT count(vote)from room_votes WHERE id = '" + row["roomid"] + "'");
                        num5 = 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(num3) == "1")
                    {
                        builder.Append(Holo.Encoding.encodeVL64(1));
                    }
                    else
                    {
                        builder.Append(Holo.Encoding.encodeVL64(0));
                    }
                    builder.Append(Holo.Encoding.encodeVL64(num4) + Holo.Encoding.encodeVL64(0) + Holo.Encoding.encodeVL64(2) + Holo.Encoding.encodeVL64(num5) + Convert.ToString(row["date"]));
                }
            }
            else
            {
                builder.Append(Holo.Encoding.encodeVL64(0));
            }
            this.sendData("GC" + builder);
        }

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

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

        internal void ProcessPacketFy()
        {
            if (this._ROOMACCESS_SECONDARY_OK && (this.Room != null))
            {
                this.sendData("@]1\x0002\x0001");
            }
        }

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

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

        internal void ProcessPacketnCG()
        {
            int num;
            StringBuilder builder = new StringBuilder();
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                client.AddParamWithValue("@ownerid", this.userID);
                client.AddParamWithValue("@id", this.petID);
                num = client.getInt("UPDATE @id FROM pets WHERE owner = @ownerid AND roomid = 0");
            }
            builder.Append(Holo.Encoding.encodeVL64(num));
            
        }

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

        internal void ProcessPacketnx()
        {
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                client.AddParamWithValue("@ownerid", this.userID);
                DataTable table = client.ReadDataTable("SELECT * FROM pets WHERE owner = @ownerid AND roomid = 0");
                StringBuilder builder = new StringBuilder();
                int i = 0;
                foreach (DataRow row in table.Rows)
                {
                    i++;
                    builder.Append(Holo.Encoding.encodeVL64(int.Parse(row["id"].ToString())));
                    builder.Append(row["name"].ToString());
                    builder.Append(Convert.ToChar(2));
                    builder.Append(int.Parse(row["type"].ToString()));
                    builder.Append(Convert.ToChar(0x20));
                    builder.Append(row["race"].ToString());
                    builder.Append(Convert.ToChar(0x20));
                    builder.Append(row["colour"].ToString());
                    builder.Append(Convert.ToChar(2));
                    builder.Append(Holo.Encoding.encodeVL64(int.Parse(row["type"].ToString())));
                }
                this.sendData("IX" + Holo.Encoding.encodeVL64(i) + builder);
            }
        }

        internal void ProcessPacketny()
        {
            int petID = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            this.sendData("IY" + this.Room.getPetString(petID));
        }

        internal void ProcessPacketnz()
        {
            int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            int num2 = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2 + Holo.Encoding.encodeVL64(i).Length));
            int y = Holo.Encoding.decodeVL64(this.currentPacket.Substring((2 + Holo.Encoding.encodeVL64(i).Length) + Holo.Encoding.encodeVL64(num2).Length));
            this.Room.addPet(i, num2, y, true);
            this.sendData(@"I\" + Holo.Encoding.encodeVL64(i));
        }

        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 ProcessPacketoF()
        {
            int num = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
            Out.WriteLine(Convert.ToString(num));
            MarketManager.BuyItem(num, this.userID, this);
            this.sendData("oF");
        }

        internal void ProcessPacketoG()
        {
            MarketManager.RemoveItem(Holo.Encoding.decodeB64(this.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 ProcessPacketOj()
        {
        }

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

        internal void ProcessPacketoV()
        {
            using (DatabaseClient client = Eucalypt.dbManager.GetClient())
            {
                int i = Holo.Encoding.decodeVL64(this.currentPacket.Substring(2));
                int num2 = client.getInt("SELECT tradeable FROM catalogue_item WHERE tid = '" + i + "'");
                this.sendData("In" + Holo.Encoding.encodeVL64(i) + Holo.Encoding.encodeVL64(num2));
            }
        }

        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 && (this.Room != null)) && (this.roomUser != null))
            {
                this.Room.sendData(string.Concat(new object[] { "DJ", Holo.Encoding.encodeVL64(this.roomUser.roomUID), this._Figure, Convert.ToChar(2), this._Sex, Convert.ToChar(2), this._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 = string.Concat(new object[] { 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 num3 = 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 num4 = 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 num5 = 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 (num3 == j)
                            {
                                builder.Append(Holo.Encoding.encodeVL64(j) + Holo.Encoding.encodeVL64(num4) + Holo.Encoding.encodeVL64(row.Table.Rows.Count) + "M");
                            }
                            else
                            {
                                builder.Append(Holo.Encoding.encodeVL64(j) + Holo.Encoding.encodeVL64(num4) + Holo.Encoding.encodeVL64(row.Table.Rows.Count - 1) + Holo.Encoding.encodeVL64(num5));
                            }
                        }
                    }
                }
            }
            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 num = 0;
            int count = table.Rows.Count;
            switch (Mode)
            {
                case "H":
                case "last":
                    this._handPage = (count - 1) / 0x2328;
                    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)
                    {
                        num = this._handPage * 0x2328;
                        if (count > (num + 0x2328))
                        {
                            count = num + 0x2328;
                        }
                        if ((num <= count) && (num != count))
                        {
                            break;
                        }
                        this._handPage--;
                    }
                    for (int i = 0; i < count; i++)
                    {
                        int num4;
                        DataRow row = table.Rows[i];
                        using (DatabaseClient client2 = Eucalypt.dbManager.GetClient())
                        {
                            num4 = 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 num5 = 1;
                        if (!template.isRecycleable)
                        {
                            num5 = 0;
                        }
                        int num6 = 1;
                        if (!template.isTradeable)
                        {
                            num6 = 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(num4));
                        builder.Append("I");
                        builder.Append(Convert.ToChar(2));
                        builder.Append(Holo.Encoding.encodeVL64(num5));
                        builder.Append(Holo.Encoding.encodeVL64(num6));
                        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 - num) + 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
            {
            }
        }

        private void whosonline()
        {
        }

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