Merge pull request #805 from Zumorica/2020-04-09-comms-console-roundend

Adds working communications console that ends the round

Content.Server/GameObjects/Components/Command/CommunicationsConsoleComponent.cs

@@ -0,0 +1,76 @@
+using Content.Server.GameObjects.Components.Power;
+using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameTicking;
+using Content.Shared.GameObjects.Components.Command;
+using Robust.Server.GameObjects.Components.UserInterface;
+using Robust.Server.Interfaces.GameObjects;
+using Robust.Server.Interfaces.Player;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.IoC;
+
+namespace Content.Server.GameObjects.Components.Command
+{
+    [RegisterComponent]
+    [ComponentReference(typeof(IActivate))]
+    public class CommunicationsConsoleComponent : SharedCommunicationsConsoleComponent, IActivate
+    {
+#pragma warning disable 649
+        [Dependency] private IEntitySystemManager _entitySystemManager;
+#pragma warning restore 649
+
+        private BoundUserInterface _userInterface;
+        private PowerDeviceComponent _powerDevice;
+        private bool Powered => _powerDevice.Powered;
+        private RoundEndSystem RoundEndSystem => _entitySystemManager.GetEntitySystem<RoundEndSystem>();
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            _userInterface = Owner.GetComponent<ServerUserInterfaceComponent>().GetBoundUserInterface(CommunicationsConsoleUiKey.Key);
+            _userInterface.OnReceiveMessage += UserInterfaceOnOnReceiveMessage;
+            _powerDevice = Owner.GetComponent<PowerDeviceComponent>();
+
+            RoundEndSystem.OnRoundEndCountdownStarted += UpdateBoundInterface;
+            RoundEndSystem.OnRoundEndCountdownCancelled += UpdateBoundInterface;
+            RoundEndSystem.OnRoundEndCountdownFinished += UpdateBoundInterface;
+        }
+
+        private void UpdateBoundInterface()
+        {
+            _userInterface.SetState(new CommunicationsConsoleInterfaceState(RoundEndSystem.ExpectedCountdownEnd));
+        }
+
+        private void UserInterfaceOnOnReceiveMessage(ServerBoundUserInterfaceMessage obj)
+        {
+            switch (obj.Message)
+            {
+                case CommunicationsConsoleCallEmergencyShuttleMessage _:
+                    RoundEndSystem.RequestRoundEnd();
+                    break;
+
+                case CommunicationsConsoleRecallEmergencyShuttleMessage _:
+                    RoundEndSystem.CancelRoundEndCountdown();
+                    break;
+            }
+        }
+
+        public void OpenUserInterface(IPlayerSession session)
+        {
+            _userInterface.Open(session);
+        }
+
+        void IActivate.Activate(ActivateEventArgs eventArgs)
+        {
+            if (!eventArgs.User.TryGetComponent(out IActorComponent actor))
+                return;
+
+            if (!Powered)
+            {
+                return;
+            }
+            OpenUserInterface(actor.playerSession);
+        }
+    }
+}

Content.Server/GameObjects/EntitySystems/RoundEndSystem.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Threading;
+using Content.Server.Interfaces.GameTicking;
+using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.Interfaces.Timing;
+using Robust.Shared.IoC;
+using Timer = Robust.Shared.Timers.Timer;
+
+namespace Content.Server.GameObjects.EntitySystems
+{
+    public class RoundEndSystem : EntitySystem
+    {
+#pragma warning disable 649
+        [Dependency] private IGameTicker _gameTicker;
+        [Dependency] private IGameTiming _gameTiming;
+#pragma warning restore 649
+
+        private CancellationTokenSource _roundEndCancellationTokenSource = new CancellationTokenSource();
+        public bool IsRoundEndCountdownStarted { get; private set; }
+        public TimeSpan RoundEndCountdownTime { get; set; } = TimeSpan.FromMinutes(4);
+        public TimeSpan? ExpectedCountdownEnd = null;
+
+        public delegate void RoundEndCountdownStarted();
+        public event RoundEndCountdownStarted OnRoundEndCountdownStarted;
+
+        public delegate void RoundEndCountdownCancelled();
+        public event RoundEndCountdownCancelled OnRoundEndCountdownCancelled;
+
+        public delegate void RoundEndCountdownFinished();
+        public event RoundEndCountdownFinished OnRoundEndCountdownFinished;
+
+        public void RequestRoundEnd()
+        {
+            if (IsRoundEndCountdownStarted)
+                return;
+
+            IsRoundEndCountdownStarted = true;
+
+            ExpectedCountdownEnd = _gameTiming.CurTime + RoundEndCountdownTime;
+            Timer.Spawn(RoundEndCountdownTime, EndRound, _roundEndCancellationTokenSource.Token);
+            OnRoundEndCountdownStarted?.Invoke();
+        }
+
+        public void CancelRoundEndCountdown()
+        {
+            if (!IsRoundEndCountdownStarted)
+                return;
+
+            IsRoundEndCountdownStarted = false;
+
+            _roundEndCancellationTokenSource.Cancel();
+            _roundEndCancellationTokenSource = new CancellationTokenSource();
+
+            ExpectedCountdownEnd = null;
+
+            OnRoundEndCountdownCancelled?.Invoke();
+        }
+
+        private void EndRound()
+        {
+            OnRoundEndCountdownFinished?.Invoke();
+            _gameTicker.EndRound();
+        }
+    }
+}

Content.Server/GameTicking/GameTicker.cs

@@ -13,6 +13,7 @@ using Content.Server.Mobs;
 using Content.Server.Mobs.Roles;
 using Content.Server.Players;
 using Content.Shared;
+using Content.Shared.Chat;
 using Content.Shared.Jobs;
 using Content.Shared.Preferences;
 using Robust.Server.Interfaces.Maps;
@@ -123,6 +124,8 @@ namespace Content.Server.GameTicking
         {
             Logger.InfoS("ticker", "Restarting round!");
 
+            SendServerMessage("Restarting round...");
+
             RunLevel = GameRunLevel.PreRoundLobby;
             _resettingCleanup();
             _preRoundSetup();
@@ -147,6 +150,8 @@ namespace Content.Server.GameTicking
             DebugTools.Assert(RunLevel == GameRunLevel.PreRoundLobby);
             Logger.InfoS("ticker", "Starting round!");
 
+            SendServerMessage("The round is starting now...");
+
             RunLevel = GameRunLevel.InRound;
 
             var preset = MakeGamePreset();
@@ -191,6 +196,14 @@ namespace Content.Server.GameTicking
             _sendStatusToAll();
         }
 
+        private void SendServerMessage(string message)
+        {
+            var msg = _netManager.CreateNetMessage<MsgChatMessage>();
+            msg.Channel = ChatChannel.Server;
+            msg.Message = message;
+            IoCManager.Resolve<IServerNetManager>().ServerSendToAll(msg);
+        }
+
         private HumanoidCharacterProfile GetPlayerProfile(IPlayerSession p) =>
             (HumanoidCharacterProfile) _prefsManager.GetPreferences(p.SessionId.Username).SelectedCharacter;
 
@@ -200,6 +213,8 @@ namespace Content.Server.GameTicking
             Logger.InfoS("ticker", "Ending round!");
 
             RunLevel = GameRunLevel.PostRound;
+
+            SendServerMessage("The round has ended!");
         }
 
         public void Respawn(IPlayerSession targetPlayer)