C# ServerMessage.AppendBoolean方法代码示例

		internal static ServerMessage Compose(GameClient Session, Quest Quest)
		{
			int amountOfQuestsInCategory = MercuryEnvironment.GetGame().GetQuestManager().GetAmountOfQuestsInCategory(Quest.Category);
			int i = (Quest == null) ? amountOfQuestsInCategory : Quest.Number;
			int i2 = (Quest == null) ? 0 : Session.GetHabbo().GetQuestProgress(Quest.Id);
			ServerMessage serverMessage = new ServerMessage(Outgoing.QuestCompletedMessageComposer);
			serverMessage.AppendString(Quest.Category);
			serverMessage.AppendInt32(i);
			serverMessage.AppendInt32(Quest.Name.Contains("xmas2012") ? 1 : amountOfQuestsInCategory);
			serverMessage.AppendInt32((Quest == null) ? 3 : Quest.RewardType);
			serverMessage.AppendUInt((Quest == null) ? 0u : Quest.Id);
			serverMessage.AppendBoolean(Quest != null && Session.GetHabbo().CurrentQuestId == Quest.Id);
			serverMessage.AppendString((Quest == null) ? string.Empty : Quest.ActionName);
			serverMessage.AppendString((Quest == null) ? string.Empty : Quest.DataBit);
			serverMessage.AppendInt32((Quest == null) ? 0 : Quest.Reward);
			serverMessage.AppendString((Quest == null) ? string.Empty : Quest.Name);
			serverMessage.AppendInt32(i2);
			serverMessage.AppendUInt((Quest == null) ? 0u : Quest.GoalData);
			serverMessage.AppendInt32((Quest == null) ? 0 : Quest.TimeUnlock);
			serverMessage.AppendString("");
			serverMessage.AppendString("");
			serverMessage.AppendBoolean(true);
			serverMessage.AppendBoolean(true);
			return serverMessage;
		}

		internal void Searialize(ServerMessage reply)
		{
			reply.AppendUInt(this.userID);
			reply.AppendString(this.username);
			reply.AppendString(this.motto);
			bool b = MercuryEnvironment.GetGame().GetClientManager().GetClient(this.userID) != null;
			reply.AppendBoolean(b);
			reply.AppendBoolean(false);
			reply.AppendString(string.Empty);
			reply.AppendInt32(0);
			reply.AppendString(this.look);
			reply.AppendString(this.last_online);
		}

        internal static ServerMessage ComposeIndex(uint Rank)
        {
            var Pages = MercuryEnvironment.GetGame().GetCatalog().Categories.Values.OfType<CatalogPage>();
            ServerMessage Message = new ServerMessage(Outgoing.CatalogueIndexMessageComposer);
            var SortedPages = Pages.Where(x => x.ParentId == -1 && x.MinRank <= Rank).OrderBy(x => x.OrderNum);

            Message.AppendBoolean(true);
            Message.AppendInt32(0);
            Message.AppendInt32(-1);
            Message.AppendString("root");
            Message.AppendString(string.Empty);
            Message.AppendInt32(0);
            Message.AppendInt32(SortedPages.Count());
            foreach (CatalogPage Cat in SortedPages)
            {
                Message.AppendBoolean(Cat.Visible);
                Message.AppendInt32(Cat.IconImage);
                Message.AppendInt32(Cat.PageId);
                Message.AppendString(Cat.CodeName);
                Message.AppendString(Cat.Caption);
                Message.AppendInt32(Cat.FlatOffers.Count);
                foreach (int i in Cat.FlatOffers.Keys)
                {
                    Message.AppendInt32(i);
                }

                var SortedSubPages = Pages.Where(x => x.ParentId == Cat.PageId && x.MinRank <= Rank).OrderBy(x => x.Caption);
                Message.AppendInt32(SortedSubPages.Count());

                foreach (CatalogPage SubCat in SortedSubPages)
                {
                    Message.AppendBoolean(SubCat.Visible);
                    Message.AppendInt32(SubCat.IconImage);
                    Message.AppendInt32(SubCat.PageId);
                    Message.AppendString(SubCat.CodeName);
                    Message.AppendString(SubCat.Caption);
                    Message.AppendInt32(SubCat.FlatOffers.Count);
                    foreach (int i2 in SubCat.FlatOffers.Keys)
                    {
                        Message.AppendInt32(i2);
                    }
                    Message.AppendInt32(0);
                }
            }
            Message.AppendBoolean(false);
            Message.AppendString("NORMAL");

            return Message;
        }

		internal static void SerializeQuest(ServerMessage Message, GameClient Session, Quest Quest, string Category)
		{
			if (Message == null || Session == null)
			{
				return;
			}
			int amountOfQuestsInCategory = MercuryEnvironment.GetGame().GetQuestManager().GetAmountOfQuestsInCategory(Category);
			checked
			{
				int num = (Quest == null) ? amountOfQuestsInCategory : (Quest.Number - 1);
				int num2 = (Quest == null) ? 0 : Session.GetHabbo().GetQuestProgress(Quest.Id);
				if (Quest != null && Quest.IsCompleted(num2))
				{
					num++;
				}
				Message.AppendString(Category);
				Message.AppendInt32((Quest == null) ? 0 : (Quest.Category.Contains("xmas2012") ? 0 : num));
				Message.AppendInt32((Quest == null) ? 0 : (Quest.Category.Contains("xmas2012") ? 0 : amountOfQuestsInCategory));
				Message.AppendInt32((Quest == null) ? 3 : Quest.RewardType);
				Message.AppendUInt((Quest == null) ? 0u : Quest.Id);
				Message.AppendBoolean(Quest != null && Session.GetHabbo().CurrentQuestId == Quest.Id);
				Message.AppendString((Quest == null) ? string.Empty : Quest.ActionName);
				Message.AppendString((Quest == null) ? string.Empty : Quest.DataBit);
				Message.AppendInt32((Quest == null) ? 0 : Quest.Reward);
				Message.AppendString((Quest == null) ? string.Empty : Quest.Name);
				Message.AppendInt32(num2);
				Message.AppendUInt((Quest == null) ? 0u : Quest.GoalData);
				Message.AppendInt32((Quest == null) ? 0 : Quest.TimeUnlock);
				Message.AppendString("");
				Message.AppendString("");
				Message.AppendBoolean(true);
			}
		}

		internal ServerMessage SerializeTool()
		{
			ServerMessage serverMessage = new ServerMessage(Outgoing.LoadModerationToolMessageComposer);
			serverMessage.AppendInt32(this.Tickets.Count);
			foreach (SupportTicket current in this.Tickets)
			{
				current.Serialize(serverMessage);
			}
			serverMessage.AppendInt32(this.UserMessagePresets.Count);
			foreach (string current2 in this.UserMessagePresets)
			{
				serverMessage.AppendString(current2);
			}
			IEnumerable<ModerationTemplate> enumerable = 
				from x in this.ModerationTemplates.Values
				where x.Category == -1
				select x;
			serverMessage.AppendInt32(enumerable.Count<ModerationTemplate>());
			using (IEnumerator<ModerationTemplate> enumerator3 = enumerable.GetEnumerator())
			{
				while (enumerator3.MoveNext())
				{
					ModerationTemplate Template = enumerator3.Current;
					IEnumerable<ModerationTemplate> enumerable2 = 
						from x in this.ModerationTemplates.Values
						where (long)x.Category == (long)((ulong)Template.Id)
						select x;
					serverMessage.AppendString(Template.Caption);
					serverMessage.AppendBoolean(true);
					serverMessage.AppendInt32(enumerable2.Count<ModerationTemplate>());
					foreach (ModerationTemplate current3 in enumerable2)
					{
						serverMessage.AppendString(current3.Caption);
						serverMessage.AppendString(current3.BanMessage);
						serverMessage.AppendInt32((int)current3.BanHours);
						serverMessage.AppendInt32(MercuryEnvironment.BoolToInteger(current3.AvatarBan));
						serverMessage.AppendInt32(MercuryEnvironment.BoolToInteger(current3.Mute));
						serverMessage.AppendInt32(MercuryEnvironment.BoolToInteger(current3.TradeLock));
						serverMessage.AppendString(current3.WarningMessage);
					}
				}
			}
			serverMessage.AppendBoolean(true);
			serverMessage.AppendBoolean(true);
			serverMessage.AppendBoolean(true);
			serverMessage.AppendBoolean(true);
			serverMessage.AppendBoolean(true);
			serverMessage.AppendBoolean(true);
			serverMessage.AppendBoolean(true);
			serverMessage.AppendInt32(this.RoomMessagePresets.Count);
			foreach (string current4 in this.RoomMessagePresets)
			{
				serverMessage.AppendString(current4);
			}
			return serverMessage;
		}

        internal static ServerMessage Compose(GameClient Session, List<Achievement> Achievements)
        {
            ServerMessage serverMessage = new ServerMessage(Outgoing.AchievementListMessageComposer);
            serverMessage.AppendInt32(Achievements.Count);
            foreach (Achievement achievement in Achievements)
            {
                UserAchievement achievementData = Session.GetHabbo().GetAchievementData(achievement.GroupName);
                int i = achievementData != null ? checked(achievementData.Level + 1) : 1;
                int count = achievement.Levels.Count;
                if (i > count)
                {
                    i = count;
                }
                AchievementLevel achievementLevel = achievement.Levels[i];
                AchievementLevel oldLevel = (achievement.Levels.ContainsKey(i - 1)) ? achievement.Levels[i - 1] : achievementLevel;

                serverMessage.AppendUInt(achievement.Id);
                serverMessage.AppendInt32(i);
                serverMessage.AppendString(achievement.GroupName + i);
                serverMessage.AppendInt32(oldLevel.Requirement); // Requisito Anterior
                serverMessage.AppendInt32(achievementLevel.Requirement); // Requisito Nuevo
                serverMessage.AppendInt32(achievementLevel.RewardPoints);
                serverMessage.AppendInt32(0);
                serverMessage.AppendInt32(achievementData != null ? achievementData.Progress : 0); // Progreso Total
                if (achievementData == null)
                {
                    serverMessage.AppendBoolean(false);
                }
                else if (achievementData.Level >= count)
                {
                    serverMessage.AppendBoolean(true);
                }
                else
                {
                    serverMessage.AppendBoolean(false); // Terminado
                }
                serverMessage.AppendString(achievement.Category);
                serverMessage.AppendString(string.Empty);
                serverMessage.AppendInt32(count); // Número de niveles
                serverMessage.AppendInt32(0);
            }
            serverMessage.AppendString("");
            return serverMessage;
        }

		internal static ServerMessage Compose(GameClient Session, List<Quest> Quests, bool Send)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			Dictionary<string, Quest> dictionary2 = new Dictionary<string, Quest>();
			foreach (Quest current in Quests)
			{
				if (!current.Category.Contains("xmas2012"))
				{
					if (!dictionary.ContainsKey(current.Category))
					{
						dictionary.Add(current.Category, 1);
						dictionary2.Add(current.Category, null);
					}
					if (current.Number >= dictionary[current.Category])
					{
						int questProgress = Session.GetHabbo().GetQuestProgress(current.Id);
						if (Session.GetHabbo().CurrentQuestId != current.Id && (long)questProgress >= (long)((ulong)current.GoalData))
						{
							dictionary[current.Category] = checked(current.Number + 1);
						}
					}
				}
			}
			foreach (Quest current2 in Quests)
			{
				foreach (KeyValuePair<string, int> current3 in dictionary)
				{
					if (!current2.Category.Contains("xmas2012") && current2.Category == current3.Key && current2.Number == current3.Value)
					{
						dictionary2[current3.Key] = current2;
						break;
					}
				}
			}
			ServerMessage serverMessage = new ServerMessage(Outgoing.QuestListMessageComposer);
			serverMessage.AppendInt32(dictionary2.Count);
			foreach (KeyValuePair<string, Quest> current4 in dictionary2)
			{
				if (current4.Value != null)
				{
					QuestListComposer.SerializeQuest(serverMessage, Session, current4.Value, current4.Key);
				}
			}
			foreach (KeyValuePair<string, Quest> current5 in dictionary2)
			{
				if (current5.Value == null)
				{
					QuestListComposer.SerializeQuest(serverMessage, Session, current5.Value, current5.Key);
				}
			}
			serverMessage.AppendBoolean(Send);
			return serverMessage;
		}

		internal void SerializeWall(ServerMessage Message, bool Inventory)
		{
			Message.AppendUInt(this.Id);
			Message.AppendString(this.mBaseItem.Type.ToString().ToUpper());
			Message.AppendUInt(this.Id);
			Message.AppendInt32(this.GetBaseItem().SpriteId);

			if (this.GetBaseItem().Name.Contains("a2"))
			{
				Message.AppendInt32(3);
			}
			else
			{
				if (this.GetBaseItem().Name.Contains("wallpaper"))
				{
					Message.AppendInt32(2);
				}
				else
				{
					if (this.GetBaseItem().Name.Contains("landscape"))
					{
						Message.AppendInt32(4);
					}
					else
					{
						Message.AppendInt32(1);
					}
				}
			}
			Message.AppendInt32(0);
			Message.AppendString(this.ExtraData);
			Message.AppendBoolean(this.GetBaseItem().AllowRecycle);
			Message.AppendBoolean(this.GetBaseItem().AllowTrade);
			Message.AppendBoolean(this.GetBaseItem().AllowInventoryStack);
			Message.AppendBoolean(false);
			Message.AppendInt32(-1);
			Message.AppendBoolean(true);
			Message.AppendInt32(-1);
		}

 internal static ServerMessage Compose(Achievement Achievement, int Level, int PointReward, int PixelReward)
 {
     ServerMessage serverMessage = new ServerMessage(Outgoing.UnlockAchievementMessageComposer);
     serverMessage.AppendUInt(Achievement.Id);
     serverMessage.AppendInt32(Level);
     serverMessage.AppendInt32(144);
     serverMessage.AppendString(Achievement.GroupName + Level);
     serverMessage.AppendInt32(PointReward);
     serverMessage.AppendInt32(PixelReward);
     serverMessage.AppendInt32(0);
     serverMessage.AppendInt32(10);
     serverMessage.AppendInt32(21);
     serverMessage.AppendString(Level > 1 ? Achievement.GroupName + checked(Level - 1) : string.Empty);
     serverMessage.AppendString(Achievement.Category);
     serverMessage.AppendBoolean(true);
     return serverMessage;
 }

 internal static ServerMessage Compose(Achievement Achievement, int TargetLevel, AchievementLevel TargetLevelData, int TotalLevels, UserAchievement UserData)
 {
     ServerMessage serverMessage = new ServerMessage(Outgoing.AchievementProgressMessageComposer);
     serverMessage.AppendUInt(Achievement.Id);
     serverMessage.AppendInt32(TargetLevel);
     serverMessage.AppendString(Achievement.GroupName + TargetLevel);
     serverMessage.AppendInt32(TargetLevelData.Requirement);
     serverMessage.AppendInt32(TargetLevelData.Requirement);
     serverMessage.AppendInt32(TargetLevelData.RewardPixels);
     serverMessage.AppendInt32(0);
     serverMessage.AppendInt32(UserData != null ? UserData.Progress : 0);
     serverMessage.AppendBoolean(UserData != null && UserData.Level >= TotalLevels);
     serverMessage.AppendString(Achievement.Category);
     serverMessage.AppendString(string.Empty);
     serverMessage.AppendInt32(TotalLevels);
     serverMessage.AppendInt32(0);
     return serverMessage;
 }

		internal List<RoomItem> RemoveAllFurniture(GameClient Session)
		{
			List<RoomItem> list = new List<RoomItem>();
			RoomItem[] array = this.mFloorItems.Values.ToArray<RoomItem>();
			for (int i = 0; i < array.Length; i++)
			{
				RoomItem roomItem = array[i];
				roomItem.Interactor.OnRemove(Session, roomItem);
				ServerMessage serverMessage = new ServerMessage(Outgoing.PickUpFloorItemMessageComposer);
				serverMessage.AppendString(roomItem.Id + string.Empty);
				serverMessage.AppendBoolean(false);
				serverMessage.AppendInt32(0);
				serverMessage.AppendUInt(roomItem.UserID);
				this.room.SendMessage(serverMessage);
				list.Add(roomItem);
			}
			RoomItem[] array2 = this.mWallItems.Values.ToArray<RoomItem>();
			for (int j = 0; j < array2.Length; j++)
			{
				RoomItem roomItem2 = array2[j];
				roomItem2.Interactor.OnRemove(Session, roomItem2);
				ServerMessage serverMessage2 = new ServerMessage(Outgoing.PickUpWallItemMessageComposer);
				serverMessage2.AppendString(roomItem2.Id + string.Empty);
				serverMessage2.AppendUInt(roomItem2.UserID);
				this.room.SendMessage(serverMessage2);
				list.Add(roomItem2);
			}
			this.mWallItems.Clear();
			this.mFloorItems.Clear();
			this.mRemovedItems.Clear();
			this.mMovedItems.Clear();
			this.mAddedItems.Clear();
			this.mRollers.QueueDelegate(new onCycleDoneDelegate(this.ClearRollers));
			using (IQueryAdapter queryreactor = MercuryEnvironment.GetDatabaseManager().getQueryreactor())
			{
				queryreactor.runFastQuery("UPDATE items SET room_id='0' WHERE room_id = " + this.room.RoomId);
			}
			this.room.GetGameMap().GenerateMaps(true);
			this.room.GetRoomUserManager().UpdateUserStatusses();
			return list;
		}

		internal void Serialize(ServerMessage Message, GameClient Session)
		{
			Relationship value = Session.GetHabbo().Relationships.FirstOrDefault((KeyValuePair<int, Relationship> x) => x.Value.UserId == Convert.ToInt32(this.UserId)).Value;
			int i = (value == null) ? 0 : value.Type;
			Message.AppendUInt(this.UserId);
			Message.AppendString(this.mUsername);
			Message.AppendInt32(1);
			if (!this.mAppearOffline || Session.GetHabbo().Rank >= 4u)
			{
				Message.AppendBoolean(this.IsOnline);
			}
			else
			{
				Message.AppendBoolean(false);
			}
			if (!this.mHideInroom || Session.GetHabbo().Rank >= 4u)
			{
				Message.AppendBoolean(this.InRoom);
			}
			else
			{
				Message.AppendBoolean(false);
			}
			Message.AppendString(this.IsOnline ? this.mLook : "");
			Message.AppendInt32(0);
			Message.AppendString(this.mMotto);
			Message.AppendString(string.Empty);
			Message.AppendString(string.Empty);
			Message.AppendBoolean(true);
			Message.AppendBoolean(false);
			Message.AppendBoolean(false);
			Message.AppendShort(i);
		}

