Re-organize all projects (#4166)

Content.Server/Light/EntitySystems/EmergencyLightSystem.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using Content.Server.Light.Components;
+using JetBrains.Annotations;
+using Robust.Shared.GameObjects;
+
+namespace Content.Server.Light.EntitySystems
+{
+    [UsedImplicitly]
+    internal sealed class EmergencyLightSystem : EntitySystem
+    {
+        private readonly HashSet<EmergencyLightComponent> _activeLights = new();
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            SubscribeLocalEvent<EmergencyLightMessage>(HandleEmergencyLightMessage);
+        }
+
+        private void HandleEmergencyLightMessage(EmergencyLightMessage message)
+        {
+            switch (message.State)
+            {
+                case EmergencyLightComponent.EmergencyLightState.On:
+                case EmergencyLightComponent.EmergencyLightState.Charging:
+                    _activeLights.Add(message.Component);
+                    break;
+                case EmergencyLightComponent.EmergencyLightState.Full:
+                case EmergencyLightComponent.EmergencyLightState.Empty:
+                    _activeLights.Remove(message.Component);
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public override void Update(float frameTime)
+        {
+            foreach (var activeLight in _activeLights)
+            {
+                activeLight.OnUpdate(frameTime);
+            }
+        }
+    }
+}

Content.Server/Light/EntitySystems/ExpendableLightSystem.cs

@@ -0,0 +1,18 @@
+using Content.Server.Light.Components;
+using JetBrains.Annotations;
+using Robust.Shared.GameObjects;
+
+namespace Content.Server.Light.EntitySystems
+{
+    [UsedImplicitly]
+    public class ExpendableLightSystem : EntitySystem
+    {
+        public override void Update(float frameTime)
+        {
+            foreach (var light in ComponentManager.EntityQuery<ExpendableLightComponent>(true))
+            {
+                light.Update(frameTime);
+            }
+        }
+    }
+}

Content.Server/Light/EntitySystems/HandHeldLightSystem.cs

@@ -0,0 +1,50 @@
+using System.Collections.Generic;
+using System.Linq;
+using Content.Server.Light.Components;
+using JetBrains.Annotations;
+using Robust.Shared.GameObjects;
+
+namespace Content.Server.Light.EntitySystems
+{
+    [UsedImplicitly]
+    internal sealed class HandHeldLightSystem : EntitySystem
+    {
+        // TODO: Ideally you'd be able to subscribe to power stuff to get events at certain percentages.. or something?
+        // But for now this will be better anyway.
+        private HashSet<HandheldLightComponent> _activeLights = new();
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            SubscribeLocalEvent<ActivateHandheldLightMessage>(HandleActivate);
+            SubscribeLocalEvent<DeactivateHandheldLightMessage>(HandleDeactivate);
+        }
+
+        public override void Shutdown()
+        {
+            base.Shutdown();
+            _activeLights.Clear();
+            UnsubscribeLocalEvent<ActivateHandheldLightMessage>();
+            UnsubscribeLocalEvent<DeactivateHandheldLightMessage>();
+        }
+
+        private void HandleActivate(ActivateHandheldLightMessage message)
+        {
+            _activeLights.Add(message.Component);
+        }
+
+        private void HandleDeactivate(DeactivateHandheldLightMessage message)
+        {
+            _activeLights.Remove(message.Component);
+        }
+
+        public override void Update(float frameTime)
+        {
+            foreach (var handheld in _activeLights.ToArray())
+            {
+                if (handheld.Deleted || handheld.Paused) continue;
+                handheld.OnUpdate(frameTime);
+            }
+        }
+    }
+}

Content.Server/Light/EntitySystems/LightReplacerSystem.cs

@@ -0,0 +1,64 @@
+#nullable enable
+using Content.Server.Light.Components;
+using Content.Server.Storage.Components;
+using Content.Shared.ActionBlocker;
+using Content.Shared.Interaction;
+using JetBrains.Annotations;
+using Robust.Shared.GameObjects;
+
+namespace Content.Server.Light.EntitySystems
+{
+    [UsedImplicitly]
+    public class LightReplacerSystem : EntitySystem
+    {
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            SubscribeLocalEvent<LightReplacerComponent, InteractUsingEvent>(HandleInteract);
+            SubscribeLocalEvent<LightReplacerComponent, AfterInteractEvent>(HandleAfterInteract);
+        }
+
+        public override void Shutdown()
+        {
+            base.Shutdown();
+
+            UnsubscribeLocalEvent<LightReplacerComponent, InteractUsingEvent>(HandleInteract);
+            UnsubscribeLocalEvent<LightReplacerComponent, AfterInteractEvent>(HandleAfterInteract);
+        }
+
+        private void HandleAfterInteract(EntityUid uid, LightReplacerComponent component, AfterInteractEvent eventArgs)
+        {
+            // standard interaction checks
+            if (!ActionBlockerSystem.CanUse(eventArgs.User)) return;
+            if (!eventArgs.CanReach) return;
+
+            // behaviour will depends on target type
+            if (eventArgs.Target != null)
+            {
+                // replace broken light in fixture?
+                if (eventArgs.Target.TryGetComponent(out PoweredLightComponent? fixture))
+                    component.TryReplaceBulb(fixture, eventArgs.User);
+                // add new bulb to light replacer container?
+                else if (eventArgs.Target.TryGetComponent(out LightBulbComponent? bulb))
+                    component.TryInsertBulb(bulb, eventArgs.User, true);
+            }
+        }
+
+        private void HandleInteract(EntityUid uid, LightReplacerComponent component, InteractUsingEvent eventArgs)
+        {
+            // standard interaction checks
+            if (!ActionBlockerSystem.CanInteract(eventArgs.User)) return;
+
+            if (eventArgs.Used != null)
+            {
+                // want to insert a new light bulb?
+                if (eventArgs.Used.TryGetComponent(out LightBulbComponent? bulb))
+                    component.TryInsertBulb(bulb, eventArgs.User, true);
+                // add bulbs from storage?
+                else if (eventArgs.Used.TryGetComponent(out ServerStorageComponent? storage))
+                    component.TryInsertBulb(storage, eventArgs.User);
+            }
+        }
+    }
+}