From 3aa5cefe03406c0a82f5705d9fe1ceb28fb97468 Mon Sep 17 00:00:00 2001 From: Pieter-Jan Briers Date: Thu, 13 May 2021 03:29:38 +0200 Subject: [PATCH] Stop using component messages in bound UI code. --- .../ClientUserInterfaceComponent.cs | 51 ++++++++----------- .../EntitySystems/UserInterfaceSystem.cs | 35 +++++++++++++ .../ServerUserInterfaceComponent.cs | 37 +++++--------- .../EntitySystems/UserInterfaceSystem.cs | 23 +++++++++ .../SharedUserInterfaceComponent.cs | 39 +++++++------- 5 files changed, 111 insertions(+), 74 deletions(-) create mode 100644 Robust.Client/GameObjects/EntitySystems/UserInterfaceSystem.cs diff --git a/Robust.Client/GameObjects/Components/UserInterface/ClientUserInterfaceComponent.cs b/Robust.Client/GameObjects/Components/UserInterface/ClientUserInterfaceComponent.cs index 0af27a7406..977a60111e 100644 --- a/Robust.Client/GameObjects/Components/UserInterface/ClientUserInterfaceComponent.cs +++ b/Robust.Client/GameObjects/Components/UserInterface/ClientUserInterfaceComponent.cs @@ -2,8 +2,6 @@ using System.Collections.Generic; using Robust.Shared.GameObjects; using Robust.Shared.IoC; -using Robust.Shared.Network; -using Robust.Shared.Players; using Robust.Shared.Reflection; using Robust.Shared.Serialization; using Robust.Shared.Serialization.Manager.Attributes; @@ -34,48 +32,40 @@ namespace Robust.Client.GameObjects } } - public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel, - ICommonSession? session = null) + internal void MessageReceived(BoundUIWrapMessage msg) { - base.HandleNetworkMessage(message, netChannel, session); - - switch (message) + switch (msg.Message) { - case BoundInterfaceMessageWrapMessage wrapped: - // Double nested switches who needs readability anyways. - switch (wrapped.Message) + case OpenBoundInterfaceMessage _: + if (_openInterfaces.ContainsKey(msg.UiKey)) { - case OpenBoundInterfaceMessage _: - if (_openInterfaces.ContainsKey(wrapped.UiKey)) - { - return; - } + return; + } - OpenInterface(wrapped); - break; + OpenInterface(msg); + break; - case CloseBoundInterfaceMessage _: - Close(wrapped.UiKey, true); - break; + case CloseBoundInterfaceMessage _: + Close(msg.UiKey, true); + break; - default: - if (_openInterfaces.TryGetValue(wrapped.UiKey, out var bi)) - { - bi.InternalReceiveMessage(wrapped.Message); - } - break; + default: + if (_openInterfaces.TryGetValue(msg.UiKey, out var bi)) + { + bi.InternalReceiveMessage(msg.Message); } break; } } - private void OpenInterface(BoundInterfaceMessageWrapMessage wrapped) + private void OpenInterface(BoundUIWrapMessage wrapped) { var data = _interfaces[wrapped.UiKey]; // TODO: This type should be cached, but I'm too lazy. var type = _reflectionManager.LooseGetType(data.ClientType); - var boundInterface = (BoundUserInterface) _dynamicTypeFactory.CreateInstance(type, new[]{this, wrapped.UiKey}); + var boundInterface = + (BoundUserInterface) _dynamicTypeFactory.CreateInstance(type, new[] {this, wrapped.UiKey}); boundInterface.Open(); _openInterfaces[wrapped.UiKey] = boundInterface; } @@ -87,7 +77,7 @@ namespace Robust.Client.GameObjects return; } - if(!remoteCall) + if (!remoteCall) SendMessage(new CloseBoundInterfaceMessage(), uiKey); _openInterfaces.Remove(uiKey); boundUserInterface.Dispose(); @@ -95,7 +85,8 @@ namespace Robust.Client.GameObjects internal void SendMessage(BoundUserInterfaceMessage message, object uiKey) { - SendNetworkMessage(new BoundInterfaceMessageWrapMessage(message, uiKey)); + EntitySystem.Get() + .Send(new BoundUIWrapMessage(Owner.Uid, message, uiKey)); } } diff --git a/Robust.Client/GameObjects/EntitySystems/UserInterfaceSystem.cs b/Robust.Client/GameObjects/EntitySystems/UserInterfaceSystem.cs new file mode 100644 index 0000000000..cd5ae396a8 --- /dev/null +++ b/Robust.Client/GameObjects/EntitySystems/UserInterfaceSystem.cs @@ -0,0 +1,35 @@ +using JetBrains.Annotations; +using Robust.Shared.GameObjects; + +namespace Robust.Client.GameObjects +{ + [UsedImplicitly] + public sealed class UserInterfaceSystem : EntitySystem + { + public override void Initialize() + { + base.Initialize(); + + SubscribeNetworkEvent(MessageReceived); + } + + public override void Shutdown() + { + base.Shutdown(); + + UnsubscribeNetworkEvent(); + } + + private void MessageReceived(BoundUIWrapMessage ev) + { + var cmp = ComponentManager.GetComponent(ev.Entity); + + cmp.MessageReceived(ev); + } + + internal void Send(BoundUIWrapMessage msg) + { + RaiseNetworkEvent(msg); + } + } +} diff --git a/Robust.Server/GameObjects/Components/UserInterface/ServerUserInterfaceComponent.cs b/Robust.Server/GameObjects/Components/UserInterface/ServerUserInterfaceComponent.cs index 5a9077679d..08cb7f0c3d 100644 --- a/Robust.Server/GameObjects/Components/UserInterface/ServerUserInterfaceComponent.cs +++ b/Robust.Server/GameObjects/Components/UserInterface/ServerUserInterfaceComponent.cs @@ -7,8 +7,6 @@ using Robust.Server.Player; using Robust.Shared.Enums; using Robust.Shared.GameObjects; using Robust.Shared.Log; -using Robust.Shared.Network; -using Robust.Shared.Players; using Robust.Shared.Serialization; using Robust.Shared.Serialization.Manager.Attributes; @@ -49,7 +47,8 @@ namespace Robust.Server.GameObjects return _interfaces[uiKey]; } - public bool TryGetBoundUserInterface(object uiKey, [NotNullWhen(true)] out BoundUserInterface? boundUserInterface) + public bool TryGetBoundUserInterface(object uiKey, + [NotNullWhen(true)] out BoundUserInterface? boundUserInterface) { return _interfaces.TryGetValue(uiKey, out boundUserInterface); } @@ -68,32 +67,20 @@ namespace Robust.Server.GameObjects internal void SendToSession(IPlayerSession session, BoundUserInterfaceMessage message, object uiKey) { - SendNetworkMessage(new BoundInterfaceMessageWrapMessage(message, uiKey), session.ConnectedClient); + EntitySystem.Get() + .SendTo(session, new BoundUIWrapMessage(Owner.Uid, message, uiKey)); } - public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel, - ICommonSession? session = null) + internal void ReceiveMessage(IPlayerSession session, BoundUIWrapMessage msg) { - base.HandleNetworkMessage(message, netChannel, session); - - switch (message) + if (!_interfaces.TryGetValue(msg.UiKey, out var @interface)) { - case BoundInterfaceMessageWrapMessage wrapped: - if (session == null) - { - throw new ArgumentNullException(nameof(session)); - } - - if (!_interfaces.TryGetValue(wrapped.UiKey, out var @interface)) - { - Logger.DebugS("go.comp.ui", "Got BoundInterfaceMessageWrapMessage for unknown UI key: {0}", - wrapped.UiKey); - return; - } - - @interface.ReceiveMessage(wrapped.Message, (IPlayerSession)session); - break; + Logger.DebugS("go.comp.ui", "Got BoundInterfaceMessageWrapMessage for unknown UI key: {0}", + msg.UiKey); + return; } + + @interface.ReceiveMessage(msg.Message, session); } } @@ -154,6 +141,7 @@ namespace Robust.Server.GameObjects { _playerStateOverrides[session] = state; } + _stateDirty = true; } @@ -179,7 +167,6 @@ namespace Robust.Server.GameObjects } - /// /// Opens this interface for a specific client. /// diff --git a/Robust.Server/GameObjects/EntitySystems/UserInterfaceSystem.cs b/Robust.Server/GameObjects/EntitySystems/UserInterfaceSystem.cs index ee7b252fa3..def4c6a46d 100644 --- a/Robust.Server/GameObjects/EntitySystems/UserInterfaceSystem.cs +++ b/Robust.Server/GameObjects/EntitySystems/UserInterfaceSystem.cs @@ -22,6 +22,29 @@ namespace Robust.Server.GameObjects /// public override void Initialize() { + base.Initialize(); + + SubscribeNetworkEvent(OnMessageReceived); + } + + public override void Shutdown() + { + base.Shutdown(); + + UnsubscribeNetworkEvent(); + } + + internal void SendTo(IPlayerSession session, BoundUIWrapMessage msg) + { + RaiseNetworkEvent(msg, session.ConnectedClient); + } + + private void OnMessageReceived(BoundUIWrapMessage msg, EntitySessionEventArgs args) + { + if (!ComponentManager.TryGetComponent(msg.Entity, out var uiComp)) + return; + + uiComp.ReceiveMessage((IPlayerSession) args.SenderSession, msg); } /// diff --git a/Robust.Shared/GameObjects/Components/UserInterface/SharedUserInterfaceComponent.cs b/Robust.Shared/GameObjects/Components/UserInterface/SharedUserInterfaceComponent.cs index 18e1b0dc46..ccaa0da4f6 100644 --- a/Robust.Shared/GameObjects/Components/UserInterface/SharedUserInterfaceComponent.cs +++ b/Robust.Shared/GameObjects/Components/UserInterface/SharedUserInterfaceComponent.cs @@ -35,25 +35,6 @@ namespace Robust.Shared.GameObjects UiKey = _uiKeyRaw; } } - - [NetSerializable, Serializable] - protected sealed class BoundInterfaceMessageWrapMessage : ComponentMessage - { - public readonly BoundUserInterfaceMessage Message; - public readonly object UiKey; - - public BoundInterfaceMessageWrapMessage(BoundUserInterfaceMessage message, object uiKey) - { - Directed = true; - Message = message; - UiKey = uiKey; - } - - public override string ToString() - { - return $"{nameof(BoundInterfaceMessageWrapMessage)}: {Message}"; - } - } } [NetSerializable, Serializable] @@ -87,4 +68,24 @@ namespace Robust.Shared.GameObjects internal sealed class CloseBoundInterfaceMessage : BoundUserInterfaceMessage { } + + [Serializable, NetSerializable] + internal sealed class BoundUIWrapMessage : EntityEventArgs + { + public readonly EntityUid Entity; + public readonly BoundUserInterfaceMessage Message; + public readonly object UiKey; + + public BoundUIWrapMessage(EntityUid entity, BoundUserInterfaceMessage message, object uiKey) + { + Message = message; + UiKey = uiKey; + Entity = entity; + } + + public override string ToString() + { + return $"{nameof(BoundUIWrapMessage)}: {Message}"; + } + } }