private static void MoveWallItem(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.WallItem)
{
return;
}
string RawPlacementData = Message.PopString();
string WallPos = Instance.SetWallItem(Session, RawPlacementData, Item);
if (WallPos.Length > 0)
{
Item.MoveToRoom(null, Instance.RoomId, new Vector3(0, 0, 0), 0, WallPos);
RoomManager.MarkWriteback(Item, false);
Instance.BroadcastMessage(RoomWallItemMovedComposer.Compose(Item));
ItemEventDispatcher.InvokeItemEventHandler(Session, Item, Instance, ItemEventType.Moved);
}
}
public void IncreaseIdleTime(bool IsOwner)
{
mIdleTime++;
if (!IsSleeping && mIdleTime >= 600)
{
mIsSleeping = true;
mInstance.BroadcastMessage(RoomUserSleepComposer.Compose(mId, true));
}
else if (!mIsLeavingRoom && mIdleTime >= 1800 && !IsOwner)
{
LeaveRoom();
return;
}
if (mCarryItemTimer > 0)
{
mCarryItemTimer--;
if (mCarryItemTimer == 0)
{
CarryItem(0);
}
}
if (mAntiSpamTicks >= 0)
{
mAntiSpamTicks--;
if (mAntiSpamTicks == -1)
{
mAntiSpamMessagesSent = 0;
}
}
}
private static void SaveSticky(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
Item Item = Instance.GetItem(Message.PopWiredUInt32());
if (Item == null || Item.Definition.Behavior != ItemBehavior.StickyNote)
{
return;
}
StickieEditingRights Rights = Instance.GetStickieEditingRights(Session, Item);
if (Rights == StickieEditingRights.ReadOnly)
{
return;
}
string RawData = Message.PopString();
string[] Bits = RawData.Split(' ');
if (Bits.Length < 2)
{
return;
}
string Color = Bits[0].ToUpper().Trim();
string Text = UserInputFilter.FilterString(RawData.Substring(Color.Length + 1, RawData.Length - (Color.Length + 1))).Trim();
if (Color != "FFFF33" && Color != "FF9CFF" && Color != "9CCEFF" && Color != "9CFF9C" || Text.Length > 391)
{
return;
}
Item.Flags = RawData;
Item.DisplayFlags = Color;
if (Rights == StickieEditingRights.GuestEdit)
{
Item.Flags += "\n-----\n" + Session.CharacterInfo.Username + "\n" + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToShortTimeString();
}
Instance.RevokeTemporaryStickieRights(Item.Id);
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Item.SynchronizeDatabase(MySqlClient, true);
}
Instance.BroadcastMessage(RoomWallItemMovedComposer.Compose(Item));
}
private static void ApplyDecoration(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
Item Item = Session.InventoryCache.GetItem(Message.PopWiredUInt32());
if (Item == null)
{
return;
}
string DecorationKey = string.Empty;
switch (Item.Definition.Behavior)
{
case ItemBehavior.Floor:
QuestManager.ProgressUserQuest(Session, QuestType.FURNI_DECORATION_FLOOR);
DecorationKey = "floor";
break;
case ItemBehavior.Wallpaper:
QuestManager.ProgressUserQuest(Session, QuestType.FURNI_DECORATION_WALL);
DecorationKey = "wallpaper";
break;
case ItemBehavior.Landscape:
DecorationKey = "landscape";
break;
}
if (DecorationKey.Length == 0)
{
return;
}
Session.InventoryCache.RemoveItem(Item.Id);
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Item.RemovePermanently(MySqlClient);
Instance.Info.ApplyDecoration(MySqlClient, DecorationKey, Item.Flags);
}
Instance.BroadcastMessage(RoomDecorationComposer.Compose(DecorationKey, Item.Flags));
Session.SendData(InventoryItemRemovedComposer.Compose(Item.Id));
}
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 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 RespectUser(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || Session.CharacterInfo.RespectCreditHuman <= 0)
{
return;
}
RoomActor TargetActor = Instance.GetActorByReferenceId(Message.PopWiredUInt32());
if (TargetActor == null)
{
return;
}
Session TargetSession = SessionManager.GetSessionByCharacterId(TargetActor.ReferenceId);
if (TargetSession == null)
{
return;
}
TargetSession.CharacterInfo.RespectPoints++;
Session.CharacterInfo.RespectCreditHuman--;
Instance.BroadcastMessage(RoomUserRespectedComposer.Compose(TargetSession.CharacterId,
TargetSession.CharacterInfo.RespectPoints));
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
TargetSession.CharacterInfo.SynchronizeRespectData(MySqlClient);
Session.CharacterInfo.SynchronizeRespectData(MySqlClient);
AchievementManager.ProgressUserAchievement(MySqlClient, TargetSession, "ACH_RespectEarned", 1);
AchievementManager.ProgressUserAchievement(MySqlClient, Session, "ACH_RespectGiven", 1);
}
QuestManager.ProgressUserQuest(Session, QuestType.SOCIAL_RESPECT);
}
private static bool HandleRoller(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData, uint Opcode)
{
switch (Event)
{
case ItemEventType.UpdateTick:
List<RoomActor> ActorsToMove = Instance.GetActorsOnPosition(Item.RoomPosition.GetVector2());
List<Item> ItemsToMove = new List<Item>();
if (ActorsToMove != null)
{
foreach (RoomActor Actor in ActorsToMove)
{
if (Actor.IsMoving)
{
continue;
}
if (Instance.IsValidStep(Actor.Position.GetVector2(), Item.SquareInFront, true))
{
Actor.PositionToSet = Item.SquareInFront;
Instance.BroadcastMessage(RollerEventComposer.Compose(Actor.Position, new Vector3(
Actor.PositionToSet.X, Actor.PositionToSet.Y,
Instance.GetUserStepHeight(Actor.PositionToSet)), Item.Id, Actor.Id, 0));
}
}
}
goto case ItemEventType.InstanceLoaded;
case ItemEventType.InstanceLoaded:
case ItemEventType.Placed:
Item.RequestUpdate(4);
break;
}
return true;
}
private static void RespectPet(Session Session, ClientMessage Message)
{
if (Session.CharacterInfo.RespectCreditPets <= 0)
{
return;
}
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Message.PopWiredUInt32(), RoomActorType.AiBot);
if (Actor == null)
{
return;
}
Pet PetData = ((Bot)Actor.ReferenceObject).PetData;
if (PetData == null)
{
return;
}
Session.CharacterInfo.RespectCreditPets = 500;/*--;*/
PetData.Score++;
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Session.CharacterInfo.SynchronizeRespectData(MySqlClient);
PetData.SynchronizeDatabase(MySqlClient);
}
Instance.BroadcastMessage(RoomPetUpdateComposer.Compose(Actor.ReferenceId, PetData));
}
private static bool HandleRoller(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData, uint Opcode)
{
switch (Event)
{
case ItemEventType.UpdateTick:
List<RoomActor> ActorsToMove = Instance.GetActorsOnPosition(Item.RoomPosition.GetVector2());
List<Item> ItemsToMove = new List<Item>();
ItemsToMove.AddRange(Instance.GetItemsOnPosition(Item.RoomPosition.GetVector2()));
if (ActorsToMove != null)
{
foreach (RoomActor Actor in ActorsToMove)
{
if (Actor.IsMoving)
{
continue;
}
if (Instance.IsValidStep(Actor.Position.GetVector2(), Item.SquareInFront, true))
{
Actor.PositionToSet = Item.SquareInFront;
Instance.BroadcastMessage(RollerEventComposer.Compose(Actor.Position, new Vector3(
Actor.PositionToSet.X, Actor.PositionToSet.Y,
Instance.GetUserStepHeight(Actor.PositionToSet)), Item.Id, Actor.Id, 0));
}
}
}
if (ItemsToMove.Count != 0)
{
foreach (Item item in ItemsToMove)
{
if (item == Item)
{
continue;
}
if (Item.RoomPosition.X == item.RoomPosition.X && Item.RoomPosition.Y == item.RoomPosition.Y)
{
Vector2 NewPosition = new Vector2(Item.SquareInFront.X, Item.SquareInFront.Y);
int NewRotation = item.RoomRotation;
Vector3 FinalizedPosition = Instance.SetFloorItem(Session, item, NewPosition, NewRotation);
Vector3 oldpos = item.RoomPosition;
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, 0);
Instance.BroadcastMessage(RollerEventComposer.Compose(oldpos, FinalizedPosition, Item.Id, 0, item.Id));
}
}
}
}
goto case ItemEventType.InstanceLoaded;
case ItemEventType.InstanceLoaded:
case ItemEventType.Placed:
Item.RequestUpdate(4);
break;
}
return true;
}
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();
}
}
public static void PrepareRoom(Session Session, uint RoomId, string Password = "", bool BypassAuthentication = false)
{
// Remove user from any previous room
RoomManager.RemoveUserFromRoom(Session, false);
// Try to retrieve room information
RoomInfo Info = RoomInfoLoader.GetRoomInfo(RoomId);
// Room not found, send kick notif and stop
if (Info == null)
{
Session.SendData(RoomKickedComposer.Compose());
return;
}
// Try to retrieve room model information
RoomModel Model = Info.TryGetModel();
// Model information not found, send kick notif and stop
if (Model == null)
{
Session.SendData(RoomKickedComposer.Compose());
return;
}
// Load room instance into the server memory if needed
if (!RoomManager.InstanceIsLoadedForRoom(Info.Id))
{
RoomManager.TryLoadRoomInstance(Info.Id);
}
// Attempt to retrieve the instance from the server memory
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Info.Id);
// If the instance was not created or is unavailable, send kick notif and stop
if (Instance == null)
{
Session.SendData(RoomKickedComposer.Compose());
return;
}
// Check if the room capacity has been reached
if (Info.CurrentUsers >= Info.MaxUsers && !Session.HasRight("enter_full_rooms"))
{
Session.SendData(RoomJoinErrorComposer.Compose(1));
Session.SendData(RoomKickedComposer.Compose());
return;
}
// Check if the user has been banned from this room
if (Instance.IsUserBanned(Session.CharacterId))
{
Session.SendData(RoomJoinErrorComposer.Compose(4));
Session.SendData(RoomKickedComposer.Compose());
return;
}
// Mark room as loading and check for initial authorization
Session.AbsoluteRoomId = Info.Id;
Session.RoomAuthed = (BypassAuthentication || Info.OwnerId == Session.CharacterId ||
Session.HasRight("enter_locked_rooms"));
Session.RoomJoined = false;
// Send confirmation that the initial checks have been passed (if this is a flat)
if (Info.Type == RoomType.Flat)
{
Session.SendData(RoomOpenFlatComposer.Compose());
}
// Try to accomplish authorization (if not already initially authorized by character rights)
if (!Session.RoomAuthed)
{
// Check for valid password, if needed
if (Info.AccessType == RoomAccessType.PasswordProtected)
{
if (Info.Password != Password)
{
Session.SendData(GenericErrorComposer.Compose(-100002));
RoomManager.RemoveUserFromRoom(Session);
return;
}
}
// Send doorbell, if any users are in this room.
else if (Info.AccessType == RoomAccessType.Locked)
{
if (Instance.HumanActorCount > 0)
{
Session.SendData(RoomDoorbellComposer.Compose());
Instance.BroadcastMessage(RoomDoorbellComposer.Compose(Session.CharacterInfo.Username), true);
return;
}
else
{
Session.SendData(RoomDoorbellNoResponseComposer.Compose());
RoomManager.RemoveUserFromRoom(Session);
return;
}
}
}
// If all these stages have been passed, mark auth as OK and continue loading
Session.RoomAuthed = true;
EnterRoom(Session, Instance);
}
public void BroadcastStateUpdate(RoomInstance Instance)
{
if (mCachedDefinition.Type == ItemType.FloorItem) {
Instance.BroadcastMessage (RoomFloorItemUpdateFlagsComposer.Compose (mId, mDisplayFlags));
} else if (mCachedDefinition.Type == ItemType.WallItem) {
Instance.BroadcastMessage (RoomWallItemMovedComposer.Compose (this));
}
}
public void BroadcastCurrentSongData(RoomInstance Instance)
{
Instance.BroadcastMessage(MusicPlayingComposer.Compose(mSong == null ? 0 : mSong.SongData.Id,
mSongQueuePosition, 0));
}
private static void PlaceItem(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
uint ItemId = 0;
string[] Data = null;
if (Message.Id == OpcodesIn.ROOM_ITEM_PLACE_STICKY)
{
ItemId = Message.PopWiredUInt32();
string RawData = Message.PopString();
string[] TmpData = RawData.Split(' ');
Data = new string[TmpData.Length + 1];
Data[0] = string.Empty;
Data[1] = TmpData[0];
Data[2] = TmpData[1];
Data[3] = TmpData[2];
}
else
{
string RawData = Message.PopString();
Data = RawData.Split(' ');
uint.TryParse(Data[0], out ItemId);
}
Item Item = Session.InventoryCache.GetItem(ItemId);
if (Item == null)
{
return;
}
bool HasPlacementRights = Instance.CheckUserRights(Session);
bool IsPlacingGuestStickie = false;
if (Item.Definition.Behavior == ItemBehavior.StickyNote && !HasPlacementRights &&
Instance.GuestsCanPlaceStickies)
{
IsPlacingGuestStickie = true;
}
else if (!HasPlacementRights)
{
Session.SendData(RoomItemPlacementErrorComposer.Compose(RoomItemPlacementErrorCode.InsufficientRights));
return;
}
if (Item.PendingExpiration && Item.ExpireTimeLeft <= 0)
{
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Item.RemovePermanently(MySqlClient);
}
Session.InventoryCache.RemoveItem(Item.Id);
Session.SendData(InventoryItemRemovedComposer.Compose(Item.Id));
return;
}
switch (Item.Definition.Type)
{
default:
case ItemType.FloorItem:
if (Data.Length != 4)
{
return;
}
int X = 0;
int Y = 0;
int Rotation = 0;
int.TryParse(Data[1], out X);
int.TryParse(Data[2], out Y);
int.TryParse(Data[3], out Rotation);
Vector3 FinalizedPosition = Instance.SetFloorItem(Session, Item, new Vector2(X, Y), Rotation);
if (FinalizedPosition != null)
{
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Item.MoveToRoom(MySqlClient, Instance.RoomId, FinalizedPosition, Rotation);
}
Instance.RegenerateRelativeHeightmap();
Session.InventoryCache.RemoveItem(Item.Id);
Session.SendData(InventoryItemRemovedComposer.Compose(Item.Id));
ItemEventDispatcher.InvokeItemEventHandler(Session, Item, Instance, ItemEventType.Placed);
Instance.BroadcastMessage(RoomFloorItemPlacedComposer.Compose(Item));
QuestManager.ProgressUserQuest(Session, QuestType.FURNI_PLACE);
if (FinalizedPosition.Z > Instance.Model.Heightmap.FloorHeight[FinalizedPosition.X, FinalizedPosition.Y])
{
QuestManager.ProgressUserQuest(Session, QuestType.FURNI_STACK);
}
}
break;
case ItemType.WallItem:
string[] CorrectedData = new string[Data.Length - 1];
for (int i = 1; i < Data.Length; i++)
{
CorrectedData[i - 1] = Data[i];
}
string WallPos = Instance.SetWallItem(Session, CorrectedData, Item);
if (WallPos.Length > 0)
{
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Item.MoveToRoom(MySqlClient, Instance.RoomId, new Vector3(0, 0, 0), 0, WallPos);
}
Session.InventoryCache.RemoveItem(Item.Id);
Session.SendData(InventoryItemRemovedComposer.Compose(Item.Id));
ItemEventDispatcher.InvokeItemEventHandler(Session, Item, Instance, ItemEventType.Placed);
Instance.BroadcastMessage(RoomWallItemPlacedComposer.Compose(Item));
if (IsPlacingGuestStickie)
{
Instance.GiveTemporaryStickieRights(Item.Id, Session.CharacterId);
Session.SendData(StickyDataComposer.Compose(Item));
}
}
break;
}
}