private static void AlertRoom(Session Session, ClientMessage Message)
{
if (!Session.HasRight("moderation_tool"))
{
return;
}
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
Session.SendData(NotificationMessageComposer.Compose("Could not send room alert."));
return;
}
int Unknown1 = Message.PopWiredInt32();
int AlertMode = Message.PopWiredInt32();
string AlertMessage = Message.PopString();
bool IsCaution = AlertMode != 3;
Instance.SendModerationAlert(AlertMessage, IsCaution);
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
ModerationLogs.LogModerationAction(MySqlClient, Session, "Sent room " + (IsCaution ? "caution" : "message"),
"Room " + Instance.Info.Name + " (ID " + Instance.RoomId + "): '" + AlertMessage + "'");
}
}
private static void ApplyEffect(Session Session, ClientMessage Message)
{
int EffectSpriteId = Message.PopWiredInt32();
if (EffectSpriteId < 0)
{
EffectSpriteId = 0;
}
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null || (EffectSpriteId != 0 && !Session.AvatarEffectCache.HasEffect(EffectSpriteId, true)))
{
return;
}
Actor.ApplyEffect(EffectSpriteId);
Session.CurrentEffect = EffectSpriteId;
}
private static void SubmitAnswer(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null)
{
return;
}
int AnswerId = Message.PopWiredInt32();
lock (mInfobusQuestions)
{
if (mInfobusQuestions.ContainsKey(Instance.RoomId))
{
mInfobusQuestions[Instance.RoomId].SubmitAnswer(Actor.Id, AnswerId);
}
}
}
private static void BanUser(Session Session, ClientMessage Message)
{
if (!Session.HasRight("moderation_tool"))
{
return;
}
uint UserId = Message.PopWiredUInt32();
string MessageText = Message.PopString();
double Length = (Message.PopWiredInt32() * 3600);
Session TargetSession = SessionManager.GetSessionByCharacterId(UserId);
if (TargetSession == null || TargetSession.HasRight("moderation_tool"))
{
Session.SendData(NotificationMessageComposer.Compose("This user is not online or you do not have permission to ban them.\nPlease use housekeeping to ban users that are offline."));
return;
}
SessionManager.StopSession(TargetSession.Id);
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
ModerationBanManager.BanUser(MySqlClient, UserId, MessageText, Session.CharacterId, Length);
ModerationLogs.LogModerationAction(MySqlClient, Session, "Banned user",
"User '" + TargetSession.CharacterInfo.Username + "' (ID " + TargetSession.CharacterId + ") for " +
Length + " hours: '" + MessageText + "'");
}
}
private static void OnSessionLatencyTest(Session Session, ClientMessage Message)
{
// Sesion timer sends a number to the server and expects it right back.
// Maybe something to do with latency testing... or a keepalive?
// Seems like a waste of bandwith since we're using pinging
Session.SendData(LatencyTestResponseComposer.Compose(Message.PopWiredInt32()));
}
private static void ActivateEffect(Session Session, ClientMessage Message)
{
AvatarEffect Effect = Session.AvatarEffectCache.GetEffect(Message.PopWiredInt32(), false, true);
// If we do not have an effect that needs activating OR if we already have an effect
// of this sort which IS activated, stop.
if (Effect == null || Session.AvatarEffectCache.HasEffect(Effect.SpriteId, true))
{
return;
}
Effect.Activate();
Session.SendData(UserEffectActivatedComposer.Compose(Effect));
}
private static void OnClientConfig(Session Session, ClientMessage Message)
{
int Volume = Message.PopWiredInt32();
bool Something = Message.PopWiredBoolean();
if (Volume < 0)
{
Volume = 0;
}
if (Volume > 100)
{
Volume = 100;
}
Session.CharacterInfo.ConfigVolume = Volume;
}
private static void UpdateMoodlight(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
Item Item = Instance.MoodlightItem;
if (Item == null)
{
return;
}
MoodlightData Data = MoodlightData.GenerateFromFlags(Item.Flags);
int PresetId = Message.PopWiredInt32();
MoodlightPreset Preset = null;
if (Data.Presets.ContainsKey(PresetId))
{
Preset = Data.Presets[PresetId];
}
if (Preset == null)
{
return;
}
Preset.BackgroundOnly = !Message.PopWiredBoolean();
Preset.ColorCode = UserInputFilter.FilterString(Message.PopString().Trim());
Preset.ColorIntensity = Message.PopWiredInt32();
if (!MoodlightData.IsValidColor(Preset.ColorCode))
{
return;
}
Item.Flags = Data.ToItemFlagData();
Item.DisplayFlags = Data.ToDisplayData();
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Item.SynchronizeDatabase(MySqlClient, true);
}
Item.BroadcastStateUpdate(Instance);
}
private static void UserDance(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null || Actor.AvatarEffectId > 0)
{
return;
}
int DanceId = Message.PopWiredInt32();
if (DanceId < 0 || DanceId > 4)
{
return;
}
if (!Session.HasRight("club_regular") && !Session.HasRight("club_vip") && DanceId != 0)
{
DanceId = 1;
}
Actor.Dance(DanceId);
QuestManager.ProgressUserQuest(Session, QuestType.SOCIAL_DANCE);
}
private static void SetBadgeOrder(Session Session, ClientMessage Message)
{
int i = 0;
Dictionary<int, Badge> NewSettings = new Dictionary<int, Badge>();
while (Message.RemainingLength > 0)
{
if (i > 5)
{
continue;
}
int SlotId = Message.PopWiredInt32();
string BadgeCode = Message.PopString();
Badge BadgeRef = RightsManager.GetBadgeByCode(BadgeCode);
if (BadgeRef == null || !Session.BadgeCache.ContainsCode(BadgeCode) || SlotId >= 6 ||
SlotId <= 0 || NewSettings.ContainsKey(SlotId))
{
continue;
}
NewSettings.Add(SlotId, BadgeRef);
i++;
}
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Session.BadgeCache.UpdateBadgeOrder(MySqlClient, NewSettings);
}
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
Instance.BroadcastMessage(RoomUserBadgesComposer.Compose(Session.CharacterId, Session.BadgeCache.EquippedBadges));
QuestManager.ProgressUserQuest(Session, QuestType.PROFILE_BADGE);
}
private static void RemoveFromPlaylist(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || Instance.MusicController == null || !Instance.CheckUserRights(Session, true))
{
return;
}
Item TakenItem = Instance.MusicController.RemoveDisk(Message.PopWiredInt32());
// playlist will skip to the next item automatically if it has to
if (TakenItem == null)
{
return;
}
Session.InventoryCache.Add(TakenItem);
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
TakenItem.MoveToUserInventory(MySqlClient, Session.CharacterId);
}
Session.SendData(InventoryItemAddedComposer.Compose(TakenItem));
Session.SendData(JukeboxDisksComposer.Compose(Session));
Session.SendData(JukeboxPlaylistComposer.Compose(Instance.MusicController.PlaylistCapacity,
Instance.MusicController.Playlist.Values.ToList()));
}
private static void GetRoomChatlog(Session Session, ClientMessage Message)
{
if (!Session.HasRight("chatlogs"))
{
Session.SendData(NotificationMessageComposer.Compose("You are not allowed to use this!"));
return;
}
int Unknown1 = Message.PopWiredInt32();
uint RoomId = Message.PopWiredUInt32();
RoomInfo Info = RoomInfoLoader.GetRoomInfo(RoomId);
if (Info == null)
{
Session.SendData(NotificationMessageComposer.Compose("Room not found; could not load chatlogs."));
return;
}
Session.SendData(ModerationRoomChatlogsComposer.Compose(Info, ModerationLogs.GetLogsForRoom(RoomId,
(UnixTimestamp.GetCurrent() - 3600), UnixTimestamp.GetCurrent())));
}
private static void OnFriendRemove(Session Session, ClientMessage Message)
{
int Amount = Message.PopWiredInt32();
// Precaution: limit queries to 50
if (Amount > 50)
{
Amount = 50;
}
List<MessengerUpdate> LocalUpdates = new List<MessengerUpdate>();
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
for (int i = 0; i < Amount; i++)
{
uint FriendId = Message.PopWiredUInt32();
if (DestroyFriendship(MySqlClient, Session.CharacterId, FriendId))
{
Session.MessengerFriendCache.RemoveFromCache(FriendId);
LocalUpdates.Add(new MessengerUpdate(-1, CharacterInfoLoader.GenerateNullCharacter(FriendId)));
Session TargetSession = SessionManager.GetSessionByCharacterId(FriendId); ;
if (TargetSession != null)
{
TargetSession.MessengerFriendCache.RemoveFromCache(Session.CharacterId);
TargetSession.SendData(MessengerUpdateListComposer.Compose(new List<MessengerUpdate>() { new MessengerUpdate(-1, CharacterInfoLoader.GenerateNullCharacter(Session.CharacterId)) }));
}
}
}
}
Session.SendData(MessengerUpdateListComposer.Compose(LocalUpdates));
}
private static void SetIcon(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
int Junk = Message.PopWiredInt32();
int Background = Message.PopWiredInt32();
if (Background < 1 || Background > 24)
{
Background = 1;
}
int Foreground = Message.PopWiredInt32();
if (Foreground < 0 || Foreground > 11)
{
Foreground = 0;
}
int ObjectCount = Message.PopWiredInt32();
Dictionary<int, int> Objects = new Dictionary<int, int>();
for (int i = 0; (i < ObjectCount && i < 10); i++)
{
int Position = Message.PopWiredInt32();
int Item = Message.PopWiredInt32();
if (Position < 0 || Position > 10 || Item < 1 || Item > 27 || Objects.ContainsKey(Position))
{
continue;
}
Objects.Add(Position, Item);
}
Instance.Info.UpdateIcon(Background, Foreground, Objects);
Session.SendData(RoomUpdatedNotification3Composer.Compose(Instance.RoomId));
Instance.BroadcastMessage(RoomUpdatedNotification2Composer.Compose(Instance.RoomId));
}
private static void EditRoom(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
// FQJ@LRoy's Office@fThis is where I handle business. Yeah.J@@RBIJ@Foffice@IbuttsechsAAAA
uint Id = Message.PopWiredUInt32();
if (Id != Instance.RoomId)
{
return;
}
string Name = UserInputFilter.FilterString(Message.PopString()).Trim();
string Description = UserInputFilter.FilterString(Message.PopString()).Trim();
RoomAccessType AccessType = (RoomAccessType)Message.PopWiredInt32();
string Password = UserInputFilter.FilterString(Message.PopString()).Trim();
int UserLimit = Message.PopWiredInt32();
int CategoryId = Message.PopWiredInt32();
int TagCount = Message.PopWiredInt32();
List<string> Tags = new List<string>();
for (int i = 0; (i < TagCount && i < 2); i++)
{
string Tag = UserInputFilter.FilterString(Message.PopString()).Trim().ToLower();
if (Tag.Length > 32)
{
Tag = Tag.Substring(0, 32);
}
if (Tag.Length > 0 && !Tags.Contains(Tag))
{
Tags.Add(Tag);
}
}
bool AllowPets = (Message.ReadBytes(1)[0] == 65);
bool AllowPetEating = (Message.ReadBytes(1)[0] == 65);
bool AllowBlocking = (Message.ReadBytes(1)[0] == 65);
bool HideWalls = (Message.ReadBytes(1)[0] == 65);
int WallThickness = Message.PopWiredInt32();
int FloorThickness = Message.PopWiredInt32();
if (WallThickness < -2 || WallThickness > 1)
{
WallThickness = 0;
}
if (FloorThickness < -2 || FloorThickness > 1)
{
FloorThickness = 0;
}
if (HideWalls && !Session.HasRight("club_vip"))
{
HideWalls = false;
}
if (Name.Length > 60) // was 25
{
Name = Name.Substring(0, 60);
}
if (Description.Length > 128)
{
Description = Description.Substring(0, 128);
}
if (Password.Length > 64)
{
Password = Password.Substring(0, 64);
}
if (UserLimit > Instance.Model.MaxUsers)
{
UserLimit = Instance.Model.MaxUsers;
}
if (Name.Length == 0)
{
Name = "Room";
}
if (AccessType == RoomAccessType.PasswordProtected && Password.Length == 0)
{
AccessType = RoomAccessType.Open;
}
Instance.Info.EditRoom(Name, Description, AccessType, Password, UserLimit, CategoryId, Tags, AllowPets,
AllowPetEating, AllowBlocking, HideWalls, WallThickness, FloorThickness);
Session.SendData(RoomUpdatedNotification1Composer.Compose(Instance.RoomId));
Instance.BroadcastMessage(RoomUpdatedNotification2Composer.Compose(Instance.RoomId));
Instance.BroadcastMessage(RoomWallsStatusComposer.Compose(Instance.Info.HideWalls, Instance.Info.WallThickness,
Instance.Info.FloorThickness));
//Instance.BroadcastMessage(RoomInfoComposer.Compose(Instance.Info, false));
if (Instance.Info.AccessType != RoomAccessType.Open && Instance.HasOngoingEvent)
{
Instance.StopEvent();
}
}
private static void CreateOrEditEvent(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true) || Instance.Info.AccessType != RoomAccessType.Open)
{
return;
}
int CategoryId = Message.PopWiredInt32();
string Name = UserInputFilter.FilterString(Message.PopString()).Trim();
string Description = UserInputFilter.FilterString(Message.PopString()).Trim();
int TagCount = Message.PopWiredInt32();
List<string> Tags = new List<string>();
for (int i = 0; (i < TagCount && i < 2); i++)
{
string Tag = UserInputFilter.FilterString(Message.PopString()).Trim().ToLower();
if (Tag.Length > 25)
{
Tag = Tag.Substring(0, 25);
}
if (Tag.Length > 0 && !Tags.Contains(Tag))
{
Tags.Add(Tag);
}
}
if (!Instance.HasOngoingEvent)
{
Session.MessengerFriendCache.BroadcastToFriends(MessengerFriendEventComposer.Compose(Session.CharacterId,
MessengerFriendEventType.EventStarted, Name));
}
Instance.StartOrUpdateEvent(Name, Description, CategoryId, Tags);
}
private static void ActivateGeneric(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null) // warning: rights need to be checked in the event handler; we do not check here
{
return;
}
Item Item = Instance.GetItem(Message.PopWiredUInt32());
if (Item == null || Item.Definition.Behavior == ItemBehavior.StaticItem)
{
return;
}
int RequestData = Message.PopWiredInt32();
ItemEventDispatcher.InvokeItemEventHandler(Session, Item, Instance, ItemEventType.Interact, RequestData, Message.Id);
QuestManager.ProgressUserQuest(Session, QuestType.EXPLORE_FIND_ITEM, Item.DefinitionId);
if (Item.Definition.Behavior == ItemBehavior.Switchable)
{
QuestManager.ProgressUserQuest(Session, QuestType.FURNI_SWITCH);
}
}
private static void UserMoveTo(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null)
{
return;
}
int RequestX = Message.PopWiredInt32();
int RequestY = Message.PopWiredInt32();
if (RequestX < 0 || RequestY < 0)
{
return;
}
Actor.MoveTo(new Vector2(RequestX, RequestY));
}
private static void OnFriendRequestAccept(Session Session, ClientMessage Message)
{
int Amount = Message.PopWiredInt32();
// Precaution: limit queries to 50.
if (Amount > 50)
{
Amount = 50;
}
List<Session> SessionsToUpdate = new List<Session>() { Session };
for (int i = 0; i < Amount; i++)
{
uint RequestId = Message.PopWiredUInt32();
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
MySqlClient.SetParameter("user1", Session.CharacterId);
MySqlClient.SetParameter("user2", RequestId);
MySqlClient.SetParameter("confirmed", 1);
int Affected = MySqlClient.ExecuteNonQuery("UPDATE messenger_friendships SET confirmed = @confirmed WHERE user_1_id = @user1 AND user_2_id = @user2 LIMIT 1");
if (Affected > 0)
{
MySqlClient.SetParameter("user1", RequestId);
MySqlClient.SetParameter("user2", Session.CharacterId);
MySqlClient.SetParameter("confirmed", 1);
MySqlClient.ExecuteNonQuery("INSERT INTO messenger_friendships (user_1_id,user_2_id,confirmed) VALUES (@user1,@user2,@confirmed)");
Session.MessengerFriendCache.AddToCache(RequestId);
Session TargetSession = SessionManager.GetSessionByCharacterId(RequestId);
if (TargetSession != null)
{
TargetSession.MessengerFriendCache.AddToCache(Session.CharacterId);
SessionsToUpdate.Add(TargetSession);
}
}
}
}
for (int i = 0; i < 2; i++)
{
foreach (Session SessionToUpdate in SessionsToUpdate)
{
ForceMessengerUpdateForSession(SessionToUpdate);
}
}
}
private static void OnFriendRequestDecline(Session Session, ClientMessage Message)
{
bool HandleAll = Message.PopWiredBoolean();
int Amount = Message.PopWiredInt32();
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
if (HandleAll)
{
MySqlClient.SetParameter("userid", Session.CharacterId);
MySqlClient.SetParameter("confirmed", 0);
MySqlClient.SetParameter("amount", Amount);
MySqlClient.ExecuteNonQuery("DELETE FROM messenger_friendships WHERE user_1_id = @userid AND confirmed = @confirmed");
}
else
{
// Precaution: limit queries to 50
if (Amount > 50)
{
Amount = 50;
}
for (int i = 0; i < Amount; i++)
{
uint RequestId = Message.PopWiredUInt32();
DestroyFriendship(MySqlClient, Session.CharacterId, RequestId);
}
}
}
}
private static void TakeRights(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
int Amount = Message.PopWiredInt32();
for (int i = 0; (i < Amount && i <= 100); i++)
{
uint UserId = Message.PopWiredUInt32();
if (UserId > 0 && Instance.TakeUserRights(UserId))
{
Session.SendData(RoomRightsRemovedConfirmationComposer.Compose(Instance.RoomId, UserId));
}
}
}
private static void OnInvite(Session Session, ClientMessage Message)
{
int Count = Message.PopWiredInt32();
List<uint> Targets = new List<uint>();
for (int i = 0; (i < Count && i < 50); i++)
{
Targets.Add(Message.PopWiredUInt32());
}
string MessageText = UserInputFilter.FilterString(Message.PopString());
if (MessageText.Length > 121)
{
MessageText = MessageText.Substring(0, 121);
}
List<Session> Users = new List<Session>();
foreach (uint UserId in Targets)
{
if (!Session.MessengerFriendCache.Friends.Contains(UserId))
{
continue;
}
Session TargetSession = SessionManager.GetSessionByCharacterId(UserId);
if (TargetSession == null)
{
continue;
}
Users.Add(TargetSession);
TargetSession.SendData(MessengerImInviteComposer.Compose(Session.CharacterId, Wordfilter.Filter(MessageText)));
}
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
String to = "";
foreach (Session User in Users)
{
to += User.CharacterInfo.Username + " [" + User.CharacterId + "], ";
}
to = to.Substring(0, to.Length - 2);
ModerationLogs.LogChatMessage(MySqlClient, Session.CharacterId, 0, "(INVITATION to " + to + ") " + MessageText);
}
}
private static void GetSongData(Session Session, ClientMessage Message)
{
int Amount = Message.PopWiredInt32();
List<SongData> Songs = new List<SongData>();
for (int i = 0; i < Amount; i++)
{
SongData Song = GetSong(Message.PopWiredUInt32());
if (Song == null)
{
continue;
}
Songs.Add(Song);
}
Session.SendData(SongDataComposer.Compose(Songs));
}
private static void MoveFloorItem(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session))
{
return;
}
Item Item = Instance.GetItem(Message.PopWiredUInt32());
if (Item == null || Item.Definition.Type != ItemType.FloorItem)
{
return;
}
Vector2 NewPosition = new Vector2(Message.PopWiredInt32(), Message.PopWiredInt32());
int NewRotation = Message.PopWiredInt32();
bool IsRotationOnly = (Item.RoomId == Instance.RoomId && Item.RoomPosition.X == NewPosition.X &&
Item.RoomPosition.Y == NewPosition.Y && NewRotation != Item.RoomRotation);
Vector3 FinalizedPosition = Instance.SetFloorItem(Session, Item, NewPosition, NewRotation);
if (FinalizedPosition != null)
{
Item.MoveToRoom(null, Instance.RoomId, FinalizedPosition, NewRotation, string.Empty);
RoomManager.MarkWriteback(Item, false);
Instance.RegenerateRelativeHeightmap();
Instance.BroadcastMessage(RoomItemUpdatedComposer.Compose(Item));
ItemEventDispatcher.InvokeItemEventHandler(Session, Item, Instance, ItemEventType.Moved,
IsRotationOnly ? 1 : 0);
QuestManager.ProgressUserQuest(Session, IsRotationOnly ? QuestType.FURNI_ROTATE : QuestType.FURNI_MOVE);
if (FinalizedPosition.Z > Instance.Model.Heightmap.FloorHeight[FinalizedPosition.X, FinalizedPosition.Y])
{
QuestManager.ProgressUserQuest(Session, QuestType.FURNI_STACK);
}
}
}
private static void MarkTabRead(Session Session, ClientMessage Message)
{
Session.NewItemsCache.MarkTabRead(Message.PopWiredInt32());
}
private static void GetCatalogPage(Session Session, ClientMessage Message)
{
int Id = Message.PopWiredInt32();
if (!mPages.ContainsKey(Id))
{
return;
}
CatalogPage Page = mPages[Id];
if (Page.DummyPage)
{
return;
}
ServerMessage Response = TryGetResponseFromCache(0, Message);
if (Response != null)
{
Session.SendData(Response);
return;
}
Response = CatalogPageComposer.Compose(Page);
AddToCacheIfNeeded(0, Message, Response);
Session.SendData(Response);
}
private static void SetWardrobe(Session Session, ClientMessage Message)
{
int SlotAmount = GetWardrobeSlotAmountForSession(Session);
int SlotId = Message.PopWiredInt32();
string Figure = Message.PopString();
CharacterGender Gender = (Message.PopString() == "M" ? CharacterGender.Male : CharacterGender.Female);
if (SlotId <= 0 || SlotId > SlotAmount)
{
return;
}
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Session.CharacterInfo.SetWardrobeSlot(MySqlClient, SlotId, Figure, Gender);
}
}
private static void TakeItem(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
int Unknown1 = Message.PopWiredInt32();
Item Item = Instance.GetItem(Message.PopWiredUInt32());
if (Item == null || Item.Definition.Behavior == ItemBehavior.StickyNote)
{
return;
}
if (Instance.TakeItem(Item.Id))
{
ItemEventDispatcher.InvokeItemEventHandler(Session, Item, Instance, ItemEventType.Removing);
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Item.MoveToUserInventory(MySqlClient, Session.CharacterId);
}
Instance.RegenerateRelativeHeightmap();
Session.InventoryCache.Add(Item);
Session.SendData(InventoryItemAddedComposer.Compose(Item));
QuestManager.ProgressUserQuest(Session, QuestType.FURNI_PICK);
}
}
private static void PlacePet(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || (!Instance.CheckUserRights(Session, true) && !Instance.Info.AllowPets))
{
return;
}
Pet Pet = Session.PetInventoryCache.GetPet(Message.PopWiredUInt32());
if (Pet == null)
{
return;
}
Vector2 DesiredPosition = new Vector2(Message.PopWiredInt32(), Message.PopWiredInt32());
if (!Instance.IsValidPosition(DesiredPosition))
{
return;
}
Bot BotDefinition = BotManager.GetHandlerDefinitionForPetType(Pet.Type);
if (BotDefinition == null)
{
Session.SendData(NotificationMessageComposer.Compose("This pet cannot be placed right now. Please try again later."));
return;
}
if (!Instance.CanPlacePet(Instance.CheckUserRights(Session, true)))
{
Session.SendData(RoomItemPlacementErrorComposer.Compose(RoomItemPlacementErrorCode.PetLimitReached));
return;
}
Vector3 Position = new Vector3(DesiredPosition.X, DesiredPosition.Y, Instance.GetUserStepHeight(DesiredPosition));
Pet.MoveToRoom(Instance.RoomId, Position);
Instance.AddBotToRoom(BotManager.CreateNewInstance(BotDefinition, Instance.RoomId, Position, Pet));
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Pet.SynchronizeDatabase(MySqlClient);
}
Session.SendData(InventoryPetRemovedComposer.Compose(Pet.Id));
}
private static void UserChangeRotation(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null || Actor.IsMoving)
{
return;
}
Vector2 PositionToFace = new Vector2(Message.PopWiredInt32(), Message.PopWiredInt32());
if ((Actor.Position.X == PositionToFace.X && Actor.Position.Y == PositionToFace.Y) ||
Actor.UserStatusses.ContainsKey("lay") || Actor.UserStatusses.ContainsKey("sit"))
{
return;
}
int NewRotation = 0;
NewRotation = Rotation.Calculate(Actor.Position.GetVector2(), PositionToFace);
if (Actor.BodyRotation != NewRotation)
{
Actor.BodyRotation = NewRotation;
Actor.UpdateNeeded = true;
}
if (Actor.HeadRotation != NewRotation)
{
Actor.HeadRotation = NewRotation;
Actor.UpdateNeeded = true;
}
}
