304 lines
12 KiB
C#
304 lines
12 KiB
C#
using System.Linq;
|
|
using Content.Server._White.Radio.Components;
|
|
using Content.Server._White.Radio.EntitySystems;
|
|
using Content.Server.CartridgeLoader;
|
|
using Content.Shared.CartridgeLoader;
|
|
using Content.Shared.PDA;
|
|
using Content.Server.GameTicking;
|
|
using Robust.Shared.Timing;
|
|
using Content.Server.DeviceNetwork.Systems;
|
|
using Content.Shared.DeviceNetwork;
|
|
using Content.Server.Station.Systems;
|
|
using Content.Shared._White.CartridgeLoader.Cartridges;
|
|
using Content.Shared.Inventory;
|
|
using Content.Shared.Mind.Components;
|
|
|
|
namespace Content.Server._White.CartridgeLoader.Cartridges;
|
|
|
|
public sealed class MessagesCartridgeSystem : EntitySystem
|
|
{
|
|
[Dependency] private readonly CartridgeLoaderSystem _cartridgeLoaderSystem = default!;
|
|
[Dependency] private readonly IGameTiming _gameTiming = default!;
|
|
[Dependency] private readonly GameTicker _gameTicker = default!;
|
|
[Dependency] private readonly MessagesServerSystem _messagesServerSystem = default!;
|
|
[Dependency] private readonly DeviceNetworkSystem _deviceNetworkSystem = default!;
|
|
[Dependency] private readonly SingletonDeviceNetServerSystem _singletonServerSystem = default!;
|
|
[Dependency] private readonly StationSystem _stationSystem = default!;
|
|
[Dependency] private readonly InventorySystem _inventorySystem = default!;
|
|
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
SubscribeLocalEvent<MessagesCartridgeComponent, CartridgeMessageEvent>(OnUiMessage);
|
|
SubscribeLocalEvent<MessagesCartridgeComponent, CartridgeUiReadyEvent>(OnUiReady);
|
|
SubscribeLocalEvent<MessagesCartridgeComponent, DeviceNetworkPacketEvent>(OnPacketReceived);
|
|
SubscribeLocalEvent<MessagesCartridgeComponent, CartridgeActivatedEvent>(OnCartActivation);
|
|
SubscribeLocalEvent<MessagesCartridgeComponent, CartridgeDeactivatedEvent>(OnCartDeactivation);
|
|
SubscribeLocalEvent<MessagesCartridgeComponent, CartridgeAddedEvent>(OnCartInsertion);
|
|
SubscribeLocalEvent<MessagesCartridgeComponent, ComponentRemove>(OnRemove);
|
|
|
|
SubscribeLocalEvent<PlayerSpawnCompleteEvent>(OnPlayerSpawned);
|
|
}
|
|
|
|
private void OnPlayerSpawned(PlayerSpawnCompleteEvent ev)
|
|
{
|
|
if (!_inventorySystem.TryGetSlotEntity(ev.Mob, "id", out var pdaUid) || !HasComp<MindContainerComponent>(ev.Mob))
|
|
return;
|
|
MessagesCartridgeComponent? comp = null;
|
|
|
|
var programs = _cartridgeLoaderSystem.GetInstalled(pdaUid.Value);
|
|
var program = programs.ToList().Find(program => TryComp(program, out comp));
|
|
|
|
if (comp == null)
|
|
return;
|
|
|
|
if (!TryComp(program, out CartridgeComponent? cartComponent))
|
|
return;
|
|
|
|
var stationId = _stationSystem.GetOwningStation(pdaUid);
|
|
if (!stationId.HasValue || !_singletonServerSystem.TryGetActiveServerAddress<MessagesServerComponent>(stationId.Value, out var address))
|
|
return;
|
|
|
|
SendName(pdaUid.Value, comp, cartComponent, address);
|
|
}
|
|
|
|
private void OnRemove(EntityUid uid, MessagesCartridgeComponent component, ComponentRemove args)
|
|
{
|
|
if (component.LastServer == null || !TryComp<MessagesServerComponent>(component.LastServer, out var messagesServerComponent) || component.UserUid == null)
|
|
return;
|
|
|
|
messagesServerComponent.Dictionary.Remove(component.UserUid.Value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// This gets called when the ui fragment needs to be updated for the first time after activating
|
|
/// </summary>
|
|
private void OnUiReady(EntityUid uid, MessagesCartridgeComponent component, CartridgeUiReadyEvent args)
|
|
{
|
|
var stationId = _stationSystem.GetOwningStation(uid);
|
|
if (stationId.HasValue && _singletonServerSystem.TryGetActiveServerAddress<MessagesServerComponent>(stationId.Value, out var address) && TryComp(uid, out CartridgeComponent? cartComponent))
|
|
SendName(uid, component, cartComponent, address);
|
|
|
|
UpdateUiState(uid, component);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The ui messages received here get wrapped by a CartridgeMessageEvent and are relayed from the <see cref="CartridgeLoaderSystem"/>
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The cartridge specific ui message event needs to inherit from the CartridgeMessageEvent
|
|
/// </remarks>
|
|
private void OnUiMessage(EntityUid uid, MessagesCartridgeComponent component, CartridgeMessageEvent args)
|
|
{
|
|
if (args is not MessagesUiMessageEvent messageEvent)
|
|
return;
|
|
|
|
if (messageEvent.Action == MessagesUiAction.Send && HasComp<CartridgeComponent>(uid) && component.UserUid is { } userId && component.ChatUid != null && messageEvent.StringInput != null)
|
|
{
|
|
var stationId = _stationSystem.GetOwningStation(uid);
|
|
if (!stationId.HasValue)
|
|
return;
|
|
|
|
var content = messageEvent.StringInput;
|
|
if (content.Length > 1000)
|
|
content = content.Substring(0, 997) + "...";
|
|
|
|
MessagesMessageData messageData = new()
|
|
{
|
|
SenderId = userId,
|
|
ReceiverId = component.ChatUid.Value,
|
|
Content = content,
|
|
Time = _gameTiming.CurTime.Subtract(_gameTicker.RoundStartTimeSpan)
|
|
};
|
|
var packet = new NetworkPayload()
|
|
{
|
|
[MessagesNetworkKeys.Message] = messageData
|
|
};
|
|
_singletonServerSystem.TryGetActiveServerAddress<MessagesServerComponent>(stationId.Value, out var address);
|
|
_deviceNetworkSystem.QueuePacket(uid, address, packet);
|
|
}
|
|
else
|
|
{
|
|
if (messageEvent.Action == MessagesUiAction.ChangeChat)
|
|
component.ChatUid = messageEvent.TargetChatUid;
|
|
}
|
|
|
|
UpdateUiState(uid, component);
|
|
}
|
|
|
|
/// <summary>
|
|
/// On cart insertion, register as background process.
|
|
/// </summary>
|
|
private void OnCartInsertion(EntityUid uid, MessagesCartridgeComponent component, CartridgeAddedEvent args)
|
|
{
|
|
_cartridgeLoaderSystem.RegisterBackgroundProgram(args.Loader, uid);
|
|
component.UserUid = args.Loader.Id;
|
|
}
|
|
|
|
/// <summary>
|
|
/// On cartridge activation, connect to messages network.
|
|
/// </summary>
|
|
private void OnCartActivation(EntityUid uid, MessagesCartridgeComponent component, CartridgeActivatedEvent args)
|
|
{
|
|
_deviceNetworkSystem.ConnectDevice(uid);
|
|
var stationId = _stationSystem.GetOwningStation(uid);
|
|
if (stationId.HasValue && _singletonServerSystem.TryGetActiveServerAddress<MessagesServerComponent>(stationId.Value, out var address) && TryComp(uid, out CartridgeComponent? cartComponent))
|
|
SendName(uid, component, cartComponent, address);
|
|
}
|
|
|
|
/// <summary>
|
|
/// On cartridge deactivation, disconnect from messages network.
|
|
/// </summary>
|
|
private void OnCartDeactivation(EntityUid uid, MessagesCartridgeComponent component, CartridgeDeactivatedEvent args)
|
|
{
|
|
_deviceNetworkSystem.DisconnectDevice(uid, null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// React and respond to packets from the server
|
|
/// </summary>
|
|
private void OnPacketReceived(EntityUid uid, MessagesCartridgeComponent component, DeviceNetworkPacketEvent args)
|
|
{
|
|
if (!TryComp(uid, out CartridgeComponent? cartComponent))
|
|
return;
|
|
component.LastServer = args.Sender;
|
|
if (args.Data.TryGetValue<MessagesMessageData>(MessagesNetworkKeys.Message, out var message) && cartComponent.LoaderUid != null)
|
|
{
|
|
if (message.ReceiverId == cartComponent.LoaderUid.Value.Id)
|
|
{
|
|
TryGetName(message.SenderId, component, out var name);
|
|
|
|
var subtitleString = Loc.GetString("messages-pda-notification-header", ("name", name));
|
|
|
|
_cartridgeLoaderSystem.SendNotification(
|
|
cartComponent.LoaderUid.Value,
|
|
subtitleString,
|
|
message.Content);
|
|
}
|
|
}
|
|
|
|
UpdateUiState(uid, component);
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the user's name in the storage component.
|
|
/// </summary>
|
|
public void SendName(EntityUid uid, MessagesCartridgeComponent component, CartridgeComponent cartComponent, string? address)
|
|
{
|
|
TryGetMessagesUser(component, cartComponent, out var messagesUser);
|
|
;
|
|
var packet = new NetworkPayload()
|
|
{
|
|
[MessagesNetworkKeys.UserId] = component.UserUid,
|
|
[MessagesNetworkKeys.NewUser] = messagesUser
|
|
};
|
|
|
|
_deviceNetworkSystem.QueuePacket(uid, address, packet);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves the name of the given user from the last contacted server
|
|
/// </summary>
|
|
private void TryGetName(int key, MessagesCartridgeComponent component, out string name)
|
|
{
|
|
if (component.LastServer != null && _messagesServerSystem.TryGetUserFromDict(component.LastServer, key, out var messagesUser))
|
|
{
|
|
name = messagesUser.Name;
|
|
return;
|
|
}
|
|
|
|
name = Loc.GetString("messages-pda-connection-error");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the user's name, job title and job department
|
|
/// </summary>
|
|
private bool TryGetMessagesUser(MessagesCartridgeComponent component, CartridgeComponent cartridgeComponent, out MessagesUserData messagesUserData)
|
|
{
|
|
messagesUserData = new MessagesUserData();
|
|
|
|
if (component.LastServer != null &&
|
|
TryComp<MessagesServerComponent>(component.LastServer, out var messagesServerComponent) &&
|
|
component.UserUid != null)
|
|
messagesUserData = messagesServerComponent.Dictionary[component.UserUid.Value];
|
|
|
|
var pda = cartridgeComponent.LoaderUid;
|
|
if (pda == null)
|
|
return false;
|
|
|
|
var pdaComponent = CompOrNull<PdaComponent>(pda);
|
|
if (pdaComponent?.OwnerName == null)
|
|
return false;
|
|
|
|
messagesUserData.SetMessagesUser(pdaComponent.OwnerName, pdaComponent.OwnerJob, pdaComponent.OwnerDepartment);
|
|
return true;
|
|
}
|
|
|
|
private void UpdateUiState(EntityUid uid, MessagesCartridgeComponent? component = null)
|
|
{
|
|
if (!Resolve(uid, ref component))
|
|
return;
|
|
|
|
if (!TryComp(uid, out CartridgeComponent? cartComponent))
|
|
return;
|
|
|
|
if (cartComponent.LoaderUid == null)
|
|
return;
|
|
|
|
var loaderUid = cartComponent.LoaderUid.Value;
|
|
MessagesUiState state;
|
|
var currentUserId = component.UserUid;
|
|
if (currentUserId == null || component.LastServer == null)
|
|
{
|
|
state = new MessagesUiState(MessagesUiStateMode.Error);
|
|
_cartridgeLoaderSystem.UpdateCartridgeUiState(loaderUid, state);
|
|
return;
|
|
}
|
|
|
|
if (component.ChatUid == null) //if no chat is loaded, list users
|
|
{
|
|
List<(MessagesUserData, int?)> userList = [];
|
|
|
|
var dictionary = _messagesServerSystem.GetNameDict(component.LastServer);
|
|
|
|
foreach (var nameEntry in dictionary.Keys)
|
|
{
|
|
if (nameEntry == currentUserId)
|
|
continue;
|
|
userList.Add((dictionary[nameEntry], nameEntry));
|
|
}
|
|
|
|
userList.Sort((a, b) => TimeSpan.Compare(b.Item1.Messages.LastOrDefault().Time, a.Item1.Messages.LastOrDefault().Time));
|
|
|
|
state = new MessagesUiState(MessagesUiStateMode.UserList, userList);
|
|
}
|
|
else
|
|
{
|
|
List<MessagesMessageData> messageList = []; //Else, list messages from the current chat
|
|
|
|
foreach (var message in _messagesServerSystem.GetMessages(component.LastServer, component.ChatUid.Value, currentUserId.Value))
|
|
{
|
|
if (message.SenderId == component.ChatUid && message.ReceiverId == currentUserId || message.ReceiverId == component.ChatUid && message.SenderId == currentUserId)
|
|
messageList.Add(message);
|
|
}
|
|
|
|
messageList.Sort((a, b) => TimeSpan.Compare(a.Time, b.Time));
|
|
|
|
List<(string, int?)> formattedMessageList = [];
|
|
|
|
foreach (var message in messageList)
|
|
{
|
|
TryGetName(message.SenderId, component, out var name);
|
|
var stationTime = message.Time.Subtract(_gameTicker.RoundStartTimeSpan);
|
|
var content = $"{stationTime:\\[hh\\:mm\\:ss\\]} {name}: {message.Content}";
|
|
formattedMessageList.Add((content, null));
|
|
}
|
|
|
|
TryGetName(component.ChatUid.Value, component, out var user);
|
|
state = new MessagesUiState(MessagesUiStateMode.Chat, null, formattedMessageList, user);
|
|
}
|
|
_cartridgeLoaderSystem.UpdateCartridgeUiState(loaderUid, state);
|
|
}
|
|
}
|