Admins can get a list of the StationEvents (#1670)

* -GetStationEventsMsg
-Fixed random in events help

* Don't send on connect

* Delete StationEvents on disconnect

* Resolve IClientNetManager when needed

* :smilethink:

* Remove setter

* Removed unused imports

* Don't resolve twice

* Add Event

Content.Client/ClientContentIoC.cs

@@ -5,6 +5,7 @@ using Content.Client.Interfaces.Chat;
 using Content.Client.Interfaces.Parallax;
 using Content.Client.Parallax;
 using Content.Client.Sandbox;
+using Content.Client.StationEvents;
 using Content.Client.UserInterface;
 using Content.Client.UserInterface.Stylesheets;
 using Content.Client.Utility;
@@ -31,6 +32,7 @@ namespace Content.Client
             IoCManager.Register<IStylesheetManager, StylesheetManager>();
             IoCManager.Register<IScreenshotHook, ScreenshotHook>();
             IoCManager.Register<IClickMapManager, ClickMapManager>();
+            IoCManager.Register<IStationEventManager, StationEventManager>();
         }
     }
 }

Content.Client/EntryPoint.cs

@@ -7,6 +7,7 @@ using Content.Client.Interfaces.Parallax;
 using Content.Client.Parallax;
 using Content.Client.Sandbox;
 using Content.Client.State;
+using Content.Client.StationEvents;
 using Content.Client.UserInterface;
 using Content.Client.UserInterface.Stylesheets;
 using Content.Shared.GameObjects.Components;
@@ -150,6 +151,7 @@ namespace Content.Client
             IoCManager.Resolve<IChatManager>().Initialize();
             IoCManager.Resolve<ISandboxManager>().Initialize();
             IoCManager.Resolve<IClientPreferencesManager>().Initialize();
