More comments and a fix.

Content.Client/Eui/BaseEui.cs

@@ -19,28 +19,43 @@ namespace Content.Client.Eui
             IoCManager.InjectDependencies(this);
         }
 
-        public void Initialize(EuiManager mgr, uint id)
+        internal void Initialize(EuiManager mgr, uint id)
         {
             Manager = mgr;
             Id = id;
         }
 
+        /// <summary>
+        ///     Called when the EUI is opened by the server.
+        /// </summary>
         public virtual void Opened()
         {
         }
 
+        /// <summary>
+        ///     Called when the EUI is closed by the server.
+        /// </summary>
         public virtual void Closed()
         {
         }
 
+        /// <summary>
+        ///     Called when a new state comes in from the server.
+        /// </summary>
         public virtual void HandleState(EuiStateBase state)
         {
         }
 
+        /// <summary>
+        ///     Called when a message comes in from the server.
+        /// </summary>
         public virtual void HandleMessage(EuiMessageBase msg)
         {
         }
 
+        /// <summary>
+        ///     Send a message to the server-side implementation.
+        /// </summary>
         protected void SendMessage(EuiMessageBase msg)
         {
             var netMsg = _netManager.CreateNetMessage<MsgEuiMessage>();

Content.Server/Eui/BaseEui.cs

@@ -9,46 +9,56 @@ using Robust.Shared.IoC;
 
 namespace Content.Server.Eui
 {
+    /// <summary>
+    ///     Base class to implement server-side for an EUI.
+    /// </summary>
+    /// <remarks>
+    ///     An EUI is a system for making a relatively-easy connection between client and server
+    ///     for the purposes of UIs.
+    /// </remarks>
+    /// <remarks>
+    ///     An equivalently named class much exist server side for an EUI to work.
+    ///     It will be instantiated, opened and closed automatically.
+    /// </remarks>
     public abstract class BaseEui
     {
         private bool _isStateDirty = false;
 
+        /// <summary>
+        ///     The player that this EUI is open for.
+        /// </summary>
+        public IPlayerSession Player { get; private set; } = default!;
         public bool IsShutDown { get; private set; }
         public EuiManager Manager { get; private set; } = default!;
-        public IPlayerSession Player { get; private set; } = default!;
         public uint Id { get; private set; }
 
-        public void Initialize(EuiManager manager, IPlayerSession player, uint id)
+        /// <summary>
-        {
+        ///     Called when the UI has been opened. Do initializing logic here.
-            Manager = manager;
+        /// </summary>
-            Player = player;
-            Id = id;
-            Opened();
-        }
-
         public virtual void Opened()
         {
 
         }
 
+        /// <summary>
+        ///     Called when the UI has been closed.
+        /// </summary>
         public virtual void Closed()
         {
 
         }
 
+        /// <summary>
+        ///     Called when a message comes in from the client.
+        /// </summary>
         public virtual void HandleMessage(EuiMessageBase msg)
         {
         }
 
-        public void Shutdown()
-        {
-            Closed();
-            IsShutDown = true;
-        }
-
         /// <summary>
         ///     Mark the current UI state as dirty and queue for an update.
         /// </summary>
+        /// <seealso cref="GetNewState"/>
         public void StateDirty()
         {
             if (_isStateDirty)
@@ -60,17 +70,43 @@ namespace Content.Server.Eui
             Manager.QueueStateUpdate(this);
         }
 
+        /// <summary>
+        ///     Called some time after <see cref="StateDirty"/> has been called
+        ///     to get a new UI state that can be sent to the client.
+        /// </summary>
         public virtual EuiStateBase GetNewState()
         {
             throw new NotSupportedException();
         }
 
+        /// <summary>
+        ///     Send a message to the client-side EUI.
+        /// </summary>
+        public void SendMessage(EuiMessageBase message)
+        {
+            var netMgr = IoCManager.Resolve<IServerNetManager>();
+            var msg = netMgr.CreateNetMessage<MsgEuiMessage>();
+            msg.Id = Id;
+            msg.Message = message;
+
+            netMgr.ServerSendMessage(msg, Player.ConnectedClient);
+        }
+
+        /// <summary>
+        ///     Close the EUI, breaking the connection between client and server.
+        /// </summary>
         public void Close()
         {
             Manager.CloseEui(this);
         }
 
-        public void DoStateUpdate()
+        internal void Shutdown()
+        {
+            Closed();
+            IsShutDown = true;
+        }
+
+        internal void DoStateUpdate()
         {
             _isStateDirty = false;
 
@@ -84,14 +120,12 @@ namespace Content.Server.Eui
             netMgr.ServerSendMessage(msg, Player.ConnectedClient);
         }
 
-        public void SendMessage(EuiMessageBase message)
+        internal void Initialize(EuiManager manager, IPlayerSession player, uint id)
         {
-            var netMgr = IoCManager.Resolve<IServerNetManager>();
+            Manager = manager;
-            var msg = netMgr.CreateNetMessage<MsgEuiMessage>();
+            Player = player;
-            msg.Id = Id;
+            Id = id;
-            msg.Message = message;
+            Opened();
-
-            netMgr.ServerSendMessage(msg, Player.ConnectedClient);
         }
     }
 }

Content.Server/Eui/EuiManager.cs

@@ -82,7 +82,7 @@ namespace Content.Server.Eui
 
         public void CloseEui(BaseEui eui)
         {
-            eui.Closed();
+            eui.Shutdown();
             _playerData[eui.Player].OpenUIs.Remove(eui.Id);
 
             var msg = _net.CreateNetMessage<MsgEuiCtl>();