Merge branch 'master' into DecimalReagents

Content.Client/GameObjects/Components/Command/CommunicationsConsoleBoundUserInterface.cs

@@ -0,0 +1,83 @@
+using System;
+using Content.Client.Command;
+using Content.Shared.GameObjects.Components.Command;
+using Robust.Client.GameObjects.Components.UserInterface;
+using Robust.Shared.GameObjects.Components.UserInterface;
+using Robust.Shared.Interfaces.Timing;
+using Robust.Shared.IoC;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Client.GameObjects.Components.Command
+{
+    public class CommunicationsConsoleBoundUserInterface : BoundUserInterface
+    {
+        [ViewVariables]
+        private CommunicationsConsoleMenu _menu;
+
+        [Dependency] private IGameTiming _gameTiming;
+
+        public bool CountdownStarted { get; private set; }
+
+        public int Countdown => _expectedCountdownTime == null
+            ? 0 : Math.Max((int)_expectedCountdownTime.Value.Subtract(_gameTiming.CurTime).TotalSeconds, 0);
+        private TimeSpan? _expectedCountdownTime;
+
+        public CommunicationsConsoleBoundUserInterface(ClientUserInterfaceComponent owner, object uiKey) : base(owner, uiKey)
+        {
+        }
+
+        protected override void Open()
+        {
+            base.Open();
+
+            _menu = new CommunicationsConsoleMenu(this);
+
+            _menu.OnClose += Close;
+
+            _menu.OpenCentered();
+        }
+
+        public void EmergencyShuttleButtonPressed()
+        {
+            if(CountdownStarted)
+                RecallShuttle();
+            else
+                CallShuttle();
+        }
+
+        public void CallShuttle()
+        {
+            SendMessage(new CommunicationsConsoleCallEmergencyShuttleMessage());
+        }
+
+        public void RecallShuttle()
+        {
+            SendMessage(new CommunicationsConsoleRecallEmergencyShuttleMessage());
+        }
+
+        protected override void ReceiveMessage(BoundUserInterfaceMessage message)
+        {
+            switch (message)
+            {
+            }
+        }
+
+        protected override void UpdateState(BoundUserInterfaceState state)
+        {
+            if (!(state is CommunicationsConsoleInterfaceState commsState))
+                return;
+
+            _expectedCountdownTime = commsState.ExpectedCountdownEnd;
+            CountdownStarted = commsState.CountdownStarted;
+            _menu?.UpdateCountdown();
+
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            base.Dispose(disposing);
+            if (!disposing) return;
+            _menu?.Dispose();
+        }
+    }
+}

Content.Client/GameObjects/Components/Research/LatheBoundUserInterface.cs

@@ -17,9 +17,9 @@ namespace Content.Client.GameObjects.Components.Research
         private IPrototypeManager _prototypeManager;
 #pragma warning restore
         [ViewVariables]
-        private LatheMenu menu;
+        private LatheMenu _menu;
         [ViewVariables]
-        private LatheQueueMenu queueMenu;
+        private LatheQueueMenu _queueMenu;
 
         public MaterialStorageComponent Storage { get; private set; }
         public SharedLatheComponent Lathe { get; private set; }
@@ -48,30 +48,30 @@ namespace Content.Client.GameObjects.Components.Research
             Lathe = lathe;
             Database = database;
 
-            menu = new LatheMenu(this);
-            queueMenu = new LatheQueueMenu { Owner = this };
+            _menu = new LatheMenu(this);
+            _queueMenu = new LatheQueueMenu { Owner = this };
 
-            menu.OnClose += Close;
+            _menu.OnClose += Close;
 
-            menu.Populate();
-            menu.PopulateMaterials();
+            _menu.Populate();
+            _menu.PopulateMaterials();
 
-            menu.QueueButton.OnPressed += (args) => { queueMenu.OpenCentered(); };
+            _menu.QueueButton.OnPressed += (args) => { _queueMenu.OpenCentered(); };
 
-            menu.ServerConnectButton.OnPressed += (args) =>
+            _menu.ServerConnectButton.OnPressed += (args) =>
             {
                 SendMessage(new SharedLatheComponent.LatheServerSelectionMessage());
             };
 
-            menu.ServerSyncButton.OnPressed += (args) =>
+            _menu.ServerSyncButton.OnPressed += (args) =>
             {
                 SendMessage(new SharedLatheComponent.LatheServerSyncMessage());
             };
 
-            storage.OnMaterialStorageChanged += menu.PopulateDisabled;
-            storage.OnMaterialStorageChanged += menu.PopulateMaterials;
+            storage.OnMaterialStorageChanged += _menu.PopulateDisabled;
+            storage.OnMaterialStorageChanged += _menu.PopulateMaterials;
 
-            menu.OpenCentered();
+            _menu.OpenCentered();
         }
 
         public void Queue(LatheRecipePrototype recipe, int quantity = 1)
@@ -85,10 +85,10 @@ namespace Content.Client.GameObjects.Components.Research
             {
                 case SharedLatheComponent.LatheProducingRecipeMessage msg:
                     if (!_prototypeManager.TryIndex(msg.ID, out LatheRecipePrototype recipe)) break;
-                    queueMenu?.SetInfo(recipe);
+                    _queueMenu?.SetInfo(recipe);
                     break;
                 case SharedLatheComponent.LatheStoppedProducingRecipeMessage _:
-                    queueMenu?.ClearInfo();
+                    _queueMenu?.ClearInfo();
                     break;
                 case SharedLatheComponent.LatheFullQueueMessage msg:
                     _queuedRecipes.Clear();
@@ -97,7 +97,7 @@ namespace Content.Client.GameObjects.Components.Research
                         if (!_prototypeManager.TryIndex(id, out LatheRecipePrototype recipePrototype)) break;
                         _queuedRecipes.Enqueue(recipePrototype);
                     }
-                    queueMenu?.PopulateList();
+                    _queueMenu?.PopulateList();
                     break;
             }
         }
@@ -106,8 +106,8 @@ namespace Content.Client.GameObjects.Components.Research
         {
             base.Dispose(disposing);
             if (!disposing) return;
-            menu?.Dispose();
-            queueMenu?.Dispose();
+            _menu?.Dispose();
+            _queueMenu?.Dispose();
         }
     }
 }