+            IoCManager.Resolve<IStationEventManager>().Initialize();
 
             _baseClient.RunLevelChanged += (sender, args) =>
             {

Content.Client/StationEvents/IStationEventManager.cs

@@ -0,0 +1,13 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+
+namespace Content.Client.StationEvents
+{
+    public interface IStationEventManager
+    {
+        public List<string>? StationEvents { get; }
+        public void Initialize();
+        public event Action OnStationEventsReceived;
+    }
+}

Content.Client/StationEvents/StationEventManager.cs

@@ -0,0 +1,42 @@
+#nullable enable
+using Content.Shared.StationEvents;
+using Robust.Shared.Interfaces.Network;
+using Robust.Shared.IoC;
+using System;
+using System.Collections.Generic;
+
+namespace Content.Client.StationEvents
+{
+    class StationEventManager : SharedStationEvent, IStationEventManager
+    {
+        private List<string>? _events;
+        public List<string>? StationEvents
+        {
+            get
+            {
+                if (_events == null)
+                    RequestEvents();
+                return _events;
+            }
+        }
+        public event Action? OnStationEventsReceived;
+
+        public void Initialize()
+        {
+            var netManager = IoCManager.Resolve<IClientNetManager>();
+            netManager.RegisterNetMessage<MsgGetStationEvents>(nameof(MsgGetStationEvents), EventHandler);
+            netManager.Disconnect += (sender, msg) => _events = null;
+        }
+
+        private void EventHandler(MsgGetStationEvents msg)
+        {
+            _events = msg.Events;
+            OnStationEventsReceived?.Invoke();
+        }
+        public void RequestEvents()
+        {
+            var netManager = IoCManager.Resolve<IClientNetManager>();
+            netManager.ClientSendMessage(netManager.CreateNetMessage<MsgGetStationEvents>());
+        }
+    }
+}

Content.Server/GameObjects/EntitySystems/StationEvents/StationEventSystem.cs

@@ -1,21 +1,28 @@
-using System;
+using Content.Server.StationEvents;
-using System.Collections.Generic;
-using System.Text;
-using Content.Server.StationEvents;
 using JetBrains.Annotations;
+using Robust.Server.Console;
 using Robust.Server.Interfaces.Player;
 using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.Interfaces.Network;
 using Robust.Shared.Interfaces.Random;
 using Robust.Shared.Interfaces.Reflection;
 using Robust.Shared.Interfaces.Timing;
 using Robust.Shared.IoC;
 using Robust.Shared.Localization;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using static Content.Shared.StationEvents.SharedStationEvent;
 
 namespace Content.Server.GameObjects.EntitySystems.StationEvents
 {
     [UsedImplicitly]
     public sealed class StationEventSystem : EntitySystem
     {
+#pragma warning disable 649
+        [Dependency] private readonly IServerNetManager _netManager;
+        [Dependency] private readonly IPlayerManager _playerManager;
+#pragma warning restore 649
         // Somewhat based off of TG's implementation of events
 
         public StationEvent CurrentEvent { get; private set; }
@@ -154,8 +161,31 @@ namespace Content.Server.GameObjects.EntitySystems.StationEvents
                 var stationEvent = (StationEvent) typeFactory.CreateInstance(type);
                 _stationEvents.Add(stationEvent);
             }
+
+            _netManager.RegisterNetMessage<MsgGetStationEvents>(nameof(MsgGetStationEvents), GetEventReceived);
         }
 
+        private void GetEventReceived(MsgGetStationEvents msg)
+        {
+            var player = _playerManager.GetSessionByChannel(msg.MsgChannel);
+            SendEvents(player);
+        }
+
+        private void SendEvents(IPlayerSession player)
+        {
+            if (!IoCManager.Resolve<IConGroupController>().CanCommand(player, "events"))
+                return;
+
+            var newMsg = _netManager.CreateNetMessage<MsgGetStationEvents>();
+            newMsg.Events = new List<string>();
+            foreach (var e in StationEvents)
+            {
+                newMsg.Events.Add(e.Name);
+            }
+            _netManager.ServerSendMessage(newMsg, player.ConnectedClient);
+        }
+
+
         public override void Update(float frameTime)
         {
             base.Update(frameTime);

Content.Server/StationEvents/StationEventCommand.cs

@@ -1,4 +1,4 @@
-#nullable enable
+#nullable enable
 using Content.Server.GameObjects.EntitySystems;
 using Content.Server.GameObjects.EntitySystems.StationEvents;
 using JetBrains.Annotations;
@@ -14,11 +14,10 @@ namespace Content.Client.Commands
     {
         public string Command => "events";
         public string Description => "Provides admin control to station events";
-        public string Help => "events <list/pause/resume/random/stop/run <eventname>>\n" + 
+        public string Help => "events <list/pause/resume/stop/run <eventname/random>>\n" + 
                               "list: return all event names that can be run\n " +
                               "pause: stop all random events from running\n" + 
                               "resume: allow random events to run again\n" +
-                              "random: choose a random event that is valid and run it\n" +
                               "run: start a particular event now; <eventname> is case-insensitive and not localized";
         public void Execute(IConsoleShell shell, IPlayerSession? player, string[] args)
         {

Content.Shared/StationEvents/SharedStationEvent.cs

@@ -0,0 +1,46 @@
+using Lidgren.Network;
+using Robust.Shared.Interfaces.Network;
+using Robust.Shared.Interfaces.Serialization;
+using Robust.Shared.IoC;
+using Robust.Shared.Network;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace Content.Shared.StationEvents
+{
+    public class SharedStationEvent
+    {
+        public class MsgGetStationEvents : NetMessage
+        {
+            #region REQUIRED
+
+            public const MsgGroups GROUP = MsgGroups.Command;
+            public const string NAME = nameof(MsgGetStationEvents);
+            public MsgGetStationEvents(INetChannel channel) : base(NAME, GROUP) { }
+
+            #endregion
+            public List<string> Events;
+            public override void ReadFromBuffer(NetIncomingMessage buffer)
+            {
+                var serializer = IoCManager.Resolve<IRobustSerializer>();
+                var length = buffer.ReadVariableInt32();
+                using var stream = buffer.ReadAsStream(length);
+                Events = serializer.Deserialize<List<string>>(stream);
+            }
+
+            public override void WriteToBuffer(NetOutgoingMessage buffer)
+            {
+                var serializer = IoCManager.Resolve<IRobustSerializer>();
+                using (var stream = new MemoryStream())
+                {
+                    serializer.Serialize(stream, Events);
+                    buffer.WriteVariableInt32((int)stream.Length);
+                    stream.TryGetBuffer(out var segment);
+                    buffer.Write(segment);
+                }
+            }
+        }
+    }
+}