public Response GetFeaturedResponse()
        {
            try
            {
                Response Response = new Response(450);
                Response.AppendInt32(FeacturedItems.Count);

                foreach (FeacturedItem FeacturedItem in GetRoomsForCategory(-1))
                {
                    FeacturedItem.GetResponse(Response);

                    foreach (FeacturedItem Room in GetRoomsForCategory(FeacturedItem.Id))
                    {
                        Room.GetResponse(Response);
                    }
                }

                return Response;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                return null;
            }
        }

        private void CreateRoom(Client Client, Request Request)
        {
            int Limit = BrickEngine.GetConfigureFile().CallIntKey("max.rooms.amount");
            int RoomAmount = BrickEngine.GetRoomReactor().GetMe(Client.GetUser().HabboId).Count;

            if (RoomAmount >= Limit)
            {
                Client.Notif("You're over the rooms limit, first delete a room before you create a new one.", false);
                return;
            }

            string RawName = Request.PopFixedString();
            string RawModel = Request.PopFixedString();

            int RoomId = -1;

            if ((RoomId = BrickEngine.GetRoomReactor().CreateRoom(Client, RawName, RawModel)) > 0)
            {
                Response Response = new Response(59);
                Response.AppendInt32(RoomId);
                Response.AppendStringWithBreak(BrickEngine.CleanString(RawName));
                Client.SendResponse(Response);
            }
            else
            {
                CheckRoomCreate(Client, null);
            }
        }

        public void GetResponse(Response Response)
        {
            StringBuilder PacketBuilder = new StringBuilder();
            Response.AppendInt32(ShopItemId);

            PacketBuilder.Append("HABBO_CLUB_");
            PacketBuilder.Append(MemberShipType.ToUpper());
            PacketBuilder.Append('_');
            PacketBuilder.Append(MonthsAmount);
            PacketBuilder.Append("_MONTH");

            if (MonthsAmount > 1)
            {
                PacketBuilder.Append('S');
            }

            Response.AppendStringWithBreak(PacketBuilder.ToString());
            Response.AppendInt32(BrickEngine.GetShopReactor().GetShopItem(ShopItemId).CreditsCost);
            Response.AppendBoolean(false);
            Response.AppendBoolean(MemberShipType == "VIP");
            Response.AppendInt32(MonthsAmount);
            Response.AppendInt32(MonthsAmount * 31);
            Response.AppendInt32(ExpireDate().Year);
            Response.AppendInt32(ExpireDate().Month);
            Response.AppendInt32(ExpireDate().Day);
        }

 private void GetEcotronInfo(Client Client, Request Request)
 {
     Response Response = new Response(507);
     Response.AppendInt32(BrickEngine.GetEcotronReactor().GetTimerTime(Client.GetUser().HabboId));
     Response.AppendInt32(BrickEngine.GetEcotronReactor().GetTimeToWait(Client.GetUser().HabboId));
     Client.SendResponse(Response);
 }

        public void ActivateEffect(Client Client, Effect Effect)
        {
            if (Effect.RemainingTime == 0)
            {
                return;
            }

            Effect.Excecute();

            if (Client != null)
            {
                Response Response = new Response(462);
                Response.AppendInt32(Effect.EffectId);
                Response.AppendInt32(Effect.EffectLength);
                Client.SendResponse(Response);
            }

            using (QueryReactor Reactor = BrickEngine.GetQueryReactor())
            {
                Reactor.SetQuery("UPDATE user_effects SET activated = @dt WHERE id = @effectid LIMIT 1");
                Reactor.AddParam("dt", Effect.Activated);
                Reactor.AddParam("effectid", Effect.Id);
                Reactor.ExcuteQuery();
            }
        }

 public void GetInternalResponse(Response Response)
 {
     Response.AppendInt32(Id);
     Response.AppendBoolean(MemberType == Items.MemberType.VIP);
     Response.AppendInt32(MemberdaysNeed);
     Response.AppendBoolean(true);
 }

        public Response GetButtonData()
        {
            Response Response = new Response(126);
            Response.AppendBoolean(true);
            Response.AppendBoolean(false);
            Response.AppendBoolean(false);
            Response.AppendInt32(-1);
            Response.AppendChar(2);
            Response.AppendInt32(GetButtonTreeAmount(-1));

            var SortedFirst = from pag in PagesForTree(-1)
                              orderby pag.OrderId ascending
                              select pag;

            foreach (ShopPage Page in SortedFirst)
            {
                Page.GetButtonData(Response);

                var SortedLast = from pag in PagesForTree(Page.Id)
                                 orderby pag.OrderId ascending
                                 select pag;

                foreach (ShopPage TreePage in SortedLast)
                {
                    TreePage.GetButtonData(Response);
                }
            }

            return Response;
        }

 public void GetButtonData(Response Response)
 {
     Response.AppendBoolean(true); // always true
     Response.AppendUInt32(IconPaint);
     Response.AppendUInt32(IconId);
     Response.AppendInt32(Id);
     Response.AppendStringWithBreak(Name);
     Response.AppendInt32(BrickEngine.GetShopReactor().GetButtonTreeAmount(Id));
 }

        private void CheckRoomCreate(Client Client, Request Request)
        {
            int Limit = BrickEngine.GetConfigureFile().CallIntKey("max.rooms.amount");
            int RoomAmount = BrickEngine.GetRoomReactor().GetMe(Client.GetUser().HabboId).Count;

            Response Response = new Response(512);
            Response.AppendBoolean(RoomAmount >= Limit);
            Response.AppendInt32(Limit);
            Client.SendResponse(Response);
        }

        public void Drop()
        {
            Response EndResponse = new Response(370);
            EndResponse.AppendRawInt32(-1);
            EndResponse.AppendChar(2);
            GetRoom().GetRoomEngine().BroadcastResponse(EndResponse);

            GetRoom().Event = null;

            BrickEngine.GetProgressReactor().GetCollector().Finialize(this);
        }

 public void GetResponse(Client Client, Response Response)
 {
     Response.AppendInt32(Id);
     Response.AppendBoolean((Client.GetUser().CurrentQuest.Equals(Id)) ? true : false);
     Response.AppendStringWithBreak(FilterAction);
     Response.AppendStringWithBreak(FilterParam);
     Response.AppendInt32(PixelReward);
     Response.AppendStringWithBreak(FilterReAction);
     Response.AppendInt32((Client.GetUser().CurrentQuest.Equals(Id)) ? Client.GetUser().CurrentQuestProgress : 0);
     Response.AppendInt32(ActionAmount);
 }

        private void ChatWithFriend(Client Client, Request Request)
        {
            int FriendId = Request.PopWiredInt32();

            if (!BrickEngine.GetMessengerHandler().HasFriend(Client.GetUser().HabboId, FriendId))
            {
                return;
            }

            BrickEmulator.HabboHotel.Users.Handlers.Messenger.Friend Friend = BrickEngine.GetMessengerHandler().GetFriend(Client.GetUser().HabboId, FriendId);

            if (Friend == null)
            {
                Response Respose = new Response(261);
                Respose.AppendInt32(6);
                Respose.AppendInt32(FriendId);
                Client.SendResponse(Respose);
                return;
            }

            if (Client.GetUser().Muted)
            {
                Response Respose = new Response(261);
                Respose.AppendInt32(4);
                Respose.AppendInt32(FriendId);
                Client.SendResponse(Respose);
                return;
            }

            if (Friend.IsAlive)
            {
                if (Friend.GetClient().GetUser().Muted)
                {
                    Response Respose = new Response(261);
                    Respose.AppendInt32(3);
                    Respose.AppendInt32(FriendId);
                    Client.SendResponse(Respose);
                }

                Response Response = new Response(134);
                Response.AppendInt32(Client.GetUser().HabboId);
                Response.AppendStringWithBreak(BrickEngine.CleanString(Request.PopFixedString()));

                Friend.GetClient().SendResponse(Response);
            }
            else
            {
                Response Respose = new Response(261);
                Respose.AppendInt32(5);
                Respose.AppendInt32(FriendId);
                Client.SendResponse(Respose);
            }
        }

        public void GetResponse(Response Response)
        {
            Response.AppendInt32(BackgroundId);
            Response.AppendInt32(ForegroundId);
            Response.AppendInt32(Items.Count);

            foreach (KeyValuePair<int, int> kvp in Items)
            {
                Response.AppendInt32(kvp.Key);
                Response.AppendInt32(kvp.Value);
            }
        }

        public void GetResponse(Response Response, int UserId)
        {
            Response.AppendInt32(-1);
            Response.AppendInt32(BrickEngine.GetStreamHandler().GetPrimairStreamIndexer(StreamType));

            Response.AppendRawInt32(HabboId);
            Response.AppendChar(2);

            Response.AppendStringWithBreak(GetUsername());
            Response.AppendStringWithBreak(GetGender().ToLower());

            if (StreamType.Equals(StreamType.AchievedAchievement))
            {
                Response.AppendStringWithBreak("http://www.habbo.com/habbo-imaging/badge/" + AchievedItem.ToString() + ".png");
            }
            else
            {
                Response.AppendStringWithBreak(BrickEngine.GetConfigureFile().CallStringKey("site.link") + "/habbo-imaging/avatar/" + GetLook() + ".gif");
            }

            Response.AppendInt32(BrickEngine.GetConvertor().ObjectToInt32(RunningTime.TotalMinutes));

            if (StreamType.Equals(StreamType.MadeFriends))
            {
                Response.AppendInt32(BrickEngine.GetStreamHandler().GetFriendState(UserId, AchievedItemId));
            }
            else
            {
                Response.AppendInt32(BrickEngine.GetStreamHandler().GetSecondairStreamIndexer(StreamType));
            }

            Response.AppendBoolean(true);
            Response.AppendBoolean(true);

            if (StreamType.Equals(StreamType.RatedRoom) || StreamType.Equals(StreamType.MadeFriends))
            {
                Response.AppendRawInt32(AchievedItemId);
                Response.AppendChar(2);

                if (StreamType.Equals(StreamType.MadeFriends))
                {
                    Response.AppendStringWithBreak(BrickEngine.GetUserReactor().GetUsername(AchievedItemId));
                }
                else
                {
                    Response.AppendStringWithBreak(AchievedItem.ToString());
                }
            }
            else
            {
                Response.AppendStringWithBreak(AchievedItem.ToString());
            }
        }

 public void GetResponse(Response Response)
 {
     Response.AppendRawInt32(GetRoom().OwnerId);
     Response.AppendChar(2);
     Response.AppendRawInt32(RoomId);
     Response.AppendChar(2);
     Response.AppendStringWithBreak(BrickEngine.GetUserReactor().GetUsername(GetRoom().OwnerId));
     Response.AppendInt32(CategoryId);
     Response.AppendStringWithBreak(Name);
     Response.AppendStringWithBreak(Description);
     Response.AppendStringWithBreak(Started.ToShortTimeString());
     Response.AppendInt32(Tags.Count);
     Tags.ToList().ForEach(Response.AppendStringWithBreak);
 }

 public void GetExternalResponse(Response Response)
 {
     Response.AppendInt32(Id);
     Response.AppendStringWithBreak(GetBaseItem().InternalName);
     Response.AppendBoolean(true);
     Response.AppendBoolean(false);
     Response.AppendBoolean(false);
     Response.AppendBoolean(true);
     Response.AppendStringWithBreak(GetBaseItem().InternalType.ToLower());
     Response.AppendInt32(GetBaseItem().SpriteId);
     Response.AppendChar(2);
     Response.AppendBoolean(true);
     Response.AppendInt32(-1);
     Response.AppendInt32((MemberType == Items.MemberType.VIP) ? 2 : 1);
 }

        public Response GetFavoriteRooms(Client Client)
        {
            Response Response = new Response(451);
            Response.AppendInt32(6);
            Response.AppendChar(2);

            var List = BrickEngine.GetRoomReactor().GetFavoriteRooms(Client);

            Response.AppendInt32(List.Count);

            foreach (VirtualRoom Room in List)
            {
                Room.GetNavigatorResponse(Response, false);
            }

            return Response;
        }

        public void GetFurniture(Client Client, Request Request)
        {
            var Items = BrickEngine.GetItemReactor().GetItemsForUser(Client.GetUser().HabboId);

            var FloorItems = new List<Item>();
            var WallItems = new List<Item>();

            foreach (Item Item in Items)
            {
                if (Item.GetBaseItem().InternalType.ToLower() == "s")
                {
                    FloorItems.Add(Item);
                }
                else if (Item.GetBaseItem().InternalType.ToLower() == "i")
                {
                    WallItems.Add(Item);
                }
            }

            Response FloorItemsResponse = new Response(140);
            FloorItemsResponse.AppendStringWithBreak("S");
            FloorItemsResponse.AppendBoolean(true);
            FloorItemsResponse.AppendBoolean(true);
            FloorItemsResponse.AppendInt32(FloorItems.Count);

            foreach (Item Item in FloorItems)
            {
                Item.GetInventoryResponse(FloorItemsResponse);
            }

            Client.SendResponse(FloorItemsResponse);

            Response WallItemsResponse = new Response(140);
            WallItemsResponse.AppendStringWithBreak("I");
            WallItemsResponse.AppendBoolean(true);
            WallItemsResponse.AppendBoolean(true);
            WallItemsResponse.AppendInt32(WallItems.Count);

            foreach (Item Item in WallItems)
            {
                Item.GetInventoryResponse(WallItemsResponse);
            }

            Client.SendResponse(WallItemsResponse);
        }

        public Response GetEventRoomsResponse(int Category)
        {
            Response Response = new Response(451);
            Response.AppendInt32(12);
            Response.AppendRawInt32(Category);
            Response.AppendChar(2);

            var List = BrickEngine.GetRoomReactor().GetEventRooms(Category);

            Response.AppendInt32(List.Count);

            foreach (VirtualRoom Room in List)
            {
                Room.GetNavigatorResponse(Response, true);
            }

            return Response;
        }

 public void GetResponse(Response Response)
 {
     Response.AppendInt32(Id);
     Response.AppendInt32(State);
     Response.AppendInt32(CategoryId);
     Response.AppendInt32(ReportedCategoryId);
     Response.AppendInt32(0); // TimeStampInteger
     Response.AppendInt32(Priority);
     Response.AppendInt32(ReporterId);
     Response.AppendStringWithBreak(ReporterUsername);
     Response.AppendInt32(ModeratorId);
     Response.AppendStringWithBreak(ModeratorUsername);
     Response.AppendStringWithBreak(IssueMessage);
     Response.AppendInt32(RoomId);
     Response.AppendStringWithBreak(RoomName);
     Response.AppendInt32(0);
     Response.AppendStringWithBreak(string.Empty);
     Response.AppendInt32(RoomCategory);
     Response.AppendInt32(0);
 }