/// <summary>
/// Queues the active room add.
/// </summary>
/// <param name="data">The data.</param>
internal void QueueActiveRoomAdd(RoomData data)
{
lock (_activeRoomsAddQueue.SyncRoot)
{
_activeRoomsAddQueue.Enqueue(data);
}
}
/// <summary>
/// Queues the vote remove.
/// </summary>
/// <param name="data">The data.</param>
internal void QueueVoteRemove(RoomData data)
{
lock (_votedRoomsRemoveQueue.SyncRoot)
{
_votedRoomsRemoveQueue.Enqueue(data);
}
}
/// <summary>
/// Queues the active room update.
/// </summary>
/// <param name="data">The data.</param>
internal void QueueActiveRoomUpdate(RoomData data)
{
lock (_activeRoomsUpdateQueue.SyncRoot)
{
_activeRoomsUpdateQueue.Enqueue(data);
}
}
/// <summary>
/// Fetches the room data.
/// </summary>
/// <param name="roomId">The room identifier.</param>
/// <param name="dRow">The d row.</param>
/// <returns>RoomData.</returns>
internal RoomData FetchRoomData(uint roomId, DataRow dRow)
{
if (LoadedRoomData.ContainsKey(roomId))
{
LoadedRoomData[roomId].LastUsed = DateTime.Now;
return LoadedRoomData[roomId];
}
RoomData roomData = new RoomData();
roomData.Fill(dRow);
LoadedRoomData.TryAdd(roomId, roomData);
return roomData;
}
/// <summary>
/// Queues the vote add.
/// </summary>
/// <param name="data">The data.</param>
internal void QueueVoteAdd(RoomData data)
{
lock (_votedRoomsAddQueue.SyncRoot)
{
_votedRoomsAddQueue.Enqueue(data);
}
}
/// <summary>
/// Serializes the room tool.
/// </summary>
/// <param name="data">The data.</param>
/// <returns>ServerMessage.</returns>
internal static ServerMessage SerializeRoomTool(RoomData data)
{
Room room = Yupi.GetGame().GetRoomManager().GetRoom(data.Id);
ServerMessage serverMessage = new ServerMessage(LibraryParser.OutgoingRequest("ModerationRoomToolMessageComposer"));
serverMessage.AppendInteger(data.Id);
serverMessage.AppendInteger(data.UsersNow);
if (room != null)
serverMessage.AppendBool(room.GetRoomUserManager().GetRoomUserByHabbo(data.Owner) != null);
else
serverMessage.AppendBool(false);
serverMessage.AppendInteger(room?.RoomData.OwnerId ?? 0);
serverMessage.AppendString(data.Owner);
serverMessage.AppendBool(room != null);
serverMessage.AppendString(data.Name);
serverMessage.AppendString(data.Description);
serverMessage.AppendInteger(data.TagCount);
foreach (string current in data.Tags)
serverMessage.AppendString(current);
serverMessage.AppendBool(false);
return serverMessage;
}
/// <summary>
/// Queues the add event.
/// </summary>
/// <param name="data">The data.</param>
internal void QueueAddEvent(RoomData data)
{
lock (_addQueue.SyncRoot)
_addQueue.Enqueue(data);
}
/// <summary>
/// Queues the add event.
/// </summary>
/// <param name="data">The data.</param>
/// <param name="roomEventCategory">The room event category.</param>
internal void QueueAddEvent(RoomData data, int roomEventCategory)
{
lock (_addQueue.SyncRoot)
_addQueue.Enqueue(data);
_eventCategories[roomEventCategory].QueueAddEvent(data);
}
/// <summary>
/// Queues the remove event.
/// </summary>
/// <param name="data">The data.</param>
/// <param name="roomEventCategory">The room event category.</param>
internal void QueueRemoveEvent(RoomData data, int roomEventCategory)
{
lock (_removeQueue.SyncRoot)
_removeQueue.Enqueue(data);
_eventCategories[roomEventCategory].QueueRemoveEvent(data);
}
/// <summary>
/// Disposes this instance.
/// </summary>
private void Dispose()
{
_mCycleEnded = true;
Yupi.GetGame().GetRoomManager().QueueActiveRoomRemove(RoomData);
using (IQueryAdapter queryReactor = Yupi.GetDatabaseManager().GetQueryReactor())
{
GetRoomItemHandler().SaveFurniture(queryReactor);
queryReactor.RunFastQuery($"UPDATE rooms_data SET users_now=0 WHERE id = {RoomId} LIMIT 1");
}
_processTimer?.Dispose();
_processTimer = null;
RoomData.Tags.Clear();
_roomUserManager.UserList.Clear();
UsersWithRights.Clear();
Bans.Clear();
LoadedGroups.Clear();
RoomData.RoomChat.Clear();
GetWiredHandler().Destroy();
foreach (RoomItem current in GetRoomItemHandler().FloorItems.Values)
current.Destroy();
foreach (RoomItem current2 in GetRoomItemHandler().WallItems.Values)
current2.Destroy();
ActiveTrades.Clear();
RoomData = null;
Yupi.GetGame().GetRoomManager().RemoveRoomData(RoomId);
}
internal void Start(RoomData data, bool forceLoad = false)
{
InitializeFromRoomData(data, forceLoad);
GetRoomItemHandler().LoadFurniture();
GetGameMap().GenerateMaps();
}
/// <summary>
/// Initializes the specified identifier.
/// </summary>
/// <param name="id">The identifier.</param>
/// <param name="roomData">The room data.</param>
/// <param name="rightOverride">if set to <c>true</c> [right override].</param>
/// <param name="wordFilter">The word filter.</param>
/// <param name="forceLoad"></param>
private void Initialize(uint id, RoomData roomData, bool rightOverride, List<string> wordFilter, bool forceLoad)
{
RoomData = roomData;
Disposed = false;
RoomId = id;
Bans = new Dictionary<long, double>();
MutedUsers = new Dictionary<uint, uint>();
ActiveTrades = new ArrayList();
MutedBots = false;
MutedPets = false;
_mCycleEnded = false;
EveryoneGotRights = rightOverride;
LoadedGroups = new Dictionary<uint, string>();
_roomKick = new Queue();
_idleTime = 0;
RoomMuted = false;
_gameMap = new Gamemap(this);
_roomItemHandler = new RoomItemHandler(this);
_roomUserManager = new RoomUserManager(this);
WordFilter = wordFilter;
LoadRights();
LoadMusic();
LoadBans();
InitUserBots();
if (!forceLoad)
{
_roomThread = new Thread(StartRoomProcessing) {Name = "Room Loader"};
_roomThread.Start();
}
Yupi.GetGame().GetRoomManager().QueueActiveRoomAdd(RoomData);
}
/// <summary>
/// Initializes from room data.
/// </summary>
/// <param name="data">The data.</param>
/// <param name="forceLoad"></param>
private void InitializeFromRoomData(RoomData data, bool forceLoad)
{
Initialize(data.Id, data, data.AllowRightsOverride, data.WordFilter, forceLoad);
}
/// <summary>
/// Queues the remove event.
/// </summary>
/// <param name="data">The data.</param>
internal void QueueRemoveEvent(RoomData data)
{
lock (_removeQueue.SyncRoot)
_removeQueue.Enqueue(data);
}
/// <summary>
/// Queues the active room remove.
/// </summary>
/// <param name="data">The data.</param>
internal void QueueActiveRoomRemove(RoomData data)
{
lock (ActiveRoomsRemoveQueue.SyncRoot)
{
ActiveRoomsRemoveQueue.Enqueue(data);
}
}
/// <summary>
/// Generates the nullable room data.
/// </summary>
/// <param name="roomId">The room identifier.</param>
/// <returns>RoomData.</returns>
internal RoomData GenerateNullableRoomData(uint roomId)
{
if (GenerateRoomData(roomId) != null)
return GenerateRoomData(roomId);
RoomData roomData = new RoomData();
roomData.FillNull(roomId);
return roomData;
}
/// <summary>
/// News the method.
/// </summary>
/// <param name="current2">The current2.</param>
private void NewMethod(RoomData current2)
{
Response.AppendInteger(current2.Id);
Response.AppendString(current2.Name);
Response.AppendBool(false);
}
/// <summary>
/// Generates the room data.
/// </summary>
/// <param name="roomId">The room identifier.</param>
/// <returns>RoomData.</returns>
internal RoomData GenerateRoomData(uint roomId)
{
if (LoadedRoomData.ContainsKey(roomId))
{
LoadedRoomData[roomId].LastUsed = DateTime.Now;
return LoadedRoomData[roomId];
}
if (IsRoomLoaded(roomId))
return GetRoom(roomId).RoomData;
RoomData roomData = new RoomData();
using (IQueryAdapter queryReactor = Yupi.GetDatabaseManager().GetQueryReactor())
{
queryReactor.SetQuery($"SELECT * FROM rooms_data WHERE id = {roomId} LIMIT 1");
DataRow dataRow = queryReactor.GetRow();
if (dataRow == null)
return null;
roomData.Fill(dataRow);
LoadedRoomData.TryAdd(roomId, roomData);
}
return roomData;
}
/// <summary>
/// Serializes the ticket chatlog.
/// </summary>
/// <param name="ticket">The ticket.</param>
/// <param name="roomData">The room data.</param>
/// <param name="timestamp">The timestamp.</param>
/// <returns>ServerMessage.</returns>
/// <exception cref="System.NullReferenceException">No room found.</exception>
internal static ServerMessage SerializeTicketChatlog(SupportTicket ticket, RoomData roomData, double timestamp)
{
ServerMessage message = new ServerMessage();
RoomData room = Yupi.GetGame().GetRoomManager().GenerateRoomData(ticket.RoomId);
if (room != null)
{
message.Init(LibraryParser.OutgoingRequest("ModerationToolIssueChatlogMessageComposer"));
message.AppendInteger(ticket.TicketId);
message.AppendInteger(ticket.SenderId);
message.AppendInteger(ticket.ReportedId);
message.AppendInteger(ticket.RoomId);
message.AppendByte(1);
message.AppendShort(2);
message.AppendString("roomName");
message.AppendByte(2);
message.AppendString(ticket.RoomName);
message.AppendString("roomId");
message.AppendByte(1);
message.AppendInteger(ticket.RoomId);
List<Chatlog> tempChatlogs =
room.RoomChat.Reverse().Skip(Math.Max(0, room.RoomChat.Count() - 60)).Take(60).ToList();
message.AppendShort(tempChatlogs.Count);
foreach (Chatlog chatLog in tempChatlogs)
chatLog.Serialize(ref message);
return message;
}
return null;
}
/// <summary>
/// Queues the update event.
/// </summary>
/// <param name="data">The data.</param>
internal void QueueUpdateEvent(RoomData data)
{
lock (_updateQueue.SyncRoot)
_updateQueue.Enqueue(data);
}