//.........这里部分代码省略.........
                                            case InteractionType.freezegreengate:
                                            case InteractionType.freezebluegate:
                                                if (cyclegameitems)
                                                {
                                                    int num4 = (int)(Item.team + 39);
                                                    TeamManager teamManagerForFreeze = User.GetClient().GetHabbo().CurrentRoom.GetTeamManagerForFreeze();
                                                    AvatarEffectsInventoryComponent avatarEffectsInventoryComponent2 = User.GetClient().GetHabbo().GetAvatarEffectsInventoryComponent();
                                                    if (User.team != Item.team)
                                                    {
                                                        if (teamManagerForFreeze.CanEnterOnTeam(Item.team))
                                                        {
                                                            if (User.team != Team.none)
                                                            {
                                                                teamManagerForFreeze.OnUserLeave(User);
                                                            }
                                                            User.team = Item.team;
                                                            teamManagerForFreeze.AddUser(User);
                                                            if (avatarEffectsInventoryComponent2.CurrentEffect != num4)
                                                            {
                                                                avatarEffectsInventoryComponent2.ActivateCustomEffect(num4);
                                                            }
                                                        }
                                                    }
                                                    else
                                                    {
                                                        teamManagerForFreeze.OnUserLeave(User);
                                                        if (avatarEffectsInventoryComponent2.CurrentEffect == num4)
                                                        {
                                                            avatarEffectsInventoryComponent2.ActivateCustomEffect(0);
                                                        }
                                                        User.team = Team.none;
                                                    }
                                                    ServerMessage serverMessage3 = new ServerMessage(Outgoing.UserIsPlayingFreezeMessageComposer);
                                                    serverMessage3.AppendBoolean(User.team != Team.none);
                                                    User.GetClient().SendMessage(serverMessage3);
                                                    continue;
                                                }
                                                continue;
                                            default:
                                                continue;
                                        }
                                    }
                                    else
                                    {
                                        if (interactionType != InteractionType.jump)
                                        {
                                            switch (interactionType)
                                            {
                                                case InteractionType.pinata:
                                                    {
                                                        if (!User.IsWalking || Item.ExtraData.Length <= 0)
                                                        {
                                                            continue;
                                                        }
                                                        int num5 = int.Parse(Item.ExtraData);
                                                        if (num5 >= 100 || User.CurrentEffect != 158)
                                                        {
                                                            continue;
                                                        }
                                                        int num6 = num5 + 1;
                                                        Item.ExtraData = num6.ToString();

                                                        Item.UpdateState();
                                                        MercuryEnvironment.GetGame().GetAchievementManager().ProgressUserAchievement(User.GetClient(), "ACH_PinataWhacker", 1, false);
                                                        if (num6 == 100)
                                                        {

        internal void RemoveUserFromRoom(GameClient Session, bool NotifyClient, bool NotifyKick)
        {
            try
            {
                if (Session == null || Session.GetHabbo() == null || this.room == null)
                {
                    return;
                }
                Session.GetHabbo().GetAvatarEffectsInventoryComponent().OnRoomExit();
                using (IQueryAdapter queryreactor = MercuryEnvironment.GetDatabaseManager().getQueryreactor())
                {
                    queryreactor.runFastQuery(string.Concat(new object[]
					{
						"UPDATE user_roomvisits SET exit_timestamp = '",
						MercuryEnvironment.GetUnixTimestamp(),
						"' WHERE room_id = '",
						this.room.RoomId,
						"' AND user_id = '",
						Session.GetHabbo().Id,
						"' ORDER BY entry_timestamp DESC LIMIT 1"
					}));
                }
                RoomUser roomUserByHabbo = this.GetRoomUserByHabbo(Session.GetHabbo().Id);
                if (roomUserByHabbo == null)
                {
                    return;
                }
                if (NotifyKick || (NotifyClient && NotifyKick))
                {
                    Room room = MercuryEnvironment.GetGame().GetRoomManager().GetRoom(roomUserByHabbo.RoomId);
                    DynamicRoomModel model = room.GetGameMap().Model;
                    roomUserByHabbo.MoveTo(model.DoorX, model.DoorY);
                    roomUserByHabbo.CanWalk = false;
                    Session.GetMessageHandler().GetResponse().Init(Outgoing.RoomErrorMessageComposer);
                    Session.GetMessageHandler().GetResponse().AppendInt32(4008);
                    Session.GetMessageHandler().SendResponse();


                    Session.GetMessageHandler().GetResponse().Init(Outgoing.OutOfRoomMessageComposer);
                    Session.GetMessageHandler().GetResponse().AppendShort(2);
                    Session.GetMessageHandler().SendResponse();
                }
                else
                {
                    if (NotifyClient && !NotifyKick)
                    {
                        ServerMessage serverMessage = new ServerMessage(Outgoing.UserIsPlayingFreezeMessageComposer);
                        serverMessage.AppendBoolean(roomUserByHabbo.team != Team.none);
                        roomUserByHabbo.GetClient().SendMessage(serverMessage);
                        Session.GetMessageHandler().GetResponse().Init(Outgoing.OutOfRoomMessageComposer);
                        Session.GetMessageHandler().GetResponse().AppendShort(2);
                        Session.GetMessageHandler().SendResponse();
                    }
                }
                if (roomUserByHabbo != null)
                {
                    if (roomUserByHabbo.team != Team.none)
                    {
                        this.room.GetTeamManagerForBanzai().OnUserLeave(roomUserByHabbo);
                        this.room.GetTeamManagerForFreeze().OnUserLeave(roomUserByHabbo);
                    }
                    if (roomUserByHabbo.RidingHorse)
                    {
                        roomUserByHabbo.RidingHorse = false;
                        RoomUser Horse = this.GetRoomUserByVirtualId((int)roomUserByHabbo.HorseID);
                        if (Horse != null)
                        {
                            Horse.RidingHorse = false;
                            Horse.HorseID = 0u;
                        }
                    }
                    if (roomUserByHabbo.IsLyingDown || roomUserByHabbo.IsSitting)
                    {
                        roomUserByHabbo.IsSitting = false;
                        roomUserByHabbo.IsLyingDown = false;
                    }
                    this.RemoveRoomUser(roomUserByHabbo);
                    if (Session.GetHabbo() != null && !roomUserByHabbo.IsSpectator)
                    {
                        if (roomUserByHabbo.CurrentItemEffect != ItemEffectType.None)
                        {
                            roomUserByHabbo.GetClient().GetHabbo().GetAvatarEffectsInventoryComponent().CurrentEffect = -1;
                        }
                        if (Session.GetHabbo() != null)
                        {
                            if (this.room.HasActiveTrade(Session.GetHabbo().Id))
                            {
                                this.room.TryStopTrade(Session.GetHabbo().Id);
                            }
                            Session.GetHabbo().CurrentRoomId = 0u;
                            if (Session.GetHabbo().GetMessenger() != null)
                            {
                                Session.GetHabbo().GetMessenger().OnStatusChanged(true);
                            }
                        }
                        DateTime now = DateTime.Now;
                        using (IQueryAdapter queryreactor2 = MercuryEnvironment.GetDatabaseManager().getQueryreactor())
                        {

                            if (Session.GetHabbo() != null)
//.........这里部分代码省略.........

        internal void OnCycle(ref int idleCount)
        {
            this.ToRemove.Clear();
            int count = 0;
            foreach (RoomUser roomUser in this.UserList.Values)
            {
                if (!this.isValid(roomUser))
                {
                    if (roomUser.GetClient() != null)
                        this.RemoveUserFromRoom(roomUser.GetClient(), false, false);
                    else
                        this.RemoveRoomUser(roomUser);
                }
                bool flag1 = false;
                checked { ++roomUser.IdleTime; }
                if (!roomUser.IsBot && !roomUser.IsAsleep && roomUser.IdleTime >= 600)
                {
                    roomUser.IsAsleep = true;
                    ServerMessage sleepMsg = new ServerMessage(Outgoing.RoomUserIdleMessageComposer);
                    sleepMsg.AppendInt32(roomUser.VirtualId);
                    sleepMsg.AppendBoolean(true);
                    this.room.SendMessage(sleepMsg);
                }
                if (roomUser.NeedsAutokick && !this.ToRemove.Contains(roomUser))
                {
                    this.ToRemove.Add(roomUser);
                }
                else
                {
                    if (roomUser.CarryItemID > 0)
                    {
                        checked { --roomUser.CarryTimer; }
                        if (roomUser.CarryTimer <= 0)
                            roomUser.CarryItem(0);
                    }
                    if (this.room.GotFreeze())
                        this.room.GetFreeze().CycleUser(roomUser);
                    bool flag2 = false;

                    if (roomUser.IsPet)
                    {
                        if (!roomUser.IsWalking && roomUser.Statusses.ContainsKey("mv"))
                        {
                            roomUser.ClearMovement(true);
                        }
                    }
                    if (roomUser.SetStep)
                    {
                        if (this.room.GetGameMap().CanWalk(roomUser.SetX, roomUser.SetY, roomUser.AllowOverride) || roomUser.RidingHorse)
                        {
                            Gamemap gameMap = this.room.GetGameMap();


                            Point coordinate = roomUser.Coordinate;
                            int x = coordinate.X;
                            coordinate = roomUser.Coordinate;
                            int y = coordinate.Y;
                            Point oldCoord = new Point(x, y);
                            Point newCoord = new Point(roomUser.SetX, roomUser.SetY);
                            RoomUser user = roomUser;
                            gameMap.UpdateUserMovement(oldCoord, newCoord, user);
                            List<RoomItem> coordinatedItems = this.room.GetGameMap().GetCoordinatedItems(new Point(roomUser.X, roomUser.Y));
                            roomUser.X = roomUser.SetX;
                            roomUser.Y = roomUser.SetY;
                            roomUser.Z = roomUser.SetZ;
                            this.ToSet.Remove(new Point(roomUser.SetX, roomUser.SetY));

                            if (this.room.GotSoccer())
                            {
                                this.room.GetSoccer().OnUserWalk(roomUser);
                            }

                            lock (coordinatedItems)
                            {
                                foreach (RoomItem itemE in coordinatedItems)
                                {
                                    itemE.UserWalksOffFurni(roomUser);

                                    switch (itemE.GetBaseItem().InteractionType)
                                    {
                                        case InteractionType.tent:
                                        case InteractionType.bedtent:
                                            if (!roomUser.IsBot && roomUser.OnCampingTent)
                                            {
                                                ServerMessage serverMessage = new ServerMessage();
                                                serverMessage.Init(Outgoing.UpdateFloorItemExtraDataMessageComposer);
                                                serverMessage.AppendString(itemE.Id.ToString());
                                                serverMessage.AppendInt32(0);
                                                serverMessage.AppendString("0");
                                                roomUser.GetClient().SendMessage(serverMessage);
                                                roomUser.OnCampingTent = false;
                                            }
                                            break;

                                        case InteractionType.runwaysage:
                                        case InteractionType.shower:
                                            itemE.ExtraData = "0";
                                            itemE.UpdateState();
                                            break;
                                    }
//.........这里部分代码省略.........