namespace Content.Client.Administration.Components;
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent]
public sealed partial class HeadstandComponent : SharedHeadstandComponent
{
namespace Content.Client.Administration.Components;
-[NetworkedComponent, RegisterComponent]
-public sealed partial class KillSignComponent : SharedKillSignComponent
-{ }
+[RegisterComponent]
+public sealed partial class KillSignComponent : SharedKillSignComponent;
[Dependency] private readonly IPrototypeManager _protoManager = default!;
[Dependency] private readonly AnimationPlayerSystem _animationPlayer = default!;
[Dependency] private readonly SharedAppearanceSystem _appearanceSystem = default!;
+ [Dependency] private readonly SharedUserInterfaceSystem _uiSystem = default!;
public override void Initialize()
{
var query = AllEntityQuery<JukeboxComponent, UserInterfaceComponent>();
- while (query.MoveNext(out _, out var ui))
+ while (query.MoveNext(out var uid, out _, out var ui))
{
- if (!ui.OpenInterfaces.TryGetValue(JukeboxUiKey.Key, out var baseBui) ||
- baseBui is not JukeboxBoundUserInterface bui)
- {
+ if (!_uiSystem.TryGetOpenUi<JukeboxBoundUserInterface>((uid, ui), JukeboxUiKey.Key, out var bui))
continue;
- }
bui.PopulateMusic();
}
private void OnJukeboxAfterState(Entity<JukeboxComponent> ent, ref AfterAutoHandleStateEvent args)
{
- if (!TryComp(ent, out UserInterfaceComponent? ui))
+ if (!_uiSystem.TryGetOpenUi<JukeboxBoundUserInterface>(ent.Owner, JukeboxUiKey.Key, out var bui))
return;
- if (!ui.OpenInterfaces.TryGetValue(JukeboxUiKey.Key, out var baseBui) ||
- baseBui is not JukeboxBoundUserInterface bui)
- {
- return;
- }
-
bui.Reload();
}
namespace Content.Client.Extinguisher;
-[NetworkedComponent, RegisterComponent]
-public sealed partial class FireExtinguisherComponent : SharedFireExtinguisherComponent
-{
-}
+[RegisterComponent]
+public sealed partial class FireExtinguisherComponent : SharedFireExtinguisherComponent;
protected override void Open()
{
base.Open();
- SendMessage(new PdaRequestUpdateInterfaceMessage());
_menu = new PdaMenu();
_menu.OpenCenteredLeft();
_menu.OnClose += Close;
_menu.EjectIdButton.OnPressed += _ =>
{
- SendMessage(new ItemSlotButtonPressedEvent(PdaComponent.PdaIdSlotId));
+ SendPredictedMessage(new ItemSlotButtonPressedEvent(PdaComponent.PdaIdSlotId));
};
_menu.EjectPenButton.OnPressed += _ =>
{
- SendMessage(new ItemSlotButtonPressedEvent(PdaComponent.PdaPenSlotId));
+ SendPredictedMessage(new ItemSlotButtonPressedEvent(PdaComponent.PdaPenSlotId));
};
_menu.EjectPaiButton.OnPressed += _ =>
{
- SendMessage(new ItemSlotButtonPressedEvent(PdaComponent.PdaPaiSlotId));
+ SendPredictedMessage(new ItemSlotButtonPressedEvent(PdaComponent.PdaPaiSlotId));
};
_menu.ActivateMusicButton.OnPressed += _ =>
using Content.Shared.Paper;
-using Robust.Shared.GameStates;
namespace Content.Client.Paper;
-[NetworkedComponent, RegisterComponent]
-public sealed partial class PaperComponent : SharedPaperComponent
-{
-}
+[RegisterComponent]
+public sealed partial class PaperComponent : SharedPaperComponent;
--- /dev/null
+using Content.Shared.Power.Components;
+using Content.Shared.UserInterface;
+using Content.Shared.Wires;
+
+namespace Content.Client.Power;
+
+public sealed class ActivatableUIRequiresPowerSystem : EntitySystem
+{
+ public override void Initialize()
+ {
+ base.Initialize();
+
+ SubscribeLocalEvent<ActivatableUIRequiresPowerComponent, ActivatableUIOpenAttemptEvent>(OnActivate);
+ }
+
+ private void OnActivate(EntityUid uid, ActivatableUIRequiresPowerComponent component, ActivatableUIOpenAttemptEvent args)
+ {
+ // Client can't predict the power properly at the moment so rely upon the server to do it.
+ args.Cancel();
+ }
+}
_storage = _entManager.System<StorageSystem>();
}
+ protected override void Open()
+ {
+ base.Open();
+
+ if (_entManager.TryGetComponent<StorageComponent>(Owner, out var comp))
+ _storage.OpenStorageWindow((Owner, comp));
+ }
+
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
_storage.CloseStorageWindow(Owner);
}
-
- protected override void ReceiveMessage(BoundUserInterfaceMessage message)
- {
- base.ReceiveMessage(message);
-
- if (message is StorageModifyWindowMessage)
- {
- if (_entManager.TryGetComponent<StorageComponent>(Owner, out var comp))
- _storage.OpenStorageWindow((Owner, comp));
- }
- }
}
if (!Resolve(entity, ref entity.Comp, false))
return;
- if (entity.Comp.OpenInterfaces.GetValueOrDefault(StorageComponent.StorageUiKey.Key) is not { } bui)
+ if (entity.Comp.ClientOpenInterfaces.GetValueOrDefault(StorageComponent.StorageUiKey.Key) is not { } bui)
return;
bui.Close();
if (!TryComp(uid, out UserInterfaceComponent? uiComp))
return;
- foreach (var ui in uiComp.OpenInterfaces.Values)
+ foreach (var ui in uiComp.ClientOpenInterfaces.Values)
{
if (ui is StrippableBoundUserInterface stripUi)
stripUi.DirtyMenu();
}
else if (args.Function == ContentKeyFunctions.ActivateItemInWorld)
{
- _entity.EntityNetManager?.SendSystemNetworkMessage(
+ _entity.RaisePredictiveEvent(
new InteractInventorySlotEvent(_entity.GetNetEntity(control.Entity), altInteract: false));
args.Handle();
}
return false;
}
- if (!ui.OpenInterfaces.TryGetValue(key, out bui))
+ if (!ui.ClientOpenInterfaces.TryGetValue(key, out bui))
{
if (shouldSucceed)
Assert.Fail($"Entity {SEntMan.ToPrettyString(SEntMan.GetEntity(target.Value))} does not have an open bui with key {key.GetType()}.{key}.");
anchored: true
- type: UserInterface
interfaces:
- - key: enum.ApcUiKey.Key
- type: ApcBoundUserInterface
+ enum.ApcUiKey.Key:
+ type: ApcBoundUserInterface
- type: AccessReader
access: [['Engineering']]
private void OnDoAfter(EntityUid uid, AccessOverriderComponent component, AccessOverriderDoAfterEvent args)
{
- if (!TryComp(args.User, out ActorComponent? actor))
- return;
-
if (args.Handled || args.Cancelled)
return;
if (args.Args.Target != null)
{
component.TargetAccessReaderId = args.Args.Target.Value;
- _userInterface.TryOpen(uid, AccessOverriderUiKey.Key, actor.PlayerSession);
+ _userInterface.OpenUi(uid, AccessOverriderUiKey.Key, args.User);
UpdateUserInterface(uid, component, args);
}
private void OnWriteToTargetAccessReaderIdMessage(EntityUid uid, AccessOverriderComponent component, WriteToTargetAccessReaderIdMessage args)
{
- if (args.Session.AttachedEntity is not { Valid: true } player)
+ if (args.Actor is not { Valid: true } player)
return;
TryWriteToTargetAccessReaderId(uid, args.AccessList, player, component);
targetLabel,
targetLabelColor);
- _userInterface.TrySetUiState(uid, AccessOverriderUiKey.Key, newState);
+ _userInterface.SetUiState(uid, AccessOverriderUiKey.Key, newState);
}
private List<ProtoId<AccessLevelPrototype>> ConvertAccessHashSetsToList(List<HashSet<ProtoId<AccessLevelPrototype>>> accessHashsets)
{
- List<ProtoId<AccessLevelPrototype>> accessList = new List<ProtoId<AccessLevelPrototype>>();
+ var accessList = new List<ProtoId<AccessLevelPrototype>>();
+
+ if (accessHashsets.Count <= 0)
+ return accessList;
- if (accessHashsets != null && accessHashsets.Any())
+ foreach (var hashSet in accessHashsets)
{
- foreach (HashSet<ProtoId<AccessLevelPrototype>> hashSet in accessHashsets)
- {
- foreach (ProtoId<AccessLevelPrototype> hash in hashSet.ToArray())
- {
- accessList.Add(hash);
- }
- }
+ accessList.AddRange(hashSet);
}
return accessList;
private void AfterUIOpen(EntityUid uid, AgentIDCardComponent component, AfterActivatableUIOpenEvent args)
{
- if (!_uiSystem.TryGetUi(uid, AgentIDCardUiKey.Key, out var ui))
+ if (!_uiSystem.HasUi(uid, AgentIDCardUiKey.Key))
return;
if (!TryComp<IdCardComponent>(uid, out var idCard))
return;
var state = new AgentIDCardBoundUserInterfaceState(idCard.FullName ?? "", idCard.JobTitle ?? "", component.Icons);
- _uiSystem.SetUiState(ui, state, args.Session);
+ _uiSystem.SetUiState(uid, AgentIDCardUiKey.Key, state);
}
private void OnJobChanged(EntityUid uid, AgentIDCardComponent comp, AgentIDCardJobChangedMessage args)
private void OnWriteToTargetIdMessage(EntityUid uid, IdCardConsoleComponent component, WriteToTargetIdMessage args)
{
- if (args.Session.AttachedEntity is not { Valid: true } player)
+ if (args.Actor is not { Valid: true } player)
return;
TryWriteToTargetId(uid, args.FullName, args.JobTitle, args.AccessList, args.JobPrototype, player, component);
Name(targetId));
}
- _userInterface.TrySetUiState(uid, IdCardConsoleUiKey.Key, newState);
+ _userInterface.SetUiState(uid, IdCardConsoleUiKey.Key, newState);
}
/// <summary>
namespace Content.Server.Administration.Components;
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent]
public sealed partial class HeadstandComponent : SharedHeadstandComponent
{
namespace Content.Server.Administration.Components;
-[NetworkedComponent, RegisterComponent]
-public sealed partial class KillSignComponent : SharedKillSignComponent
-{ }
+[RegisterComponent]
+public sealed partial class KillSignComponent : SharedKillSignComponent;
Text = Loc.GetString("configure-verb-get-data-text"),
Icon = new SpriteSpecifier.Texture(new ("/Textures/Interface/VerbIcons/settings.svg.192dpi.png")),
Category = VerbCategory.Debug,
- Act = () => _uiSystem.TryOpen(args.Target, ConfigurationUiKey.Key, actor.PlayerSession)
+ Act = () => _uiSystem.OpenUi(args.Target, ConfigurationUiKey.Key, actor.PlayerSession)
};
args.Verbs.Add(verb);
}
using Content.Shared.Advertise;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
+using ActivatableUIComponent = Content.Shared.UserInterface.ActivatableUIComponent;
namespace Content.Server.Advertise;
if (!Resolve(uid, ref controller))
return;
- if (!_userInterfaceSystem.TryGetUi(uid, AmeControllerUiKey.Key, out var bui))
+ if (!_userInterfaceSystem.HasUi(uid, AmeControllerUiKey.Key))
return;
var state = GetUiState(uid, controller);
- _userInterfaceSystem.SetUiState(bui, state);
+ _userInterfaceSystem.SetUiState(uid, AmeControllerUiKey.Key, state);
controller.NextUIUpdate = _gameTiming.CurTime + controller.UpdateUIPeriod;
}
private void OnUiButtonPressed(EntityUid uid, AmeControllerComponent comp, UiButtonPressedMessage msg)
{
- var user = msg.Session.AttachedEntity;
+ var user = msg.Actor;
if (!Exists(user))
return;
_ => true,
};
- if (!PlayerCanUseController(uid, user!.Value, needsPower, comp))
+ if (!PlayerCanUseController(uid, user, needsPower, comp))
return;
_audioSystem.PlayPvs(comp.ClickSound, uid, AudioParams.Default.WithVolume(-2f));
var materialAmount = _material.GetMaterialAmount(uid, component.RequiredMaterial);
var state = new AnomalyGeneratorUserInterfaceState(component.CooldownEndTime, materialAmount, component.MaterialPerAnomaly);
- _ui.TrySetUiState(uid, AnomalyGeneratorUiKey.Key, state);
+ _ui.SetUiState(uid, AnomalyGeneratorUiKey.Key, state);
}
public void TryGeneratorCreateAnomaly(EntityUid uid, AnomalyGeneratorComponent? component = null)
{
if (component.ScannedAnomaly != args.Anomaly)
continue;
- _ui.TryCloseAll(uid, AnomalyScannerUiKey.Key);
+
+ _ui.CloseUi(uid, AnomalyScannerUiKey.Key);
}
}
Popup.PopupEntity(Loc.GetString("anomaly-scanner-component-scan-complete"), uid);
UpdateScannerWithNewAnomaly(uid, args.Args.Target.Value, component);
- if (TryComp<ActorComponent>(args.Args.User, out var actor)) _ui.TryOpen(uid, AnomalyScannerUiKey.Key, actor.PlayerSession);
+ _ui.OpenUi(uid, AnomalyScannerUiKey.Key, args.User);
args.Handled = true;
}
nextPulse = anomalyComponent.NextPulseTime;
var state = new AnomalyScannerUserInterfaceState(GetScannerMessage(component), nextPulse);
- _ui.TrySetUiState(uid, AnomalyScannerUiKey.Key, state);
+ _ui.SetUiState(uid, AnomalyScannerUiKey.Key, state);
}
public void UpdateScannerWithNewAnomaly(EntityUid scanner, EntityUid anomaly, AnomalyScannerComponent? scannerComp = null, AnomalyComponent? anomalyComp = null)
/// <param name="message">The message to broadcase to all players/spectators.</param>
private void SendMessage(BoundUserInterfaceMessage message)
{
- if (_uiSystem.TryGetUi(_owner, BlockGameUiKey.Key, out var bui))
- _uiSystem.SendUiMessage(bui, message);
+ _uiSystem.ServerSendUiMessage(_entityManager.GetEntity(message.Entity), BlockGameUiKey.Key, message);
}
/// <summary>
/// Handles sending a message to a specific player/spectator.
/// </summary>
/// <param name="message">The message to send to a specific player/spectator.</param>
- /// <param name="session">The target recipient.</param>
- private void SendMessage(BoundUserInterfaceMessage message, ICommonSession session)
+ /// <param name="actor">The target recipient.</param>
+ private void SendMessage(BoundUserInterfaceMessage message, EntityUid actor)
{
- if (_uiSystem.TryGetUi(_owner, BlockGameUiKey.Key, out var bui))
- _uiSystem.TrySendUiMessage(bui, message, session);
+ _uiSystem.ServerSendUiMessage(_entityManager.GetEntity(message.Entity), BlockGameUiKey.Key, message, actor);
}
/// <summary>
/// Handles sending the current state of the game to a player that has just opened the UI.
/// </summary>
- /// <param name="session">The target recipient.</param>
- public void UpdateNewPlayerUI(ICommonSession session)
+ /// <param name="actor">The target recipient.</param>
+ public void UpdateNewPlayerUI(EntityUid actor)
{
if (_gameOver)
{
- SendMessage(new BlockGameMessages.BlockGameGameOverScreenMessage(Points, _highScorePlacement?.LocalPlacement, _highScorePlacement?.GlobalPlacement), session);
+ SendMessage(new BlockGameMessages.BlockGameGameOverScreenMessage(Points, _highScorePlacement?.LocalPlacement, _highScorePlacement?.GlobalPlacement), actor);
return;
}
if (Paused)
- SendMessage(new BlockGameMessages.BlockGameSetScreenMessage(BlockGameMessages.BlockGameScreen.Pause, Started), session);
+ SendMessage(new BlockGameMessages.BlockGameSetScreenMessage(BlockGameMessages.BlockGameScreen.Pause, Started), actor);
else
- SendMessage(new BlockGameMessages.BlockGameSetScreenMessage(BlockGameMessages.BlockGameScreen.Game, Started), session);
+ SendMessage(new BlockGameMessages.BlockGameSetScreenMessage(BlockGameMessages.BlockGameScreen.Game, Started), actor);
- FullUpdate(session);
+ FullUpdate(actor);
}
/// <summary>
/// Handles broadcasting the full player-visible game state to a specific player/spectator.
/// </summary>
/// <param name="session">The target recipient.</param>
- private void FullUpdate(ICommonSession session)
+ private void FullUpdate(EntityUid actor)
{
- UpdateFieldUI(session);
- SendNextPieceUpdate(session);
- SendHoldPieceUpdate(session);
- SendLevelUpdate(session);
- SendPointsUpdate(session);
- SendHighscoreUpdate(session);
+ UpdateFieldUI(actor);
+ SendNextPieceUpdate(actor);
+ SendHoldPieceUpdate(actor);
+ SendLevelUpdate(actor);
+ SendPointsUpdate(actor);
+ SendHighscoreUpdate(actor);
}
/// <summary>
/// <summary>
/// Handles broadcasting the current location of all of the blocks in the playfield + the active piece to a specific player/spectator.
/// </summary>
- /// <param name="session">The target recipient.</param>
- public void UpdateFieldUI(ICommonSession session)
+ public void UpdateFieldUI(EntityUid actor)
{
if (!Started)
return;
var computedField = ComputeField();
- SendMessage(new BlockGameMessages.BlockGameVisualUpdateMessage(computedField.ToArray(), BlockGameMessages.BlockGameVisualType.GameField), session);
+ SendMessage(new BlockGameMessages.BlockGameVisualUpdateMessage(computedField.ToArray(), BlockGameMessages.BlockGameVisualType.GameField), actor);
}
/// <summary>
/// <summary>
/// Broadcasts the state of the next queued piece to a specific viewer.
/// </summary>
- /// <param name="session">The target recipient.</param>
- private void SendNextPieceUpdate(ICommonSession session)
+ private void SendNextPieceUpdate(EntityUid actor)
{
- SendMessage(new BlockGameMessages.BlockGameVisualUpdateMessage(NextPiece.BlocksForPreview(), BlockGameMessages.BlockGameVisualType.NextBlock), session);
+ SendMessage(new BlockGameMessages.BlockGameVisualUpdateMessage(NextPiece.BlocksForPreview(), BlockGameMessages.BlockGameVisualType.NextBlock), actor);
}
/// <summary>
/// <summary>
/// Broadcasts the state of the currently held piece to a specific viewer.
/// </summary>
- /// <param name="session">The target recipient.</param>
- private void SendHoldPieceUpdate(ICommonSession session)
+ private void SendHoldPieceUpdate(EntityUid actor)
{
if (HeldPiece.HasValue)
- SendMessage(new BlockGameMessages.BlockGameVisualUpdateMessage(HeldPiece.Value.BlocksForPreview(), BlockGameMessages.BlockGameVisualType.HoldBlock), session);
+ SendMessage(new BlockGameMessages.BlockGameVisualUpdateMessage(HeldPiece.Value.BlocksForPreview(), BlockGameMessages.BlockGameVisualType.HoldBlock), actor);
else
- SendMessage(new BlockGameMessages.BlockGameVisualUpdateMessage(Array.Empty<BlockGameBlock>(), BlockGameMessages.BlockGameVisualType.HoldBlock), session);
+ SendMessage(new BlockGameMessages.BlockGameVisualUpdateMessage(Array.Empty<BlockGameBlock>(), BlockGameMessages.BlockGameVisualType.HoldBlock), actor);
}
/// <summary>
/// <summary>
/// Broadcasts the current game level to a specific viewer.
/// </summary>
- /// <param name="session">The target recipient.</param>
- private void SendLevelUpdate(ICommonSession session)
+ private void SendLevelUpdate(EntityUid actor)
{
- SendMessage(new BlockGameMessages.BlockGameLevelUpdateMessage(Level), session);
+ SendMessage(new BlockGameMessages.BlockGameLevelUpdateMessage(Level), actor);
}
/// <summary>
/// <summary>
/// Broadcasts the current game score to a specific viewer.
/// </summary>
- /// <param name="session">The target recipient.</param>
- private void SendPointsUpdate(ICommonSession session)
+ private void SendPointsUpdate(EntityUid actor)
{
- SendMessage(new BlockGameMessages.BlockGameScoreUpdateMessage(Points), session);
+ SendMessage(new BlockGameMessages.BlockGameScoreUpdateMessage(Points), actor);
}
/// <summary>
/// <summary>
/// Broadcasts the current game high score positions to a specific viewer.
/// </summary>
- /// <param name="session">The target recipient.</param>
- private void SendHighscoreUpdate(ICommonSession session)
+ private void SendHighscoreUpdate(EntityUid actor)
{
- SendMessage(new BlockGameMessages.BlockGameHighScoreUpdateMessage(_arcadeSystem.GetLocalHighscores(), _arcadeSystem.GetGlobalHighscores()), session);
+ SendMessage(new BlockGameMessages.BlockGameHighScoreUpdateMessage(_arcadeSystem.GetLocalHighscores(), _arcadeSystem.GetGlobalHighscores()), actor);
}
}
{
[Dependency] private readonly IEntityManager _entityManager = default!;
[Dependency] private readonly IRobustRandom _random = default!;
- private readonly ArcadeSystem _arcadeSystem = default!;
- private readonly UserInterfaceSystem _uiSystem = default!;
+ private readonly ArcadeSystem _arcadeSystem;
+ private readonly UserInterfaceSystem _uiSystem;
/// <summary>
/// What entity is currently hosting this game of NT-BG.
_gameOver = true;
if (_entityManager.TryGetComponent<BlockGameArcadeComponent>(_owner, out var cabinet)
- && _entityManager.TryGetComponent<MetaDataComponent>(cabinet.Player?.AttachedEntity, out var meta))
+ && _entityManager.TryGetComponent<MetaDataComponent>(cabinet.Player, out var meta))
{
_highScorePlacement = _arcadeSystem.RegisterHighScore(meta.EntityName, Points);
SendHighscoreUpdate();
/// <summary>
/// The player currently playing the active session of NT-BG.
/// </summary>
- public ICommonSession? Player = null;
+ public EntityUid? Player = null;
/// <summary>
/// The players currently viewing (but not playing) the active session of NT-BG.
/// </summary>
- public readonly List<ICommonSession> Spectators = new();
+ public readonly List<EntityUid> Spectators = new();
}
}
}
- private void UpdatePlayerStatus(EntityUid uid, ICommonSession session, PlayerBoundUserInterface? bui = null, BlockGameArcadeComponent? blockGame = null)
+ private void UpdatePlayerStatus(EntityUid uid, EntityUid actor, BlockGameArcadeComponent? blockGame = null)
{
if (!Resolve(uid, ref blockGame))
return;
- if (bui == null && !_uiSystem.TryGetUi(uid, BlockGameUiKey.Key, out bui))
- return;
- _uiSystem.TrySendUiMessage(bui, new BlockGameMessages.BlockGameUserStatusMessage(blockGame.Player == session), session);
+ _uiSystem.ServerSendUiMessage(uid, BlockGameUiKey.Key, new BlockGameMessages.BlockGameUserStatusMessage(blockGame.Player == actor), actor);
}
private void OnComponentInit(EntityUid uid, BlockGameArcadeComponent component, ComponentInit args)
private void OnAfterUIOpen(EntityUid uid, BlockGameArcadeComponent component, AfterActivatableUIOpenEvent args)
{
- if (!TryComp<ActorComponent>(args.User, out var actor))
- return;
- if (!_uiSystem.TryGetUi(uid, BlockGameUiKey.Key, out var bui))
- return;
-
- var session = actor.PlayerSession;
- if (!bui.SubscribedSessions.Contains(session))
- return;
-
if (component.Player == null)
- component.Player = session;
+ component.Player = args.Actor;
else
- component.Spectators.Add(session);
+ component.Spectators.Add(args.Actor);
- UpdatePlayerStatus(uid, session, bui, component);
- component.Game?.UpdateNewPlayerUI(session);
+ UpdatePlayerStatus(uid, args.Actor, component);
+ component.Game?.UpdateNewPlayerUI(args.Actor);
}
private void OnAfterUiClose(EntityUid uid, BlockGameArcadeComponent component, BoundUIClosedEvent args)
{
- if (args.Session is not { } session)
- return;
-
- if (component.Player != session)
+ if (component.Player != args.Actor)
{
- component.Spectators.Remove(session);
- UpdatePlayerStatus(uid, session, blockGame: component);
+ component.Spectators.Remove(args.Actor);
+ UpdatePlayerStatus(uid, args.Actor, blockGame: component);
return;
}
if (component.Spectators.Count > 0)
{
component.Player = component.Spectators[0];
- component.Spectators.Remove(component.Player);
- UpdatePlayerStatus(uid, component.Player, blockGame: component);
+ component.Spectators.Remove(component.Player.Value);
+ UpdatePlayerStatus(uid, component.Player.Value, blockGame: component);
}
- UpdatePlayerStatus(uid, temp, blockGame: component);
+ UpdatePlayerStatus(uid, temp.Value, blockGame: component);
}
private void OnBlockPowerChanged(EntityUid uid, BlockGameArcadeComponent component, ref PowerChangedEvent args)
if (args.Powered)
return;
- if (_uiSystem.TryGetUi(uid, BlockGameUiKey.Key, out var bui))
- _uiSystem.CloseAll(bui);
+ _uiSystem.CloseUi(uid, BlockGameUiKey.Key);
component.Player = null;
component.Spectators.Clear();
}
return;
if (!BlockGameUiKey.Key.Equals(msg.UiKey))
return;
- if (msg.Session != component.Player)
+ if (msg.Actor != component.Player)
return;
if (msg.PlayerAction == BlockGamePlayerAction.NewGame)
_audioSystem.PlayPvs(component.NewGameSound, uid, AudioParams.Default.WithVolume(-4f));
component.Game = new SpaceVillainGame(uid, component, this);
- if (_uiSystem.TryGetUi(uid, SpaceVillainArcadeUiKey.Key, out var bui))
- _uiSystem.SendUiMessage(bui, component.Game.GenerateMetaDataMessage());
+ _uiSystem.ServerSendUiMessage(uid, SpaceVillainArcadeUiKey.Key, component.Game.GenerateMetaDataMessage());
break;
case PlayerAction.RequestData:
- if (_uiSystem.TryGetUi(uid, SpaceVillainArcadeUiKey.Key, out bui))
- _uiSystem.SendUiMessage(bui, component.Game.GenerateMetaDataMessage());
+ _uiSystem.ServerSendUiMessage(uid, SpaceVillainArcadeUiKey.Key, component.Game.GenerateMetaDataMessage());
break;
}
}
if (TryComp<ApcPowerReceiverComponent>(uid, out var power) && power.Powered)
return;
- if (_uiSystem.TryGetUi(uid, SpaceVillainArcadeUiKey.Key, out var bui))
- _uiSystem.CloseAll(bui);
+ _uiSystem.CloseUi(uid, SpaceVillainArcadeUiKey.Key);
}
}
/// </summary>
private void UpdateUi(EntityUid uid, bool metadata = false)
{
- if (_uiSystem.TryGetUi(uid, SpaceVillainArcadeUiKey.Key, out var bui))
- _uiSystem.SendUiMessage(bui, metadata ? GenerateMetaDataMessage() : GenerateUpdateMessage());
+ _uiSystem.ServerSendUiMessage(uid, SpaceVillainArcadeUiKey.Key, metadata ? GenerateMetaDataMessage() : GenerateUpdateMessage());
}
private void UpdateUi(EntityUid uid, string message1, string message2, bool metadata = false)
if (!Resolve(uid, ref component))
return;
- if (user != null && TryComp<ActorComponent>(user, out var actor))
- _userInterface.TryClose(uid, GasAnalyzerUiKey.Key, actor.PlayerSession);
+ _userInterface.CloseUi(uid, GasAnalyzerUiKey.Key, user);
component.Enabled = false;
Dirty(uid, component);
/// </summary>
private void OnDisabledMessage(EntityUid uid, GasAnalyzerComponent component, GasAnalyzerDisableMessage message)
{
- if (message.Session.AttachedEntity is not { Valid: true })
- return;
DisableAnalyzer(uid, component);
}
if (!Resolve(uid, ref component, false))
return;
- if (!TryComp<ActorComponent>(user, out var actor))
- return;
-
- _userInterface.TryOpen(uid, GasAnalyzerUiKey.Key, actor.PlayerSession);
+ _userInterface.OpenUi(uid, GasAnalyzerUiKey.Key, user);
}
/// <summary>
if (gasMixList.Count == 0)
return false;
- _userInterface.TrySendUiMessage(uid, GasAnalyzerUiKey.Key,
+ _userInterface.ServerSendUiMessage(uid, GasAnalyzerUiKey.Key,
new GasAnalyzerUserMessage(gasMixList.ToArray(),
component.Target != null ? Name(component.Target.Value) : string.Empty,
GetNetEntity(component.Target) ?? NetEntity.Invalid,
public void UpdateUserInterface(Entity<GasTankComponent> ent, bool initialUpdate = false)
{
var (owner, component) = ent;
- _ui.TrySetUiState(owner, SharedGasTankUiKey.Key,
+ _ui.SetUiState(owner, SharedGasTankUiKey.Key,
new GasTankBoundUserInterfaceState
{
TankPressure = component.Air?.Pressure ?? 0,
public readonly Dictionary<string, GasVentScrubberData> ScrubberData = new();
public readonly Dictionary<string, AtmosSensorData> SensorData = new();
- public HashSet<NetUserId> ActivePlayers = new();
-
public bool CanSync = true;
/// <summary>
private void OnClose(EntityUid uid, AirAlarmComponent component, BoundUIClosedEvent args)
{
- component.ActivePlayers.Remove(args.Session.UserId);
- if (component.ActivePlayers.Count == 0)
+ if (!_ui.IsUiOpen(uid, SharedAirAlarmInterfaceKey.Key))
RemoveActiveInterface(uid);
}
private void OnActivate(EntityUid uid, AirAlarmComponent component, ActivateInWorldEvent args)
{
- if (!TryComp<ActorComponent>(args.User, out var actor))
- return;
-
if (TryComp<WiresPanelComponent>(uid, out var panel) && panel.Open)
{
args.Handled = false;
if (!this.IsPowered(uid, EntityManager))
return;
- var ui = _ui.GetUiOrNull(uid, SharedAirAlarmInterfaceKey.Key);
- if (ui != null)
- _ui.OpenUi(ui, actor.PlayerSession);
- component.ActivePlayers.Add(actor.PlayerSession.UserId);
+ _ui.OpenUi(uid, SharedAirAlarmInterfaceKey.Key, args.User);
AddActiveInterface(uid);
SyncAllDevices(uid);
UpdateUI(uid, component);
private void OnResyncAll(EntityUid uid, AirAlarmComponent component, AirAlarmResyncAllDevicesMessage args)
{
- if (!AccessCheck(uid, args.Session.AttachedEntity, component))
+ if (!AccessCheck(uid, args.Actor, component))
{
return;
}
private void OnUpdateAlarmMode(EntityUid uid, AirAlarmComponent component, AirAlarmUpdateAlarmModeMessage args)
{
- if (AccessCheck(uid, args.Session.AttachedEntity, component))
+ if (AccessCheck(uid, args.Actor, component))
{
var addr = string.Empty;
if (TryComp<DeviceNetworkComponent>(uid, out var netConn))
private void OnUpdateThreshold(EntityUid uid, AirAlarmComponent component, AirAlarmUpdateAlarmThresholdMessage args)
{
- if (AccessCheck(uid, args.Session.AttachedEntity, component))
+ if (AccessCheck(uid, args.Actor, component))
SetThreshold(uid, args.Address, args.Type, args.Threshold, args.Gas);
else
UpdateUI(uid, component);
private void OnUpdateDeviceData(EntityUid uid, AirAlarmComponent component, AirAlarmUpdateDeviceDataMessage args)
{
- if (AccessCheck(uid, args.Session.AttachedEntity, component)
+ if (AccessCheck(uid, args.Actor, component)
&& _deviceList.ExistsInDeviceList(uid, args.Address))
{
SetDeviceData(uid, args.Address, args.Data);
private void OnCopyDeviceData(EntityUid uid, AirAlarmComponent component, AirAlarmCopyDeviceDataMessage args)
{
- if (!AccessCheck(uid, args.Session.AttachedEntity, component))
+ if (!AccessCheck(uid, args.Actor, component))
{
UpdateUI(uid, component);
return;
private void OnAtmosAlarm(EntityUid uid, AirAlarmComponent component, AtmosAlarmEvent args)
{
- if (component.ActivePlayers.Count != 0)
+ if (_ui.IsUiOpen(uid, SharedAirAlarmInterfaceKey.Key))
{
SyncAllDevices(uid);
}
/// </summary>
private void ForceCloseAllInterfaces(EntityUid uid)
{
- _ui.TryCloseAll(uid, SharedAirAlarmInterfaceKey.Key);
+ _ui.CloseUi(uid, SharedAirAlarmInterfaceKey.Key);
}
private void OnAtmosUpdate(EntityUid uid, AirAlarmComponent alarm, ref AtmosDeviceUpdateEvent args)
highestAlarm = AtmosAlarmType.Normal;
}
- _ui.TrySetUiState(
+ _ui.SetUiState(
uid,
SharedAirAlarmInterfaceKey.Key,
new AirAlarmUIState(devNet.Address, deviceCount, pressure, temperature, dataToSend, alarm.CurrentMode, alarm.CurrentTab, highestAlarm.Value, alarm.AutoMode));
UpdateAppearance(uid, pump);
DirtyUI(uid, pump);
- _userInterfaceSystem.TryCloseAll(uid, GasPressurePumpUiKey.Key);
+ _userInterfaceSystem.CloseUi(uid, GasPressurePumpUiKey.Key);
}
private void OnPumpActivate(EntityUid uid, GasPressurePumpComponent pump, ActivateInWorldEvent args)
if (Transform(uid).Anchored)
{
- _userInterfaceSystem.TryOpen(uid, GasPressurePumpUiKey.Key, actor.PlayerSession);
+ _userInterfaceSystem.OpenUi(uid, GasPressurePumpUiKey.Key, actor.PlayerSession);
DirtyUI(uid, pump);
}
else
{
pump.Enabled = args.Enabled;
_adminLogger.Add(LogType.AtmosPowerChanged, LogImpact.Medium,
- $"{ToPrettyString(args.Session.AttachedEntity!.Value):player} set the power on {ToPrettyString(uid):device} to {args.Enabled}");
+ $"{ToPrettyString(args.Actor):player} set the power on {ToPrettyString(uid):device} to {args.Enabled}");
DirtyUI(uid, pump);
UpdateAppearance(uid, pump);
}
{
pump.TargetPressure = Math.Clamp(args.Pressure, 0f, Atmospherics.MaxOutputPressure);
_adminLogger.Add(LogType.AtmosPressureChanged, LogImpact.Medium,
- $"{ToPrettyString(args.Session.AttachedEntity!.Value):player} set the pressure on {ToPrettyString(uid):device} to {args.Pressure}kPa");
+ $"{ToPrettyString(args.Actor):player} set the pressure on {ToPrettyString(uid):device} to {args.Pressure}kPa");
DirtyUI(uid, pump);
}
if (!Resolve(uid, ref pump))
return;
- _userInterfaceSystem.TrySetUiState(uid, GasPressurePumpUiKey.Key,
+ _userInterfaceSystem.SetUiState(uid, GasPressurePumpUiKey.Key,
new GasPressurePumpBoundUserInterfaceState(EntityManager.GetComponent<MetaDataComponent>(uid).EntityName, pump.TargetPressure, pump.Enabled));
}
UpdateAppearance(uid, pump);
DirtyUI(uid, pump);
- _userInterfaceSystem.TryCloseAll(uid, GasVolumePumpUiKey.Key);
+ _userInterfaceSystem.CloseUi(uid, GasVolumePumpUiKey.Key);
}
private void OnPumpActivate(EntityUid uid, GasVolumePumpComponent pump, ActivateInWorldEvent args)
if (Transform(uid).Anchored)
{
- _userInterfaceSystem.TryOpen(uid, GasVolumePumpUiKey.Key, actor.PlayerSession);
+ _userInterfaceSystem.OpenUi(uid, GasVolumePumpUiKey.Key, actor.PlayerSession);
DirtyUI(uid, pump);
}
else
{
pump.Enabled = args.Enabled;
_adminLogger.Add(LogType.AtmosPowerChanged, LogImpact.Medium,
- $"{ToPrettyString(args.Session.AttachedEntity!.Value):player} set the power on {ToPrettyString(uid):device} to {args.Enabled}");
+ $"{ToPrettyString(args.Actor):player} set the power on {ToPrettyString(uid):device} to {args.Enabled}");
DirtyUI(uid, pump);
UpdateAppearance(uid, pump);
}
{
pump.TransferRate = Math.Clamp(args.TransferRate, 0f, pump.MaxTransferRate);
_adminLogger.Add(LogType.AtmosVolumeChanged, LogImpact.Medium,
- $"{ToPrettyString(args.Session.AttachedEntity!.Value):player} set the transfer rate on {ToPrettyString(uid):device} to {args.TransferRate}");
+ $"{ToPrettyString(args.Actor):player} set the transfer rate on {ToPrettyString(uid):device} to {args.TransferRate}");
DirtyUI(uid, pump);
}
if (!Resolve(uid, ref pump))
return;
- _userInterfaceSystem.TrySetUiState(uid, GasVolumePumpUiKey.Key,
+ _userInterfaceSystem.SetUiState(uid, GasVolumePumpUiKey.Key,
new GasVolumePumpBoundUserInterfaceState(Name(uid), pump.TransferRate, pump.Enabled));
}
_ambientSoundSystem.SetAmbience(uid, false);
DirtyUI(uid, filter);
- _userInterfaceSystem.TryCloseAll(uid, GasFilterUiKey.Key);
+ _userInterfaceSystem.CloseUi(uid, GasFilterUiKey.Key);
}
private void OnFilterActivate(EntityUid uid, GasFilterComponent filter, ActivateInWorldEvent args)
if (EntityManager.GetComponent<TransformComponent>(uid).Anchored)
{
- _userInterfaceSystem.TryOpen(uid, GasFilterUiKey.Key, actor.PlayerSession);
+ _userInterfaceSystem.OpenUi(uid, GasFilterUiKey.Key, actor.PlayerSession);
DirtyUI(uid, filter);
}
else
if (!Resolve(uid, ref filter))
return;
- _userInterfaceSystem.TrySetUiState(uid, GasFilterUiKey.Key,
+ _userInterfaceSystem.SetUiState(uid, GasFilterUiKey.Key,
new GasFilterBoundUserInterfaceState(MetaData(uid).EntityName, filter.TransferRate, filter.Enabled, filter.FilteredGas));
}
{
filter.Enabled = args.Enabled;
_adminLogger.Add(LogType.AtmosPowerChanged, LogImpact.Medium,
- $"{ToPrettyString(args.Session.AttachedEntity!.Value):player} set the power on {ToPrettyString(uid):device} to {args.Enabled}");
+ $"{ToPrettyString(args.Actor):player} set the power on {ToPrettyString(uid):device} to {args.Enabled}");
DirtyUI(uid, filter);
UpdateAppearance(uid, filter);
}
{
filter.TransferRate = Math.Clamp(args.Rate, 0f, filter.MaxTransferRate);
_adminLogger.Add(LogType.AtmosVolumeChanged, LogImpact.Medium,
- $"{ToPrettyString(args.Session.AttachedEntity!.Value):player} set the transfer rate on {ToPrettyString(uid):device} to {args.Rate}");
+ $"{ToPrettyString(args.Actor):player} set the transfer rate on {ToPrettyString(uid):device} to {args.Rate}");
DirtyUI(uid, filter);
}
{
filter.FilteredGas = parsedGas;
_adminLogger.Add(LogType.AtmosFilterChanged, LogImpact.Medium,
- $"{ToPrettyString(args.Session.AttachedEntity!.Value):player} set the filter on {ToPrettyString(uid):device} to {parsedGas.ToString()}");
+ $"{ToPrettyString(args.Actor):player} set the filter on {ToPrettyString(uid):device} to {parsedGas.ToString()}");
DirtyUI(uid, filter);
}
else
{
filter.FilteredGas = null;
_adminLogger.Add(LogType.AtmosFilterChanged, LogImpact.Medium,
- $"{ToPrettyString(args.Session.AttachedEntity!.Value):player} set the filter on {ToPrettyString(uid):device} to none");
+ $"{ToPrettyString(args.Actor):player} set the filter on {ToPrettyString(uid):device} to none");
DirtyUI(uid, filter);
}
}
DirtyUI(uid, mixer);
UpdateAppearance(uid, mixer);
- _userInterfaceSystem.TryCloseAll(uid, GasFilterUiKey.Key);
+ _userInterfaceSystem.CloseUi(uid, GasFilterUiKey.Key);
}
private void OnMixerActivate(EntityUid uid, GasMixerComponent mixer, ActivateInWorldEvent args)
if (Transform(uid).Anchored)
{
- _userInterfaceSystem.TryOpen(uid, GasMixerUiKey.Key, actor.PlayerSession);
+ _userInterfaceSystem.OpenUi(uid, GasMixerUiKey.Key, actor.PlayerSession);
DirtyUI(uid, mixer);
}
else
if (!Resolve(uid, ref mixer))
return;
- _userInterfaceSystem.TrySetUiState(uid, GasMixerUiKey.Key,
+ _userInterfaceSystem.SetUiState(uid, GasMixerUiKey.Key,
new GasMixerBoundUserInterfaceState(EntityManager.GetComponent<MetaDataComponent>(uid).EntityName, mixer.TargetPressure, mixer.Enabled, mixer.InletOneConcentration));
}
{
mixer.Enabled = args.Enabled;
_adminLogger.Add(LogType.AtmosPowerChanged, LogImpact.Medium,
- $"{ToPrettyString(args.Session.AttachedEntity!.Value):player} set the power on {ToPrettyString(uid):device} to {args.Enabled}");
+ $"{ToPrettyString(args.Actor):player} set the power on {ToPrettyString(uid):device} to {args.Enabled}");
DirtyUI(uid, mixer);
UpdateAppearance(uid, mixer);
}
{
mixer.TargetPressure = Math.Clamp(args.Pressure, 0f, mixer.MaxTargetPressure);
_adminLogger.Add(LogType.AtmosPressureChanged, LogImpact.Medium,
- $"{ToPrettyString(args.Session.AttachedEntity!.Value):player} set the pressure on {ToPrettyString(uid):device} to {args.Pressure}kPa");
+ $"{ToPrettyString(args.Actor):player} set the pressure on {ToPrettyString(uid):device} to {args.Pressure}kPa");
DirtyUI(uid, mixer);
}
mixer.InletOneConcentration = nodeOne;
mixer.InletTwoConcentration = 1.0f - mixer.InletOneConcentration;
_adminLogger.Add(LogType.AtmosRatioChanged, LogImpact.Medium,
- $"{EntityManager.ToPrettyString(args.Session.AttachedEntity!.Value):player} set the ratio on {EntityManager.ToPrettyString(uid):device} to {mixer.InletOneConcentration}:{mixer.InletTwoConcentration}");
+ $"{EntityManager.ToPrettyString(args.Actor):player} set the ratio on {EntityManager.ToPrettyString(uid):device} to {mixer.InletOneConcentration}:{mixer.InletTwoConcentration}");
DirtyUI(uid, mixer);
}
tankPressure = tankComponent.Air.Pressure;
}
- _ui.TrySetUiState(uid, GasCanisterUiKey.Key,
+ _ui.SetUiState(uid, GasCanisterUiKey.Key,
new GasCanisterBoundUserInterfaceState(Name(uid),
canister.Air.Pressure, portStatus, tankLabel, tankPressure, canister.ReleasePressure,
canister.ReleaseValve, canister.MinReleasePressure, canister.MaxReleasePressure));
private void OnHoldingTankEjectMessage(EntityUid uid, GasCanisterComponent canister, GasCanisterHoldingTankEjectMessage args)
{
- if (canister.GasTankSlot.Item == null || args.Session.AttachedEntity == null)
+ if (canister.GasTankSlot.Item == null)
return;
var item = canister.GasTankSlot.Item;
- _slots.TryEjectToHands(uid, canister.GasTankSlot, args.Session.AttachedEntity);
- _adminLogger.Add(LogType.CanisterTankEjected, LogImpact.Medium, $"Player {ToPrettyString(args.Session.AttachedEntity.GetValueOrDefault()):player} ejected tank {ToPrettyString(item):tank} from {ToPrettyString(uid):canister}");
+ _slots.TryEjectToHands(uid, canister.GasTankSlot, args.Actor);
+ _adminLogger.Add(LogType.CanisterTankEjected, LogImpact.Medium, $"Player {ToPrettyString(args.Actor):player} ejected tank {ToPrettyString(item):tank} from {ToPrettyString(uid):canister}");
}
private void OnCanisterChangeReleasePressure(EntityUid uid, GasCanisterComponent canister, GasCanisterChangeReleasePressureMessage args)
{
var pressure = Math.Clamp(args.Pressure, canister.MinReleasePressure, canister.MaxReleasePressure);
- _adminLogger.Add(LogType.CanisterPressure, LogImpact.Medium, $"{ToPrettyString(args.Session.AttachedEntity.GetValueOrDefault()):player} set the release pressure on {ToPrettyString(uid):canister} to {args.Pressure}");
+ _adminLogger.Add(LogType.CanisterPressure, LogImpact.Medium, $"{ToPrettyString(args.Actor):player} set the release pressure on {ToPrettyString(uid):canister} to {args.Pressure}");
canister.ReleasePressure = pressure;
DirtyUI(uid, canister);
impact = canister.GasTankSlot.HasItem ? LogImpact.Medium : LogImpact.High;
var containedGasDict = new Dictionary<Gas, float>();
- var containedGasArray = Gas.GetValues(typeof(Gas));
+ var containedGasArray = Enum.GetValues(typeof(Gas));
for (int i = 0; i < containedGasArray.Length; i++)
{
containedGasDict.Add((Gas)i, canister.Air[i]);
}
- _adminLogger.Add(LogType.CanisterValve, impact, $"{ToPrettyString(args.Session.AttachedEntity.GetValueOrDefault()):player} set the valve on {ToPrettyString(uid):canister} to {args.Valve:valveState} while it contained [{string.Join(", ", containedGasDict)}]");
+ _adminLogger.Add(LogType.CanisterValve, impact, $"{ToPrettyString(args.Actor):player} set the valve on {ToPrettyString(uid):canister} to {args.Valve:valveState} while it contained [{string.Join(", ", containedGasDict)}]");
canister.ReleaseValve = args.Valve;
DirtyUI(uid, canister);
if (args.Handled)
return;
- _ui.TryOpen(uid, GasCanisterUiKey.Key, actor.PlayerSession);
+ _ui.OpenUi(uid, GasCanisterUiKey.Key, actor.PlayerSession);
args.Handled = true;
}
if (CheckLocked(uid, component, args.User))
return;
- _ui.TryOpen(uid, GasCanisterUiKey.Key, actor.PlayerSession);
+ _ui.OpenUi(uid, GasCanisterUiKey.Key, actor.PlayerSession);
args.Handled = true;
}
private void OnToggleMessage(EntityUid uid, GasThermoMachineComponent thermoMachine, GasThermomachineToggleMessage args)
{
var powerState = _power.TogglePower(uid);
- _adminLogger.Add(LogType.AtmosPowerChanged, $"{ToPrettyString(args.Session.AttachedEntity)} turned {(powerState ? "On" : "Off")} {ToPrettyString(uid)}");
+ _adminLogger.Add(LogType.AtmosPowerChanged, $"{ToPrettyString(args.Actor)} turned {(powerState ? "On" : "Off")} {ToPrettyString(uid)}");
DirtyUI(uid, thermoMachine);
}
else
thermoMachine.TargetTemperature = MathF.Max(args.Temperature, thermoMachine.MinTemperature);
thermoMachine.TargetTemperature = MathF.Max(thermoMachine.TargetTemperature, Atmospherics.TCMB);
- _adminLogger.Add(LogType.AtmosTemperatureChanged, $"{ToPrettyString(args.Session.AttachedEntity)} set temperature on {ToPrettyString(uid)} to {thermoMachine.TargetTemperature}");
+ _adminLogger.Add(LogType.AtmosTemperatureChanged, $"{ToPrettyString(args.Actor)} set temperature on {ToPrettyString(uid)} to {thermoMachine.TargetTemperature}");
DirtyUI(uid, thermoMachine);
}
if (!Resolve(uid, ref powerReceiver))
return;
- _userInterfaceSystem.TrySetUiState(uid, ThermomachineUiKey.Key,
- new GasThermomachineBoundUserInterfaceState(thermoMachine.MinTemperature, thermoMachine.MaxTemperature, thermoMachine.TargetTemperature, !powerReceiver.PowerDisabled, IsHeater(thermoMachine)), null, ui);
+ _userInterfaceSystem.SetUiState(uid, ThermomachineUiKey.Key,
+ new GasThermomachineBoundUserInterfaceState(thermoMachine.MinTemperature, thermoMachine.MaxTemperature, thermoMachine.TargetTemperature, !powerReceiver.PowerDisabled, IsHeater(thermoMachine)));
}
private void OnExamined(EntityUid uid, GasThermoMachineComponent thermoMachine, ExaminedEvent args)
{
return;
}
- _userInterfaceSystem.TrySetUiState(uid, SpaceHeaterUiKey.Key,
+ _userInterfaceSystem.SetUiState(uid, SpaceHeaterUiKey.Key,
new SpaceHeaterBoundUserInterfaceState(spaceHeater.MinTemperature, spaceHeater.MaxTemperature, thermoMachine.TargetTemperature, !powerReceiver.PowerDisabled, spaceHeater.Mode, spaceHeater.PowerLevel));
}
using Robust.Shared.Audio;
using Robust.Shared.Audio.Components;
using Robust.Shared.Audio.Systems;
+using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using JukeboxComponent = Content.Shared.Audio.Jukebox.JukeboxComponent;
private void OnJukeboxSetTime(EntityUid uid, JukeboxComponent component, JukeboxSetTimeMessage args)
{
- var offset = (args.Session.Channel.Ping * 1.5f) / 1000f;
- Audio.SetPlaybackPosition(component.AudioStream, args.SongTime + offset);
+ if (TryComp(args.Actor, out ActorComponent? actorComp))
+ {
+ var offset = actorComp.PlayerSession.Channel.Ping * 1.5f / 1000f;
+ Audio.SetPlaybackPosition(component.AudioStream, args.SongTime + offset);
+ }
}
private void OnPowerChanged(Entity<JukeboxComponent> entity, ref PowerChangedEvent args)
private void OnRemoveItemBuiMessage(Entity<CryostorageComponent> ent, ref CryostorageRemoveItemBuiMessage args)
{
var (_, comp) = ent;
- if (args.Session.AttachedEntity is not { } attachedEntity)
- return;
-
+ var attachedEntity = args.Actor;
var cryoContained = GetEntity(args.StoredEntity);
if (!comp.StoredPlayers.Contains(cryoContained) || !IsInPausedMap(cryoContained))
AdminLog.Add(LogType.Action, LogImpact.High,
$"{ToPrettyString(attachedEntity):player} removed item {ToPrettyString(entity)} from cryostorage-contained player " +
$"{ToPrettyString(cryoContained):player}, stored in cryostorage {ToPrettyString(ent)}");
+
_container.TryRemoveFromContainer(entity.Value);
_transform.SetCoordinates(entity.Value, Transform(attachedEntity).Coordinates);
_hands.PickupOrDrop(attachedEntity, entity.Value);
private void UpdateCryostorageUIState(Entity<CryostorageComponent> ent)
{
- var state = new CryostorageBuiState(GetAllContainedData(ent).ToList());
- _ui.TrySetUiState(ent, CryostorageUIKey.Key, state);
+ var state = new CryostorageBuiState(GetAllContainedData(ent));
+ _ui.SetUiState(ent.Owner, CryostorageUIKey.Key, state);
}
private void OnPlayerSpawned(Entity<CryostorageContainedComponent> ent, ref PlayerSpawnCompleteEvent args)
_chatManager.ChatMessageToOne(ChatChannel.Server, msg, msg, uid, false, actor.PlayerSession.Channel);
}
- private IEnumerable<CryostorageContainedPlayerData> GetAllContainedData(Entity<CryostorageComponent> ent)
+ private List<CryostorageContainedPlayerData> GetAllContainedData(Entity<CryostorageComponent> ent)
{
+ var data = new List<CryostorageContainedPlayerData>();
+ data.EnsureCapacity(ent.Comp.StoredPlayers.Count);
+
foreach (var contained in ent.Comp.StoredPlayers)
{
- yield return GetContainedData(contained);
+ data.Add(GetContainedData(contained));
}
+
+ return data;
}
private CryostorageContainedPlayerData GetContainedData(EntityUid uid)
return;
var untilNextSkip = bountyDb.NextSkipTime - _timing.CurTime;
- _uiSystem.TrySetUiState(uid, CargoConsoleUiKey.Bounty, new CargoBountyConsoleState(bountyDb.Bounties, untilNextSkip));
+ _uiSystem.SetUiState(uid, CargoConsoleUiKey.Bounty, new CargoBountyConsoleState(bountyDb.Bounties, untilNextSkip));
}
private void OnPrintLabelMessage(EntityUid uid, CargoBountyConsoleComponent component, BountyPrintLabelMessage args)
if (!TryGetBountyFromId(station, args.BountyId, out var bounty))
return;
- if (args.Session.AttachedEntity is not { Valid: true } mob)
+ if (args.Actor is not { Valid: true } mob)
return;
if (TryComp<AccessReaderComponent>(uid, out var accessReaderComponent) &&
FillBountyDatabase(station);
db.NextSkipTime = _timing.CurTime + db.SkipDelay;
var untilNextSkip = db.NextSkipTime - _timing.CurTime;
- _uiSystem.TrySetUiState(uid, CargoConsoleUiKey.Bounty, new CargoBountyConsoleState(db.Bounties, untilNextSkip));
+ _uiSystem.SetUiState(uid, CargoConsoleUiKey.Bounty, new CargoBountyConsoleState(db.Bounties, untilNextSkip));
_audio.PlayPvs(component.SkipSound, uid);
}
{
if (_station.GetOwningStation(uid) is not { } station ||
!TryComp<StationCargoBountyDatabaseComponent>(station, out var db))
+ {
continue;
+ }
var untilNextSkip = db.NextSkipTime - _timing.CurTime;
- _uiSystem.TrySetUiState(uid, CargoConsoleUiKey.Bounty, new CargoBountyConsoleState(db.Bounties, untilNextSkip), ui: ui);
+ _uiSystem.SetUiState((uid, ui), CargoConsoleUiKey.Bounty, new CargoBountyConsoleState(db.Bounties, untilNextSkip));
}
}
private void OnApproveOrderMessage(EntityUid uid, CargoOrderConsoleComponent component, CargoConsoleApproveOrderMessage args)
{
- if (args.Session.AttachedEntity is not { Valid: true } player)
+ if (args.Actor is not { Valid: true } player)
return;
if (!_accessReaderSystem.IsAllowed(player, uid))
{
- ConsolePopup(args.Session, Loc.GetString("cargo-console-order-not-allowed"));
+ ConsolePopup(args.Actor, Loc.GetString("cargo-console-order-not-allowed"));
PlayDenySound(uid, component);
return;
}
!TryComp(station, out StationDataComponent? stationData) ||
!TryGetOrderDatabase(station, out var orderDatabase))
{
- ConsolePopup(args.Session, Loc.GetString("cargo-console-station-not-found"));
+ ConsolePopup(args.Actor, Loc.GetString("cargo-console-station-not-found"));
PlayDenySound(uid, component);
return;
}
// Invalid order
if (!_protoMan.HasIndex<EntityPrototype>(order.ProductId))
{
- ConsolePopup(args.Session, Loc.GetString("cargo-console-invalid-product"));
+ ConsolePopup(args.Actor, Loc.GetString("cargo-console-invalid-product"));
PlayDenySound(uid, component);
return;
}
// Too many orders, avoid them getting spammed in the UI.
if (amount >= capacity)
{
- ConsolePopup(args.Session, Loc.GetString("cargo-console-too-many"));
+ ConsolePopup(args.Actor, Loc.GetString("cargo-console-too-many"));
PlayDenySound(uid, component);
return;
}
if (cappedAmount != order.OrderQuantity)
{
order.OrderQuantity = cappedAmount;
- ConsolePopup(args.Session, Loc.GetString("cargo-console-snip-snip"));
+ ConsolePopup(args.Actor, Loc.GetString("cargo-console-snip-snip"));
PlayDenySound(uid, component);
}
// Not enough balance
if (cost > bank.Balance)
{
- ConsolePopup(args.Session, Loc.GetString("cargo-console-insufficient-funds", ("cost", cost)));
+ ConsolePopup(args.Actor, Loc.GetString("cargo-console-insufficient-funds", ("cost", cost)));
PlayDenySound(uid, component);
return;
}
if (ev.FulfillmentEntity == null)
{
- ConsolePopup(args.Session, Loc.GetString("cargo-console-unfulfilled"));
+ ConsolePopup(args.Actor, Loc.GetString("cargo-console-unfulfilled"));
PlayDenySound(uid, component);
return;
}
("approverJob", approverJob),
("cost", cost));
_radio.SendRadioMessage(uid, message, component.AnnouncementChannel, uid, escapeMarkup: false);
- ConsolePopup(args.Session, Loc.GetString("cargo-console-trade-station", ("destination", MetaData(ev.FulfillmentEntity.Value).EntityName)));
+ ConsolePopup(args.Actor, Loc.GetString("cargo-console-trade-station", ("destination", MetaData(ev.FulfillmentEntity.Value).EntityName)));
// Log order approval
_adminLogger.Add(LogType.Action, LogImpact.Low,
private void OnAddOrderMessage(EntityUid uid, CargoOrderConsoleComponent component, CargoConsoleAddOrderMessage args)
{
- if (args.Session.AttachedEntity is not { Valid: true } player)
+ if (args.Actor is not { Valid: true } player)
return;
if (args.Amount <= 0)
!TryComp<StationCargoOrderDatabaseComponent>(station, out var orderDatabase) ||
!TryComp<StationBankAccountComponent>(station, out var bankAccount)) return;
- if (_uiSystem.TryGetUi(consoleUid, CargoConsoleUiKey.Orders, out var bui))
+ if (_uiSystem.HasUi(consoleUid, CargoConsoleUiKey.Orders))
{
- _uiSystem.SetUiState(bui, new CargoConsoleInterfaceState(
+ _uiSystem.SetUiState(consoleUid, CargoConsoleUiKey.Orders, new CargoConsoleInterfaceState(
MetaData(station.Value).EntityName,
GetOutstandingOrderCount(orderDatabase),
orderDatabase.Capacity,
}
}
- private void ConsolePopup(ICommonSession session, string text)
+ private void ConsolePopup(EntityUid actor, string text)
{
- _popup.PopupCursor(text, session);
+ _popup.PopupCursor(text, actor);
}
private void PlayDenySound(EntityUid uid, CargoOrderConsoleComponent component)
private void UpdatePalletConsoleInterface(EntityUid uid)
{
- var bui = _uiSystem.GetUi(uid, CargoPalletConsoleUiKey.Sale);
if (Transform(uid).GridUid is not EntityUid gridUid)
{
- _uiSystem.SetUiState(bui,
+ _uiSystem.SetUiState(uid, CargoPalletConsoleUiKey.Sale,
new CargoPalletConsoleInterfaceState(0, 0, false));
return;
}
GetPalletGoods(gridUid, out var toSell, out var amount);
- _uiSystem.SetUiState(bui,
+ _uiSystem.SetUiState(uid, CargoPalletConsoleUiKey.Sale,
new CargoPalletConsoleInterfaceState((int) amount, toSell.Count, true));
}
private void OnPalletUIOpen(EntityUid uid, CargoPalletConsoleComponent component, BoundUIOpenedEvent args)
{
- var player = args.Session.AttachedEntity;
+ var player = args.Actor;
if (player == null)
return;
private void OnPalletAppraise(EntityUid uid, CargoPalletConsoleComponent component, CargoPalletAppraiseMessage args)
{
- var player = args.Session.AttachedEntity;
+ var player = args.Actor;
if (player == null)
return;
var orders = GetProjectedOrders(station ?? EntityUid.Invalid, orderDatabase, shuttle);
var shuttleName = orderDatabase?.Shuttle != null ? MetaData(orderDatabase.Shuttle.Value).EntityName : string.Empty;
- if (_uiSystem.TryGetUi(uid, CargoConsoleUiKey.Shuttle, out var bui))
- _uiSystem.SetUiState(bui, new CargoShuttleConsoleBoundUserInterfaceState(
+ if (_uiSystem.HasUi(uid, CargoConsoleUiKey.Shuttle))
+ _uiSystem.SetUiState(uid, CargoConsoleUiKey.Shuttle, new CargoShuttleConsoleBoundUserInterfaceState(
station != null ? MetaData(station.Value).EntityName : Loc.GetString("cargo-shuttle-console-station-unknown"),
string.IsNullOrEmpty(shuttleName) ? Loc.GetString("cargo-shuttle-console-shuttle-not-found") : shuttleName,
orders
private void OnPalletSale(EntityUid uid, CargoPalletConsoleComponent component, CargoPalletSellMessage args)
{
- var player = args.Session.AttachedEntity;
+ var player = args.Actor;
if (player == null)
return;
- var bui = _uiSystem.GetUi(uid, CargoPalletConsoleUiKey.Sale);
var xform = Transform(uid);
if (xform.GridUid is not EntityUid gridUid)
{
- _uiSystem.SetUiState(bui,
+ _uiSystem.SetUiState(uid, CargoPalletConsoleUiKey.Sale,
new CargoPalletConsoleInterfaceState(0, 0, false));
return;
}
if (!Resolve(loaderUid, ref loader))
return;
- if (!_userInterfaceSystem.TryGetUi(loaderUid, loader.UiKey, out var ui))
+ if (!_userInterfaceSystem.HasUi(loaderUid, loader.UiKey))
return;
var programs = GetAvailablePrograms(loaderUid, loader);
var state = new CartridgeLoaderUiState(programs, GetNetEntity(loader.ActiveProgram));
- _userInterfaceSystem.SetUiState(ui, state, session);
+ _userInterfaceSystem.SetUiState(loaderUid, loader.UiKey, state);
}
/// <summary>
if (!Resolve(loaderUid, ref loader))
return;
- if (_userInterfaceSystem.TryGetUi(loaderUid, loader.UiKey, out var ui))
- _userInterfaceSystem.SetUiState(ui, state, session);
+ if (_userInterfaceSystem.HasUi(loaderUid, loader.UiKey))
+ _userInterfaceSystem.SetUiState(loaderUid, loader.UiKey, state);
}
/// <summary>
chemMaster.Mode, BuildInputContainerInfo(inputContainer), BuildOutputContainerInfo(outputContainer),
bufferReagents, bufferCurrentVolume, chemMaster.PillType, chemMaster.PillDosageLimit, updateLabel);
- _userInterfaceSystem.TrySetUiState(owner, ChemMasterUiKey.Key, state);
+ _userInterfaceSystem.SetUiState(owner, ChemMasterUiKey.Key, state);
}
private void OnSetModeMessage(Entity<ChemMasterComponent> chemMaster, ref ChemMasterSetModeMessage message)
private void OnCreatePillsMessage(Entity<ChemMasterComponent> chemMaster, ref ChemMasterCreatePillsMessage message)
{
- var user = message.Session.AttachedEntity;
+ var user = message.Actor;
var maybeContainer = _itemSlotsSystem.GetItemOrNull(chemMaster, SharedChemMaster.OutputSlotName);
if (maybeContainer is not { Valid: true } container
|| !TryComp(container, out StorageComponent? storage))
pill.PillType = chemMaster.Comp.PillType;
Dirty(item, pill);
- if (user.HasValue)
- {
- // Log pill creation by a user
- _adminLogger.Add(LogType.Action, LogImpact.Low,
- $"{ToPrettyString(user.Value):user} printed {ToPrettyString(item):pill} {SolutionContainerSystem.ToPrettyString(itemSolution.Comp.Solution)}");
- }
- else
- {
- // Log pill creation by magic? This should never happen... right?
- _adminLogger.Add(LogType.Action, LogImpact.Low,
- $"Unknown printed {ToPrettyString(item):pill} {SolutionContainerSystem.ToPrettyString(itemSolution.Comp.Solution)}");
- }
+ // Log pill creation by a user
+ _adminLogger.Add(LogType.Action, LogImpact.Low,
+ $"{ToPrettyString(user):user} printed {ToPrettyString(item):pill} {SharedSolutionContainerSystem.ToPrettyString(itemSolution.Comp.Solution)}");
}
UpdateUiState(chemMaster);
private void OnOutputToBottleMessage(Entity<ChemMasterComponent> chemMaster, ref ChemMasterOutputToBottleMessage message)
{
- var user = message.Session.AttachedEntity;
+ var user = message.Actor;
var maybeContainer = _itemSlotsSystem.GetItemOrNull(chemMaster, SharedChemMaster.OutputSlotName);
if (maybeContainer is not { Valid: true } container
|| !_solutionContainerSystem.TryGetSolution(container, SharedChemMaster.BottleSolutionName, out var soln, out var solution))
_labelSystem.Label(container, message.Label);
_solutionContainerSystem.TryAddSolution(soln.Value, withdrawal);
- if (user.HasValue)
- {
- // Log bottle creation by a user
- _adminLogger.Add(LogType.Action, LogImpact.Low,
- $"{ToPrettyString(user.Value):user} bottled {ToPrettyString(container):bottle} {SolutionContainerSystem.ToPrettyString(solution)}");
- }
- else
- {
- // Log bottle creation by magic? This should never happen... right?
- _adminLogger.Add(LogType.Action, LogImpact.Low,
- $"Unknown bottled {ToPrettyString(container):bottle} {SolutionContainerSystem.ToPrettyString(solution)}");
- }
+ // Log bottle creation by a user
+ _adminLogger.Add(LogType.Action, LogImpact.Low,
+ $"{ToPrettyString(user):user} bottled {ToPrettyString(container):bottle} {SharedSolutionContainerSystem.ToPrettyString(solution)}");
UpdateUiState(chemMaster);
ClickSound(chemMaster);
var inventory = GetInventory(reagentDispenser);
var state = new ReagentDispenserBoundUserInterfaceState(outputContainerInfo, GetNetEntity(outputContainer), inventory, reagentDispenser.Comp.DispenseAmount);
- _userInterfaceSystem.TrySetUiState(reagentDispenser, ReagentDispenserUiKey.Key, state);
+ _userInterfaceSystem.SetUiState(reagentDispenser.Owner, ReagentDispenserUiKey.Key, state);
}
private ContainerInfo? BuildOutputContainerInfo(EntityUid? container)
public void UpdateUserInterface(EntityUid consoleUid, CloningConsoleComponent consoleComponent)
{
- if (!_uiSystem.TryGetUi(consoleUid, CloningConsoleUiKey.Key, out var ui))
+ if (!_uiSystem.HasUi(consoleUid, CloningConsoleUiKey.Key))
return;
if (!_powerReceiverSystem.IsPowered(consoleUid))
{
- _uiSystem.CloseAll(ui);
+ _uiSystem.CloseUis(consoleUid);
return;
}
var newState = GetUserInterfaceState(consoleComponent);
- _uiSystem.SetUiState(ui, newState);
+ _uiSystem.SetUiState(consoleUid, CloningConsoleUiKey.Key, newState);
}
public void TryClone(EntityUid uid, EntityUid cloningPodUid, EntityUid scannerUid, CloningPodComponent? cloningPod = null, MedicalScannerComponent? scannerComp = null, CloningConsoleComponent? consoleComponent = null)
return;
var state = new ChameleonBoundUserInterfaceState(component.Slot, component.Default);
- _uiSystem.TrySetUiState(uid, ChameleonUiKey.Key, state);
+ _uiSystem.SetUiState(uid, ChameleonUiKey.Key, state);
}
/// <summary>
comp.UIUpdateAccumulator -= UIUpdateInterval;
- if (_uiSystem.TryGetUi(uid, CommunicationsConsoleUiKey.Key, out var ui) && ui.SubscribedSessions.Count > 0)
- UpdateCommsConsoleInterface(uid, comp, ui);
+ if (_uiSystem.IsUiOpen(uid, CommunicationsConsoleUiKey.Key))
+ UpdateCommsConsoleInterface(uid, comp);
}
base.Update(frameTime);
/// <summary>
/// Updates the UI for a particular comms console.
/// </summary>
- public void UpdateCommsConsoleInterface(EntityUid uid, CommunicationsConsoleComponent comp, PlayerBoundUserInterface? ui = null)
+ public void UpdateCommsConsoleInterface(EntityUid uid, CommunicationsConsoleComponent comp)
{
- if (ui == null && !_uiSystem.TryGetUi(uid, CommunicationsConsoleUiKey.Key, out ui))
- return;
-
var stationUid = _stationSystem.GetOwningStation(uid);
List<string>? levels = null;
string currentLevel = default!;
}
}
- _uiSystem.SetUiState(ui, new CommunicationsConsoleInterfaceState(
+ _uiSystem.SetUiState(uid, CommunicationsConsoleUiKey.Key, new CommunicationsConsoleInterfaceState(
CanAnnounce(comp),
CanCallOrRecall(comp),
levels,
private void OnSelectAlertLevelMessage(EntityUid uid, CommunicationsConsoleComponent comp, CommunicationsConsoleSelectAlertLevelMessage message)
{
- if (message.Session.AttachedEntity is not { Valid: true } mob)
+ if (message.Actor is not { Valid: true } mob)
return;
if (!CanUse(mob, uid))
{
- _popupSystem.PopupCursor(Loc.GetString("comms-console-permission-denied"), message.Session, PopupType.Medium);
+ _popupSystem.PopupCursor(Loc.GetString("comms-console-permission-denied"), message.Actor, PopupType.Medium);
return;
}
var maxLength = _cfg.GetCVar(CCVars.ChatMaxAnnouncementLength);
var msg = SharedChatSystem.SanitizeAnnouncement(message.Message, maxLength);
var author = Loc.GetString("comms-console-announcement-unknown-sender");
- if (message.Session.AttachedEntity is { Valid: true } mob)
+ if (message.Actor is { Valid: true } mob)
{
if (!CanAnnounce(comp))
{
if (!CanUse(mob, uid))
{
- _popupSystem.PopupEntity(Loc.GetString("comms-console-permission-denied"), uid, message.Session);
+ _popupSystem.PopupEntity(Loc.GetString("comms-console-permission-denied"), uid, message.Actor);
return;
}
comp.AnnouncementCooldownRemaining = comp.Delay;
UpdateCommsConsoleInterface(uid, comp);
- var ev = new CommunicationConsoleAnnouncementEvent(uid, comp, msg, message.Session.AttachedEntity);
+ var ev = new CommunicationConsoleAnnouncementEvent(uid, comp, msg, message.Actor);
RaiseLocalEvent(ref ev);
// allow admemes with vv
{
_chatSystem.DispatchGlobalAnnouncement(msg, title, announcementSound: comp.Sound, colorOverride: comp.Color);
- if (message.Session.AttachedEntity != null)
- _adminLogger.Add(LogType.Chat, LogImpact.Low, $"{ToPrettyString(message.Session.AttachedEntity.Value):player} has sent the following global announcement: {msg}");
-
+ _adminLogger.Add(LogType.Chat, LogImpact.Low, $"{ToPrettyString(message.Actor):player} has sent the following global announcement: {msg}");
return;
}
+
_chatSystem.DispatchStationAnnouncement(uid, msg, title, colorOverride: comp.Color);
- if (message.Session.AttachedEntity != null)
- _adminLogger.Add(LogType.Chat, LogImpact.Low, $"{ToPrettyString(message.Session.AttachedEntity.Value):player} has sent the following station announcement: {msg}");
+ _adminLogger.Add(LogType.Chat, LogImpact.Low, $"{ToPrettyString(message.Actor):player} has sent the following station announcement: {msg}");
+
}
private void OnBroadcastMessage(EntityUid uid, CommunicationsConsoleComponent component, CommunicationsConsoleBroadcastMessage message)
_deviceNetworkSystem.QueuePacket(uid, null, payload, net.TransmitFrequency);
- if (message.Session.AttachedEntity != null)
- _adminLogger.Add(LogType.DeviceNetwork, LogImpact.Low, $"{ToPrettyString(message.Session.AttachedEntity.Value):player} has sent the following broadcast: {message.Message:msg}");
+ _adminLogger.Add(LogType.DeviceNetwork, LogImpact.Low, $"{ToPrettyString(message.Actor):player} has sent the following broadcast: {message.Message:msg}");
}
private void OnCallShuttleMessage(EntityUid uid, CommunicationsConsoleComponent comp, CommunicationsConsoleCallEmergencyShuttleMessage message)
if (!CanCallOrRecall(comp))
return;
- if (message.Session.AttachedEntity is not { Valid: true } mob)
- return;
+ var mob = message.Actor;
if (!CanUse(mob, uid))
{
- _popupSystem.PopupEntity(Loc.GetString("comms-console-permission-denied"), uid, message.Session);
+ _popupSystem.PopupEntity(Loc.GetString("comms-console-permission-denied"), uid, message.Actor);
return;
}
RaiseLocalEvent(ref ev);
if (ev.Cancelled)
{
- _popupSystem.PopupEntity(ev.Reason ?? Loc.GetString("comms-console-shuttle-unavailable"), uid, message.Session);
+ _popupSystem.PopupEntity(ev.Reason ?? Loc.GetString("comms-console-shuttle-unavailable"), uid, message.Actor);
return;
}
if (!CanCallOrRecall(comp))
return;
- if (message.Session.AttachedEntity is not { Valid: true } mob)
- return;
-
- if (!CanUse(mob, uid))
+ if (!CanUse(message.Actor, uid))
{
- _popupSystem.PopupEntity(Loc.GetString("comms-console-permission-denied"), uid, message.Session);
+ _popupSystem.PopupEntity(Loc.GetString("comms-console-permission-denied"), uid, message.Actor);
return;
}
_roundEndSystem.CancelRoundEndCountdown(uid);
- _adminLogger.Add(LogType.Action, LogImpact.Extreme, $"{ToPrettyString(mob):player} has recalled the shuttle.");
+ _adminLogger.Add(LogType.Action, LogImpact.Extreme, $"{ToPrettyString(message.Actor):player} has recalled the shuttle.");
}
}
if (!TryComp(args.Used, out ToolComponent? tool) || !tool.Qualities.Contains(component.QualityNeeded))
return;
- if (!TryComp(args.User, out ActorComponent? actor))
- return;
-
- args.Handled = _uiSystem.TryOpen(uid, ConfigurationUiKey.Key, actor.PlayerSession);
+ args.Handled = _uiSystem.TryOpenUi(uid, ConfigurationUiKey.Key, args.User);
}
private void OnStartup(EntityUid uid, ConfigurationComponent component, ComponentStartup args)
private void UpdateUi(EntityUid uid, ConfigurationComponent component)
{
- if (_uiSystem.TryGetUi(uid, ConfigurationUiKey.Key, out var ui))
- _uiSystem.SetUiState(ui, new ConfigurationBoundUserInterfaceState(component.Config));
+ if (_uiSystem.HasUi(uid, ConfigurationUiKey.Key))
+ _uiSystem.SetUiState(uid, ConfigurationUiKey.Key, new ConfigurationBoundUserInterfaceState(component.Config));
}
private void OnUpdate(EntityUid uid, ConfigurationComponent component, ConfigurationUpdatedMessage args)
if (args.Handled)
return;
- if (!TryComp<ActorComponent>(args.User, out var actor) ||
- !_uiSystem.TryGetUi(uid, SharedCrayonComponent.CrayonUiKey.Key, out var ui))
+ if (!_uiSystem.HasUi(uid, SharedCrayonComponent.CrayonUiKey.Key))
{
return;
}
- _uiSystem.ToggleUi(ui, actor.PlayerSession);
- if (ui.SubscribedSessions.Contains(actor.PlayerSession))
- {
- // Tell the user interface the selected stuff
- _uiSystem.SetUiState(ui, new CrayonBoundUserInterfaceState(component.SelectedState, component.SelectableColor, component.Color));
- }
+ _uiSystem.TryToggleUi(uid, SharedCrayonComponent.CrayonUiKey.Key, args.User);
+ _uiSystem.SetUiState(uid, SharedCrayonComponent.CrayonUiKey.Key, new CrayonBoundUserInterfaceState(component.SelectedState, component.SelectableColor, component.Color));
args.Handled = true;
}
private void OnCrayonDropped(EntityUid uid, CrayonComponent component, DroppedEvent args)
{
- if (TryComp<ActorComponent>(args.User, out var actor))
- _uiSystem.TryClose(uid, SharedCrayonComponent.CrayonUiKey.Key, actor.PlayerSession);
+ // TODO: Use the existing event.
+ _uiSystem.CloseUi(uid, SharedCrayonComponent.CrayonUiKey.Key, args.User);
}
private void UseUpCrayon(EntityUid uid, EntityUid user)
return;
var owningStation = _stationSystem.GetOwningStation(uid);
- if (owningStation == null || ev.Session is not { } session)
+ if (owningStation == null || !TryComp(ev.Actor, out ActorComponent? actorComp))
{
return;
}
- CloseEui(owningStation.Value, session, uid);
+ CloseEui(owningStation.Value, actorComp.PlayerSession, uid);
}
/// <summary>
{
Log.Error(
"{User} tried to open crew manifest from wrong UI: {Key}. Correct owned is {ExpectedKey}",
- msg.Session, msg.UiKey, component.OwnerKey);
+ msg.Actor, msg.UiKey, component.OwnerKey);
return;
}
var owningStation = _stationSystem.GetOwningStation(uid);
- if (owningStation == null || msg.Session is not { } session)
+ if (owningStation == null || !TryComp(msg.Actor, out ActorComponent? actorComp))
{
return;
}
return;
}
- OpenEui(owningStation.Value, session, uid);
+ OpenEui(owningStation.Value, actorComp.PlayerSession, uid);
}
/// <summary>
msg.Status == SecurityStatus.Suspected != (msg.Reason != null))
return;
- if (!CheckSelected(ent, msg.Session, out var mob, out var key))
+ if (!CheckSelected(ent, msg.Actor, out var mob, out var key))
return;
if (!_stationRecords.TryGetRecord<CriminalRecord>(key.Value, out var record) || record.Status == msg.Status)
private void OnAddHistory(Entity<CriminalRecordsConsoleComponent> ent, ref CriminalRecordAddHistory msg)
{
- if (!CheckSelected(ent, msg.Session, out _, out var key))
+ if (!CheckSelected(ent, msg.Actor, out _, out var key))
return;
var line = msg.Line.Trim();
private void OnDeleteHistory(Entity<CriminalRecordsConsoleComponent> ent, ref CriminalRecordDeleteHistory msg)
{
- if (!CheckSelected(ent, msg.Session, out _, out var key))
+ if (!CheckSelected(ent, msg.Actor, out _, out var key))
return;
if (!_criminalRecords.TryDeleteHistory(key.Value, msg.Index))
if (!TryComp<StationRecordsComponent>(owningStation, out var stationRecords))
{
- _ui.TrySetUiState(uid, CriminalRecordsConsoleKey.Key, new CriminalRecordsConsoleState());
+ _ui.SetUiState(uid, CriminalRecordsConsoleKey.Key, new CriminalRecordsConsoleState());
return;
}
state.SelectedKey = id;
}
- _ui.TrySetUiState(uid, CriminalRecordsConsoleKey.Key, state);
+ _ui.SetUiState(uid, CriminalRecordsConsoleKey.Key, state);
}
/// <summary>
/// Boilerplate that most actions use, if they require that a record be selected.
/// Obviously shouldn't be used for selecting records.
/// </summary>
- private bool CheckSelected(Entity<CriminalRecordsConsoleComponent> ent, ICommonSession session,
+ private bool CheckSelected(Entity<CriminalRecordsConsoleComponent> ent, EntityUid user,
[NotNullWhen(true)] out EntityUid? mob, [NotNullWhen(true)] out StationRecordKey? key)
{
key = null;
mob = null;
- if (session.AttachedEntity is not { } user)
- return false;
if (!_access.IsAllowed(user, ent))
{
- _popup.PopupEntity(Loc.GetString("criminal-records-permission-denied"), ent, session);
+ _popup.PopupEntity(Loc.GetString("criminal-records-permission-denied"), ent, user);
return false;
}
{
var time = TryComp<ActiveSignalTimerComponent>(uid, out var active) ? active.TriggerTime : TimeSpan.Zero;
- if (_ui.TryGetUi(uid, SignalTimerUiKey.Key, out var bui))
+ if (_ui.HasUi(uid, SignalTimerUiKey.Key))
{
- _ui.SetUiState(bui, new SignalTimerBoundUserInterfaceState(component.Label,
+ _ui.SetUiState(uid, SignalTimerUiKey.Key, new SignalTimerBoundUserInterfaceState(component.Label,
TimeSpan.FromSeconds(component.Delay).Minutes.ToString("D2"),
TimeSpan.FromSeconds(component.Delay).Seconds.ToString("D2"),
component.CanEditLabel,
_audio.PlayPvs(signalTimer.DoneSound, uid);
_signalSystem.InvokePort(uid, signalTimer.TriggerPort);
- if (_ui.TryGetUi(uid, SignalTimerUiKey.Key, out var bui))
+ if (_ui.HasUi(uid, SignalTimerUiKey.Key))
{
- _ui.SetUiState(bui, new SignalTimerBoundUserInterfaceState(signalTimer.Label,
+ _ui.SetUiState(uid, SignalTimerUiKey.Key, new SignalTimerBoundUserInterfaceState(signalTimer.Label,
TimeSpan.FromSeconds(signalTimer.Delay).Minutes.ToString("D2"),
TimeSpan.FromSeconds(signalTimer.Delay).Seconds.ToString("D2"),
signalTimer.CanEditLabel,
/// <param name="uid">The entity that is interacted with.</param>
private bool IsMessageValid(EntityUid uid, BoundUserInterfaceMessage message)
{
- if (message.Session.AttachedEntity is not { Valid: true } mob)
- return false;
-
- if (!_accessReader.IsAllowed(mob, uid))
+ if (!_accessReader.IsAllowed(message.Actor, uid))
return false;
return true;
continue;
//The network configurator is a handheld device. There can only ever be an ui session open for the player holding the device.
- _uiSystem.TryCloseAll(uid, NetworkConfiguratorUiKey.Configure);
+ _uiSystem.CloseUi(uid, NetworkConfiguratorUiKey.Configure);
}
}
private void OnComponentRemoved(EntityUid uid, DeviceListComponent component, ComponentRemove args)
{
- _uiSystem.TryCloseAll(uid, NetworkConfiguratorUiKey.Configure);
+ _uiSystem.CloseUi(uid, NetworkConfiguratorUiKey.Configure);
}
/// <summary>
return;
- _uiSystem.TryOpen(configuratorUid, NetworkConfiguratorUiKey.Link, actor.PlayerSession);
+ _uiSystem.OpenUi(configuratorUid, NetworkConfiguratorUiKey.Link, actor.PlayerSession);
configurator.DeviceLinkTarget = targetUid;
var sinkAddress = Resolve(sinkUid, ref sinkNetworkComponent, false) ? sinkNetworkComponent.Address : "";
var state = new DeviceLinkUserInterfaceState(sources, sinks, links, sourceAddress, sinkAddress, defaults);
- _uiSystem.TrySetUiState(configuratorUid, NetworkConfiguratorUiKey.Link, state);
+ _uiSystem.SetUiState(configuratorUid, NetworkConfiguratorUiKey.Link, state);
}
/// <summary>
if (Delay(configurator))
return;
- if (!targetUid.HasValue || !TryComp(userUid, out ActorComponent? actor) || !AccessCheck(targetUid.Value, userUid, configurator))
+ if (!targetUid.HasValue || !AccessCheck(targetUid.Value, userUid, configurator))
return;
if (!TryComp(targetUid, out DeviceListComponent? list))
configurator.ActiveDeviceList = targetUid;
Dirty(configuratorUid, configurator);
- if (!_uiSystem.TryGetUi(configuratorUid, NetworkConfiguratorUiKey.Configure, out var bui))
- return;
-
- if (_uiSystem.OpenUi(bui, actor.PlayerSession))
- _uiSystem.SetUiState(bui, new DeviceListUserInterfaceState(
+ if (_uiSystem.TryOpenUi(configuratorUid, NetworkConfiguratorUiKey.Configure, userUid))
+ {
+ _uiSystem.SetUiState(configuratorUid, NetworkConfiguratorUiKey.Configure, new DeviceListUserInterfaceState(
_deviceListSystem.GetDeviceList(configurator.ActiveDeviceList.Value)
.Select(v => (v.Key, MetaData(v.Value).EntityName)).ToHashSet()
));
+ }
}
/// <summary>
component.Devices.Remove(invalidDevice);
}
- if (_uiSystem.TryGetUi(uid, NetworkConfiguratorUiKey.List, out var bui))
- _uiSystem.SetUiState(bui, new NetworkConfiguratorUserInterfaceState(devices));
+ _uiSystem.SetUiState(uid, NetworkConfiguratorUiKey.List, new NetworkConfiguratorUserInterfaceState(devices));
}
/// <summary>
/// </summary>
private void OnRemoveDevice(EntityUid uid, NetworkConfiguratorComponent component, NetworkConfiguratorRemoveDeviceMessage args)
{
- if (component.Devices.TryGetValue(args.Address, out var removedDevice) && args.Session.AttachedEntity != null)
+ if (component.Devices.TryGetValue(args.Address, out var removedDevice))
{
_adminLogger.Add(LogType.DeviceLinking, LogImpact.Low,
- $"{ToPrettyString(args.Session.AttachedEntity.Value):actor} removed buffered device {ToPrettyString(removedDevice):subject} from {ToPrettyString(uid):tool}");
+ $"{ToPrettyString(args.Actor):actor} removed buffered device {ToPrettyString(removedDevice):subject} from {ToPrettyString(uid):tool}");
}
component.Devices.Remove(args.Address);
/// </summary>
private void OnClearDevice(EntityUid uid, NetworkConfiguratorComponent component, NetworkConfiguratorClearDevicesMessage args)
{
- if (args.Session.AttachedEntity != null)
- _adminLogger.Add(LogType.DeviceLinking, LogImpact.Low,
- $"{ToPrettyString(args.Session.AttachedEntity.Value):actor} cleared buffered devices from {ToPrettyString(uid):tool}");
-
+ _adminLogger.Add(LogType.DeviceLinking, LogImpact.Low,
+ $"{ToPrettyString(args.Actor):actor} cleared buffered devices from {ToPrettyString(uid):tool}");
ClearDevices(uid, component);
UpdateListUiState(uid, component);
if (!configurator.ActiveDeviceLink.HasValue || !configurator.DeviceLinkTarget.HasValue)
return;
- if (args.Session.AttachedEntity != null)
- _adminLogger.Add(LogType.DeviceLinking, LogImpact.Low,
- $"{ToPrettyString(args.Session.AttachedEntity.Value):actor} cleared links between {ToPrettyString(configurator.ActiveDeviceLink.Value):subject} and {ToPrettyString(configurator.DeviceLinkTarget.Value):subject2} with {ToPrettyString(uid):tool}");
+ _adminLogger.Add(LogType.DeviceLinking, LogImpact.Low,
+ $"{ToPrettyString(args.Actor):actor} cleared links between {ToPrettyString(configurator.ActiveDeviceLink.Value):subject} and {ToPrettyString(configurator.DeviceLinkTarget.Value):subject2} with {ToPrettyString(uid):tool}");
if (HasComp<DeviceLinkSourceComponent>(configurator.ActiveDeviceLink) && HasComp<DeviceLinkSinkComponent>(configurator.DeviceLinkTarget))
{
if (TryComp(configurator.ActiveDeviceLink, out DeviceLinkSourceComponent? activeSource) && TryComp(configurator.DeviceLinkTarget, out DeviceLinkSinkComponent? targetSink))
{
_deviceLinkSystem.ToggleLink(
- args.Session.AttachedEntity,
+ args.Actor,
configurator.ActiveDeviceLink.Value,
configurator.DeviceLinkTarget.Value,
args.Source, args.Sink,
else if (TryComp(configurator.DeviceLinkTarget, out DeviceLinkSourceComponent? targetSource) && TryComp(configurator.ActiveDeviceLink, out DeviceLinkSinkComponent? activeSink))
{
_deviceLinkSystem.ToggleLink(
- args.Session.AttachedEntity,
+ args.Actor,
configurator.DeviceLinkTarget.Value,
configurator.ActiveDeviceLink.Value,
args.Source, args.Sink,
if (TryComp(configurator.ActiveDeviceLink, out DeviceLinkSourceComponent? activeSource) && TryComp(configurator.DeviceLinkTarget, out DeviceLinkSinkComponent? targetSink))
{
_deviceLinkSystem.SaveLinks(
- args.Session.AttachedEntity,
+ args.Actor,
configurator.ActiveDeviceLink.Value,
configurator.DeviceLinkTarget.Value,
args.Links,
else if (TryComp(configurator.DeviceLinkTarget, out DeviceLinkSourceComponent? targetSource) && TryComp(configurator.ActiveDeviceLink, out DeviceLinkSinkComponent? activeSink))
{
_deviceLinkSystem.SaveLinks(
- args.Session.AttachedEntity,
+ args.Actor,
configurator.DeviceLinkTarget.Value,
configurator.ActiveDeviceLink.Value,
args.Links,
switch (args.ButtonKey)
{
case NetworkConfiguratorButtonKey.Set:
- if (args.Session.AttachedEntity != null)
- _adminLogger.Add(LogType.DeviceLinking, LogImpact.Low,
- $"{ToPrettyString(args.Session.AttachedEntity.Value):actor} set device links to {ToPrettyString(component.ActiveDeviceList.Value):subject} with {ToPrettyString(uid):tool}");
+ _adminLogger.Add(LogType.DeviceLinking, LogImpact.Low,
+ $"{ToPrettyString(args.Actor):actor} set device links to {ToPrettyString(component.ActiveDeviceList.Value):subject} with {ToPrettyString(uid):tool}");
result = _deviceListSystem.UpdateDeviceList(component.ActiveDeviceList.Value, new HashSet<EntityUid>(component.Devices.Values));
break;
case NetworkConfiguratorButtonKey.Add:
- if (args.Session.AttachedEntity != null)
- _adminLogger.Add(LogType.DeviceLinking, LogImpact.Low,
- $"{ToPrettyString(args.Session.AttachedEntity.Value):actor} added device links to {ToPrettyString(component.ActiveDeviceList.Value):subject} with {ToPrettyString(uid):tool}");
+ _adminLogger.Add(LogType.DeviceLinking, LogImpact.Low,
+ $"{ToPrettyString(args.Actor):actor} added device links to {ToPrettyString(component.ActiveDeviceList.Value):subject} with {ToPrettyString(uid):tool}");
result = _deviceListSystem.UpdateDeviceList(component.ActiveDeviceList.Value, new HashSet<EntityUid>(component.Devices.Values), true);
break;
case NetworkConfiguratorButtonKey.Clear:
- if (args.Session.AttachedEntity != null)
- _adminLogger.Add(LogType.DeviceLinking, LogImpact.Low,
- $"{ToPrettyString(args.Session.AttachedEntity.Value):actor} cleared device links from {ToPrettyString(component.ActiveDeviceList.Value):subject} with {ToPrettyString(uid):tool}");
+ _adminLogger.Add(LogType.DeviceLinking, LogImpact.Low,
+ $"{ToPrettyString(args.Actor):actor} cleared device links from {ToPrettyString(component.ActiveDeviceList.Value):subject} with {ToPrettyString(uid):tool}");
result = _deviceListSystem.UpdateDeviceList(component.ActiveDeviceList.Value, new HashSet<EntityUid>());
break;
case NetworkConfiguratorButtonKey.Copy:
- if (args.Session.AttachedEntity != null)
- _adminLogger.Add(LogType.DeviceLinking, LogImpact.Low,
- $"{ToPrettyString(args.Session.AttachedEntity.Value):actor} copied devices from {ToPrettyString(component.ActiveDeviceList.Value):subject} to {ToPrettyString(uid):tool}");
+ _adminLogger.Add(LogType.DeviceLinking, LogImpact.Low,
+ $"{ToPrettyString(args.Actor):actor} copied devices from {ToPrettyString(component.ActiveDeviceList.Value):subject} to {ToPrettyString(uid):tool}");
ClearDevices(uid, component);
_ => "error"
};
- _popupSystem.PopupCursor(Loc.GetString(resultText), args.Session, PopupType.Medium);
- _uiSystem.TrySetUiState(
+ _popupSystem.PopupCursor(Loc.GetString(resultText), args.Actor, PopupType.Medium);
+ _uiSystem.SetUiState(
uid,
NetworkConfiguratorUiKey.Configure,
new DeviceListUserInterfaceState(
args.Handled = true;
UpdateTargetList(uid, component);
- if (_userInterfaceSystem.TryGetUi(uid, MailingUnitUiKey.Key, out var bui))
- _userInterfaceSystem.OpenUi(bui, actor.PlayerSession);
+ _userInterfaceSystem.OpenUi(uid, MailingUnitUiKey.Key, actor.PlayerSession);
}
/// <summary>
return;
var state = new MailingUnitBoundUserInterfaceState(component.DisposalUnitInterfaceState, component.Target, component.TargetList, component.Tag);
- if (_userInterfaceSystem.TryGetUi(uid, MailingUnitUiKey.Key, out var bui))
- _userInterfaceSystem.SetUiState(bui, state);
+ _userInterfaceSystem.SetUiState(uid, MailingUnitUiKey.Key, state);
}
private void OnTargetSelected(EntityUid uid, MailingUnitComponent component, TargetSelectedMessage args)
/// <param name="msg">A user interface message from the client.</param>
private void OnUiAction(EntityUid uid, DisposalRouterComponent router, SharedDisposalRouterComponent.UiActionMessage msg)
{
- if (!EntityManager.EntityExists(msg.Session.AttachedEntity))
+ if (!EntityManager.EntityExists(msg.Actor))
return;
+
if (TryComp<PhysicsComponent>(uid, out var physBody) && physBody.BodyType != BodyType.Static)
return;
private void OnOpenTaggerUI(EntityUid uid, DisposalTaggerComponent tagger, BoundUIOpenedEvent args)
{
- if (_uiSystem.TryGetUi(uid, DisposalTaggerUiKey.Key, out var bui))
+ if (_uiSystem.HasUi(uid, DisposalTaggerUiKey.Key))
{
- _uiSystem.SetUiState(bui,
+ _uiSystem.SetUiState(uid, DisposalTaggerUiKey.Key,
new DisposalTaggerUserInterfaceState(tagger.Tag));
}
}
/// <returns>Returns a <see cref="SharedDisposalRouterComponent.DisposalRouterUserInterfaceState"/></returns>
private void UpdateRouterUserInterface(EntityUid uid, DisposalRouterComponent router)
{
- var bui = _uiSystem.GetUiOrNull(uid, DisposalRouterUiKey.Key);
- if (bui == null)
- return;
-
if (router.Tags.Count <= 0)
{
- _uiSystem.SetUiState(bui, new DisposalRouterUserInterfaceState(""));
+ _uiSystem.SetUiState(uid, DisposalRouterUiKey.Key, new DisposalRouterUserInterfaceState(""));
return;
}
taglist.Remove(taglist.Length - 2, 2);
- _uiSystem.SetUiState(bui, new DisposalRouterUserInterfaceState(taglist.ToString()));
+ _uiSystem.SetUiState(uid, DisposalRouterUiKey.Key, new DisposalRouterUserInterfaceState(taglist.ToString()));
}
private void OnAnchorChange(EntityUid uid, DisposalTubeComponent component, ref AnchorStateChangedEvent args)
#region UI Handlers
private void OnUiButtonPressed(EntityUid uid, SharedDisposalUnitComponent component, SharedDisposalUnitComponent.UiButtonPressedMessage args)
{
- if (args.Session.AttachedEntity is not { Valid: true } player)
+ if (args.Actor is not { Valid: true } player)
{
return;
}
_adminLogger.Add(LogType.Action, LogImpact.Low, $"{ToPrettyString(player):player} hit flush button on {ToPrettyString(uid)}, it's now {(component.Engaged ? "on" : "off")}");
break;
case SharedDisposalUnitComponent.UiButton.Power:
- _power.TogglePower(uid, user: args.Session.AttachedEntity);
+ _power.TogglePower(uid, user: args.Actor);
break;
default:
throw new ArgumentOutOfRangeException($"{ToPrettyString(player):player} attempted to hit a nonexistant button on {ToPrettyString(uid)}");
}
args.Handled = true;
- _ui.TryOpen(uid, SharedDisposalUnitComponent.DisposalUnitUiKey.Key, actor.PlayerSession);
+ _ui.OpenUi(uid, SharedDisposalUnitComponent.DisposalUnitUiKey.Key, actor.PlayerSession);
}
private void OnAfterInteractUsing(EntityUid uid, SharedDisposalUnitComponent component, AfterInteractUsingEvent args)
var compState = GetState(uid, component);
var stateString = Loc.GetString($"disposal-unit-state-{compState}");
var state = new SharedDisposalUnitComponent.DisposalUnitBoundUserInterfaceState(Name(uid), stateString, EstimatedFullPressure(uid, component), powered, component.Engaged);
- _ui.TrySetUiState(uid, SharedDisposalUnitComponent.DisposalUnitUiKey.Key, state);
+ _ui.SetUiState(uid, SharedDisposalUnitComponent.DisposalUnitUiKey.Key, state);
var stateUpdatedEvent = new DisposalUnitUIStateUpdatedEvent(state);
RaiseLocalEvent(uid, stateUpdatedEvent);
QueueAutomaticEngage(uid, component);
- if (TryComp(inserted, out ActorComponent? actor))
- {
- _ui.TryClose(uid, SharedDisposalUnitComponent.DisposalUnitUiKey.Key, actor.PlayerSession);
- }
+ _ui.CloseUi(uid, SharedDisposalUnitComponent.DisposalUnitUiKey.Key, inserted);
// Maybe do pullable instead? Eh still fine.
Joints.RecursiveClearJoints(inserted);
}
var state = new DoorElectronicsConfigurationState(accesses);
- _uiSystem.TrySetUiState(uid, DoorElectronicsConfigurationUiKey.Key, state);
+ _uiSystem.SetUiState(uid, DoorElectronicsConfigurationUiKey.Key, state);
}
private void OnChangeConfiguration(
namespace Content.Server.Extinguisher;
-[NetworkedComponent, RegisterComponent]
+[RegisterComponent]
[Access(typeof(FireExtinguisherSystem))]
public sealed partial class FireExtinguisherComponent : SharedFireExtinguisherComponent
{
using Content.Shared.Eye.Blinding.Systems;
using Robust.Shared.Player;
using Robust.Server.GameObjects;
+using Robust.Shared.Collections;
namespace Content.Server.Eye.Blinding;
if (!args.Blind)
return;
- if (!TryComp<ActorComponent>(uid, out var actor))
- return;
-
- var uiList = _userInterfaceSystem.GetAllUIsForSession(actor.PlayerSession);
- if (uiList == null)
- return;
-
- Queue<PlayerBoundUserInterface> closeList = new(); // foreach collection modified moment
+ var toClose = new ValueList<(EntityUid Entity, Enum Key)>();
- foreach (var ui in uiList)
+ foreach (var bui in _userInterfaceSystem.GetActorUis(uid))
{
- if (HasComp<ActivatableUIRequiresVisionComponent>(ui.Owner))
- closeList.Enqueue(ui);
+ if (HasComp<ActivatableUIRequiresVisionComponent>(bui.Entity))
+ {
+ toClose.Add(bui);
+ }
}
- foreach (var ui in closeList)
+ foreach (var bui in toClose)
{
- _userInterfaceSystem.CloseUi(ui, actor.PlayerSession);
+ _userInterfaceSystem.CloseUi(bui.Entity, bui.Key, uid);
}
}
}
/// </summary>
[ValidatePrototypeId<EntityPrototype>]
private const string DefaultPaperPrototypeId = "Paper";
-
+
[ValidatePrototypeId<EntityPrototype>]
private const string OfficePaperPrototypeId = "PaperOffice";
private void OnSendButtonPressed(EntityUid uid, FaxMachineComponent component, FaxSendMessage args)
{
- Send(uid, component, args.Session.AttachedEntity);
+ Send(uid, component, args.Actor);
}
private void OnRefreshButtonPressed(EntityUid uid, FaxMachineComponent component, FaxRefreshMessage args)
component.SendTimeoutRemaining <= 0 &&
component.InsertingTimeRemaining <= 0;
var state = new FaxUiState(component.FaxName, component.KnownFaxes, canSend, canCopy, isPaperInserted, component.DestinationFaxAddress);
- _userInterface.TrySetUiState(uid, FaxUiKey.Key, state);
+ _userInterface.SetUiState(uid, FaxUiKey.Key, state);
}
/// <summary>
prototype = DefaultPaperPrototypeId;
var name = Loc.GetString("fax-machine-printed-paper-name");
-
+
var printout = new FaxPrintout(args.Content, name, prototype);
component.PrintingQueue.Enqueue(printout);
component.SendTimeoutRemaining += component.SendTimeout;
UpdateUserInterface(uid, component);
- if (args.Session.AttachedEntity != null)
- _adminLogger.Add(LogType.Action, LogImpact.Low,
- $"{ToPrettyString(args.Session.AttachedEntity.Value):actor} added print job to {ToPrettyString(uid):tool} with text: {args.Content}");
- else
- _adminLogger.Add(LogType.Action, LogImpact.Low,
- $"Someone added print job to {ToPrettyString(uid):tool} with text: {args.Content}");
+ _adminLogger.Add(LogType.Action, LogImpact.Low,
+ $"{ToPrettyString(args.Actor):actor} added print job to {ToPrettyString(uid):tool} with text: {args.Content}");
}
/// <summary>
UpdateUserInterface(uid, component);
- if (args.Session.AttachedEntity != null)
- _adminLogger.Add(LogType.Action, LogImpact.Low,
- $"{ToPrettyString(args.Session.AttachedEntity.Value):actor} added copy job to {ToPrettyString(uid):tool} with text: {ToPrettyString(component.PaperSlot.Item):subject}");
+ _adminLogger.Add(LogType.Action, LogImpact.Low,
+ $"{ToPrettyString(args.Actor):actor} added copy job to {ToPrettyString(uid):tool} with text: {ToPrettyString(component.PaperSlot.Item):subject}");
}
/// <summary>
component.PrintCooldown,
component.PrintReadyAt);
- if (!_uiSystem.TrySetUiState(uid, ForensicScannerUiKey.Key, state))
- Log.Warning($"{ToPrettyString(uid)} was unable to set UI state.");
+ _uiSystem.SetUiState(uid, ForensicScannerUiKey.Key, state);
}
private void OnDoAfter(EntityUid uid, ForensicScannerComponent component, DoAfterEvent args)
private void OpenUserInterface(EntityUid user, Entity<ForensicScannerComponent> scanner)
{
- if (!TryComp<ActorComponent>(user, out var actor))
- return;
-
UpdateUserInterface(scanner, scanner.Comp);
- _uiSystem.TryOpen(scanner, ForensicScannerUiKey.Key, actor.PlayerSession);
+ _uiSystem.OpenUi(scanner.Owner, ForensicScannerUiKey.Key, user);
}
private void OnPrint(EntityUid uid, ForensicScannerComponent component, ForensicScannerPrintMessage args)
{
- if (!args.Session.AttachedEntity.HasValue)
- {
- Log.Warning($"{ToPrettyString(uid)} got OnPrint without Session.AttachedEntity");
- return;
- }
-
- var user = args.Session.AttachedEntity.Value;
+ var user = args.Actor;
if (_gameTiming.CurTime < component.PrintReadyAt)
{
// Spawn a piece of paper.
var printed = EntityManager.SpawnEntity(component.MachineOutput, Transform(uid).Coordinates);
- _handsSystem.PickupOrDrop(args.Session.AttachedEntity, printed, checkActionBlocker: false);
+ _handsSystem.PickupOrDrop(args.Actor, printed, checkActionBlocker: false);
if (!HasComp<PaperComponent>(printed))
{
private void OnClear(EntityUid uid, ForensicScannerComponent component, ForensicScannerClearMessage args)
{
- if (!args.Session.AttachedEntity.HasValue)
- return;
-
component.Fingerprints = new();
component.Fibers = new();
component.DNAs = new();
unlockTime
);
- _ui.TrySetUiState(uid, GatewayUiKey.Key, state);
+ _ui.SetUiState(uid, GatewayUiKey.Key, state);
}
private void UpdateAppearance(EntityUid uid)
private void OnOpenPortal(EntityUid uid, GatewayComponent comp, GatewayOpenPortalMessage args)
{
- if (args.Session.AttachedEntity == null || GetNetEntity(uid) == args.Destination ||
+ if (GetNetEntity(uid) == args.Destination ||
!comp.Enabled || !comp.Interactable)
+ {
return;
+ }
// if the gateway has an access reader check it before allowing opening
- var user = args.Session.AttachedEntity.Value;
+ var user = args.Actor;
if (CheckAccess(user, uid, comp))
return;
}
private void SetSwitchedOn(EntityUid uid, GravityGeneratorComponent component, bool on,
- ApcPowerReceiverComponent? powerReceiver = null, ICommonSession? session = null)
+ ApcPowerReceiverComponent? powerReceiver = null, EntityUid? user = null)
{
if (!Resolve(uid, ref powerReceiver))
return;
- if (session is { AttachedEntity: { } })
- _adminLogger.Add(LogType.Action, on ? LogImpact.Medium : LogImpact.High, $"{session:player} set ${ToPrettyString(uid):target} to {(on ? "on" : "off")}");
+ if (user != null)
+ _adminLogger.Add(LogType.Action, on ? LogImpact.Medium : LogImpact.High, $"{ToPrettyString(user)} set ${ToPrettyString(uid):target} to {(on ? "on" : "off")}");
component.SwitchedOn = on;
UpdatePowerState(component, powerReceiver);
private void UpdateUI(Entity<GravityGeneratorComponent, ApcPowerReceiverComponent> ent, float chargeRate)
{
var (_, component, powerReceiver) = ent;
- if (!_uiSystem.IsUiOpen(ent, SharedGravityGeneratorComponent.GravityGeneratorUiKey.Key))
+ if (!_uiSystem.IsUiOpen(ent.Owner, SharedGravityGeneratorComponent.GravityGeneratorUiKey.Key))
return;
var chargeTarget = chargeRate < 0 ? 0 : component.MaxCharge;
chargeEta
);
- _uiSystem.TrySetUiState(
- ent,
+ _uiSystem.SetUiState(
+ ent.Owner,
SharedGravityGeneratorComponent.GravityGeneratorUiKey.Key,
state);
private void OnInteractHand(EntityUid uid, GravityGeneratorComponent component, InteractHandEvent args)
{
- if (!EntityManager.TryGetComponent(args.User, out ActorComponent? actor))
- return;
-
ApcPowerReceiverComponent? powerReceiver = default!;
if (!Resolve(uid, ref powerReceiver))
return;
if (!component.Intact || powerReceiver.PowerReceived < component.IdlePowerUse)
return;
- _uiSystem.TryOpen(uid, SharedGravityGeneratorComponent.GravityGeneratorUiKey.Key, actor.PlayerSession);
+ _uiSystem.OpenUi(uid, SharedGravityGeneratorComponent.GravityGeneratorUiKey.Key, args.User);
component.NeedUIUpdate = true;
}
GravityGeneratorComponent component,
SharedGravityGeneratorComponent.SwitchGeneratorMessage args)
{
- SetSwitchedOn(uid, component, args.On, session:args.Session);
+ SetSwitchedOn(uid, component, args.On, user: args.Actor);
}
}
}
Icon = new SpriteSpecifier.Rsi(new("/Textures/Mobs/Customization/reptilian_parts.rsi"), "tail_smooth"),
Act = () =>
{
- _uiSystem.TryOpen(uid, HumanoidMarkingModifierKey.Key, actor.PlayerSession);
- _uiSystem.TrySetUiState(
+ _uiSystem.OpenUi(uid, HumanoidMarkingModifierKey.Key, actor.PlayerSession);
+ _uiSystem.SetUiState(
uid,
HumanoidMarkingModifierKey.Key,
new HumanoidMarkingModifierState(component.MarkingSet, component.Species,
private void OnBaseLayersSet(EntityUid uid, HumanoidAppearanceComponent component,
HumanoidMarkingModifierBaseLayersSetMessage message)
{
- if (message.Session is not { } player
- || !_adminManager.HasAdminFlag(player, AdminFlags.Fun))
+ if (!_adminManager.HasAdminFlag(message.Actor, AdminFlags.Fun))
{
return;
}
if (message.ResendState)
{
- _uiSystem.TrySetUiState(
+ _uiSystem.SetUiState(
uid,
HumanoidMarkingModifierKey.Key,
new HumanoidMarkingModifierState(component.MarkingSet, component.Species,
private void OnMarkingsSet(EntityUid uid, HumanoidAppearanceComponent component,
HumanoidMarkingModifierMarkingSetMessage message)
{
- if (message.Session is not { } player
- || !_adminManager.HasAdminFlag(player, AdminFlags.Fun))
+ if (!_adminManager.HasAdminFlag(message.Actor, AdminFlags.Fun))
{
return;
}
if (message.ResendState)
{
- _uiSystem.TrySetUiState(
+ _uiSystem.SetUiState(
uid,
HumanoidMarkingModifierKey.Key,
new HumanoidMarkingModifierState(component.MarkingSet, component.Species,
using Content.Server.UserInterface;
using Content.Shared.Instruments;
using Robust.Shared.Player;
+using ActivatableUIComponent = Content.Shared.UserInterface.ActivatableUIComponent;
namespace Content.Server.Instruments;
[ViewVariables] public uint LastSequencerTick = 0;
// TODO Instruments: Make this ECS
- public ICommonSession? InstrumentPlayer =>
+ public EntityUid? InstrumentPlayer =>
_entMan.GetComponentOrNull<ActivatableUIComponent>(Owner)?.CurrentSingleUser
- ?? _entMan.GetComponentOrNull<ActorComponent>(Owner)?.PlayerSession;
+ ?? _entMan.GetComponentOrNull<ActorComponent>(Owner)?.PlayerSession.AttachedEntity;
}
[RegisterComponent]
if (!TryComp(uid, out InstrumentComponent? instrument))
return;
- if (args.SenderSession != instrument.InstrumentPlayer)
+ if (args.SenderSession.AttachedEntity != instrument.InstrumentPlayer)
return;
instrument.Playing = true;
if (!TryComp(uid, out InstrumentComponent? instrument))
return;
- if (args.SenderSession != instrument.InstrumentPlayer)
+ if (args.SenderSession.AttachedEntity != instrument.InstrumentPlayer)
return;
Clean(uid, instrument);
if (!TryComp(uid, out InstrumentComponent? instrument))
return;
- if (args.SenderSession != instrument.InstrumentPlayer)
+ if (args.SenderSession.AttachedEntity != instrument.InstrumentPlayer)
return;
if (master != null)
if (!TryComp(uid, out InstrumentComponent? instrument))
return;
- if (args.SenderSession != instrument.InstrumentPlayer)
+ if (args.SenderSession.AttachedEntity != instrument.InstrumentPlayer)
return;
if (msg.Channel == RobustMidiEvent.PercussionChannel && !instrument.AllowPercussion)
private void OnBoundUIClosed(EntityUid uid, InstrumentComponent component, BoundUIClosedEvent args)
{
if (HasComp<ActiveInstrumentComponent>(uid)
- && _bui.TryGetUi(uid, args.UiKey, out var bui)
- && bui.SubscribedSessions.Count == 0)
+ && !_bui.IsUiOpen(uid, args.UiKey))
{
RemComp<ActiveInstrumentComponent>(uid);
}
var instrumentQuery = EntityManager.GetEntityQuery<InstrumentComponent>();
if (!TryComp(uid, out InstrumentComponent? originInstrument)
- || originInstrument.InstrumentPlayer?.AttachedEntity is not {} originPlayer)
+ || originInstrument.InstrumentPlayer is not {} originPlayer)
return Array.Empty<(NetEntity, string)>();
// It's probably faster to get all possible active instruments than all entities in range
continue;
// We want to use the instrument player's name.
- if (instrument.InstrumentPlayer?.AttachedEntity is not {} playerUid)
+ if (instrument.InstrumentPlayer is not {} playerUid)
continue;
// Maybe a bit expensive but oh well GetBands is queued and has a timer anyway.
return;
if (!instrument.Playing
- || args.SenderSession != instrument.InstrumentPlayer
+ || args.SenderSession.AttachedEntity != instrument.InstrumentPlayer
|| instrument.InstrumentPlayer == null
|| args.SenderSession.AttachedEntity is not { } attached)
{
var entity = GetEntity(request.Entity);
var nearby = GetBands(entity);
- _bui.TrySendUiMessage(entity, request.UiKey, new InstrumentBandResponseBuiMessage(nearby),
- request.Session);
+ _bui.ServerSendUiMessage(entity, request.UiKey, new InstrumentBandResponseBuiMessage(nearby), request.Actor);
}
_bandRequestQueue.Clear();
(instrument.BatchesDropped >= MaxMidiBatchesDropped
|| instrument.LaggedBatches >= MaxMidiLaggedBatches))
{
- if (instrument.InstrumentPlayer?.AttachedEntity is {Valid: true} mob)
+ if (instrument.InstrumentPlayer is {Valid: true} mob)
{
_stuns.TryParalyze(mob, TimeSpan.FromSeconds(1), true);
// Just in case
Clean(uid);
- _bui.TryCloseAll(uid, InstrumentUiKey.Key);
+ _bui.CloseUi(uid, InstrumentUiKey.Key);
}
instrument.Timer += frameTime;
}
}
- public void ToggleInstrumentUi(EntityUid uid, ICommonSession session, InstrumentComponent? component = null)
+ public void ToggleInstrumentUi(EntityUid uid, EntityUid actor, InstrumentComponent? component = null)
{
if (!Resolve(uid, ref component))
return;
- if (_bui.TryGetUi(uid, InstrumentUiKey.Key, out var bui))
- _bui.ToggleUi(bui, session);
+ _bui.TryToggleUi(uid, InstrumentUiKey.Key, actor);
}
public override bool ResolveInstrument(EntityUid uid, ref SharedInstrumentComponent? component)
[Dependency] private readonly SharedContainerSystem _container = default!;
[Dependency] private readonly UserInterfaceSystem _uiSystem = default!;
- public override void Initialize()
- {
- base.Initialize();
-
- SubscribeLocalEvent<BoundUserInterfaceCheckRangeEvent>(HandleUserInterfaceRangeCheck);
- }
-
public override bool CanAccessViaStorage(EntityUid user, EntityUid target)
{
if (Deleted(target))
if (storage.Container?.ID != container.ID)
return false;
- if (!TryComp(user, out ActorComponent? actor))
- return false;
-
// we don't check if the user can access the storage entity itself. This should be handed by the UI system.
- return _uiSystem.SessionHasOpenUi(container.Owner, StorageComponent.StorageUiKey.Key, actor.PlayerSession);
- }
-
- private void HandleUserInterfaceRangeCheck(ref BoundUserInterfaceCheckRangeEvent ev)
- {
- if (ev.Player.AttachedEntity is not { } user || ev.Result == BoundUserInterfaceRangeResult.Fail)
- return;
-
- if (InRangeUnobstructed(user, ev.Target, ev.UserInterface.InteractionRange))
- {
- ev.Result = BoundUserInterfaceRangeResult.Pass;
- }
- else
- {
- ev.Result = BoundUserInterfaceRangeResult.Fail;
- }
+ return _uiSystem.IsUiOpen(container.Owner, StorageComponent.StorageUiKey.Key, user);
}
}
}
SubscribeLocalEvent<MicrowaveComponent, SignalReceivedEvent>(OnSignalReceived);
- SubscribeLocalEvent<MicrowaveComponent, MicrowaveStartCookMessage>((u, c, m) => Wzhzhzh(u, c, m.Session.AttachedEntity));
+ SubscribeLocalEvent<MicrowaveComponent, MicrowaveStartCookMessage>((u, c, m) => Wzhzhzh(u, c, m.Actor));
SubscribeLocalEvent<MicrowaveComponent, MicrowaveEjectMessage>(OnEjectMessage);
SubscribeLocalEvent<MicrowaveComponent, MicrowaveEjectSolidIndexedMessage>(OnEjectIndex);
SubscribeLocalEvent<MicrowaveComponent, MicrowaveSelectCookTimeMessage>(OnSelectTime);
public void UpdateUserInterfaceState(EntityUid uid, MicrowaveComponent component)
{
- var ui = _userInterface.GetUiOrNull(uid, MicrowaveUiKey.Key);
- if (ui == null)
- return;
-
- _userInterface.SetUiState(ui, new MicrowaveUpdateUserInterfaceState(
+ _userInterface.SetUiState(uid, MicrowaveUiKey.Key, new MicrowaveUpdateUserInterfaceState(
GetNetEntityArray(component.Storage.ContainedEntities.ToArray()),
HasComp<ActiveMicrowaveComponent>(uid),
component.CurrentCookTimeButtonIndex,
_solutionContainersSystem.TryAddSolution(containerSoln.Value, solution);
}
- _userInterfaceSystem.TrySendUiMessage(uid, ReagentGrinderUiKey.Key,
+ _userInterfaceSystem.ServerSendUiMessage(uid, ReagentGrinderUiKey.Key,
new ReagentGrinderWorkCompleteMessage());
UpdateUiState(uid);
GetNetEntityArray(inputContainer.ContainedEntities.ToArray()),
containerSolution?.Contents.ToArray()
);
- _userInterfaceSystem.TrySetUiState(uid, ReagentGrinderUiKey.Key, state);
+ _userInterfaceSystem.SetUiState(uid, ReagentGrinderUiKey.Key, state);
}
private void OnStartMessage(Entity<ReagentGrinderComponent> entity, ref ReagentGrinderStartMessage message)
reagentGrinder.AudioStream = _audioSystem.PlayPvs(sound, uid,
AudioParams.Default.WithPitchScale(1 / reagentGrinder.WorkTimeMultiplier)).Value.Entity; //slightly higher pitched
- _userInterfaceSystem.TrySendUiMessage(uid, ReagentGrinderUiKey.Key,
+ _userInterfaceSystem.ServerSendUiMessage(uid, ReagentGrinderUiKey.Key,
new ReagentGrinderWorkStartedMessage(program));
}
private void OnHandLabelerLabelChanged(EntityUid uid, HandLabelerComponent handLabeler, HandLabelerLabelChangedMessage args)
{
- if (args.Session.AttachedEntity is not {Valid: true} player)
+ if (args.Actor is not {Valid: true} player)
return;
var label = args.Label.Trim();
if (!Resolve(uid, ref handLabeler))
return;
- _userInterfaceSystem.TrySetUiState(uid, HandLabelerUiKey.Key,
+ _userInterfaceSystem.SetUiState(uid, HandLabelerUiKey.Key,
new HandLabelerBoundUserInterfaceState(handLabeler.AssignedLabel));
}
}
if (!Resolve(uid, ref component))
return;
- var ui = _uiSys.GetUi(uid, LatheUiKey.Key);
var producing = component.CurrentRecipe ?? component.Queue.FirstOrDefault();
var state = new LatheUpdateState(GetAvailableRecipes(uid, component), component.Queue, producing);
- _uiSys.SetUiState(ui, state);
+ _uiSys.SetUiState(uid, LatheUiKey.Key, state);
}
private void OnGetRecipes(EntityUid uid, TechnologyDatabaseComponent component, LatheGetRecipesEvent args)
else
break;
}
- if (count > 0 && args.Session.AttachedEntity != null)
+ if (count > 0)
{
_adminLogger.Add(LogType.Action, LogImpact.Low,
- $"{ToPrettyString(args.Session.AttachedEntity.Value):player} queued {count} {recipe.Name} at {ToPrettyString(uid):lathe}");
+ $"{ToPrettyString(args.Actor):player} queued {count} {recipe.Name} at {ToPrettyString(uid):lathe}");
}
}
TryStartProducing(uid, component);
using Content.Shared.UserInterface;
using Content.Shared.Lock;
using Content.Server.UserInterface;
+using ActivatableUISystem = Content.Shared.UserInterface.ActivatableUISystem;
namespace Content.Server.Lock.EntitySystems;
public sealed class ActivatableUIRequiresLockSystem : EntitySystem
Subs.BuiEvents<MagicMirrorComponent>(MagicMirrorUiKey.Key, subs =>
{
- subs.Event<BoundUIClosedEvent>(OnUIClosed);
+ subs.Event<BoundUIClosedEvent>(OnUiClosed);
subs.Event<MagicMirrorSelectMessage>(OnMagicMirrorSelect);
subs.Event<MagicMirrorChangeColorMessage>(OnTryMagicMirrorChangeColor);
subs.Event<MagicMirrorAddSlotMessage>(OnTryMagicMirrorAddSlot);
if (!args.CanReach || args.Target == null)
return;
- if (!TryComp<ActorComponent>(args.User, out var actor))
- return;
-
- if (!_uiSystem.TryOpen(mirror.Owner, MagicMirrorUiKey.Key, actor.PlayerSession))
+ if (!_uiSystem.TryOpenUi(mirror.Owner, MagicMirrorUiKey.Key, args.User))
return;
UpdateInterface(mirror.Owner, args.Target.Value, mirror.Comp);
private void OnMagicMirrorSelect(EntityUid uid, MagicMirrorComponent component, MagicMirrorSelectMessage message)
{
- if (component.Target is not { } target || message.Session.AttachedEntity is not { } user)
+ if (component.Target is not { } target)
return;
_doAfterSystem.Cancel(component.DoAfter);
Marking = message.Marking,
};
- _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, user, component.SelectSlotTime, doAfter, uid, target: target, used: uid)
+ _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, message.Actor, component.SelectSlotTime, doAfter, uid, target: target, used: uid)
{
DistanceThreshold = SharedInteractionSystem.InteractionRange,
BreakOnDamage = true,
private void OnTryMagicMirrorChangeColor(EntityUid uid, MagicMirrorComponent component, MagicMirrorChangeColorMessage message)
{
- if (component.Target is not { } target || message.Session.AttachedEntity is not { } user)
+ if (component.Target is not { } target)
return;
_doAfterSystem.Cancel(component.DoAfter);
Colors = message.Colors,
};
- _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, user, component.ChangeSlotTime, doAfter, uid, target: target, used: uid)
+ _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, message.Actor, component.ChangeSlotTime, doAfter, uid, target: target, used: uid)
{
BreakOnDamage = true,
BreakOnMove = true,
private void OnTryMagicMirrorRemoveSlot(EntityUid uid, MagicMirrorComponent component, MagicMirrorRemoveSlotMessage message)
{
- if (component.Target is not { } target || message.Session.AttachedEntity is not { } user)
+ if (component.Target is not { } target)
return;
_doAfterSystem.Cancel(component.DoAfter);
Slot = message.Slot,
};
- _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, user, component.RemoveSlotTime, doAfter, uid, target: target, used: uid)
+ _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, message.Actor, component.RemoveSlotTime, doAfter, uid, target: target, used: uid)
{
DistanceThreshold = SharedInteractionSystem.InteractionRange,
BreakOnDamage = true,
if (component.Target == null)
return;
- if (message.Session.AttachedEntity == null)
- return;
-
_doAfterSystem.Cancel(component.DoAfter);
component.DoAfter = null;
Category = message.Category,
};
- _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, message.Session.AttachedEntity.Value, component.AddSlotTime, doAfter, uid, target: component.Target.Value, used: uid)
+ _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, message.Actor, component.AddSlotTime, doAfter, uid, target: component.Target.Value, used: uid)
{
BreakOnDamage = true,
BreakOnMove = true,
humanoid.MarkingSet.PointsLeft(MarkingCategories.FacialHair) + facialHair.Count);
component.Target = targetUid;
- _uiSystem.TrySetUiState(mirrorUid, MagicMirrorUiKey.Key, state);
+ _uiSystem.SetUiState(mirrorUid, MagicMirrorUiKey.Key, state);
}
- private void OnUIClosed(Entity<MagicMirrorComponent> ent, ref BoundUIClosedEvent args)
+ private void OnUiClosed(Entity<MagicMirrorComponent> ent, ref BoundUIClosedEvent args)
{
ent.Comp.Target = null;
}
if (msg.ArticleNum >= articles.Count)
return;
- if (msg.Session.AttachedEntity is not { } actor)
- return;
-
var article = articles[msg.ArticleNum];
- if (CheckDeleteAccess(article, ent, actor))
+ if (CheckDeleteAccess(article, ent, msg.Actor))
{
_adminLogger.Add(
LogType.Chat, LogImpact.Medium,
- $"{ToPrettyString(actor):actor} deleted news article {article.Title} by {article.Author}: {article.Content}"
+ $"{ToPrettyString(msg.Actor):actor} deleted news article {article.Title} by {article.Author}: {article.Content}"
);
articles.RemoveAt(msg.ArticleNum);
if (!TryGetArticles(ent, out var articles))
return;
- if (msg.Session.AttachedEntity is not { } author)
- return;
-
- if (!_accessReader.FindStationRecordKeys(author, out _))
+ if (!_accessReader.FindStationRecordKeys(msg.Actor, out _))
return;
string? authorName = null;
- if (_idCardSystem.TryFindIdCard(author, out var idCard))
+ if (_idCardSystem.TryFindIdCard(msg.Actor, out var idCard))
authorName = idCard.Comp.FullName;
var title = msg.Title.Trim();
_adminLogger.Add(
LogType.Chat,
LogImpact.Medium,
- $"{ToPrettyString(author):actor} created news article {article.Title} by {article.Author}: {article.Content}"
+ $"{ToPrettyString(msg.Actor):actor} created news article {article.Title} by {article.Author}: {article.Content}"
);
articles.Add(article);
private void UpdateWriterUi(Entity<NewsWriterComponent> ent)
{
- if (!_ui.TryGetUi(ent, NewsWriterUiKey.Key, out var ui))
+ if (!_ui.HasUi(ent, NewsWriterUiKey.Key))
return;
if (!TryGetArticles(ent, out var articles))
return;
var state = new NewsWriterBoundUserInterfaceState(articles.ToArray(), ent.Comp.PublishEnabled, ent.Comp.NextPublish);
- _ui.SetUiState(ui, state);
+ _ui.SetUiState(ent.Owner, NewsWriterUiKey.Key, state);
}
private void UpdateReaderUi(Entity<NewsReaderCartridgeComponent> ent, EntityUid loaderUid)
{
EquipmentStates = ev.States
};
- var ui = _ui.GetUi(uid, MechUiKey.Key);
- _ui.SetUiState(ui, state);
+ _ui.SetUiState(uid, MechUiKey.Key, state);
}
public override void BreakMech(EntityUid uid, MechComponent? component = null)
{
base.BreakMech(uid, component);
- _ui.TryCloseAll(uid, MechUiKey.Key);
+ _ui.CloseUi(uid, MechUiKey.Key);
_actionBlocker.UpdateCanMove(uid);
}
if (!Resolve(uid, ref component))
return;
- if (!_uiSystem.TryGetUi(uid, CrewMonitoringUIKey.Key, out var bui))
+ if (!_uiSystem.IsUiOpen(uid, CrewMonitoringUIKey.Key))
return;
// The grid must have a NavMapComponent to visualize the map in the UI
// Update all sensors info
var allSensors = component.ConnectedSensors.Values.ToList();
- _uiSystem.SetUiState(bui, new CrewMonitoringState(allSensors));
+ _uiSystem.SetUiState(uid, CrewMonitoringUIKey.Key, new CrewMonitoringState(allSensors));
}
}
healthAnalyzer.ScannedEntity = entity.Comp.BodyContainer.ContainedEntity;
}
- _userInterfaceSystem.TrySendUiMessage(
+ // TODO: This should be a state my dude
+ _userInterfaceSystem.ServerSendUiMessage(
entity.Owner,
HealthAnalyzerUiKey.Key,
new HealthAnalyzerScannedUserMessage(GetNetEntity(entity.Comp.BodyContainer.ContainedEntity),
else
{
RemComp<ActiveCryoPodComponent>(entity);
- _uiSystem.TryCloseAll(entity.Owner, HealthAnalyzerUiKey.Key);
+ _uiSystem.CloseUi(entity.Owner, HealthAnalyzerUiKey.Key);
}
UpdateAppearance(entity.Owner, entity.Comp);
}
}
// if body is ejected - no need to display health-analyzer
- _uiSystem.TryCloseAll(cryoPod.Owner, HealthAnalyzerUiKey.Key);
+ _uiSystem.CloseUi(cryoPod.Owner, HealthAnalyzerUiKey.Key);
}
#endregion
private void OpenUserInterface(EntityUid user, EntityUid analyzer)
{
- if (!TryComp<ActorComponent>(user, out var actor) || !_uiSystem.TryGetUi(analyzer, HealthAnalyzerUiKey.Key, out var ui))
+ if (!_uiSystem.HasUi(analyzer, HealthAnalyzerUiKey.Key))
return;
- _uiSystem.OpenUi(ui, actor.PlayerSession);
+ _uiSystem.OpenUi(analyzer, HealthAnalyzerUiKey.Key, user);
}
/// <summary>
/// <param name="scanMode">True makes the UI show ACTIVE, False makes the UI show INACTIVE</param>
public void UpdateScannedUser(EntityUid healthAnalyzer, EntityUid target, bool scanMode)
{
- if (!_uiSystem.TryGetUi(healthAnalyzer, HealthAnalyzerUiKey.Key, out var ui))
+ if (!_uiSystem.HasUi(healthAnalyzer, HealthAnalyzerUiKey.Key))
return;
if (!HasComp<DamageableComponent>(target))
bleeding = bloodstream.BleedAmount > 0;
}
-
-
- _uiSystem.SendUiMessage(ui, new HealthAnalyzerScannedUserMessage(
+ _uiSystem.ServerSendUiMessage(healthAnalyzer, HealthAnalyzerUiKey.Key, new HealthAnalyzerScannedUserMessage(
GetNetEntity(target),
bodyTemperature,
bloodAmount,
continue;
var msg = Loc.GetString("nuke-component-cant-anchor-floor");
- _popups.PopupEntity(msg, uid, args.Session, PopupType.MediumCaution);
+ _popups.PopupEntity(msg, uid, args.Actor, PopupType.MediumCaution);
return;
}
else
{
- if (args.Session.AttachedEntity is not { } user)
- return;
-
- DisarmBombDoafter(uid, user, component);
+ DisarmBombDoafter(uid, args.Actor, component);
}
}
if (!Resolve(uid, ref component))
return;
- var ui = _ui.GetUiOrNull(uid, NukeUiKey.Key);
- if (ui == null)
+ if (!_ui.HasUi(uid, NukeUiKey.Key))
return;
var anchored = Transform(uid).Anchored;
CooldownTime = (int) component.CooldownTime
};
- _ui.SetUiState(ui, state);
+ _ui.SetUiState(uid, NukeUiKey.Key, state);
}
private void PlayNukeKeypadSound(EntityUid uid, int number, NukeComponent? component = null)
private void OnActivated(Entity<WarDeclaratorComponent> ent, ref WarDeclaratorActivateMessage args)
{
- if (args.Session.AttachedEntity is not {} playerEntity)
- return;
-
var ev = new WarDeclaredEvent(ent.Comp.CurrentStatus, ent);
RaiseLocalEvent(ref ev);
{
var title = Loc.GetString(ent.Comp.SenderTitle);
_chat.DispatchGlobalAnnouncement(ent.Comp.Message, title, true, ent.Comp.Sound, ent.Comp.Color);
- _adminLogger.Add(LogType.Chat, LogImpact.Low, $"{ToPrettyString(playerEntity):player} has declared war with this text: {ent.Comp.Message}");
+ _adminLogger.Add(LogType.Chat, LogImpact.Low, $"{ToPrettyString(args.Actor):player} has declared war with this text: {ent.Comp.Message}");
}
UpdateUI(ent, ev.Status);
private void UpdateUI(Entity<WarDeclaratorComponent> ent, WarConditionStatus? status = null)
{
- _userInterfaceSystem.TrySetUiState(
- ent,
+ _userInterfaceSystem.SetUiState(
+ ent.Owner,
WarDeclaratorUiKey.Key,
new WarDeclaratorBoundUserInterfaceState(status, ent.Comp.DisableAt, ent.Comp.ShuttleDisabledTime));
}
{
// Close the instrument interface if it was open
// before closing
- if (HasComp<ActiveInstrumentComponent>(uid) && TryComp<ActorComponent>(uid, out var actor))
+ if (HasComp<ActiveInstrumentComponent>(uid))
{
- _instrumentSystem.ToggleInstrumentUi(uid, actor.PlayerSession);
+ _instrumentSystem.ToggleInstrumentUi(uid, uid);
}
// Stop instrument
- if (TryComp<InstrumentComponent>(uid, out var instrument)) _instrumentSystem.Clean(uid, instrument);
+ if (TryComp<InstrumentComponent>(uid, out var instrument))
+ _instrumentSystem.Clean(uid, instrument);
+
if (TryComp<MetaDataComponent>(uid, out var metadata))
{
var proto = metadata.EntityPrototype;
SubscribeLocalEvent<PdaComponent, LightToggleEvent>(OnLightToggle);
// UI Events:
+ SubscribeLocalEvent<PdaComponent, BoundUIOpenedEvent>(OnPdaOpen);
SubscribeLocalEvent<PdaComponent, PdaRequestUpdateInterfaceMessage>(OnUiMessage);
SubscribeLocalEvent<PdaComponent, PdaToggleFlashlightMessage>(OnUiMessage);
SubscribeLocalEvent<PdaComponent, PdaShowRingtoneMessage>(OnUiMessage);
if (!Resolve(uid, ref pda, false))
return;
- if (!_ui.TryGetUi(uid, PdaUiKey.Key, out var ui))
+ if (!_ui.HasUi(uid, PdaUiKey.Key))
return;
var address = GetDeviceNetAddress(uid);
hasInstrument,
address);
- _ui.SetUiState(ui, state);
+ _ui.SetUiState(uid, PdaUiKey.Key, state);
+ }
+
+ private void OnPdaOpen(Entity<PdaComponent> ent, ref BoundUIOpenedEvent args)
+ {
+ if (!PdaUiKey.Key.Equals(args.UiKey))
+ return;
+
+ UpdatePdaUi(ent.Owner, ent.Comp);
}
private void OnUiMessage(EntityUid uid, PdaComponent pda, PdaRequestUpdateInterfaceMessage msg)
return;
if (HasComp<RingerComponent>(uid))
- _ringer.ToggleRingerUI(uid, msg.Session);
+ _ringer.ToggleRingerUI(uid, msg.Actor);
}
private void OnUiMessage(EntityUid uid, PdaComponent pda, PdaShowMusicMessage msg)
return;
if (TryComp<InstrumentComponent>(uid, out var instrument))
- _instrument.ToggleInstrumentUi(uid, msg.Session, instrument);
+ _instrument.ToggleInstrumentUi(uid, msg.Actor, instrument);
}
private void OnUiMessage(EntityUid uid, PdaComponent pda, PdaShowUplinkMessage msg)
// check if its locked again to prevent malicious clients opening locked uplinks
if (TryComp<StoreComponent>(uid, out var store) && IsUnlocked(uid))
- _store.ToggleUi(msg.Session.AttachedEntity!.Value, uid, store);
+ _store.ToggleUi(msg.Actor, uid, store);
}
private void OnUiMessage(EntityUid uid, PdaComponent pda, PdaLockUplinkMessage msg)
private void OnSetRingtone(EntityUid uid, RingerComponent ringer, RingerSetRingtoneMessage args)
{
- ref var lastSetAt = ref CollectionsMarshal.GetValueRefOrAddDefault(_lastSetRingtoneAt, args.Session.UserId, out var exists);
+ if (!TryComp(args.Actor, out ActorComponent? actorComp))
+ return;
+
+ ref var lastSetAt = ref CollectionsMarshal.GetValueRefOrAddDefault(_lastSetRingtoneAt, actorComp.PlayerSession.UserId, out var exists);
// Delay on the client is 0.333, 0.25 is still enough and gives some leeway in case of small time differences
if (exists && lastSetAt > _gameTiming.CurTime - TimeSpan.FromMilliseconds(250))
// can't keep store open after locking it
if (!uplink.Unlocked)
- _ui.TryCloseAll(uid, StoreUiKey.Key);
+ _ui.CloseUi(uid, StoreUiKey.Key);
// no saving the code to prevent meta click set on sus guys pda -> wewlad
args.Handled = true;
return;
uplink.Unlocked = false;
- _ui.TryCloseAll(uid, StoreUiKey.Key);
+ _ui.CloseUi(uid, StoreUiKey.Key);
}
public void RandomizeRingtone(EntityUid uid, RingerComponent ringer, MapInitEvent args)
private void UpdateRingerUserInterface(EntityUid uid, RingerComponent ringer, bool isPlaying)
{
- if (_ui.TryGetUi(uid, RingerUiKey.Key, out var bui))
- _ui.SetUiState(bui, new RingerUpdateState(isPlaying, ringer.Ringtone));
+ _ui.SetUiState(uid, RingerUiKey.Key, new RingerUpdateState(isPlaying, ringer.Ringtone));
}
- public bool ToggleRingerUI(EntityUid uid, ICommonSession session)
+ public bool ToggleRingerUI(EntityUid uid, EntityUid actor)
{
- if (_ui.TryGetUi(uid, RingerUiKey.Key, out var bui))
- _ui.ToggleUi(bui, session);
+ _ui.TryToggleUi(uid, RingerUiKey.Key, actor);
return true;
}
namespace Content.Server.Paper;
-[NetworkedComponent, RegisterComponent]
+[RegisterComponent]
public sealed partial class PaperComponent : SharedPaperComponent
{
public PaperAction Mode;
private void BeforeUIOpen(EntityUid uid, PaperComponent paperComp, BeforeActivatableUIOpenEvent args)
{
paperComp.Mode = PaperAction.Read;
-
- if (!TryComp<ActorComponent>(args.User, out var actor))
- return;
-
- UpdateUserInterface(uid, paperComp, actor.PlayerSession);
+ UpdateUserInterface(uid, paperComp);
}
private void OnExamined(EntityUid uid, PaperComponent paperComp, ExaminedEvent args)
{
var writeEvent = new PaperWriteEvent(uid, args.User);
RaiseLocalEvent(args.Used, ref writeEvent);
- if (!TryComp<ActorComponent>(args.User, out var actor))
- return;
paperComp.Mode = PaperAction.Write;
- _uiSystem.TryOpen(uid, PaperUiKey.Key, actor.PlayerSession);
- UpdateUserInterface(uid, paperComp, actor.PlayerSession);
+ _uiSystem.OpenUi(uid, PaperUiKey.Key, args.User);
+ UpdateUserInterface(uid, paperComp);
args.Handled = true;
return;
}
if (TryComp<MetaDataComponent>(uid, out var meta))
_metaSystem.SetEntityDescription(uid, "", meta);
- if (args.Session.AttachedEntity != null)
- _adminLogger.Add(LogType.Chat, LogImpact.Low,
- $"{ToPrettyString(args.Session.AttachedEntity.Value):player} has written on {ToPrettyString(uid):entity} the following text: {args.Text}");
+ _adminLogger.Add(LogType.Chat, LogImpact.Low,
+ $"{ToPrettyString(args.Actor):player} has written on {ToPrettyString(uid):entity} the following text: {args.Text}");
_audio.PlayPvs(paperComp.Sound, uid);
}
_appearance.SetData(uid, PaperVisuals.Status, status, appearance);
}
- public void UpdateUserInterface(EntityUid uid, PaperComponent? paperComp = null, ICommonSession? session = null)
+ public void UpdateUserInterface(EntityUid uid, PaperComponent? paperComp = null)
{
if (!Resolve(uid, ref paperComp))
return;
- if (_uiSystem.TryGetUi(uid, PaperUiKey.Key, out var bui))
- _uiSystem.SetUiState(bui, new PaperBoundUserInterfaceState(paperComp.Content, paperComp.StampedBy, paperComp.Mode), session);
+ _uiSystem.SetUiState(uid, PaperUiKey.Key, new PaperBoundUserInterfaceState(paperComp.Content, paperComp.StampedBy, paperComp.Mode));
}
}
FireEmitter(comp.StarboardEmitter!.Value, strength);
}
- public void SwitchOn(EntityUid uid, ICommonSession? user = null, ParticleAcceleratorControlBoxComponent? comp = null)
+ public void SwitchOn(EntityUid uid, EntityUid? user = null, ParticleAcceleratorControlBoxComponent? comp = null)
{
if (!Resolve(uid, ref comp))
return;
if (comp.Enabled || !comp.CanBeEnabled)
return;
- if (user?.AttachedEntity is { } player)
+ if (user is { } player)
_adminLogger.Add(LogType.Action, LogImpact.Low, $"{ToPrettyString(player):player} has turned {ToPrettyString(uid)} on");
comp.Enabled = true;
UpdateUI(uid, comp);
}
- public void SwitchOff(EntityUid uid, ICommonSession? user = null, ParticleAcceleratorControlBoxComponent? comp = null)
+ public void SwitchOff(EntityUid uid, EntityUid? user = null, ParticleAcceleratorControlBoxComponent? comp = null)
{
if (!Resolve(uid, ref comp))
return;
if (!comp.Enabled)
return;
- if (user?.AttachedEntity is { } player)
+ if (user is { } player)
_adminLogger.Add(LogType.Action, LogImpact.Low, $"{ToPrettyString(player):player} has turned {ToPrettyString(uid)} off");
comp.Enabled = false;
UpdateUI(uid, comp);
}
- public void SetStrength(EntityUid uid, ParticleAcceleratorPowerState strength, ICommonSession? user = null, ParticleAcceleratorControlBoxComponent? comp = null)
+ public void SetStrength(EntityUid uid, ParticleAcceleratorPowerState strength, EntityUid? user = null, ParticleAcceleratorControlBoxComponent? comp = null)
{
if (!Resolve(uid, ref comp))
return;
if (strength == comp.SelectedStrength)
return;
- if (user?.AttachedEntity is { } player)
+ if (user is { } player)
{
var impact = strength switch
{
{
if (!Resolve(uid, ref comp))
return;
- if (!_uiSystem.TryGetUi(uid, ParticleAcceleratorControlBoxUiKey.Key, out var bui))
+
+ if (!_uiSystem.HasUi(uid, ParticleAcceleratorControlBoxUiKey.Key))
return;
var draw = 0f;
receive = powerConsumer.ReceivedPower;
}
- _uiSystem.SetUiState(bui, new ParticleAcceleratorUIState(
+ _uiSystem.SetUiState(uid, ParticleAcceleratorControlBoxUiKey.Key, new ParticleAcceleratorUIState(
comp.Assembled,
comp.Enabled,
comp.SelectedStrength,
UpdateAppearance(uid, comp);
if (!args.Powered)
- _uiSystem.TryCloseAll(uid, ParticleAcceleratorControlBoxUiKey.Key);
+ _uiSystem.CloseUi(uid, ParticleAcceleratorControlBoxUiKey.Key);
}
private void OnUISetEnableMessage(EntityUid uid, ParticleAcceleratorControlBoxComponent comp, ParticleAcceleratorSetEnableMessage msg)
if (msg.Enabled)
{
if (comp.Assembled)
- SwitchOn(uid, msg.Session, comp);
+ SwitchOn(uid, msg.Actor, comp);
}
else
- SwitchOff(uid, msg.Session, comp);
+ SwitchOff(uid, msg.Actor, comp);
UpdateUI(uid, comp);
}
if (TryComp<ApcPowerReceiverComponent>(uid, out var apcPower) && !apcPower.Powered)
return;
- SetStrength(uid, msg.State, msg.Session, comp);
+ SetStrength(uid, msg.State, msg.Actor, comp);
UpdateUI(uid, comp);
}
if (TryComp<ApcPowerReceiverComponent>(uid, out var apcPower) && !apcPower.Powered)
return;
- RescanParts(uid, msg.Session, comp);
+ RescanParts(uid, msg.Actor, comp);
UpdateUI(uid, comp);
}
SubscribeLocalEvent<ParticleAcceleratorPartComponent, PhysicsBodyTypeChangedEvent>(BodyTypeChanged);
}
- public void RescanParts(EntityUid uid, ICommonSession? user = null, ParticleAcceleratorControlBoxComponent? controller = null)
+ public void RescanParts(EntityUid uid, EntityUid? user = null, ParticleAcceleratorControlBoxComponent? controller = null)
{
if (!Resolve(uid, ref controller))
return;
// Yes, it's a feature that mending this wire WON'T WORK if the strength wire is also cut.
// Since that blocks SetStrength().
var paSystem = EntityManager.System<ParticleAcceleratorSystem>();
- var userSession = EntityManager.TryGetComponent<ActorComponent>(user, out var actor) ? actor.PlayerSession : null;
- paSystem.SetStrength(wire.Owner, controller.MaxStrength, userSession, controller);
+ paSystem.SetStrength(wire.Owner, controller.MaxStrength, user, controller);
return true;
}
public override void Pulse(EntityUid user, Wire wire, ParticleAcceleratorControlBoxComponent controller)
{
var paSystem = EntityManager.System<ParticleAcceleratorSystem>();
- var userSession = EntityManager.TryGetComponent<ActorComponent>(user, out var actor) ? actor.PlayerSession : null;
- paSystem.SetStrength(wire.Owner, (ParticleAcceleratorPowerState) ((int) controller.SelectedStrength + 1), userSession, controller);
+ paSystem.SetStrength(wire.Owner, (ParticleAcceleratorPowerState) ((int) controller.SelectedStrength + 1), user, controller);
}
}
public override bool Cut(EntityUid user, Wire wire, ParticleAcceleratorControlBoxComponent controller)
{
var paSystem = EntityManager.System<ParticleAcceleratorSystem>();
- var userSession = EntityManager.TryGetComponent<ActorComponent>(user, out var actor) ? actor.PlayerSession : null;
controller.CanBeEnabled = false;
- paSystem.SwitchOff(wire.Owner, userSession, controller);
+ paSystem.SwitchOff(wire.Owner, user, controller);
return true;
}
public override void Pulse(EntityUid user, Wire wire, ParticleAcceleratorControlBoxComponent controller)
{
var paSystem = EntityManager.System<ParticleAcceleratorSystem>();
- var userSession = EntityManager.TryGetComponent<ActorComponent>(user, out var actor) ? actor.PlayerSession : null;
if (controller.Enabled)
- paSystem.SwitchOff(wire.Owner, userSession, controller);
+ paSystem.SwitchOff(wire.Owner, user, controller);
else if (controller.Assembled)
- paSystem.SwitchOn(wire.Owner, userSession, controller);
+ paSystem.SwitchOn(wire.Owner, user, controller);
}
}
private void OnConfigureMessage(Entity<ConfigurableNavMapBeaconComponent> ent, ref NavMapBeaconConfigureBuiMessage args)
{
- if (args.Session.AttachedEntity is not { } user)
- return;
-
if (!TryComp<NavMapBeaconComponent>(ent, out var beacon))
return;
return;
_adminLog.Add(LogType.Action, LogImpact.Medium,
- $"{ToPrettyString(user):player} configured NavMapBeacon \'{ToPrettyString(ent):entity}\' with text \'{args.Text}\', color {args.Color.ToHexNoAlpha()}, and {(args.Enabled ? "enabled" : "disabled")} it.");
+ $"{ToPrettyString(args.Actor):player} configured NavMapBeacon \'{ToPrettyString(ent):entity}\' with text \'{args.Text}\', color {args.Color.ToHexNoAlpha()}, and {(args.Enabled ? "enabled" : "disabled")} it.");
if (TryComp<WarpPointComponent>(ent, out var warpPoint))
{
private void OnStationMapClosed(EntityUid uid, StationMapComponent component, BoundUIClosedEvent args)
{
- if (!Equals(args.UiKey, StationMapUiKey.Key) || args.Session.AttachedEntity == null)
+ if (!Equals(args.UiKey, StationMapUiKey.Key))
return;
- RemCompDeferred<StationMapUserComponent>(args.Session.AttachedEntity.Value);
+ RemCompDeferred<StationMapUserComponent>(args.Actor);
}
private void OnUserParentChanged(EntityUid uid, StationMapUserComponent component, ref EntParentChangedMessage args)
{
- if (TryComp<ActorComponent>(uid, out var actor))
- {
- _ui.TryClose(component.Map, StationMapUiKey.Key, actor.PlayerSession);
- }
+ _ui.CloseUi(component.Map, StationMapUiKey.Key, uid);
}
private void OnStationMapOpened(EntityUid uid, StationMapComponent component, BoundUIOpenedEvent args)
{
- if (args.Session.AttachedEntity == null)
- return;
-
if (!_cell.TryUseActivatableCharge(uid))
return;
- var comp = EnsureComp<StationMapUserComponent>(args.Session.AttachedEntity.Value);
+ var comp = EnsureComp<StationMapUserComponent>(args.Actor);
comp.Map = uid;
}
}
+++ /dev/null
-namespace Content.Server.Power.Components
-{
- [RegisterComponent]
- public sealed partial class ActivatableUIRequiresPowerComponent : Component
- {
- }
-}
-
using JetBrains.Annotations;
using Content.Shared.Wires;
using Content.Server.UserInterface;
+using Content.Shared.Power.Components;
+using ActivatableUISystem = Content.Shared.UserInterface.ActivatableUISystem;
namespace Content.Server.Power.EntitySystems;
-[UsedImplicitly]
-internal sealed class ActivatableUIRequiresPowerSystem : EntitySystem
+public sealed class ActivatableUIRequiresPowerSystem : EntitySystem
{
[Dependency] private readonly ActivatableUISystem _activatableUI = default!;
[Dependency] private readonly SharedPopupSystem _popup = default!;
//Update the HasAccess var for UI to read
private void OnBoundUiOpen(EntityUid uid, ApcComponent component, BoundUIOpenedEvent args)
{
- if (args.Session.AttachedEntity == null)
- return;
-
// TODO: this should be per-player not stored on the apc
- component.HasAccess = _accessReader.IsAllowed(args.Session.AttachedEntity.Value, uid);
+ component.HasAccess = _accessReader.IsAllowed(args.Actor, uid);
UpdateApcState(uid, component);
}
if (attemptEv.Cancelled)
{
_popup.PopupCursor(Loc.GetString("apc-component-on-toggle-cancel"),
- args.Session, PopupType.Medium);
+ args.Actor, PopupType.Medium);
return;
}
- if (args.Session.AttachedEntity == null)
- return;
-
- if (_accessReader.IsAllowed(args.Session.AttachedEntity.Value, uid))
+ if (_accessReader.IsAllowed(args.Actor, uid))
{
ApcToggleBreaker(uid, component);
}
else
{
_popup.PopupCursor(Loc.GetString("apc-component-insufficient-access"),
- args.Session, PopupType.Medium);
+ args.Actor, PopupType.Medium);
}
}
(int) MathF.Ceiling(battery.CurrentSupply), apc.LastExternalState,
battery.CurrentStorage / battery.Capacity);
- _ui.TrySetUiState(uid, ApcUiKey.Key, state, ui: ui);
+ _ui.SetUiState((uid, ui), ApcUiKey.Key, state);
}
private ApcChargeState CalcChargeState(EntityUid uid, PowerState.Battery battery)
var query = AllEntityQuery<PowerMonitoringConsoleComponent>();
while (query.MoveNext(out var ent, out var console))
{
- if (!_userInterfaceSystem.TryGetUi(ent, PowerMonitoringConsoleUiKey.Key, out var bui))
+ if (!_userInterfaceSystem.IsUiOpen(ent, PowerMonitoringConsoleUiKey.Key))
continue;
- foreach (var session in bui.SubscribedSessions)
- UpdateUIState(ent, console, session);
+ UpdateUIState(ent, console);
+
}
}
}
- public void UpdateUIState(EntityUid uid, PowerMonitoringConsoleComponent component, ICommonSession session)
+ private void UpdateUIState(EntityUid uid, PowerMonitoringConsoleComponent component)
{
- if (!_userInterfaceSystem.TryGetUi(uid, PowerMonitoringConsoleUiKey.Key, out var bui))
- return;
-
var consoleXform = Transform(uid);
if (consoleXform?.GridUid == null)
}
// Set the UI state
- _userInterfaceSystem.SetUiState(bui,
+ _userInterfaceSystem.SetUiState(uid,
+ PowerMonitoringConsoleUiKey.Key,
new PowerMonitoringConsoleBoundInterfaceState
(totalSources,
totalBatteryUsage,
totalLoads,
allEntries.ToArray(),
sourcesForFocus.ToArray(),
- loadsForFocus.ToArray()),
- session);
+ loadsForFocus.ToArray()));
}
private double GetPrimaryPowerValues(EntityUid uid, PowerMonitoringDeviceComponent device, out double powerSupplied, out double powerUsage, out double batteryUsage)
private void GeneratorSwitchOutputMessage(EntityUid uid, PortableGeneratorComponent component, PortableGeneratorSwitchOutputMessage args)
{
- if (args.Session.AttachedEntity == null)
- return;
-
var fuelGenerator = Comp<FuelGeneratorComponent>(uid);
if (fuelGenerator.On)
return;
- _switchable.Cycle(uid, args.Session.AttachedEntity.Value);
+ _switchable.Cycle(uid, args.Actor);
}
private void GeneratorStopMessage(EntityUid uid, PortableGeneratorComponent component, PortableGeneratorStopMessage args)
{
- if (args.Session.AttachedEntity == null)
- return;
-
- StopGenerator(uid, component, args.Session.AttachedEntity.Value);
+ StopGenerator(uid, component, args.Actor);
}
private void GeneratorStartMessage(EntityUid uid, PortableGeneratorComponent component, PortableGeneratorStartMessage args)
{
- if (args.Session.AttachedEntity == null)
- return;
-
- StartGenerator(uid, component, args.Session.AttachedEntity.Value);
+ StartGenerator(uid, component, args.Actor);
}
private void StartGenerator(EntityUid uid, PortableGeneratorComponent component, EntityUid user)
if (powerSupplier.Net is { IsConnectedNetwork: true } net)
networkStats = (net.NetworkNode.LastCombinedLoad, net.NetworkNode.LastCombinedSupply);
- _uiSystem.TrySetUiState(
+ _uiSystem.SetUiState(
uid,
GeneratorComponentUiKey.Key,
new PortableGeneratorComponentBuiState(fuelComp, fuel, clogged, networkStats));
using Content.Server.UserInterface;
using Content.Shared.Containers.ItemSlots;
using Content.Shared.Popups;
+using ActivatableUISystem = Content.Shared.UserInterface.ActivatableUISystem;
namespace Content.Server.PowerCell;
private void OnToggleIntercomMic(EntityUid uid, IntercomComponent component, ToggleIntercomMicMessage args)
{
- if (component.RequiresPower && !this.IsPowered(uid, EntityManager) || args.Session.AttachedEntity is not { } user)
+ if (component.RequiresPower && !this.IsPowered(uid, EntityManager))
return;
- SetMicrophoneEnabled(uid, user, args.Enabled, true);
+ SetMicrophoneEnabled(uid, args.Actor, args.Enabled, true);
UpdateIntercomUi(uid, component);
}
private void OnToggleIntercomSpeaker(EntityUid uid, IntercomComponent component, ToggleIntercomSpeakerMessage args)
{
- if (component.RequiresPower && !this.IsPowered(uid, EntityManager) || args.Session.AttachedEntity is not { } user)
+ if (component.RequiresPower && !this.IsPowered(uid, EntityManager))
return;
- SetSpeakerEnabled(uid, user, args.Enabled, true);
+ SetSpeakerEnabled(uid, args.Actor, args.Enabled, true);
UpdateIntercomUi(uid, component);
}
private void OnSelectIntercomChannel(EntityUid uid, IntercomComponent component, SelectIntercomChannelMessage args)
{
- if (component.RequiresPower && !this.IsPowered(uid, EntityManager) || args.Session.AttachedEntity is not { })
+ if (component.RequiresPower && !this.IsPowered(uid, EntityManager))
return;
if (!_protoMan.TryIndex<RadioChannelPrototype>(args.Channel, out _) || !component.SupportedChannels.Contains(args.Channel))
var availableChannels = component.SupportedChannels;
var selectedChannel = micComp?.BroadcastChannel ?? SharedChatSystem.CommonChannel;
var state = new IntercomBoundUIState(micEnabled, speakerEnabled, availableChannels, selectedChannel);
- _ui.TrySetUiState(uid, IntercomUiKey.Key, state);
+ _ui.SetUiState(uid, IntercomUiKey.Key, state);
}
}
if (!this.IsPowered(uid, EntityManager))
return;
- _uiSystem.TryToggleUi(uid, ResearchClientUiKey.Key, args.Session);
+ _uiSystem.TryToggleUi(uid, ResearchClientUiKey.Key, args.Actor);
}
#endregion
var state = new ResearchClientBoundInterfaceState(names.Length, names,
GetServerIds(), serverComponent?.Id ?? -1);
- _uiSystem.TrySetUiState(uid, ResearchClientUiKey.Key, state);
+ _uiSystem.SetUiState(uid, ResearchClientUiKey.Key, state);
}
/// <summary>
private void OnConsoleUnlock(EntityUid uid, ResearchConsoleComponent component, ConsoleUnlockTechnologyMessage args)
{
- if (args.Session.AttachedEntity is not { } ent)
- return;
+ var act = args.Actor;
if (!this.IsPowered(uid, EntityManager))
return;
if (!PrototypeManager.TryIndex<TechnologyPrototype>(args.Id, out var technologyPrototype))
return;
- if (TryComp<AccessReaderComponent>(uid, out var access) && !_accessReader.IsAllowed(ent, uid, access))
+ if (TryComp<AccessReaderComponent>(uid, out var access) && !_accessReader.IsAllowed(act, uid, access))
{
- _popup.PopupEntity(Loc.GetString("research-console-no-access-popup"), ent);
+ _popup.PopupEntity(Loc.GetString("research-console-no-access-popup"), act);
return;
}
- if (!UnlockTechnology(uid, args.Id, ent))
+ if (!UnlockTechnology(uid, args.Id, act))
return;
var message = Loc.GetString("research-console-unlock-technology-radio-broadcast",
state = new ResearchConsoleBoundInterfaceState(default);
}
- _uiSystem.TrySetUiState(uid, ResearchConsoleUiKey.Key, state);
+ _uiSystem.SetUiState(uid, ResearchConsoleUiKey.Key, state);
}
private void OnPointsChanged(EntityUid uid, ResearchConsoleComponent component, ref ResearchServerPointsChangedEvent args)
totalPoints >= component.PricePerDisk;
var state = new DiskConsoleBoundUserInterfaceState(totalPoints, component.PricePerDisk, canPrint);
- _ui.TrySetUiState(uid, DiskConsoleUiKey.Key, state);
+ _ui.SetUiState(uid, DiskConsoleUiKey.Key, state);
}
private void OnShutdown(EntityUid uid, DiskConsolePrintingComponent component, ComponentShutdown args)
if (station != component.Owner)
continue;
- _ui.TrySetUiState(uid, SalvageConsoleUiKey.Expedition, state, ui: uiComp);
+ _ui.SetUiState((uid, uiComp), SalvageConsoleUiKey.Expedition, state);
}
}
state = new SalvageExpeditionConsoleState(TimeSpan.Zero, false, true, 0, new List<SalvageMissionParams>());
}
- _ui.TrySetUiState(component, SalvageConsoleUiKey.Expedition, state);
+ _ui.SetUiState(component.Owner, SalvageConsoleUiKey.Expedition, state);
}
}
private void OnMagnetClaim(EntityUid uid, SalvageMagnetComponent component, ref MagnetClaimOfferEvent args)
{
- var player = args.Session.AttachedEntity;
-
- if (player is null)
- return;
-
var station = _station.GetOwningStation(uid);
if (!TryComp(station, out SalvageMagnetDataComponent? dataComp) ||
// Fuck with the seed to mix wrecks and asteroids.
seed = (int) (seed / 10f) * 10;
-
+
if (i >= data.Comp.OfferCount / 2)
{
seed++;
}
-
+
data.Comp.Offered.Add(seed);
}
if (!TryComp(station, out SalvageMagnetDataComponent? dataComp))
return;
- _ui.TrySetUiState(entity, SalvageMagnetUiKey.Key,
+ _ui.SetUiState(entity.Owner, SalvageMagnetUiKey.Key,
new SalvageMagnetBoundUserInterfaceState(dataComp.Offered)
{
Cooldown = dataComp.OfferCooldown,
if (station != data.Owner)
continue;
- _ui.TrySetUiState(magnetUid, SalvageMagnetUiKey.Key,
+ _ui.SetUiState(magnetUid, SalvageMagnetUiKey.Key,
new SalvageMagnetBoundUserInterfaceState(data.Comp.Offered)
{
Cooldown = data.Comp.OfferCooldown,
public TimeSpan RetentionTime = TimeSpan.FromMinutes(1);
// UI update tracking stuff.
- public HashSet<ICommonSession> InitialUIStateSent = new();
+ public HashSet<EntityUid> InitialUIStateSent = new();
public TimeSpan LastUIUpdate;
public ValueList<int> RemovedSensors;
private void UpdateConsoleUI(EntityUid uid, SensorMonitoringConsoleComponent comp)
{
- if (!_userInterface.TryGetUi(uid, SensorMonitoringConsoleUiKey.Key, out var ui))
- return;
-
- if (ui.SubscribedSessions.Count == 0)
+ if (!_userInterface.IsUiOpen(uid, SensorMonitoringConsoleUiKey.Key))
+ {
return;
+ }
ConsoleUIState? fullState = null;
SensorMonitoringIncrementalUpdate? incrementalUpdate = null;
- foreach (var session in ui.SubscribedSessions)
+ foreach (var actorUid in _userInterface.GetActors(uid, SensorMonitoringConsoleUiKey.Key))
{
- if (comp.InitialUIStateSent.Contains(session))
+ if (comp.InitialUIStateSent.Contains(actorUid))
{
incrementalUpdate ??= CalculateIncrementalUpdate();
- _userInterface.TrySendUiMessage(ui, incrementalUpdate, session);
+ _userInterface.ServerSendUiMessage(uid, SensorMonitoringConsoleUiKey.Key, incrementalUpdate, actorUid);
}
else
{
fullState ??= CalculateFullState();
- _userInterface.SetUiState(ui, fullState, session);
- comp.InitialUIStateSent.Add(session);
+ _userInterface.SetUiState(uid, SensorMonitoringConsoleUiKey.Key, fullState);
+ comp.InitialUIStateSent.Add(actorUid);
}
}
if (!args.UiKey.Equals(SensorMonitoringConsoleUiKey.Key))
return;
- if (args.Session is not { } player)
- return;
-
- component.InitialUIStateSent.Remove(player);
+ component.InitialUIStateSent.Remove(args.Actor);
}
}
private void OnEmergencyRepealAll(EntityUid uid, EmergencyShuttleConsoleComponent component, EmergencyShuttleRepealAllMessage args)
{
- var player = args.Session.AttachedEntity;
- if (player == null) return;
+ var player = args.Actor;
- if (!_reader.FindAccessTags(player.Value).Contains(EmergencyRepealAllAccess))
+ if (!_reader.FindAccessTags(player).Contains(EmergencyRepealAllAccess))
{
- _popup.PopupCursor(Loc.GetString("emergency-shuttle-console-denied"), player.Value, PopupType.Medium);
+ _popup.PopupCursor(Loc.GetString("emergency-shuttle-console-denied"), player, PopupType.Medium);
return;
}
if (component.AuthorizedEntities.Count == 0)
return;
- _logger.Add(LogType.EmergencyShuttle, LogImpact.High, $"Emergency shuttle early launch REPEAL ALL by {args.Session:user}");
+ _logger.Add(LogType.EmergencyShuttle, LogImpact.High, $"Emergency shuttle early launch REPEAL ALL by {args.Actor:user}");
_chatSystem.DispatchGlobalAnnouncement(Loc.GetString("emergency-shuttle-console-auth-revoked", ("remaining", component.AuthorizationsRequired)));
component.AuthorizedEntities.Clear();
UpdateAllEmergencyConsoles();
private void OnEmergencyRepeal(EntityUid uid, EmergencyShuttleConsoleComponent component, EmergencyShuttleRepealMessage args)
{
- var player = args.Session.AttachedEntity;
- if (player == null)
- return;
+ var player = args.Actor;
- if (!_idSystem.TryFindIdCard(player.Value, out var idCard) || !_reader.IsAllowed(idCard, uid))
+ if (!_idSystem.TryFindIdCard(player, out var idCard) || !_reader.IsAllowed(idCard, uid))
{
- _popup.PopupCursor(Loc.GetString("emergency-shuttle-console-denied"), player.Value, PopupType.Medium);
+ _popup.PopupCursor(Loc.GetString("emergency-shuttle-console-denied"), player, PopupType.Medium);
return;
}
if (!component.AuthorizedEntities.Remove(MetaData(idCard).EntityName))
return;
- _logger.Add(LogType.EmergencyShuttle, LogImpact.High, $"Emergency shuttle early launch REPEAL by {args.Session:user}");
+ _logger.Add(LogType.EmergencyShuttle, LogImpact.High, $"Emergency shuttle early launch REPEAL by {args.Actor:user}");
var remaining = component.AuthorizationsRequired - component.AuthorizedEntities.Count;
_chatSystem.DispatchGlobalAnnouncement(Loc.GetString("emergency-shuttle-console-auth-revoked", ("remaining", remaining)));
CheckForLaunch(component);
private void OnEmergencyAuthorize(EntityUid uid, EmergencyShuttleConsoleComponent component, EmergencyShuttleAuthorizeMessage args)
{
- var player = args.Session.AttachedEntity;
- if (player == null)
- return;
+ var player = args.Actor;
- if (!_idSystem.TryFindIdCard(player.Value, out var idCard) || !_reader.IsAllowed(idCard, uid))
+ if (!_idSystem.TryFindIdCard(player, out var idCard) || !_reader.IsAllowed(idCard, uid))
{
- _popup.PopupCursor(Loc.GetString("emergency-shuttle-console-denied"), args.Session, PopupType.Medium);
+ _popup.PopupCursor(Loc.GetString("emergency-shuttle-console-denied"), args.Actor, PopupType.Medium);
return;
}
if (!component.AuthorizedEntities.Add(MetaData(idCard).EntityName))
return;
- _logger.Add(LogType.EmergencyShuttle, LogImpact.High, $"Emergency shuttle early launch AUTH by {args.Session:user}");
+ _logger.Add(LogType.EmergencyShuttle, LogImpact.High, $"Emergency shuttle early launch AUTH by {args.Actor:user}");
var remaining = component.AuthorizationsRequired - component.AuthorizedEntities.Count;
if (remaining > 0)
auths.Add(auth);
}
- if (_uiSystem.TryGetUi(uid, EmergencyConsoleUiKey.Key, out var bui))
+ if (_uiSystem.HasUi(uid, EmergencyConsoleUiKey.Key))
_uiSystem.SetUiState(
- bui,
+ uid,
+ EmergencyConsoleUiKey.Key,
new EmergencyConsoleBoundUserInterfaceState()
{
EarlyLaunchTime = EarlyLaunchAuthorized ? _timing.CurTime + TimeSpan.FromSeconds(_consoleAccumulator) : null,
angle = Angle.Zero;
}
- if (_uiSystem.TryGetUi(uid, RadarConsoleUiKey.Key, out var bui))
+ if (_uiSystem.HasUi(uid, RadarConsoleUiKey.Key))
{
NavInterfaceState state;
var docks = _console.GetAllDocks();
state = _console.GetNavState(uid, docks);
}
- _uiSystem.SetUiState(bui, new NavBoundUserInterfaceState(state));
+ _uiSystem.SetUiState(uid, RadarConsoleUiKey.Key, new NavBoundUserInterfaceState(state));
}
}
}
/// </summary>
private void OnConsoleUIClose(EntityUid uid, ShuttleConsoleComponent component, BoundUIClosedEvent args)
{
- if ((ShuttleConsoleUiKey) args.UiKey != ShuttleConsoleUiKey.Key ||
- args.Session.AttachedEntity is not { } user)
+ if ((ShuttleConsoleUiKey) args.UiKey != ShuttleConsoleUiKey.Key)
{
return;
}
- RemovePilot(user);
+ RemovePilot(args.Actor);
}
private void OnConsoleUIOpenAttempt(EntityUid uid, ShuttleConsoleComponent component,
new List<ShuttleExclusionObject>());
}
- if (_ui.TryGetUi(consoleUid, ShuttleConsoleUiKey.Key, out var bui))
+ if (_ui.HasUi(consoleUid, ShuttleConsoleUiKey.Key))
{
- _ui.SetUiState(bui, new ShuttleBoundUserInterfaceState(navState, mapState, dockState));
+ _ui.SetUiState(consoleUid, ShuttleConsoleUiKey.Key, new ShuttleBoundUserInterfaceState(navState, mapState, dockState));
}
}
!TryComp<TransformComponent>(uid, out var xform) ||
!TryComp<IFFComponent>(xform.GridUid, out var iff))
{
- _uiSystem.TrySetUiState(uid, IFFConsoleUiKey.Key, new IFFConsoleBoundUserInterfaceState()
+ _uiSystem.SetUiState(uid, IFFConsoleUiKey.Key, new IFFConsoleBoundUserInterfaceState()
{
AllowedFlags = component.AllowedFlags,
Flags = IFFFlags.None,
}
else
{
- _uiSystem.TrySetUiState(uid, IFFConsoleUiKey.Key, new IFFConsoleBoundUserInterfaceState()
+ _uiSystem.SetUiState(uid, IFFConsoleUiKey.Key, new IFFConsoleBoundUserInterfaceState()
{
AllowedFlags = component.AllowedFlags,
Flags = iff.Flags,
if (xform.GridUid != gridUid)
continue;
- _uiSystem.TrySetUiState(uid, IFFConsoleUiKey.Key, new IFFConsoleBoundUserInterfaceState()
+ _uiSystem.SetUiState(uid, IFFConsoleUiKey.Key, new IFFConsoleBoundUserInterfaceState()
{
AllowedFlags = comp.AllowedFlags,
Flags = component.Flags,
private void OnEjectBrainBuiMessage(EntityUid uid, BorgChassisComponent component, BorgEjectBrainBuiMessage args)
{
- if (args.Session.AttachedEntity is not { } attachedEntity || component.BrainEntity is not { } brain)
+ if (component.BrainEntity is not { } brain)
return;
_adminLog.Add(LogType.Action, LogImpact.Medium,
- $"{ToPrettyString(attachedEntity):player} removed brain {ToPrettyString(brain)} from borg {ToPrettyString(uid)}");
+ $"{ToPrettyString(args.Actor):player} removed brain {ToPrettyString(brain)} from borg {ToPrettyString(uid)}");
_container.Remove(brain, component.BrainContainer);
- _hands.TryPickupAnyHand(attachedEntity, brain);
+ _hands.TryPickupAnyHand(args.Actor, brain);
UpdateUI(uid, component);
}
private void OnEjectBatteryBuiMessage(EntityUid uid, BorgChassisComponent component, BorgEjectBatteryBuiMessage args)
{
- if (args.Session.AttachedEntity is not { } attachedEntity ||
- !TryComp<PowerCellSlotComponent>(uid, out var slotComp) ||
+ if (!TryComp<PowerCellSlotComponent>(uid, out var slotComp) ||
!Container.TryGetContainer(uid, slotComp.CellSlotId, out var container) ||
!container.ContainedEntities.Any())
{
}
var ents = Container.EmptyContainer(container);
- _hands.TryPickupAnyHand(attachedEntity, ents.First());
+ _hands.TryPickupAnyHand(args.Actor, ents.First());
}
private void OnSetNameBuiMessage(EntityUid uid, BorgChassisComponent component, BorgSetNameBuiMessage args)
{
- if (args.Session.AttachedEntity is not { } attachedEntity)
- return;
-
if (args.Name.Length > HumanoidCharacterProfile.MaxNameLength ||
args.Name.Length == 0 ||
string.IsNullOrWhiteSpace(args.Name) ||
if (metaData.EntityName.Equals(name, StringComparison.InvariantCulture))
return;
- _adminLog.Add(LogType.Action, LogImpact.High, $"{ToPrettyString(attachedEntity):player} set borg \"{ToPrettyString(uid)}\"'s name to: {name}");
+ _adminLog.Add(LogType.Action, LogImpact.High, $"{ToPrettyString(args.Actor):player} set borg \"{ToPrettyString(uid)}\"'s name to: {name}");
_metaData.SetEntityName(uid, name, metaData);
}
private void OnRemoveModuleBuiMessage(EntityUid uid, BorgChassisComponent component, BorgRemoveModuleBuiMessage args)
{
- if (args.Session.AttachedEntity is not { } attachedEntity)
- return;
-
var module = GetEntity(args.Module);
if (!component.ModuleContainer.Contains(module))
return;
_adminLog.Add(LogType.Action, LogImpact.Medium,
- $"{ToPrettyString(attachedEntity):player} removed module {ToPrettyString(module)} from borg {ToPrettyString(uid)}");
+ $"{ToPrettyString(args.Actor):player} removed module {ToPrettyString(module)} from borg {ToPrettyString(uid)}");
_container.Remove(module, component.ModuleContainer);
- _hands.TryPickupAnyHand(attachedEntity, module);
+ _hands.TryPickupAnyHand(args.Actor, module);
UpdateUI(uid, component);
}
}
var state = new BorgBuiState(chargePercent, hasBattery);
- _ui.TrySetUiState(uid, BorgUiKey.Key, state);
+ _ui.SetUiState(uid, BorgUiKey.Key, state);
}
}
private void OnBoundUIOpened(EntityUid uid, SiliconLawBoundComponent component, BoundUIOpenedEvent args)
{
_entityManager.TryGetComponent<IntrinsicRadioTransmitterComponent>(uid, out var intrinsicRadio);
- HashSet<string>? radioChannels = intrinsicRadio?.Channels;
+ var radioChannels = intrinsicRadio?.Channels;
var state = new SiliconLawBuiState(GetLaws(uid).Laws, radioChannels);
- _userInterface.TrySetUiState(args.Entity, SiliconLawsUiKey.Key, state, args.Session);
+ _userInterface.SetUiState(args.Entity, SiliconLawsUiKey.Key, state);
}
private void OnPlayerSpawnComplete(EntityUid uid, SiliconLawBoundComponent component, PlayerSpawnCompleteEvent args)
_updateTimer -= 1;
var state = new SolarControlConsoleBoundInterfaceState(_powerSolarSystem.TargetPanelRotation, _powerSolarSystem.TargetPanelVelocity, _powerSolarSystem.TotalPanelPower, _powerSolarSystem.TowardsSun);
var query = EntityQueryEnumerator<SolarControlConsoleComponent, UserInterfaceComponent>();
- while (query.MoveNext(out var uid, out var _, out var uiComp))
+ while (query.MoveNext(out var uid, out _, out var uiComp))
{
- _uiSystem.TrySetUiState(uid, SolarControlConsoleUiKey.Key, state, ui: uiComp);
+ _uiSystem.SetUiState((uid, uiComp), SolarControlConsoleUiKey.Key, state);
}
}
}
-
+
private void OnUIMessage(EntityUid uid, SolarControlConsoleComponent component, SolarControlConsoleAdjustMessage msg)
{
if (double.IsFinite(msg.Rotation))
if (!TryComp<StationRecordsComponent>(owningStation, out var stationRecords))
{
- _ui.TrySetUiState(uid, GeneralStationRecordConsoleKey.Key, new GeneralStationRecordConsoleState());
+ _ui.SetUiState(uid, GeneralStationRecordConsoleKey.Key, new GeneralStationRecordConsoleState());
return;
}
switch (listing.Count)
{
case 0:
- _ui.TrySetUiState(uid, GeneralStationRecordConsoleKey.Key, new GeneralStationRecordConsoleState());
+ _ui.SetUiState(uid, GeneralStationRecordConsoleKey.Key, new GeneralStationRecordConsoleState());
return;
case 1:
console.ActiveKey = listing.Keys.First();
_stationRecords.TryGetRecord<GeneralStationRecord>(key, out var record, stationRecords);
GeneralStationRecordConsoleState newState = new(id, record, listing, console.Filter);
- _ui.TrySetUiState(uid, GeneralStationRecordConsoleKey.Key, newState);
+ _ui.SetUiState(uid, GeneralStationRecordConsoleKey.Key, newState);
}
}
using Content.Shared.Storage;
using Content.Shared.Storage.Components;
using Content.Shared.Storage.EntitySystems;
-using Content.Shared.Timing;
using Content.Shared.Verbs;
using Robust.Server.GameObjects;
-using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
public sealed partial class StorageSystem : SharedStorageSystem
{
- [Dependency] private readonly IAdminManager _admin = default!;
[Dependency] private readonly IPrototypeManager _prototype = default!;
- [Dependency] private readonly UserInterfaceSystem _uiSystem = default!;
- [Dependency] private readonly SharedAudioSystem _audio = default!;
-
- private const string OpenUiUseDelayID = "storage";
public override void Initialize()
{
base.Initialize();
- SubscribeLocalEvent<StorageComponent, GetVerbsEvent<ActivationVerb>>(AddUiVerb);
- Subs.BuiEvents<StorageComponent>(StorageComponent.StorageUiKey.Key, subs =>
- {
- subs.Event<BoundUIClosedEvent>(OnBoundUIClosed);
- });
SubscribeLocalEvent<StorageComponent, BeforeExplodeEvent>(OnExploded);
SubscribeLocalEvent<StorageFillComponent, MapInitEvent>(OnStorageFillMapInit);
}
- protected override void OnMapInit(Entity<StorageComponent> entity, ref MapInitEvent args)
- {
- base.OnMapInit(entity, ref args);
-
- if (TryComp<UseDelayComponent>(entity, out var useDelay))
- UseDelay.SetLength((entity, useDelay), entity.Comp.OpenUiCooldown, OpenUiUseDelayID);
- }
-
- private void AddUiVerb(EntityUid uid, StorageComponent component, GetVerbsEvent<ActivationVerb> args)
- {
- var silent = false;
- if (!args.CanAccess || !args.CanInteract || TryComp<LockComponent>(uid, out var lockComponent) && lockComponent.Locked)
- {
- // we allow admins to open the storage anyways
- if (!_admin.HasAdminFlag(args.User, AdminFlags.Admin))
- return;
-
- silent = true;
- }
-
- silent |= HasComp<GhostComponent>(args.User);
-
- // Get the session for the user
- if (!TryComp<ActorComponent>(args.User, out var actor))
- return;
-
- // Does this player currently have the storage UI open?
- var uiOpen = _uiSystem.SessionHasOpenUi(uid, StorageComponent.StorageUiKey.Key, actor.PlayerSession);
-
- ActivationVerb verb = new()
- {
- Act = () =>
- {
- if (uiOpen)
- {
- _uiSystem.TryClose(uid, StorageComponent.StorageUiKey.Key, actor.PlayerSession);
- }
- else
- {
- OpenStorageUI(uid, args.User, component, silent);
- }
- }
- };
- if (uiOpen)
- {
- verb.Text = Loc.GetString("comp-storage-verb-close-storage");
- verb.Icon = new SpriteSpecifier.Texture(
- new("/Textures/Interface/VerbIcons/close.svg.192dpi.png"));
- }
- else
- {
- verb.Text = Loc.GetString("comp-storage-verb-open-storage");
- verb.Icon = new SpriteSpecifier.Texture(
- new("/Textures/Interface/VerbIcons/open.svg.192dpi.png"));
- }
- args.Verbs.Add(verb);
- }
-
- private void OnBoundUIClosed(EntityUid uid, StorageComponent storageComp, BoundUIClosedEvent args)
- {
- if (TryComp<ActorComponent>(args.Session.AttachedEntity, out var actor) && actor?.PlayerSession != null)
- CloseNestedInterfaces(uid, actor.PlayerSession, storageComp);
-
- // If UI is closed for everyone
- if (!_uiSystem.IsUiOpen(uid, args.UiKey))
- {
- storageComp.IsUiOpen = false;
- UpdateAppearance((uid, storageComp, null));
-
- if (storageComp.StorageCloseSound is not null)
- Audio.PlayEntity(storageComp.StorageCloseSound, Filter.Pvs(uid, entityManager: EntityManager), uid, true, storageComp.StorageCloseSound.Params);
- }
- }
-
private void OnExploded(Entity<StorageComponent> ent, ref BeforeExplodeEvent args)
{
args.Contents.AddRange(ent.Comp.Container.ContainedEntities);
}
- /// <summary>
- /// Opens the storage UI for an entity
- /// </summary>
- /// <param name="entity">The entity to open the UI for</param>
- public override void OpenStorageUI(EntityUid uid, EntityUid entity, StorageComponent? storageComp = null, bool silent = false)
- {
- if (!Resolve(uid, ref storageComp, false) || !TryComp(entity, out ActorComponent? player))
- return;
-
- // prevent spamming bag open / honkerton honk sound
- silent |= TryComp<UseDelayComponent>(uid, out var useDelay) && UseDelay.IsDelayed((uid, useDelay), OpenUiUseDelayID);
- if (!silent)
- {
- if (!storageComp.IsUiOpen)
- _audio.PlayPvs(storageComp.StorageOpenSound, uid);
- if (useDelay != null)
- UseDelay.TryResetDelay((uid, useDelay), id: OpenUiUseDelayID);
- }
-
- Log.Debug($"Storage (UID {uid}) \"used\" by player session (UID {player.PlayerSession.AttachedEntity}).");
-
- var bui = _uiSystem.GetUiOrNull(uid, StorageComponent.StorageUiKey.Key);
- if (bui == null)
- return;
- _uiSystem.OpenUi(bui, player.PlayerSession);
- _uiSystem.SendUiMessage(bui, new StorageModifyWindowMessage());
- }
-
/// <inheritdoc />
public override void PlayPickupAnimation(EntityUid uid, EntityCoordinates initialCoordinates, EntityCoordinates finalCoordinates,
Angle initialRotation, EntityUid? user = null)
var filter = Filter.Pvs(uid).RemoveWhereAttachedEntity(e => e == user);
RaiseNetworkEvent(new PickupAnimationEvent(GetNetEntity(uid), GetNetCoordinates(initialCoordinates), GetNetCoordinates(finalCoordinates), initialRotation), filter);
}
-
- /// <summary>
- /// If the user has nested-UIs open (e.g., PDA UI open when pda is in a backpack), close them.
- /// </summary>
- /// <param name="session"></param>
- public void CloseNestedInterfaces(EntityUid uid, ICommonSession session, StorageComponent? storageComp = null)
- {
- if (!Resolve(uid, ref storageComp))
- return;
-
- // for each containing thing
- // if it has a storage comp
- // ensure unsubscribe from session
- // if it has a ui component
- // close ui
- foreach (var entity in storageComp.Container.ContainedEntities)
- {
- if (!TryComp(entity, out UserInterfaceComponent? ui))
- continue;
-
- foreach (var bui in ui.Interfaces.Values)
- {
- _uiSystem.TryClose(entity, bui.UiKey, session, ui);
- }
- }
- }
}
if (!Resolve(uid, ref component))
return;
- _ui.TryCloseAll(uid, StoreUiKey.Key);
+ _ui.CloseUi(uid, StoreUiKey.Key);
}
/// <summary>
/// <param name="store">The store entity itself</param>
/// <param name="component">The store component being refreshed.</param>
/// <param name="ui"></param>
- public void UpdateUserInterface(EntityUid? user, EntityUid store, StoreComponent? component = null, PlayerBoundUserInterface? ui = null)
+ public void UpdateUserInterface(EntityUid? user, EntityUid store, StoreComponent? component = null)
{
if (!Resolve(store, ref component))
return;
- if (ui == null && !_ui.TryGetUi(store, StoreUiKey.Key, out ui))
+ // TODO: Why is the state not being set unless this?
+ if (!_ui.IsUiOpen(store, StoreUiKey.Key))
return;
//this is the person who will be passed into logic for all listing filtering.
// only tell operatives to lock their uplink if it can be locked
var showFooter = HasComp<RingerUplinkComponent>(store);
var state = new StoreUpdateState(component.LastAvailableListings, allCurrency, showFooter, component.RefundAllowed);
- _ui.SetUiState(ui, state);
+ _ui.SetUiState(store, StoreUiKey.Key, state);
}
private void OnRequestUpdate(EntityUid uid, StoreComponent component, StoreRequestUpdateInterfaceMessage args)
{
- UpdateUserInterface(args.Session.AttachedEntity, GetEntity(args.Entity), component);
+ UpdateUserInterface(args.Actor, GetEntity(args.Entity), component);
}
private void BeforeActivatableUiOpen(EntityUid uid, StoreComponent component, BeforeActivatableUIOpenEvent args)
return;
}
- if (msg.Session.AttachedEntity is not { Valid: true } buyer)
- return;
+ var buyer = msg.Actor;
//verify that we can actually buy this listing and it wasn't added
if (!ListingHasCategory(listing, component.Categories))
$"{ToPrettyString(buyer):player} purchased listing \"{ListingLocalisationHelpers.GetLocalisedNameOrEntityName(listing, _prototypeManager)}\" from {ToPrettyString(uid)}");
listing.PurchaseAmount++; //track how many times something has been purchased
- _audio.PlayEntity(component.BuySuccessSound, msg.Session, uid); //cha-ching!
+ _audio.PlayEntity(component.BuySuccessSound, msg.Actor, uid); //cha-ching!
UpdateUserInterface(buyer, uid, component);
}
if (proto.Cash == null || !proto.CanWithdraw)
return;
- if (msg.Session.AttachedEntity is not { Valid: true } buyer)
- return;
+ var buyer = msg.Actor;
FixedPoint2 amountRemaining = msg.Amount;
var coordinates = Transform(buyer).Coordinates;
{
// TODO: Remove guardian/holopara
- if (args.Session.AttachedEntity is not { Valid: true } buyer)
+ if (args.Actor is not { Valid: true } buyer)
return;
if (!IsOnStartingMap(uid, component))
if (component.Balance == new Dictionary<string, FixedPoint2>() && preset.InitialBalance != null) //if we don't have a value stored, use the preset
TryAddCurrency(preset.InitialBalance, uid, component);
- var ui = _ui.GetUiOrNull(uid, StoreUiKey.Key);
- if (ui != null)
+ if (_ui.HasUi(uid, StoreUiKey.Key))
{
- _ui.SetUiState(ui, new StoreInitializeState(preset.StoreName));
+ _ui.SetUiState(uid, StoreUiKey.Key, new StoreInitializeState(preset.StoreName));
}
}
}
if (TryComp<CombatModeComponent>(user, out var mode) && mode.IsInCombatMode && !openInCombat)
return;
- if (TryComp<ActorComponent>(user, out var actor) && HasComp<StrippingComponent>(user))
+ if (HasComp<StrippingComponent>(user))
{
- if (_userInterfaceSystem.SessionHasOpenUi(strippable, StrippingUiKey.Key, actor.PlayerSession))
- return;
- _userInterfaceSystem.TryOpen(strippable, StrippingUiKey.Key, actor.PlayerSession);
+ _userInterfaceSystem.OpenUi(strippable.Owner, StrippingUiKey.Key, user);
}
}
private void OnStripButtonPressed(Entity<StrippableComponent> strippable, ref StrippingSlotButtonPressed args)
{
- if (args.Session.AttachedEntity is not { Valid: true } user ||
+ if (args.Actor is not { Valid: true } user ||
!TryComp<HandsComponent>(user, out var userHands))
return;
private void OnStripEnsnareMessage(EntityUid uid, EnsnareableComponent component, StrippingEnsnareButtonPressed args)
{
- if (args.Session.AttachedEntity is not { Valid: true } user)
+ if (args.Actor is not { Valid: true } user)
return;
foreach (var entity in component.Container.ContainedEntities)
private void OnSubnetRequest(EntityUid uid, SurveillanceCameraMonitorComponent component,
SurveillanceCameraMonitorSubnetRequestMessage args)
{
- if (args.Session.AttachedEntity != null)
+ if (args.Actor != null)
{
SetActiveSubnet(uid, args.Subnet, component);
}
private void OnBoundUiClose(EntityUid uid, SurveillanceCameraMonitorComponent component, BoundUIClosedEvent args)
{
- if (args.Session.AttachedEntity == null)
- {
- return;
- }
-
- RemoveViewer(uid, args.Session.AttachedEntity.Value, component);
+ RemoveViewer(uid, args.Actor, component);
}
+
#endregion
private void SendHeartbeat(EntityUid uid, SurveillanceCameraMonitorComponent? monitor = null)
}
var state = new SurveillanceCameraMonitorUiState(GetNetEntity(monitor.ActiveCamera), monitor.KnownSubnets.Keys.ToHashSet(), monitor.ActiveCameraAddress, monitor.ActiveSubnet, monitor.KnownCameras);
- _userInterface.TrySetUiState(uid, SurveillanceCameraMonitorUiKey.Key, state);
+ _userInterface.SetUiState(uid, SurveillanceCameraMonitorUiKey.Key, state);
}
}
UpdateSetupInterface(uid, component);
}
- private void OpenSetupInterface(EntityUid uid, EntityUid player, SurveillanceCameraRouterComponent? camera = null, ActorComponent? actor = null)
+ private void OpenSetupInterface(EntityUid uid, EntityUid player, SurveillanceCameraRouterComponent? camera = null)
{
- if (!Resolve(uid, ref camera) || !Resolve(player, ref actor))
+ if (!Resolve(uid, ref camera))
return;
- if (!_userInterface.TryGetUi(uid, SurveillanceCameraSetupUiKey.Router, out var bui))
+
+ if (!_userInterface.TryOpenUi(uid, SurveillanceCameraSetupUiKey.Router, player))
return;
- _userInterface.OpenUi(bui, actor.PlayerSession);
UpdateSetupInterface(uid, camera);
}
if (router.AvailableNetworks.Count == 0 || router.SubnetFrequencyId != null)
{
- _userInterface.TryCloseAll(uid, SurveillanceCameraSetupUiKey.Router);
+ _userInterface.CloseUi(uid, SurveillanceCameraSetupUiKey.Router);
return;
}
var state = new SurveillanceCameraSetupBoundUiState(router.SubnetName, deviceNet.ReceiveFrequency ?? 0,
router.AvailableNetworks, true, router.SubnetFrequencyId != null);
- _userInterface.TrySetUiState(uid, SurveillanceCameraSetupUiKey.Router, state);
+ _userInterface.SetUiState(uid, SurveillanceCameraSetupUiKey.Router, state);
}
private void SendHeartbeat(EntityUid uid, string origin, string destination,
UpdateSetupInterface(uid, component);
}
- private void OpenSetupInterface(EntityUid uid, EntityUid player, SurveillanceCameraComponent? camera = null, ActorComponent? actor = null)
+ private void OpenSetupInterface(EntityUid uid, EntityUid player, SurveillanceCameraComponent? camera = null)
{
- if (!Resolve(uid, ref camera) || !Resolve(player, ref actor))
+ if (!Resolve(uid, ref camera))
return;
- if (!_userInterface.TryGetUi(uid, SurveillanceCameraSetupUiKey.Camera, out var bui))
+
+ if (!_userInterface.TryOpenUi(uid, SurveillanceCameraSetupUiKey.Camera, player))
return;
- _userInterface.OpenUi(bui, actor.PlayerSession);
UpdateSetupInterface(uid, camera);
}
if (camera.NameSet && camera.NetworkSet)
{
- _userInterface.TryCloseAll(uid, SurveillanceCameraSetupUiKey.Camera);
+ _userInterface.CloseUi(uid, SurveillanceCameraSetupUiKey.Camera);
return;
}
}
else if (!camera.NetworkSet)
{
- _userInterface.TryCloseAll(uid, SurveillanceCameraSetupUiKey.Camera);
+ _userInterface.CloseUi(uid, SurveillanceCameraSetupUiKey.Camera);
return;
}
}
var state = new SurveillanceCameraSetupBoundUiState(camera.CameraId, deviceNet.ReceiveFrequency ?? 0,
camera.AvailableNetworks, camera.NameSet, camera.NetworkSet);
- _userInterface.TrySetUiState(uid, SurveillanceCameraSetupUiKey.Camera, state);
+ _userInterface.SetUiState(uid, SurveillanceCameraSetupUiKey.Camera, state);
}
// If the camera deactivates for any reason, it must have all viewers removed,
data.Add(i, info);
}
- _ui.TrySetUiState(uid, ThiefBackpackUIKey.Key, new ThiefBackpackBoundUserInterfaceState(data, MaxSelectedSets));
+ _ui.SetUiState(uid, ThiefBackpackUIKey.Key, new ThiefBackpackBoundUserInterfaceState(data, MaxSelectedSets));
}
}
/// <summary>
/// List of UIs and their actions that this entity has.
/// </summary>
- [DataField("uis", required: true)] public List<IntrinsicUIEntry> UIs = new();
+ [DataField("uis", required: true)] public Dictionary<Enum, IntrinsicUIEntry> UIs = new();
}
[DataDefinition]
-public partial class IntrinsicUIEntry
+public sealed partial class IntrinsicUIEntry
{
- /// <summary>
- /// The BUI key that this intrinsic UI should open.
- /// </summary>
- [DataField("key", required: true)]
- public Enum? Key { get; private set; }
-
[DataField("toggleAction", customTypeSerializer: typeof(PrototypeIdSerializer<EntityPrototype>), required: true)]
public string? ToggleAction;
private void OnActionToggle(EntityUid uid, IntrinsicUIComponent component, ToggleIntrinsicUIEvent args)
{
+ if (args.Key == null)
+ return;
+
args.Handled = InteractUI(uid, args.Key, component);
}
private void InitActions(EntityUid uid, IntrinsicUIComponent component, MapInitEvent args)
{
- foreach (var entry in component.UIs)
+ foreach (var entry in component.UIs.Values)
{
_actionsSystem.AddAction(uid, ref entry.ToggleActionEntity, entry.ToggleAction);
}
}
- public bool InteractUI(EntityUid uid, Enum? key, IntrinsicUIComponent? iui = null, ActorComponent? actor = null)
+ public bool InteractUI(EntityUid uid, Enum key, IntrinsicUIComponent? iui = null, ActorComponent? actor = null)
{
if (!Resolve(uid, ref iui, ref actor))
return false;
- if (key is null)
- {
- Log.Error($"Entity {ToPrettyString(uid)} has an invalid intrinsic UI.");
- }
-
- var ui = GetUIOrNull(uid, key, iui);
-
- if (ui is null)
- {
- Log.Error($"Couldn't get UI {key} on {ToPrettyString(uid)}");
- return false;
- }
-
var attempt = new IntrinsicUIOpenAttemptEvent(uid, key);
RaiseLocalEvent(uid, attempt);
if (attempt.Cancelled)
return false;
- _uiSystem.ToggleUi(ui, actor.PlayerSession);
- return true;
- }
-
- private PlayerBoundUserInterface? GetUIOrNull(EntityUid uid, Enum? key, IntrinsicUIComponent? component = null)
- {
- if (!Resolve(uid, ref component))
- return null;
-
- return key is null ? null : _uiSystem.GetUiOrNull(uid, key);
+ return _uiSystem.TryToggleUi(uid, key, actor.PlayerSession);
}
}
{
var state = new VendingMachineInterfaceState(GetAllInventory(uid, component));
- _userInterfaceSystem.TrySetUiState(uid, VendingMachineUiKey.Key, state);
+ _userInterfaceSystem.SetUiState(uid, VendingMachineUiKey.Key, state);
}
private void OnInventoryEjectMessage(EntityUid uid, VendingMachineComponent component, VendingMachineEjectMessage args)
if (!this.IsPowered(uid, EntityManager))
return;
- if (args.Session.AttachedEntity is not { Valid: true } entity || Deleted(entity))
+ if (args.Actor is not { Valid: true } entity || Deleted(entity))
return;
AuthorizedVend(uid, entity, args.Type, args.ID, component);
{
if (message.Name.Length > HumanoidCharacterProfile.MaxNameLength || message.Name.Length <= 0)
{
- _popupSystem.PopupEntity(Loc.GetString("voice-mask-popup-failure"), uid, message.Session, PopupType.SmallCaution);
+ _popupSystem.PopupEntity(Loc.GetString("voice-mask-popup-failure"), uid, message.Actor, PopupType.SmallCaution);
return;
}
component.VoiceName = message.Name;
- if (message.Session.AttachedEntity != null)
- _adminLogger.Add(LogType.Action, LogImpact.Medium, $"{ToPrettyString(message.Session.AttachedEntity.Value):player} set voice of {ToPrettyString(uid):mask}: {component.VoiceName}");
- else
- _adminLogger.Add(LogType.Action, LogImpact.Medium, $"Voice of {ToPrettyString(uid):mask} set: {component.VoiceName}");
+ _adminLogger.Add(LogType.Action, LogImpact.Medium, $"{ToPrettyString(message.Actor):player} set voice of {ToPrettyString(uid):mask}: {component.VoiceName}");
- _popupSystem.PopupEntity(Loc.GetString("voice-mask-popup-success"), uid, message.Session);
+ _popupSystem.PopupEntity(Loc.GetString("voice-mask-popup-success"), uid, message.Actor);
TrySetLastKnownName(uid, message.Name);
ent.Comp.SpeechVerb = msg.Verb;
// verb is only important to metagamers so no need to log as opposed to name
- _popupSystem.PopupEntity(Loc.GetString("voice-mask-popup-success"), ent, msg.Session);
+ _popupSystem.PopupEntity(Loc.GetString("voice-mask-popup-success"), ent, msg.Actor);
TrySetLastSpeechVerb(ent, msg.Verb);
ent.Comp.Enabled = !args.IsToggled;
}
- private void OpenUI(EntityUid player, ActorComponent? actor = null)
+ private void OpenUI(EntityUid player)
{
- if (!Resolve(player, ref actor))
- return;
- if (!_uiSystem.TryGetUi(player, VoiceMaskUIKey.Key, out var bui))
+ if (!_uiSystem.HasUi(player, VoiceMaskUIKey.Key))
return;
- _uiSystem.OpenUi(bui, actor.PlayerSession);
+ _uiSystem.OpenUi(player, VoiceMaskUIKey.Key, player);
UpdateUI(player);
}
return;
}
- if (_uiSystem.TryGetUi(owner, VoiceMaskUIKey.Key, out var bui))
- _uiSystem.SetUiState(bui, new VoiceMaskBuiState(component.VoiceName, component.SpeechVerb));
+ if (_uiSystem.HasUi(owner, VoiceMaskUIKey.Key))
+ _uiSystem.SetUiState(owner, VoiceMaskUIKey.Key, new VoiceMaskBuiState(component.VoiceName, component.SpeechVerb));
}
}
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
+using ActivatableUISystem = Content.Shared.UserInterface.ActivatableUISystem;
namespace Content.Server.Wires;
private void OnWiresActionMessage(EntityUid uid, WiresComponent component, WiresActionMessage args)
{
- if (args.Session.AttachedEntity == null)
+ if (args.Actor == null)
{
return;
}
- var player = (EntityUid) args.Session.AttachedEntity;
+ var player = (EntityUid) args.Actor;
if (!EntityManager.TryGetComponent(player, out HandsComponent? handsComponent))
{
{
if (TryComp(args.User, out ActorComponent? actor))
{
- _uiSystem.TryOpen(uid, WiresUiKey.Key, actor.PlayerSession);
+ _uiSystem.OpenUi(uid, WiresUiKey.Key, actor.PlayerSession);
args.Handled = true;
}
}
{
if (args.Open)
return;
- _uiSystem.TryCloseAll(ent, WiresUiKey.Key);
+
+ _uiSystem.CloseUi(ent.Owner, WiresUiKey.Key);
}
private void OnAttemptOpenActivatableUI(EntityUid uid, ActivatableUIRequiresPanelComponent component, ActivatableUIOpenAttemptEvent args)
statuses.Sort((a, b) => a.position.CompareTo(b.position));
- _uiSystem.TrySetUiState(uid, WiresUiKey.Key, new WiresBoundUserInterfaceState(
+ _uiSystem.SetUiState((uid, ui), WiresUiKey.Key, new WiresBoundUserInterfaceState(
clientList.ToArray(),
statuses.Select(p => new StatusEntry(p.key, p.value)).ToArray(),
Loc.GetString(wires.BoardName),
wires.SerialNumber,
- wires.WireSeed), ui: ui);
+ wires.WireSeed));
}
public void OpenUserInterface(EntityUid uid, ICommonSession player)
{
- if (_uiSystem.TryGetUi(uid, WiresUiKey.Key, out var ui))
- _uiSystem.OpenUi(ui, player);
+ _uiSystem.OpenUi(uid, WiresUiKey.Key, player);
}
/// <summary>
if (!args.WiresAccessible)
{
- _uiSystem.TryCloseAll(uid, WiresUiKey.Key);
+ _uiSystem.CloseUi(uid, WiresUiKey.Key);
}
}
var state = new AnalysisConsoleUpdateState(GetNetEntity(artifact), analyzerConnected, serverConnected,
canScan, canPrint, msg, scanning, paused, active?.StartTime, active?.AccumulatedRunTime, totalTime, points, biasDirection == BiasDirection.Down);
- var bui = _ui.GetUi(uid, ArtifactAnalzyerUiKey.Key);
- _ui.SetUiState(bui, state);
+ _ui.SetUiState(uid, ArtifactAnalzyerUiKey.Key, state);
}
/// <summary>
/// <param name="args"></param>
private void OnServerSelectionMessage(EntityUid uid, AnalysisConsoleComponent component, AnalysisConsoleServerSelectionMessage args)
{
- _ui.TryOpen(uid, ResearchClientUiKey.Key, args.Session);
+ _ui.OpenUi(uid, ResearchClientUiKey.Key, args.Actor);
}
/// <summary>
-namespace Content.Shared.Administration.Components;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Administration.Components;
/// <summary>
/// Flips the target's sprite on it's head, so they do a headstand.
/// </summary>
+[NetworkedComponent]
public abstract partial class SharedHeadstandComponent : Component { }
-namespace Content.Shared.Administration.Components;
+using Robust.Shared.GameStates;
+namespace Content.Shared.Administration.Components;
+
+[NetworkedComponent]
public abstract partial class SharedKillSignComponent : Component
{
var newTransferAmount = FixedPoint2.Clamp(message.Value, ent.Comp.MinimumTransferAmount, ent.Comp.MaximumTransferAmount);
ent.Comp.TransferAmount = newTransferAmount;
- if (message.Session.AttachedEntity is { Valid: true } user)
+ if (message.Actor is { Valid: true } user)
_popup.PopupClient(Loc.GetString("comp-solution-transfer-set-amount", ("amount", newTransferAmount)), ent, user);
}
if (!args.CanAccess || !args.CanInteract || !comp.CanChangeTransferAmount || args.Hands == null)
return;
- if (!TryComp<ActorComponent>(args.User, out var actor))
- return;
-
// Custom transfer verb
+ var @event = args;
+
args.Verbs.Add(new AlternativeVerb()
{
Text = Loc.GetString("comp-solution-transfer-verb-custom-amount"),
// TODO: remove server check when bui prediction is a thing
Act = () =>
{
- if (_net.IsServer)
- _ui.TryOpen(uid, TransferAmountUiKey.Key, actor.PlayerSession);
+ _ui.OpenUi(uid, TransferAmountUiKey.Key, @event.User);
},
Priority = 1
});
return;
if (args.TryEject && slot.HasItem)
- TryEjectToHands(uid, slot, args.Session.AttachedEntity, false);
- else if (args.TryInsert && !slot.HasItem && args.Session.AttachedEntity is EntityUid user)
- TryInsertFromHand(uid, slot, user);
+ TryEjectToHands(uid, slot, args.Actor, true);
+ else if (args.TryInsert && !slot.HasItem)
+ TryInsertFromHand(uid, slot, args.Actor);
}
#endregion
<Private>false</Private>
</ProjectReference>
</ItemGroup>
+ <ItemGroup>
+ <Folder Include="Power\Components\" />
+ </ItemGroup>
<Import Project="..\RobustToolbox\MSBuild\Robust.Properties.targets" />
<Import Project="..\RobustToolbox\MSBuild\Robust.CompNetworkGenerator.targets" />
</Project>
using Robust.Shared.Audio;
+using Robust.Shared.GameStates;
using Robust.Shared.Serialization;
namespace Content.Shared.Extinguisher;
+[NetworkedComponent]
public abstract partial class SharedFireExtinguisherComponent : Component
{
[DataField("refillSound")] public SoundSpecifier RefillSound = new SoundPathSpecifier("/Audio/Effects/refill.ogg");
public override void Initialize()
{
+ SubscribeLocalEvent<BoundUserInterfaceCheckRangeEvent>(HandleUserInterfaceRangeCheck);
SubscribeLocalEvent<BoundUserInterfaceMessageAttempt>(OnBoundInterfaceInteractAttempt);
+
SubscribeAllEvent<InteractInventorySlotEvent>(HandleInteractInventorySlotEvent);
+
SubscribeLocalEvent<UnremoveableComponent, ContainerGettingRemovedAttemptEvent>(OnRemoveAttempt);
SubscribeLocalEvent<UnremoveableComponent, GotUnequippedEvent>(OnUnequip);
SubscribeLocalEvent<UnremoveableComponent, GotUnequippedHandEvent>(OnUnequipHand);
/// </summary>
private void OnBoundInterfaceInteractAttempt(BoundUserInterfaceMessageAttempt ev)
{
- if (ev.Sender.AttachedEntity is not { } user || !_actionBlockerSystem.CanInteract(user, ev.Target))
+ var user = ev.Actor;
+
+ if (!_actionBlockerSystem.CanInteract(user, ev.Target))
{
ev.Cancel();
return;
RaiseLocalEvent(uidA, new ContactInteractionEvent(uidB.Value));
RaiseLocalEvent(uidB.Value, new ContactInteractionEvent(uidA));
}
+
+ private void HandleUserInterfaceRangeCheck(ref BoundUserInterfaceCheckRangeEvent ev)
+ {
+ if (ev.Result == BoundUserInterfaceRangeResult.Fail)
+ return;
+
+ if (InRangeUnobstructed(ev.Actor, ev.Target, ev.Data.InteractionRange))
+ {
+ ev.Result = BoundUserInterfaceRangeResult.Pass;
+ }
+ else
+ {
+ ev.Result = BoundUserInterfaceRangeResult.Fail;
+ }
+ }
}
/// <summary>
using Robust.Shared.Audio;
+using Robust.Shared.GameStates;
using Robust.Shared.Serialization;
namespace Content.Shared.Paper;
+[NetworkedComponent]
public abstract partial class SharedPaperComponent : Component
{
/// <summary>
--- /dev/null
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Power.Components;
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class ActivatableUIRequiresPowerComponent : Component
+{
+}
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using Content.Shared.ActionBlocker;
+using Content.Shared.Administration;
+using Content.Shared.Administration.Managers;
using Content.Shared.Containers.ItemSlots;
using Content.Shared.Destructible;
using Content.Shared.DoAfter;
+using Content.Shared.Ghost;
using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Implants.Components;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Robust.Shared.Serialization;
+using Robust.Shared.Utility;
namespace Content.Shared.Storage.EntitySystems;
{
[Dependency] private readonly IPrototypeManager _prototype = default!;
[Dependency] protected readonly IRobustRandom Random = default!;
+ [Dependency] private readonly ISharedAdminManager _admin = default!;
[Dependency] protected readonly ActionBlockerSystem ActionBlocker = default!;
[Dependency] private readonly EntityLookupSystem _entityLookupSystem = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
private FrozenDictionary<string, ItemSizePrototype> _nextSmallest = FrozenDictionary<string, ItemSizePrototype>.Empty;
private const string QuickInsertUseDelayID = "quickInsert";
+ private const string OpenUiUseDelayID = "storage";
protected readonly List<string> CantFillReasons = [];
_xformQuery = GetEntityQuery<TransformComponent>();
_prototype.PrototypesReloaded += OnPrototypesReloaded;
+ Subs.BuiEvents<StorageComponent>(StorageComponent.StorageUiKey.Key, subs =>
+ {
+ subs.Event<BoundUIClosedEvent>(OnBoundUIClosed);
+ });
+
SubscribeLocalEvent<StorageComponent, MapInitEvent>(OnMapInit);
+ SubscribeLocalEvent<StorageComponent, GetVerbsEvent<ActivationVerb>>(AddUiVerb);
SubscribeLocalEvent<StorageComponent, ComponentGetState>(OnStorageGetState);
SubscribeLocalEvent<StorageComponent, ComponentHandleState>(OnStorageHandleState);
SubscribeLocalEvent<StorageComponent, ComponentInit>(OnComponentInit, before: new[] { typeof(SharedContainerSystem) });
UpdatePrototypeCache();
}
- protected virtual void OnMapInit(Entity<StorageComponent> entity, ref MapInitEvent args)
+ private void OnMapInit(Entity<StorageComponent> entity, ref MapInitEvent args)
{
if (TryComp<UseDelayComponent>(entity, out var useDelayComp))
+ {
UseDelay.SetLength((entity, useDelayComp), entity.Comp.QuickInsertCooldown, QuickInsertUseDelayID);
+ UseDelay.SetLength((entity, useDelayComp), entity.Comp.OpenUiCooldown, OpenUiUseDelayID);
+ }
}
private void OnStorageGetState(EntityUid uid, StorageComponent component, ref ComponentGetState args)
args.State = new StorageComponentState()
{
Grid = new List<Box2i>(component.Grid),
- IsUiOpen = component.IsUiOpen,
MaxItemSize = component.MaxItemSize,
StoredItems = storedItems,
SavedLocations = component.SavedLocations
component.Grid.Clear();
component.Grid.AddRange(state.Grid);
- component.IsUiOpen = state.IsUiOpen;
component.MaxItemSize = state.MaxItemSize;
component.StoredItems.Clear();
UpdateAppearance((uid, storageComp, null));
}
- public virtual void UpdateUI(Entity<StorageComponent?> entity) {}
+ /// <summary>
+ /// If the user has nested-UIs open (e.g., PDA UI open when pda is in a backpack), close them.
+ /// </summary>
+ private void CloseNestedInterfaces(EntityUid uid, EntityUid actor, StorageComponent? storageComp = null)
+ {
+ if (!Resolve(uid, ref storageComp))
+ return;
- public virtual void OpenStorageUI(EntityUid uid, EntityUid entity, StorageComponent? storageComp = null, bool silent = false) { }
+ // for each containing thing
+ // if it has a storage comp
+ // ensure unsubscribe from session
+ // if it has a ui component
+ // close ui
+ foreach (var entity in storageComp.Container.ContainedEntities)
+ {
+ _ui.CloseUis(entity, actor);
+ }
+ }
+
+ private void OnBoundUIClosed(EntityUid uid, StorageComponent storageComp, BoundUIClosedEvent args)
+ {
+ CloseNestedInterfaces(uid, args.Actor, storageComp);
+
+ // If UI is closed for everyone
+ if (!_ui.IsUiOpen(uid, args.UiKey))
+ {
+ UpdateAppearance((uid, storageComp, null));
+ Audio.PlayPredicted(storageComp.StorageCloseSound, uid, args.Actor);
+ }
+ }
+
+ private void AddUiVerb(EntityUid uid, StorageComponent component, GetVerbsEvent<ActivationVerb> args)
+ {
+ var silent = false;
+ if (!args.CanAccess || !args.CanInteract || TryComp<LockComponent>(uid, out var lockComponent) && lockComponent.Locked)
+ {
+ // we allow admins to open the storage anyways
+ if (!_admin.HasAdminFlag(args.User, AdminFlags.Admin))
+ return;
+
+ silent = true;
+ }
+
+ silent |= HasComp<GhostComponent>(args.User);
+
+ // Does this player currently have the storage UI open?
+ var uiOpen = _ui.IsUiOpen(uid, StorageComponent.StorageUiKey.Key, args.User);
+
+ ActivationVerb verb = new()
+ {
+ Act = () =>
+ {
+ if (uiOpen)
+ {
+ _ui.CloseUi(uid, StorageComponent.StorageUiKey.Key, args.User);
+ }
+ else
+ {
+ OpenStorageUI(uid, args.User, component, silent);
+ }
+ }
+ };
+
+ if (uiOpen)
+ {
+ verb.Text = Loc.GetString("comp-storage-verb-close-storage");
+ verb.Icon = new SpriteSpecifier.Texture(
+ new("/Textures/Interface/VerbIcons/close.svg.192dpi.png"));
+ }
+ else
+ {
+ verb.Text = Loc.GetString("comp-storage-verb-open-storage");
+ verb.Icon = new SpriteSpecifier.Texture(
+ new("/Textures/Interface/VerbIcons/open.svg.192dpi.png"));
+ }
+ args.Verbs.Add(verb);
+ }
+
+ /// <summary>
+ /// Opens the storage UI for an entity
+ /// </summary>
+ /// <param name="entity">The entity to open the UI for</param>
+ public void OpenStorageUI(EntityUid uid, EntityUid entity, StorageComponent? storageComp = null, bool silent = false)
+ {
+ if (!Resolve(uid, ref storageComp, false))
+ return;
+
+ // prevent spamming bag open / honkerton honk sound
+ silent |= TryComp<UseDelayComponent>(uid, out var useDelay) && UseDelay.IsDelayed((uid, useDelay));
+ if (!silent)
+ {
+ if (!_ui.IsUiOpen(uid, StorageComponent.StorageUiKey.Key))
+ Audio.PlayPredicted(storageComp.StorageOpenSound, uid, entity);
+
+ if (useDelay != null)
+ UseDelay.TryResetDelay((uid, useDelay));
+ }
+
+ _ui.OpenUi(uid, StorageComponent.StorageUiKey.Key, entity);
+ }
+
+ public virtual void UpdateUI(Entity<StorageComponent?> entity) {}
private void AddTransferVerbs(EntityUid uid, StorageComponent component, GetVerbsEvent<UtilityVerb> args)
{
if (args.Handled || TryComp<LockComponent>(uid, out var lockComponent) && lockComponent.Locked)
return;
- OpenStorageUI(uid, args.User, storageComp);
+ // Toggle
+ if (_ui.IsUiOpen(uid, StorageComponent.StorageUiKey.Key, args.User))
+ {
+ _ui.CloseUi(uid, StorageComponent.StorageUiKey.Key, args.User);
+ }
+ else
+ {
+ OpenStorageUI(uid, args.User, storageComp);
+ }
+
args.Handled = true;
}
if (!TryComp<StorageComponent>(uid, out var storageComp))
return;
- if (!_ui.TryGetUi(uid, StorageComponent.StorageUiKey.Key, out var bui) ||
- !bui.SubscribedSessions.Contains(args.SenderSession))
+ if (!_ui.IsUiOpen(uid, StorageComponent.StorageUiKey.Key, player))
return;
if (!Exists(entity))
if (!TryComp<StorageComponent>(storageEnt, out var storageComp))
return;
- if (!_ui.TryGetUi(storageEnt, StorageComponent.StorageUiKey.Key, out var bui) ||
- !bui.SubscribedSessions.Contains(args.SenderSession))
+ if (!_ui.IsUiOpen(storageEnt, StorageComponent.StorageUiKey.Key, player))
return;
if (!Exists(itemEnt))
if (!TryComp<StorageComponent>(storageEnt, out var storageComp))
return;
- if (!_ui.TryGetUi(storageEnt, StorageComponent.StorageUiKey.Key, out var bui) ||
- !bui.SubscribedSessions.Contains(args.SenderSession))
+ if (!_ui.IsUiOpen(storageEnt, StorageComponent.StorageUiKey.Key, player))
return;
if (!Exists(itemEnt))
if (!TryComp<StorageComponent>(storageEnt, out var storageComp))
return;
- if (!_ui.TryGetUi(storageEnt, StorageComponent.StorageUiKey.Key, out var bui) ||
- !bui.SubscribedSessions.Contains(args.SenderSession))
+ if (!_ui.IsUiOpen(storageEnt, StorageComponent.StorageUiKey.Key, player))
return;
if (!Exists(itemEnt))
var storage = GetEntity(msg.Storage);
var item = GetEntity(msg.Item);
- if (!TryComp<StorageComponent>(storage, out var storageComp))
+ if (!HasComp<StorageComponent>(storage))
return;
- if (!_ui.TryGetUi(storage, StorageComponent.StorageUiKey.Key, out var bui) ||
- !bui.SubscribedSessions.Contains(args.SenderSession))
+ if (!_ui.IsUiOpen(storage, StorageComponent.StorageUiKey.Key, player))
return;
if (!Exists(item))
private void OnBoundUIOpen(EntityUid uid, StorageComponent storageComp, BoundUIOpenedEvent args)
{
- if (!storageComp.IsUiOpen)
- {
- storageComp.IsUiOpen = true;
- UpdateAppearance((uid, storageComp, null));
- }
+ UpdateAppearance((uid, storageComp, null));
}
private void OnEntInserted(Entity<StorageComponent> entity, ref EntInsertedIntoContainerMessage args)
var capacity = storage.Grid.GetArea();
var used = GetCumulativeItemAreas((uid, storage));
+ var isOpen = _ui.IsUiOpen(entity.Owner, StorageComponent.StorageUiKey.Key);
+
_appearance.SetData(uid, StorageVisuals.StorageUsed, used, appearance);
_appearance.SetData(uid, StorageVisuals.Capacity, capacity, appearance);
- _appearance.SetData(uid, StorageVisuals.Open, storage.IsUiOpen, appearance);
- _appearance.SetData(uid, SharedBagOpenVisuals.BagState, storage.IsUiOpen ? SharedBagState.Open : SharedBagState.Closed, appearance);
- _appearance.SetData(uid, StackVisuals.Hide, !storage.IsUiOpen, appearance);
+ _appearance.SetData(uid, StorageVisuals.Open, isOpen, appearance);
+ _appearance.SetData(uid, SharedBagOpenVisuals.BagState, isOpen ? SharedBagState.Open : SharedBagState.Closed, appearance);
+ _appearance.SetData(uid, StackVisuals.Hide, !isOpen, appearance);
}
/// <summary>
[Serializable, NetSerializable]
protected sealed class StorageComponentState : ComponentState
{
- public bool IsUiOpen;
-
public Dictionary<NetEntity, ItemStorageLocation> StoredItems = new();
public Dictionary<string, List<ItemStorageLocation>> SavedLocations = new();
{
public static string ContainerId = "storagebase";
- // TODO: This fucking sucks
- [ViewVariables(VVAccess.ReadWrite), DataField]
- public bool IsUiOpen;
-
[ViewVariables]
public Container Container = default!;
}
}
- /// <summary>
- /// An extra BUI message that either opens, closes, or focuses the storage window based on context.
- /// </summary>
- [Serializable, NetSerializable]
- public sealed class StorageModifyWindowMessage : BoundUserInterfaceMessage
- {
-
- }
-
[NetSerializable]
[Serializable]
public enum StorageVisuals : byte
using Content.Shared.Whitelist;
-using Robust.Server.GameObjects;
-using Robust.Server.Player;
-using Robust.Shared.Player;
+using Robust.Shared.GameStates;
using Robust.Shared.Serialization.TypeSerializers.Implementations;
-namespace Content.Server.UserInterface
+namespace Content.Shared.UserInterface
{
- [RegisterComponent]
+ [RegisterComponent, NetworkedComponent]
public sealed partial class ActivatableUIComponent : Component
{
- [DataField(required: true, customTypeSerializer:typeof(EnumSerializer))]
- public Enum? Key { get; set; }
+ [DataField(required: true, customTypeSerializer: typeof(EnumSerializer))]
+ public Enum Key { get; set; } = default!;
[ViewVariables(VVAccess.ReadWrite)]
[DataField]
/// NOTE: DO NOT DIRECTLY SET, USE ActivatableUISystem.SetCurrentSingleUser
/// </summary>
[ViewVariables]
- public ICommonSession? CurrentSingleUser;
+ public EntityUid? CurrentSingleUser;
}
}
public sealed class AfterActivatableUIOpenEvent : EntityEventArgs
{
public EntityUid User { get; }
- public readonly ICommonSession Session;
+ public readonly EntityUid Actor;
- public AfterActivatableUIOpenEvent(EntityUid who, ICommonSession session)
+ public AfterActivatableUIOpenEvent(EntityUid who, EntityUid actor)
{
User = who;
- Session = session;
+ Actor = actor;
}
}
-using Content.Server.PowerCell;
using Content.Shared.PowerCell;
-using Content.Shared.UserInterface;
+using Robust.Shared.GameStates;
-namespace Content.Server.UserInterface;
+namespace Content.Shared.UserInterface;
/// <summary>
/// Specifies that the attached entity requires <see cref="PowerCellDrawComponent"/> power.
/// </summary>
-[RegisterComponent]
+[RegisterComponent, NetworkedComponent]
public sealed partial class ActivatableUIRequiresPowerCellComponent : Component
{
-using Content.Server.PowerCell;
using Content.Shared.PowerCell;
-using Content.Shared.UserInterface;
using Robust.Shared.Containers;
-namespace Content.Server.UserInterface;
+namespace Content.Shared.UserInterface;
public sealed partial class ActivatableUISystem
{
- [Dependency] private readonly PowerCellSystem _cell = default!;
+ [Dependency] private readonly SharedPowerCellSystem _cell = default!;
private void InitializePower()
{
_cell.SetPowerCellDrawEnabled(uid, false);
if (HasComp<ActivatableUIRequiresPowerCellComponent>(uid) &&
- TryComp<ActivatableUIComponent>(uid, out var activatable) &&
- activatable.Key != null)
+ TryComp<ActivatableUIComponent>(uid, out var activatable))
{
- _uiSystem.TryCloseAll(uid, activatable.Key);
+ _uiSystem.CloseUi(uid, activatable.Key);
}
}
/// </summary>
public void CheckUsage(EntityUid uid, ActivatableUIComponent? active = null, ActivatableUIRequiresPowerCellComponent? component = null, PowerCellDrawComponent? draw = null)
{
- if (!Resolve(uid, ref component, ref draw, ref active, false) || active.Key == null)
+ if (!Resolve(uid, ref component, ref draw, ref active, false))
return;
- if (_cell.HasCharge(uid, draw.UseRate))
+ if (_cell.HasActivatableCharge(uid))
return;
- _uiSystem.TryCloseAll(uid, active.Key);
+ _uiSystem.CloseUi(uid, active.Key);
}
private void OnBatteryOpenAttempt(EntityUid uid, ActivatableUIRequiresPowerCellComponent component, ActivatableUIOpenAttemptEvent args)
return;
// Check if we have the appropriate drawrate / userate to even open it.
- if (args.Cancelled || !_cell.HasCharge(uid, MathF.Max(draw.DrawRate, draw.UseRate), user: args.User))
+ if (args.Cancelled ||
+ !_cell.HasActivatableCharge(uid, draw, user: args.User) ||
+ !_cell.HasDrawCharge(uid, draw, user: args.User))
{
args.Cancel();
- return;
}
}
}
-using Content.Server.Administration.Managers;
using Content.Shared.ActionBlocker;
+using Content.Shared.Administration.Managers;
using Content.Shared.Ghost;
using Content.Shared.Hands;
using Content.Shared.Hands.Components;
using Content.Shared.Interaction;
using Content.Shared.Interaction.Events;
using Content.Shared.Popups;
-using Content.Shared.UserInterface;
using Content.Shared.Verbs;
-using Robust.Server.GameObjects;
using Robust.Shared.Player;
-namespace Content.Server.UserInterface;
+namespace Content.Shared.UserInterface;
public sealed partial class ActivatableUISystem : EntitySystem
{
- [Dependency] private readonly IAdminManager _adminManager = default!;
+ [Dependency] private readonly ISharedAdminManager _adminManager = default!;
[Dependency] private readonly ActionBlockerSystem _blockerSystem = default!;
- [Dependency] private readonly UserInterfaceSystem _uiSystem = default!;
+ [Dependency] private readonly SharedUserInterfaceSystem _uiSystem = default!;
[Dependency] private readonly SharedPopupSystem _popupSystem = default!;
public override void Initialize()
if (!comp.RequireHands)
return;
- if (!TryComp(ev.Sender.AttachedEntity, out HandsComponent? hands) || hands.Hands.Count == 0)
+ if (!TryComp(ev.Actor, out HandsComponent? hands) || hands.Hands.Count == 0)
ev.Cancel();
}
private void OnUIClose(EntityUid uid, ActivatableUIComponent component, BoundUIClosedEvent args)
{
- if (args.Session != component.CurrentSingleUser)
+ var user = args.Actor;
+
+ if (user != component.CurrentSingleUser)
return;
if (!Equals(args.UiKey, component.Key))
private bool InteractUI(EntityUid user, EntityUid uiEntity, ActivatableUIComponent aui)
{
- if (!TryComp(user, out ActorComponent? actor))
- return false;
-
- if (aui.Key == null)
+ if (!_uiSystem.HasUi(uiEntity, aui.Key))
return false;
- if (!_uiSystem.TryGetUi(uiEntity, aui.Key, out var ui))
- return false;
-
- if (ui.SubscribedSessions.Contains(actor.PlayerSession))
+ if (_uiSystem.IsUiOpen(uiEntity, aui.Key, user))
{
- _uiSystem.CloseUi(ui, actor.PlayerSession);
+ _uiSystem.CloseUi(uiEntity, aui.Key, user);
return true;
}
if (aui.RequireHands && !HasComp<HandsComponent>(user))
return false;
- if (aui.AdminOnly && !_adminManager.IsAdmin(actor.PlayerSession))
+ if (aui.AdminOnly && !_adminManager.IsAdmin(user))
return false;
- if (aui.SingleUser && (aui.CurrentSingleUser != null) && (actor.PlayerSession != aui.CurrentSingleUser))
+ if (aui.SingleUser && aui.CurrentSingleUser != null && user != aui.CurrentSingleUser)
{
string message = Loc.GetString("machine-already-in-use", ("machine", uiEntity));
_popupSystem.PopupEntity(message, uiEntity, user);
// If we get here, supposedly, the object is in use.
// Check with BUI that it's ACTUALLY in use just in case.
// Since this could brick the object if it goes wrong.
- if (ui.SubscribedSessions.Count != 0)
+ if (_uiSystem.IsUiOpen(uiEntity, aui.Key))
return false;
}
var bae = new BeforeActivatableUIOpenEvent(user);
RaiseLocalEvent(uiEntity, bae);
- SetCurrentSingleUser(uiEntity, actor.PlayerSession, aui);
- _uiSystem.OpenUi(ui, actor.PlayerSession);
+ SetCurrentSingleUser(uiEntity, user, aui);
+ _uiSystem.OpenUi(uiEntity, aui.Key, user);
//Let the component know a user opened it so it can do whatever it needs to do
- var aae = new AfterActivatableUIOpenEvent(user, actor.PlayerSession);
+ var aae = new AfterActivatableUIOpenEvent(user, user);
RaiseLocalEvent(uiEntity, aae);
return true;
}
- public void SetCurrentSingleUser(EntityUid uid, ICommonSession? v, ActivatableUIComponent? aui = null)
+ public void SetCurrentSingleUser(EntityUid uid, EntityUid? user, ActivatableUIComponent? aui = null)
{
if (!Resolve(uid, ref aui))
return;
+
if (!aui.SingleUser)
return;
- aui.CurrentSingleUser = v;
+ aui.CurrentSingleUser = user;
RaiseLocalEvent(uid, new ActivatableUIPlayerChangedEvent());
}
if (!Resolve(uid, ref aui, false))
return;
- if (aui.Key == null || !_uiSystem.TryGetUi(uid, aui.Key, out var ui))
+ if (!_uiSystem.HasUi(uid, aui.Key))
return;
- _uiSystem.CloseAll(ui);
+ _uiSystem.CloseUi(uid, aui.Key);
}
private void OnHandDeselected(EntityUid uid, ActivatableUIComponent? aui, HandDeselectedEvent args)
key: enum.PaperUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.PaperUiKey.Key
- type: PaperBoundUserInterface
+ enum.PaperUiKey.Key:
+ type: PaperBoundUserInterface
- type: Paper
content: book-text-holoparasite-info
ents: []
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
# to prevent bag open/honk spam
- type: UseDelay
delay: 0.5
- type: Sprite
sprite: Clothing/Back/Backpacks/syndicate.rsi
- type: ExplosionResistance
- damageCoefficient: 0.1
+ damageCoefficient: 0.1
#Special
- type: entity
default: ClothingBackpack
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
+ enum.StorageUiKey.Key:
type: StorageBoundUserInterface
- - key: enum.ChameleonUiKey.Key
+ enum.ChameleonUiKey.Key:
type: ChameleonBoundUserInterface
- type: entity
canChangeTransferAmount: true
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: DrawableSolution
solution: tank
- type: RefillableSolution
ents: []
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: entity
abstract: true
default: ClothingHeadsetGrey
- type: UserInterface
interfaces:
- - key: enum.ChameleonUiKey.Key
+ enum.ChameleonUiKey.Key:
type: ChameleonBoundUserInterface
default: ClothingEyesGlassesSunglasses
- type: UserInterface
interfaces:
- - key: enum.ChameleonUiKey.Key
+ enum.ChameleonUiKey.Key:
type: ChameleonBoundUserInterface
- type: Actions
- type: UserInterface
interfaces:
- - key: enum.MeleeSpeechUiKey.Key
+ enum.MeleeSpeechUiKey.Key:
type: MeleeSpeechBoundUserInterface
- type: StaticPrice
price: 0
- type: FingerprintMask
- type: UserInterface
interfaces:
- - key: enum.ChameleonUiKey.Key
+ enum.ChameleonUiKey.Key:
type: ChameleonBoundUserInterface
-
+
- type: entity
parent: ClothingHandsChameleon
id: ClothingHandsChameleonThief
- 0,0,0,0
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
+ enum.StorageUiKey.Key:
type: StorageBoundUserInterface
- type: ContainerContainer
containers:
- 0,0,0,0
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: ContainerContainer
containers:
storagebase: !type:Container
default: ClothingHeadHatBeret
- type: UserInterface
interfaces:
- - key: enum.ChameleonUiKey.Key
+ enum.ChameleonUiKey.Key:
type: ChameleonBoundUserInterface
- type: IdentityBlocker # need that for default ClothingMaskGas
- type: UserInterface
interfaces:
- - key: enum.ChameleonUiKey.Key
+ enum.ChameleonUiKey.Key:
type: ChameleonBoundUserInterface
- type: HideLayerClothing
slots:
default: ClothingNeckScarfStripedRed
- type: UserInterface
interfaces:
- - key: enum.ChameleonUiKey.Key
+ enum.ChameleonUiKey.Key:
type: ChameleonBoundUserInterface
ents: []
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: StaticPrice
price: 70
default: ClothingOuterVest
- type: UserInterface
interfaces:
- - key: enum.ChameleonUiKey.Key
+ enum.ChameleonUiKey.Key:
type: ChameleonBoundUserInterface
key: enum.SharedGasTankUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.SharedGasTankUiKey.Key
+ enum.SharedGasTankUiKey.Key:
type: GasTankBoundUserInterface
- type: Explosive
explosionType: Default
default: ClothingShoesColorBlack
- type: UserInterface
interfaces:
- - key: enum.ChameleonUiKey.Key
+ enum.ChameleonUiKey.Key:
type: ChameleonBoundUserInterface
- type: entity
default: ClothingUniformJumpsuitColorBlack
- type: UserInterface
interfaces:
- - key: enum.ChameleonUiKey.Key
- type: ChameleonBoundUserInterface
\ No newline at end of file
+ enum.ChameleonUiKey.Key:
+ type: ChameleonBoundUserInterface
locPrefix: silicon
- type: UserInterface
interfaces:
- - key: enum.SiliconLawsUiKey.Key
- type: SiliconLawBoundUserInterface
- - key: enum.BorgUiKey.Key
- type: BorgBoundUserInterface
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.SiliconLawsUiKey.Key:
+ type: SiliconLawBoundUserInterface
+ enum.BorgUiKey.Key:
+ type: BorgBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: ActivatableUI
key: enum.BorgUiKey.Key
- type: SiliconLawBound
- id: FoodMeat
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: DamageStateVisuals
states:
Alive:
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: Sprite
drawdepth: Mobs
layers:
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: DamageStateVisuals
states:
Alive:
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: DamageStateVisuals
states:
Alive:
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: DamageStateVisuals
states:
Alive:
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: DamageStateVisuals
states:
Alive:
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: DamageStateVisuals
states:
Alive:
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: DamageStateVisuals
states:
Alive:
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: DamageStateVisuals
states:
Alive:
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: DamageStateVisuals
states:
Alive:
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: DamageStateVisuals
states:
Alive:
bloodMaxVolume: 60
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: DamageStateVisuals
states:
Alive:
- id: BikeHorn
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: MobThresholds
thresholds:
0: Alive
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: DamageStateVisuals
states:
Alive:
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: DamageStateVisuals
states:
Alive:
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: DamageStateVisuals
states:
Alive:
softness: 1
- type: UserInterface
interfaces:
- - key: enum.StoreUiKey.Key
- type: StoreBoundUserInterface
+ enum.StoreUiKey.Key:
+ type: StoreBoundUserInterface
- type: Visibility
layer: 2 #ghost vis layer
- type: Store
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: Sprite
layers:
- map: ["enum.DamageStateVisualLayers.Base"]
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
- type: entity
id: MobKangarooSpaceSalvage
- CentralCommand
- type: UserInterface
interfaces:
- - key: enum.SolarControlConsoleUiKey.Key
+ enum.SolarControlConsoleUiKey.Key:
type: SolarControlConsoleBoundUserInterface
- - key: enum.CommunicationsConsoleUiKey.Key
+ enum.CommunicationsConsoleUiKey.Key:
type: CommunicationsConsoleBoundUserInterface
- - key: enum.RadarConsoleUiKey.Key
+ enum.RadarConsoleUiKey.Key:
type: RadarConsoleBoundUserInterface
- - key: enum.CargoConsoleUiKey.Orders
+ enum.CargoConsoleUiKey.Orders:
type: CargoOrderConsoleBoundUserInterface
- - key: enum.CrewMonitoringUIKey.Key
+ enum.CrewMonitoringUIKey.Key:
type: CrewMonitoringBoundUserInterface
- - key: enum.GeneralStationRecordConsoleKey.Key
- # who the fuck named this bruh
+ enum.GeneralStationRecordConsoleKey.Key:
+ # who the fuck named this bruh
type: GeneralStationRecordConsoleBoundUserInterface
- type: IntrinsicUI
uis:
- - key: enum.SolarControlConsoleUiKey.Key
+ enum.SolarControlConsoleUiKey.Key:
toggleAction: ActionAGhostShowSolar
- - key: enum.CommunicationsConsoleUiKey.Key
+ enum.CommunicationsConsoleUiKey.Key:
toggleAction: ActionAGhostShowCommunications
- - key: enum.RadarConsoleUiKey.Key
+ enum.RadarConsoleUiKey.Key:
toggleAction: ActionAGhostShowRadar
- - key: enum.CargoConsoleUiKey.Orders
+ enum.CargoConsoleUiKey.Orders:
toggleAction: ActionAGhostShowCargo
- - key: enum.CrewMonitoringUIKey.Key
+ enum.CrewMonitoringUIKey.Key:
toggleAction: ActionAGhostShowCrewMonitoring
- - key: enum.GeneralStationRecordConsoleKey.Key
+ enum.GeneralStationRecordConsoleKey.Key:
toggleAction: ActionAGhostShowStationRecords
- type: SolarControlConsole # look ma i AM the computer!
- type: CommunicationsConsole
- type: MeleeSpeech
- type: UserInterface
interfaces:
- - key: enum.MeleeSpeechUiKey.Key
- type: MeleeSpeechBoundUserInterface
+ enum.MeleeSpeechUiKey.Key:
+ type: MeleeSpeechBoundUserInterface
- type: Actions
- type: Guardian
- type: InteractionPopup
- type: Strippable
- type: UserInterface
interfaces:
- - key: enum.VoiceMaskUIKey.Key
+ enum.VoiceMaskUIKey.Key:
type: VoiceMaskBoundUserInterface
- - key: enum.HumanoidMarkingModifierKey.Key
+ enum.HumanoidMarkingModifierKey.Key:
type: HumanoidMarkingModifierBoundUserInterface
- - key: enum.StrippingUiKey.Key
+ enum.StrippingUiKey.Key:
type: StrippableBoundUserInterface
- type: Puller
- type: Speech
requiredLegs: 2
- type: UserInterface
interfaces:
- - key: enum.HumanoidMarkingModifierKey.Key # sure, this can go here too
+ enum.HumanoidMarkingModifierKey.Key: # sure, this can go here too
type: HumanoidMarkingModifierBoundUserInterface
ents: []
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
- - key: enum.VoiceMaskUIKey.Key
- type: VoiceMaskBoundUserInterface
- - key: enum.HumanoidMarkingModifierKey.Key
- type: HumanoidMarkingModifierBoundUserInterface
- - key: enum.StrippingUiKey.Key
- type: StrippableBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
+ enum.VoiceMaskUIKey.Key:
+ type: VoiceMaskBoundUserInterface
+ enum.HumanoidMarkingModifierKey.Key:
+ type: HumanoidMarkingModifierBoundUserInterface
+ enum.StrippingUiKey.Key:
+ type: StrippableBoundUserInterface
# to prevent bag open/honk spam
- type: UseDelay
delay: 0.5
solution: drink
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: entity
parent: DrinkBase
maxTransferAmount: 15
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: Sprite
state: icon
layers:
maxTransferAmount: 10
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: Drink
- type: Sprite
state: icon
state: icon
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: PhysicalComposition
materialComposition:
Steel: 50
solution: drink
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: DamageOnLand
damage:
types:
solution: drink
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: Damageable
damageContainer: Inorganic
- type: Destructible
canChangeTransferAmount: true
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: Destructible
thresholds:
- trigger:
- DoorElectronicsConfigurator
- type: UserInterface
interfaces:
- - key: enum.DoorElectronicsConfigurationUiKey.Key
- type: DoorElectronicsBoundUserInterface
+ enum.DoorElectronicsConfigurationUiKey.Key:
+ type: DoorElectronicsBoundUserInterface
key: enum.WarDeclaratorUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.WarDeclaratorUiKey.Key
+ enum.WarDeclaratorUiKey.Key:
type: WarDeclaratorBoundUserInterface
- type: WarDeclarator
message: war-declarator-default-message
closeOnHandDeselect: false
- type: UserInterface
interfaces:
- - key: enum.ForensicScannerUiKey.Key
- type: ForensicScannerBoundUserInterface
+ enum.ForensicScannerUiKey.Key:
+ type: ForensicScannerBoundUserInterface
- type: ForensicScanner
- type: GuideHelp
guides:
closeOnHandDeselect: false
- type: UserInterface
interfaces:
- - key: enum.PdaUiKey.Key
- type: PdaBoundUserInterface
- - key: enum.StoreUiKey.Key
- type: StoreBoundUserInterface
- - key: enum.RingerUiKey.Key
- type: RingerBoundUserInterface
- - key: enum.InstrumentUiKey.Key
- type: InstrumentBoundUserInterface
- - key: enum.HealthAnalyzerUiKey.Key
- type: HealthAnalyzerBoundUserInterface
+ enum.PdaUiKey.Key:
+ type: PdaBoundUserInterface
+ enum.StoreUiKey.Key:
+ type: StoreBoundUserInterface
+ enum.RingerUiKey.Key:
+ type: RingerBoundUserInterface
+ enum.InstrumentUiKey.Key:
+ type: InstrumentBoundUserInterface
+ enum.HealthAnalyzerUiKey.Key:
+ type: HealthAnalyzerBoundUserInterface
- type: Tag
tags:
- DoorBumpOpener
singleUser: true
- type: UserInterface
interfaces:
- - key: enum.NavMapBeaconUiKey.Key
- type: NavMapBeaconBoundUserInterface
+ enum.NavMapBeaconUiKey.Key:
+ type: NavMapBeaconBoundUserInterface
- type: Item
size: Small
- type: SubFloorHide
acts: [ "Destruction" ]
- type: UserInterface
interfaces:
- - key: enum.StationMapUiKey.Key
+ enum.StationMapUiKey.Key:
type: StationMapBoundUserInterface
- type: entity
key: enum.InstrumentUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.InstrumentUiKey.Key
- type: InstrumentBoundUserInterface
+ enum.InstrumentUiKey.Key:
+ type: InstrumentBoundUserInterface
- type: Item
size: Normal
- type: StaticPrice
acts: ["Destruction"]
- type: UserInterface
interfaces:
- - key: enum.InstrumentUiKey.Key
- type: InstrumentBoundUserInterface
+ enum.InstrumentUiKey.Key:
+ type: InstrumentBoundUserInterface
- type: Fixtures
fixtures:
fix1:
ents: []
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
# to prevent bag open/honk spam
- type: UseDelay
delay: 0.5
- type: SpaceGarbage
- type: UserInterface
interfaces:
- - key: enum.CrayonUiKey.Key
- type: CrayonBoundUserInterface
+ enum.CrayonUiKey.Key:
+ type: CrayonBoundUserInterface
- type: Crayon
capacity: 15
- type: Food
program: 2
- type: UserInterface
interfaces:
- - key: enum.InstrumentUiKey.Key
- type: InstrumentBoundUserInterface
- - key: enum.StationMapUiKey.Key
- type: UntrackedStationMapBoundUserInterface
+ enum.InstrumentUiKey.Key:
+ type: InstrumentBoundUserInterface
+ enum.StationMapUiKey.Key:
+ type: UntrackedStationMapBoundUserInterface
- type: Sprite
sprite: Objects/Fun/pai.rsi
layers:
closeOnHandDeselect: false
- type: UserInterface
interfaces:
- - key: enum.PaperUiKey.Key
- type: PaperBoundUserInterface
+ enum.PaperUiKey.Key:
+ type: PaperBoundUserInterface
- type: Tag
tags:
- Book
color: "#0a2a6b"
- state: decor_wingette
color: "#082561"
- - state: icon_text
+ - state: icon_text
color: gold
- state: icon_planet
color: "#42b6f5"
description: Each book is unique! What is hidden in this one?
components:
- type: RandomMetadata
- nameSegments:
+ nameSegments:
- book_hint_appearance
- book_type
- type: RandomSprite
icon_skull: ""
icon_text: ""
icon_text2: ""
- icon_text3: ""
+ icon_text3: ""
overlay:
overlay_blood: ""
overlay_dirt: Sixteen
- book_story_element_trait
- "."
storySeparator: ""
-
+
- type: entity
parent: BookBase
id: BookAtmosDistro
- state: icon_corner
color: gold
- type: Paper
- content: book-text-atmos-vents
\ No newline at end of file
+ content: book-text-atmos-vents
default: PassengerIDCard
- type: UserInterface
interfaces:
- - key: enum.AgentIDCardUiKey.Key
+ enum.AgentIDCardUiKey.Key:
type: AgentIDCardBoundUserInterface
- - key: enum.ChameleonUiKey.Key
+ enum.ChameleonUiKey.Key:
type: ChameleonBoundUserInterface
- type: entity
requireHands: false
- type: UserInterface
interfaces:
- - key: enum.PaperUiKey.Key
- type: PaperBoundUserInterface
+ enum.PaperUiKey.Key:
+ type: PaperBoundUserInterface
- type: Item
size: Tiny
- type: Tag
key: enum.PaperUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.PaperUiKey.Key
- type: PaperBoundUserInterface
+ enum.PaperUiKey.Key:
+ type: PaperBoundUserInterface
- type: entity
parent: Paper
key: enum.CargoConsoleUiKey.Orders
- type: UserInterface
interfaces:
- - key: enum.CargoConsoleUiKey.Orders
- type: CargoOrderConsoleBoundUserInterface
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.CargoConsoleUiKey.Orders:
+ type: CargoOrderConsoleBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: MeleeWeapon
wideAnimationRotation: 180
damage:
ents: [ ]
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
+ enum.StorageUiKey.Key:
type: StorageBoundUserInterface
- type: entity
Telecrystal: 0
- type: UserInterface
interfaces:
- - key: enum.StoreUiKey.Key
- type: StoreBoundUserInterface
+ enum.StoreUiKey.Key:
+ type: StoreBoundUserInterface
- type: entity
parent: BaseSubdermalImplant
- 0,0,0,1
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: Tag
tags:
- Book
- 0,0,0,1
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: Sprite
sprite: Objects/Specific/Chapel/chaplainurn.rsi
state: icon
- type: Item
size: Normal
- sprite: Objects/Specific/Chapel/chaplainurn.rsi
\ No newline at end of file
+ sprite: Objects/Specific/Chapel/chaplainurn.rsi
- type: Appearance
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: Storage
maxItemSize: Normal
grid:
doAfterDelay: 10
- type: UserInterface
interfaces:
- - key: enum.MechUiKey.Key
- type: MechBoundUserInterface
+ enum.MechUiKey.Key:
+ type: MechBoundUserInterface
- type: MeleeWeapon
hidden: true
attackRate: 0.75
closeOnHandDeselect: false
- type: UserInterface
interfaces:
- - key: enum.CrewMonitoringUIKey.Key
+ enum.CrewMonitoringUIKey.Key:
type: CrewMonitoringBoundUserInterface
- type: CrewMonitoringConsole
- type: DeviceNetwork
closeOnHandDeselect: false
- type: UserInterface
interfaces:
- - key: enum.HealthAnalyzerUiKey.Key
+ enum.HealthAnalyzerUiKey.Key:
type: HealthAnalyzerBoundUserInterface
- type: HealthAnalyzer
scanningEndSound:
inHandsOnly: true
- type: UserInterface
interfaces:
- - key: enum.AnomalyScannerUiKey.Key
+ enum.AnomalyScannerUiKey.Key:
type: AnomalyScannerBoundUserInterface
- type: AnomalyScanner
- type: GuideHelp
closeOnHandDeselect: true
- type: UserInterface
interfaces:
- - key: enum.MagicMirrorUiKey.Key
- type: MagicMirrorBoundUserInterface
+ enum.MagicMirrorUiKey.Key:
+ type: MagicMirrorBoundUserInterface
- type: MeleeWeapon
wideAnimationRotation: -135
attackRate: 1
ano01_on: Rainbow
- type: UserInterface #needs to be here for certain effects
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
- - key: enum.InstrumentUiKey.Key
- type: InstrumentBoundUserInterface
- - key: enum.IntercomUiKey.Key
- type: IntercomBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
+ enum.InstrumentUiKey.Key:
+ type: InstrumentBoundUserInterface
+ enum.IntercomUiKey.Key:
+ type: IntercomBoundUserInterface
- type: Appearance
- type: Item
size: Normal
noRot: true
- type: UserInterface #needs to be here for certain effects
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
- - key: enum.InstrumentUiKey.Key
- type: InstrumentBoundUserInterface
- - key: enum.IntercomUiKey.Key
- type: IntercomBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
+ enum.InstrumentUiKey.Key:
+ type: InstrumentBoundUserInterface
+ enum.IntercomUiKey.Key:
+ type: IntercomBoundUserInterface
- type: Reactive
groups:
Acidic: [Touch]
key: enum.GasAnalyzerUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.GasAnalyzerUiKey.Key
- type: GasAnalyzerBoundUserInterface
+ enum.GasAnalyzerUiKey.Key:
+ type: GasAnalyzerBoundUserInterface
- type: Appearance
- type: GenericVisualizer
visuals:
solution: beaker
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
+ enum.TransferAmountUiKey.Key:
type: TransferAmountBoundUserInterface
- type: Drink
solution: beaker
canChangeTransferAmount: true
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: Item
size: Tiny
sprite: Objects/Specific/Chemistry/beaker.rsi
canChangeTransferAmount: true
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: Item
size: Tiny
sprite: Objects/Specific/Chemistry/vial.rsi
solution: beaker
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: Drink
solution: beaker
- type: Appearance
canChangeTransferAmount: true
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: Drink
solution: beaker
- type: Appearance
solution: dropper
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: Spillable
solution: injector
- type: Item
heldPrefix: old-radio
- type: UserInterface
interfaces:
- - key: enum.StoreUiKey.Key
- type: StoreBoundUserInterface
+ enum.StoreUiKey.Key:
+ type: StoreBoundUserInterface
- type: ActivatableUI
key: enum.StoreUiKey.Key
- type: Store
doAfter: 0.5
- type: UserInterface
interfaces:
- - key: enum.AccessOverriderUiKey.Key
+ enum.AccessOverriderUiKey.Key:
type: AccessOverriderBoundUserInterface
- type: ActivatableUI
key: enum.AccessOverriderUiKey.Key
canChangeTransferAmount: true
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: MeleeWeapon
soundNoDamage:
path: "/Audio/Effects/Fluids/splat.ogg"
- type: GasAnalyzer
- type: UserInterface
interfaces:
- - key: enum.GasAnalyzerUiKey.Key
- type: GasAnalyzerBoundUserInterface
+ enum.GasAnalyzerUiKey.Key:
+ type: GasAnalyzerBoundUserInterface
- type: Appearance
- type: entity
key: enum.SharedGasTankUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.SharedGasTankUiKey.Key
- type: GasTankBoundUserInterface
+ enum.SharedGasTankUiKey.Key:
+ type: GasTankBoundUserInterface
- type: GasTank
outputPressure: 21.3
air:
inHandsOnly: true
- type: UserInterface
interfaces:
- - key: enum.HandLabelerUiKey.Key
+ enum.HandLabelerUiKey.Key:
type: HandLabelerBoundUserInterface
- type: HandLabeler
whitelist:
singleUser: true
- type: UserInterface
interfaces:
- - key: enum.RadarConsoleUiKey.Key
+ enum.RadarConsoleUiKey.Key:
type: RadarConsoleBoundUserInterface
- type: StaticPrice
price: 150
name: power-cell-slot-component-slot-name-default
startingItem: PowerCellMicroreactor
disableEject: true
- swap: false
\ No newline at end of file
+ swap: false
size: Huge
- type: UserInterface
interfaces:
- - key: enum.SharedGasTankUiKey.Key
+ enum.SharedGasTankUiKey.Key:
type: GasTankBoundUserInterface
- type: Clothing
sprite: Objects/Tanks/Jetpacks/blue.rsi
key: enum.SprayPainterUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.SprayPainterUiKey.Key
- type: SprayPainterBoundUserInterface
+ enum.SprayPainterUiKey.Key:
+ type: SprayPainterBoundUserInterface
- type: SprayPainter
colorPalette:
red: '#FF1212FF'
key: enum.ThiefBackpackUIKey.Key
- type: UserInterface
interfaces:
- - key: enum.ThiefBackpackUIKey.Key
+ enum.ThiefBackpackUIKey.Key:
type: ThiefBackpackBoundUserInterface
inHandsOnly: true
- type: UserInterface
interfaces:
- - key: enum.NetworkConfiguratorUiKey.List
+ enum.NetworkConfiguratorUiKey.List:
type: NetworkConfiguratorBoundUserInterface
- - key: enum.NetworkConfiguratorUiKey.Configure
+ enum.NetworkConfiguratorUiKey.Configure:
type: NetworkConfiguratorBoundUserInterface
- - key: enum.NetworkConfiguratorUiKey.Link
+ enum.NetworkConfiguratorUiKey.Link:
type: NetworkConfiguratorBoundUserInterface
- type: Tag
tags:
- DoorElectronicsConfigurator
- type: UserInterface
interfaces:
- - key: enum.NetworkConfiguratorUiKey.List
+ enum.NetworkConfiguratorUiKey.List:
type: NetworkConfiguratorBoundUserInterface
- - key: enum.NetworkConfiguratorUiKey.Configure
+ enum.NetworkConfiguratorUiKey.Configure:
type: NetworkConfiguratorBoundUserInterface
- - key: enum.NetworkConfiguratorUiKey.Link
+ enum.NetworkConfiguratorUiKey.Link:
type: NetworkConfiguratorBoundUserInterface
- type: StaticPrice
price: 56
price: 100
- type: UserInterface
interfaces:
- - key: enum.RcdUiKey.Key
- type: RCDMenuBoundUserInterface
+ enum.RcdUiKey.Key:
+ type: RCDMenuBoundUserInterface
- type: ActivatableUI
key: enum.RcdUiKey.Key
canChangeTransferAmount: true
- type: UserInterface
interfaces:
- - key: enum.TransferAmountUiKey.Key
- type: TransferAmountBoundUserInterface
+ enum.TransferAmountUiKey.Key:
+ type: TransferAmountBoundUserInterface
- type: DrawableSolution
solution: chamber
- type: RefillableSolution
- type: Storage
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: ContainerContainer
containers:
storagebase: !type:Container
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.ReagentDispenserUiKey.Key
- type: ReagentDispenserBoundUserInterface
+ enum.ReagentDispenserUiKey.Key:
+ type: ReagentDispenserBoundUserInterface
- type: Anchorable
- type: Pullable
- type: Damageable
- type: SpawnOnOverload
- type: UserInterface
interfaces:
- - key: enum.WiresUiKey.Key
- type: WiresBoundUserInterface
+ enum.WiresUiKey.Key:
+ type: WiresBoundUserInterface
- type: Airtight
noAirWhenFullyAirBlocked: false
- type: RadiationBlocker
alwaysRandomize: true
- type: UserInterface
interfaces:
- - key: enum.WiresUiKey.Key
- type: WiresBoundUserInterface
+ enum.WiresUiKey.Key:
+ type: WiresBoundUserInterface
- type: Airtight
- type: Occluder
- type: Damageable
- type: WiresPanel
- type: UserInterface
interfaces:
- - key: enum.WiresUiKey.Key
+ enum.WiresUiKey.Key:
type: WiresBoundUserInterface
- type: Physics
canCollide: false
- type: Appearance
- type: UserInterface
interfaces:
- - key: enum.WiresUiKey.Key
- type: WiresBoundUserInterface
+ enum.WiresUiKey.Key:
+ type: WiresBoundUserInterface
- type: Airtight
- type: RadiationBlocker
resistance: 2
damageContainer: Inorganic
damageModifierSet: Glass
- type: ExaminableDamage
- messages: WindowMessages
+ messages: WindowMessages
- type: RCDDeconstructable
cost: 8
delay: 8
layoutId: Airlock
- type: UserInterface
interfaces:
- - key: enum.WiresUiKey.Key
- type: WiresBoundUserInterface
+ enum.WiresUiKey.Key:
+ type: WiresBoundUserInterface
- type: Appearance
- type: WiresVisuals
- type: Airtight
- Spellbook
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: InteractionOutline
- type: ContainerContainer
containers:
storagebase: !type:Container
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: InteractionOutline
- type: Clickable
- type: Tag
price: 25
- type: UserInterface
interfaces:
- - key: enum.DisposalUnitUiKey.Key
- type: DisposalUnitBoundUserInterface
+ enum.DisposalUnitUiKey.Key:
+ type: DisposalUnitBoundUserInterface
- type: RatKingRummageable
- type: SolutionContainerManager
solutions:
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.SpaceVillainArcadeUiKey.Key
+ enum.SpaceVillainArcadeUiKey.Key:
type: SpaceVillainArcadeBoundUserInterface
- - key: enum.WiresUiKey.Key
+ enum.WiresUiKey.Key:
type: WiresBoundUserInterface
- type: Computer
board: SpaceVillainArcadeComputerCircuitboard
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.BlockGameUiKey.Key
+ enum.BlockGameUiKey.Key:
type: BlockGameBoundUserInterface
- - key: enum.WiresUiKey.Key
+ enum.WiresUiKey.Key:
type: WiresBoundUserInterface
- type: Computer
board: BlockGameArcadeComputerCircuitboard
key: enum.EmergencyConsoleUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.EmergencyConsoleUiKey.Key
- type: EmergencyConsoleBoundUserInterface
+ enum.EmergencyConsoleUiKey.Key:
+ type: EmergencyConsoleBoundUserInterface
- type: PointLight
radius: 1.5
energy: 1.6
key: enum.ShuttleConsoleUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.ShuttleConsoleUiKey.Key
- type: ShuttleConsoleBoundUserInterface
+ enum.ShuttleConsoleUiKey.Key:
+ type: ShuttleConsoleBoundUserInterface
- type: RadarConsole
- type: WorldLoader
radius: 256
key: enum.IFFConsoleUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.IFFConsoleUiKey.Key
- type: IFFConsoleBoundUserInterface
+ enum.IFFConsoleUiKey.Key:
+ type: IFFConsoleBoundUserInterface
- type: Computer
board: ComputerIFFCircuitboard
key: enum.IFFConsoleUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.IFFConsoleUiKey.Key
- type: IFFConsoleBoundUserInterface
+ enum.IFFConsoleUiKey.Key:
+ type: IFFConsoleBoundUserInterface
- type: Computer
board: ComputerIFFSyndicateCircuitboard
key: enum.PowerMonitoringConsoleUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.PowerMonitoringConsoleUiKey.Key
- type: PowerMonitoringConsoleBoundUserInterface
+ enum.PowerMonitoringConsoleUiKey.Key:
+ type: PowerMonitoringConsoleBoundUserInterface
- type: entity
parent: BaseComputer
- type: CriminalRecordsConsole
- type: UserInterface
interfaces:
- - key: enum.CriminalRecordsConsoleKey.Key
- type: CriminalRecordsConsoleBoundUserInterface
+ enum.CriminalRecordsConsoleKey.Key:
+ type: CriminalRecordsConsoleBoundUserInterface
- type: ActivatableUI
key: enum.CriminalRecordsConsoleKey.Key
- type: Sprite
- type: GeneralStationRecordConsole
- type: UserInterface
interfaces:
- - key: enum.GeneralStationRecordConsoleKey.Key
- type: GeneralStationRecordConsoleBoundUserInterface
+ enum.GeneralStationRecordConsoleKey.Key:
+ type: GeneralStationRecordConsoleBoundUserInterface
- type: ActivatableUI
key: enum.GeneralStationRecordConsoleKey.Key
- type: PointLight
key: enum.CrewMonitoringUIKey.Key
- type: UserInterface
interfaces:
- - key: enum.CrewMonitoringUIKey.Key
+ enum.CrewMonitoringUIKey.Key:
type: CrewMonitoringBoundUserInterface
- type: CrewMonitoringConsole
- type: DeviceNetwork
key: enum.ResearchConsoleUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.ResearchConsoleUiKey.Key
- type: ResearchConsoleBoundUserInterface
- - key: enum.ResearchClientUiKey.Key
- type: ResearchClientBoundUserInterface
+ enum.ResearchConsoleUiKey.Key:
+ type: ResearchConsoleBoundUserInterface
+ enum.ResearchClientUiKey.Key:
+ type: ResearchClientBoundUserInterface
- type: ApcPowerReceiver
powerLoad: 1000
- type: Computer
key: enum.ArtifactAnalzyerUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.ArtifactAnalzyerUiKey.Key
- type: AnalysisConsoleBoundUserInterface
- - key: enum.ResearchClientUiKey.Key
- type: ResearchClientBoundUserInterface
+ enum.ArtifactAnalzyerUiKey.Key:
+ type: AnalysisConsoleBoundUserInterface
+ enum.ResearchClientUiKey.Key:
+ type: ResearchClientBoundUserInterface
- type: ApcPowerReceiver
powerLoad: 1000
- type: Computer
key: enum.IdCardConsoleUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.IdCardConsoleUiKey.Key
- type: IdCardConsoleBoundUserInterface
+ enum.IdCardConsoleUiKey.Key:
+ type: IdCardConsoleBoundUserInterface
- type: CrewManifestViewer
ownerKey: enum.IdCardConsoleUiKey.Key
- type: Sprite
key: enum.CommunicationsConsoleUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.CommunicationsConsoleUiKey.Key
- type: CommunicationsConsoleBoundUserInterface
+ enum.CommunicationsConsoleUiKey.Key:
+ type: CommunicationsConsoleBoundUserInterface
- type: Computer
board: CommsComputerCircuitboard
- type: PointLight
key: enum.SolarControlConsoleUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.SolarControlConsoleUiKey.Key
- type: SolarControlConsoleBoundUserInterface
+ enum.SolarControlConsoleUiKey.Key:
+ type: SolarControlConsoleBoundUserInterface
- type: Computer
board: SolarControlComputerCircuitboard
- type: PointLight
key: enum.RadarConsoleUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.RadarConsoleUiKey.Key
- type: RadarConsoleBoundUserInterface
+ enum.RadarConsoleUiKey.Key:
+ type: RadarConsoleBoundUserInterface
- type: Computer
board: RadarConsoleCircuitboard
- type: PointLight
key: enum.CargoConsoleUiKey.Shuttle
- type: UserInterface
interfaces:
- - key: enum.CargoConsoleUiKey.Shuttle
- type: CargoShuttleConsoleBoundUserInterface
+ enum.CargoConsoleUiKey.Shuttle:
+ type: CargoShuttleConsoleBoundUserInterface
- type: Computer
board: CargoShuttleComputerCircuitboard
- type: PointLight
key: enum.CargoConsoleUiKey.Orders
- type: UserInterface
interfaces:
- - key: enum.CargoConsoleUiKey.Orders
- type: CargoOrderConsoleBoundUserInterface
+ enum.CargoConsoleUiKey.Orders:
+ type: CargoOrderConsoleBoundUserInterface
- type: Computer
board: CargoRequestComputerCircuitboard
- type: PointLight
key: enum.CargoConsoleUiKey.Bounty
- type: UserInterface
interfaces:
- - key: enum.CargoConsoleUiKey.Bounty
- type: CargoBountyConsoleBoundUserInterface
+ enum.CargoConsoleUiKey.Bounty:
+ type: CargoBountyConsoleBoundUserInterface
- type: Computer
board: CargoBountyComputerCircuitboard
- type: PointLight
key: enum.CloningConsoleUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.CloningConsoleUiKey.Key
- type: CloningConsoleBoundUserInterface
+ enum.CloningConsoleUiKey.Key:
+ type: CloningConsoleBoundUserInterface
- type: Speech
speechVerb: Robotic
speechSounds: Pai
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.SalvageConsoleUiKey.Expedition
+ enum.SalvageConsoleUiKey.Expedition:
type: SalvageExpeditionConsoleBoundUserInterface
- type: Computer
board: SalvageExpeditionsComputerCircuitboard
anchored: true
- type: UserInterface
interfaces:
- - key: enum.SurveillanceCameraMonitorUiKey.Key
- type: SurveillanceCameraMonitorBoundUserInterface
+ enum.SurveillanceCameraMonitorUiKey.Key:
+ type: SurveillanceCameraMonitorBoundUserInterface
- type: entity
parent: BaseComputer
- type: ActivatableUIRequiresVision
- type: UserInterface
interfaces:
- - key: enum.SurveillanceCameraMonitorUiKey.Key
- type: SurveillanceCameraMonitorBoundUserInterface
+ enum.SurveillanceCameraMonitorUiKey.Key:
+ type: SurveillanceCameraMonitorBoundUserInterface
- type: entity
id: ComputerPalletConsole
key: enum.CargoPalletConsoleUiKey.Sale
- type: UserInterface
interfaces:
- - key: enum.CargoPalletConsoleUiKey.Sale
- type: CargoPalletConsoleBoundUserInterface
+ enum.CargoPalletConsoleUiKey.Sale:
+ type: CargoPalletConsoleBoundUserInterface
- type: Computer
board: CargoRequestComputerCircuitboard
- type: PointLight
anchored: true
- type: UserInterface
interfaces:
- - key: enum.NewsWriterUiKey.Key
- type: NewsWriterBoundUserInterface
+ enum.NewsWriterUiKey.Key:
+ type: NewsWriterBoundUserInterface
- type: entity
parent: BaseComputer
key: enum.SensorMonitoringConsoleUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.SensorMonitoringConsoleUiKey.Key
+ enum.SensorMonitoringConsoleUiKey.Key:
type: SensorMonitoringConsoleBoundUserInterface
- type: DeviceNetwork
deviceNetId: AtmosDevices
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.DiskConsoleUiKey.Key
- type: DiskConsoleBoundUserInterface
- - key: enum.ResearchClientUiKey.Key
- type: ResearchClientBoundUserInterface
+ enum.DiskConsoleUiKey.Key:
+ type: DiskConsoleBoundUserInterface
+ enum.ResearchClientUiKey.Key:
+ type: ResearchClientBoundUserInterface
- type: ExtensionCableReceiver
- type: Computer
board: TechDiskComputerCircuitboard
scanDelay: 0
- type: UserInterface
interfaces:
- - key: enum.HealthAnalyzerUiKey.Key
+ enum.HealthAnalyzerUiKey.Key:
type: HealthAnalyzerBoundUserInterface
- - key: enum.WiresUiKey.Key
+ enum.WiresUiKey.Key:
type: WiresBoundUserInterface
- type: ActivatableUI
key: enum.HealthAnalyzerUiKey.Key
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.ResearchClientUiKey.Key
- type: ResearchClientBoundUserInterface
+ enum.ResearchClientUiKey.Key:
+ type: ResearchClientBoundUserInterface
- type: Machine
board: AnomalyVesselCircuitboard
- type: PointLight
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.AnomalyGeneratorUiKey.Key
- type: AnomalyGeneratorBoundUserInterface
+ enum.AnomalyGeneratorUiKey.Key:
+ type: AnomalyGeneratorBoundUserInterface
- type: Appearance
- type: ActiveRadio
channels:
- type: InteractionOutline
- type: UserInterface
interfaces:
- - key: enum.WiresUiKey.Key
+ enum.WiresUiKey.Key:
type: WiresBoundUserInterface
- type: Wires
layoutId: Defusable
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.ChemMasterUiKey.Key
- type: ChemMasterBoundUserInterface
+ enum.ChemMasterUiKey.Key:
+ type: ChemMasterBoundUserInterface
- type: ApcPowerReceiver
powerLoad: 250
- type: Appearance
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.FaxUiKey.Key
- type: FaxBoundUi
+ enum.FaxUiKey.Key:
+ type: FaxBoundUi
- type: ApcPowerReceiver
powerLoad: 250
- type: FaxMachine
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.FlatpackCreatorUIKey.Key
- type: FlatpackCreatorBoundUserInterface
+ enum.FlatpackCreatorUIKey.Key:
+ type: FlatpackCreatorBoundUserInterface
- type: ItemSlots
slots:
board_slot:
key: enum.GatewayUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.GatewayUiKey.Key
- type: GatewayBoundUserInterface
+ enum.GatewayUiKey.Key:
+ type: GatewayBoundUserInterface
- type: Gateway
on: "on"
- type: UserInterface
interfaces:
- - key: enum.GravityGeneratorUiKey.Key
- type: GravityGeneratorBoundUserInterface
+ enum.GravityGeneratorUiKey.Key:
+ type: GravityGeneratorBoundUserInterface
- type: Appearance
- type: PointLight
radius: 2.5
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.JukeboxUiKey.Key
- type: JukeboxBoundUserInterface
+ enum.JukeboxUiKey.Key:
+ type: JukeboxBoundUserInterface
- type: Damageable
damageContainer: Inorganic
damageModifierSet: Metallic
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.LatheUiKey.Key
- type: LatheBoundUserInterface
- - key: enum.ResearchClientUiKey.Key
- type: ResearchClientBoundUserInterface
+ enum.LatheUiKey.Key:
+ type: LatheBoundUserInterface
+ enum.ResearchClientUiKey.Key:
+ type: ResearchClientBoundUserInterface
- type: Transform
anchored: true
- type: Pullable
range: 200
- type: UserInterface
interfaces:
- - key: enum.MicrowaveUiKey.Key
- type: MicrowaveBoundUserInterface
+ enum.MicrowaveUiKey.Key:
+ type: MicrowaveBoundUserInterface
- type: Physics
- type: Fixtures
fixtures:
key: enum.NukeUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.NukeUiKey.Key
- type: NukeBoundUserInterface
+ enum.NukeUiKey.Key:
+ type: NukeBoundUserInterface
- type: StaticPrice
price: 50000 # YOU STOLE A NUCLEAR FISSION EXPLOSIVE?!
- type: CargoSellBlacklist
key: enum.ReagentGrinderUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.ReagentGrinderUiKey.Key
- type: ReagentGrinderBoundUserInterface
+ enum.ReagentGrinderUiKey.Key:
+ type: ReagentGrinderBoundUserInterface
- type: Appearance
- type: GenericVisualizer
visuals:
- type: DrainableSolution
solution: output
- type: ExaminableSolution
- solution: output
\ No newline at end of file
+ solution: output
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.ResearchClientUiKey.Key
- type: ResearchClientBoundUserInterface
+ enum.ResearchClientUiKey.Key:
+ type: ResearchClientBoundUserInterface
- type: Appearance
- type: GenericVisualizer
visuals:
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.SalvageMagnetUiKey.Key
- type: SalvageMagnetBoundUserInterface
+ enum.SalvageMagnetUiKey.Key:
+ type: SalvageMagnetBoundUserInterface
- type: Transform
noRot: false
- type: Appearance
- type: DeviceNetworkRequiresPower
- type: UserInterface
interfaces:
- - key: enum.SurveillanceCameraSetupUiKey.Router
+ enum.SurveillanceCameraSetupUiKey.Router:
type: SurveillanceCameraSetupBoundUi
- type: Machine
board: SurveillanceCameraRouterCircuitboard
- type: DeviceNetworkRequiresPower
- type: UserInterface
interfaces:
- - key: enum.SurveillanceCameraSetupUiKey.Router
+ enum.SurveillanceCameraSetupUiKey.Router:
type: SurveillanceCameraSetupBoundUi
- type: Machine
board: SurveillanceCameraWirelessRouterCircuitboard
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.VendingMachineUiKey.Key
- type: VendingMachineBoundUserInterface
- - key: enum.WiresUiKey.Key
- type: WiresBoundUserInterface
+ enum.VendingMachineUiKey.Key:
+ type: VendingMachineBoundUserInterface
+ enum.WiresUiKey.Key:
+ type: WiresBoundUserInterface
- type: WiresPanel
- type: Wires
boardName: wires-board-name-vendingmachine
range: 10
- type: UserInterface
interfaces:
- - key: enum.SurveillanceCameraSetupUiKey.Camera
+ enum.SurveillanceCameraSetupUiKey.Camera:
type: SurveillanceCameraSetupBoundUi
placement:
mode: SnapgridCenter
enabled: false
- type: UserInterface
interfaces:
- - key: enum.GasPressurePumpUiKey.Key
- type: GasPressurePumpBoundUserInterface
+ enum.GasPressurePumpUiKey.Key:
+ type: GasPressurePumpBoundUserInterface
- type: Construction
graph: GasBinary
node: pressurepump
enabled: false
- type: UserInterface
interfaces:
- - key: enum.GasVolumePumpUiKey.Key
+ enum.GasVolumePumpUiKey.Key:
type: GasVolumePumpBoundUserInterface
- type: Construction
graph: GasBinary
layer:
- MachineLayer
- type: ApcPowerReceiver
- powerDisabled: true #starts off
+ powerDisabled: true #starts off
- type: Sprite
sprite: Structures/Piping/Atmospherics/Portable/portable_sheater.rsi
noRot: true
- type: WiresVisuals
- type: UserInterface
interfaces:
- - key: enum.SpaceHeaterUiKey.Key
- type: SpaceHeaterBoundUserInterface
+ enum.SpaceHeaterUiKey.Key:
+ type: SpaceHeaterBoundUserInterface
- type: ActivatableUI
inHandsOnly: false
key: enum.SpaceHeaterUiKey.Key
suffix: Anchored, Enabled
components:
- type: ApcPowerReceiver
- powerDisabled: false
\ No newline at end of file
+ powerDisabled: false
- type: PipeColorVisuals
- type: UserInterface
interfaces:
- - key: enum.GasFilterUiKey.Key
+ enum.GasFilterUiKey.Key:
type: GasFilterBoundUserInterface
- type: GasFilter
enabled: false
- type: PipeColorVisuals
- type: UserInterface
interfaces:
- - key: enum.GasMixerUiKey.Key
+ enum.GasMixerUiKey.Key:
type: GasMixerBoundUserInterface
- type: GasMixer
enabled: false
- type: AtmosDevice
- type: UserInterface
interfaces:
- - key: enum.ThermomachineUiKey.Key
- type: GasThermomachineBoundUserInterface
+ enum.ThermomachineUiKey.Key:
+ type: GasThermomachineBoundUserInterface
- type: ActivatableUI
inHandsOnly: false
key: enum.ThermomachineUiKey.Key
key: enum.DisposalTaggerUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.DisposalTaggerUiKey.Key
- type: DisposalTaggerBoundUserInterface
+ enum.DisposalTaggerUiKey.Key:
+ type: DisposalTaggerBoundUserInterface
- type: Construction
graph: DisposalPipe
node: tagger
key: enum.DisposalRouterUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.DisposalRouterUiKey.Key
- type: DisposalRouterBoundUserInterface
+ enum.DisposalRouterUiKey.Key:
+ type: DisposalRouterBoundUserInterface
- type: Fixtures
fixtures:
fix1:
- type: Appearance
- type: UserInterface
interfaces:
- - key: enum.DisposalUnitUiKey.Key
- type: DisposalUnitBoundUserInterface
+ enum.DisposalUnitUiKey.Key:
+ type: DisposalUnitBoundUserInterface
- type: ContainerContainer
containers:
disposals: !type:Container
- type: DisposalUnit
- type: UserInterface
interfaces:
- - key: enum.DisposalUnitUiKey.Key
- type: DisposalUnitBoundUserInterface
+ enum.DisposalUnitUiKey.Key:
+ type: DisposalUnitBoundUserInterface
- type: RatKingRummageable
- type: entity
- type: Appearance
- type: UserInterface
interfaces:
- - key: enum.MailingUnitUiKey.Key
- type: DisposalUnitBoundUserInterface
- - key: enum.ConfigurationUiKey.Key
- type: ConfigurationBoundUserInterface
+ enum.MailingUnitUiKey.Key:
+ type: DisposalUnitBoundUserInterface
+ enum.ConfigurationUiKey.Key:
+ type: ConfigurationBoundUserInterface
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.ParticleAcceleratorControlBoxUiKey.Key
- type: ParticleAcceleratorBoundUserInterface
- - key: enum.WiresUiKey.Key
- type: WiresBoundUserInterface
+ enum.ParticleAcceleratorControlBoxUiKey.Key:
+ type: ParticleAcceleratorBoundUserInterface
+ enum.WiresUiKey.Key:
+ type: WiresBoundUserInterface
- type: WiresPanel
- type: Wires
boardName: wires-board-name-pa
key: enum.AmeControllerUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.AmeControllerUiKey.Key
- type: AmeControllerBoundUserInterface
+ enum.AmeControllerUiKey.Key:
+ type: AmeControllerBoundUserInterface
- type: Appearance
- type: GenericVisualizer
visuals:
- type: WiresPanel
- type: UserInterface
interfaces:
- - key: enum.GeneratorComponentUiKey.Key
+ enum.GeneratorComponentUiKey.Key:
type: PortableGeneratorBoundUserInterface
- type: ActivatableUI
key: enum.GeneratorComponentUiKey.Key
- type: ExtensionCableProvider
- type: UserInterface
interfaces:
- - key: enum.ApcUiKey.Key
- type: ApcBoundUserInterface
+ enum.ApcUiKey.Key:
+ type: ApcBoundUserInterface
- type: ActivatableUI
inHandsOnly: false
singleUser: true
fillBaseName: cart_water-
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: Drink
solution: bucket
- type: ContainerContainer
3: { state: can-o3, shader: "unshaded" }
- type: UserInterface
interfaces:
- - key: enum.GasCanisterUiKey.Key
+ enum.GasCanisterUiKey.Key:
type: GasCanisterBoundUserInterface
- type: Destructible
thresholds:
map: ["openLayer"]
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: Transform
noRot: true
- type: Fixtures
- type: Appearance
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: Transform
noRot: true
- type: Fixtures
- Ore
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: ContainerContainer
containers:
storagebase: !type:Container
- type: InteractionOutline
- type: UserInterface
interfaces:
- - key: enum.SharedAirAlarmInterfaceKey.Key
- type: AirAlarmBoundUserInterface
- - key: enum.WiresUiKey.Key
- type: WiresBoundUserInterface
+ enum.SharedAirAlarmInterfaceKey.Key:
+ type: AirAlarmBoundUserInterface
+ enum.WiresUiKey.Key:
+ type: WiresBoundUserInterface
- type: WiresPanel
- type: Wires
boardName: wires-board-name-airalarm
delta: fire_3
- type: UserInterface
interfaces:
- - key: enum.WiresUiKey.Key
- type: WiresBoundUserInterface
+ enum.WiresUiKey.Key:
+ type: WiresBoundUserInterface
- type: WiresPanel
- type: Wires
boardName: wires-board-name-firealarm
key: enum.IntercomUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.IntercomUiKey.Key
+ enum.IntercomUiKey.Key:
type: IntercomBoundUserInterface
- - key: enum.WiresUiKey.Key
+ enum.WiresUiKey.Key:
type: WiresBoundUserInterface
- type: Construction
graph: Intercom
key: enum.MagicMirrorUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.MagicMirrorUiKey.Key
- type: MagicMirrorBoundUserInterface
+ enum.MagicMirrorUiKey.Key:
+ type: MagicMirrorBoundUserInterface
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.SurveillanceCameraMonitorUiKey.Key
- type: SurveillanceCameraMonitorBoundUserInterface
+ enum.SurveillanceCameraMonitorUiKey.Key:
+ type: SurveillanceCameraMonitorBoundUserInterface
# Wall Televisions
- type: ActivatableUIRequiresPower
- type: UserInterface
interfaces:
- - key: enum.SurveillanceCameraMonitorUiKey.Key
- type: SurveillanceCameraMonitorBoundUserInterface
+ enum.SurveillanceCameraMonitorUiKey.Key:
+ type: SurveillanceCameraMonitorBoundUserInterface
- type: PointLight
radius: 1.5
energy: 1.6
- Write
- type: UserInterface
interfaces:
- - key: enum.StorageUiKey.Key
- type: StorageBoundUserInterface
+ enum.StorageUiKey.Key:
+ type: StorageBoundUserInterface
- type: ContainerContainer
containers:
storagebase: !type:Container
acts: [ "Destruction" ]
- type: UserInterface
interfaces:
- - key: enum.StationMapUiKey.Key
+ enum.StationMapUiKey.Key:
type: StationMapBoundUserInterface
- type: entity
InUse: camera_in_use
- type: UserInterface
interfaces:
- - key: enum.SurveillanceCameraSetupUiKey.Camera
+ enum.SurveillanceCameraSetupUiKey.Camera:
type: SurveillanceCameraSetupBoundUi
- - key: enum.WiresUiKey.Key
+ enum.WiresUiKey.Key:
type: WiresBoundUserInterface
- type: StaticPrice
price: 200
key: enum.SignalTimerUiKey.Key
- type: UserInterface
interfaces:
- - key: enum.SignalTimerUiKey.Key
- type: SignalTimerBoundUserInterface
+ enum.SignalTimerUiKey.Key:
+ type: SignalTimerBoundUserInterface
- type: ApcPowerReceiver
powerLoad: 100
- type: Electrified
map: ["base"]
- type: UserInterface
interfaces:
- - key: enum.CryostorageUIKey.Key
- type: CryostorageBoundUserInterface
+ enum.CryostorageUIKey.Key:
+ type: CryostorageBoundUserInterface
- type: ActivatableUI
key: enum.CryostorageUIKey.Key
- type: AccessReader
permanentComponents:
- type: UserInterface
interfaces:
- - key: enum.SignalLinkerUiKey.Key
- type: SignalPortSelectorBoundUserInterface
+ enum.SignalLinkerUiKey.Key:
+ type: SignalPortSelectorBoundUserInterface
- type: ToolTileCompatible
- type: Tool
qualities:
projects / space-station-14.git / commitdiff