ECS emergency lights (#7230)

Content.Server/Light/Components/EmergencyLightComponent.cs

@@ -1,165 +1,28 @@
-using System;
+using Content.Server.Light.EntitySystems;
-using System.Collections.Generic;
-using Content.Server.Power.Components;
-using Content.Shared.Examine;
 using Content.Shared.Light.Component;
-using Robust.Server.GameObjects;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Localization;
-using Robust.Shared.Serialization.Manager.Attributes;
-using Robust.Shared.Utility;
-using Robust.Shared.ViewVariables;
 
 namespace Content.Server.Light.Components
 {
     /// <summary>
     ///     Component that represents an emergency light, it has an internal battery that charges when the power is on.
     /// </summary>
-    [RegisterComponent]
+    [RegisterComponent, Friend(typeof(EmergencyLightSystem))]
-#pragma warning disable 618
+    public sealed class EmergencyLightComponent : SharedEmergencyLightComponent
-    public sealed class EmergencyLightComponent : SharedEmergencyLightComponent, IExamine
-#pragma warning restore 618
     {
-        [Dependency] private readonly IEntityManager _entMan = default!;
-
         [ViewVariables]
-        private EmergencyLightState State
+        public EmergencyLightState State;
-        {
-            get => _state;
-            set
-            {
-                if (_state == value)
-                    return;
-
-                _state = value;
-                _entMan.EventBus.RaiseEvent(EventSource.Local, new EmergencyLightMessage(this, _state));
-            }
-        }
-
-        private EmergencyLightState _state = EmergencyLightState.Empty;
 
         [ViewVariables(VVAccess.ReadWrite)]
         [DataField("wattage")]
-        private float _wattage = 5;
+        public float Wattage = 5;
+
         [ViewVariables(VVAccess.ReadWrite)]
         [DataField("chargingWattage")]
-        private float _chargingWattage = 60;
+        public float ChargingWattage = 60;
+
         [ViewVariables(VVAccess.ReadWrite)]
         [DataField("chargingEfficiency")]
-        private float _chargingEfficiency = 0.85f;
+        public float ChargingEfficiency = 0.85f;
-
-        /// <summary>
-        ///     For attaching UpdateState() to events.
-        /// </summary>
-        public void UpdateState(PowerChangedMessage e)
-        {
-            UpdateState();
-        }
-
-        /// <summary>
-        ///     Updates the light's power drain, battery drain, sprite and actual light state.
-        /// </summary>
-        public void UpdateState()
-        {
-            if (!_entMan.TryGetComponent(Owner, out ApcPowerReceiverComponent? receiver))
-            {
-                return;
-            }
-
-            if (receiver.Powered)
-            {
-                receiver.Load = (int) Math.Abs(_wattage);
-                TurnOff();
-                State = EmergencyLightState.Charging;
-            }
-            else
-            {
-                TurnOn();
-                State = EmergencyLightState.On;
-            }
-        }
-
-        public void OnUpdate(float frameTime)
-        {
-            if ((!_entMan.EntityExists(Owner) || !_entMan.TryGetComponent(Owner, out BatteryComponent? battery) || _entMan.GetComponent<MetaDataComponent>(Owner).EntityPaused))
-            {
-                return;
-            }
-
-            if(State == EmergencyLightState.On)
-            {
-                if (!battery.TryUseCharge(_wattage * frameTime))
-                {
-                    State = EmergencyLightState.Empty;
-                    TurnOff();
-                }
-            }
-            else
-            {
-                battery.CurrentCharge += _chargingWattage * frameTime * _chargingEfficiency;
-                if (battery.IsFullyCharged)
-                {
-                    if (_entMan.TryGetComponent(Owner, out ApcPowerReceiverComponent? receiver))
-                    {
-                        receiver.Load = 1;
-                    }
-
-                    State = EmergencyLightState.Full;
-                }
-            }
-        }
-
-        private void TurnOff()
-        {
-            if (_entMan.TryGetComponent(Owner, out PointLightComponent? light))
-            {
-                light.Enabled = false;
-            }
-
-            if (_entMan.TryGetComponent(Owner, out AppearanceComponent? appearance))
-                appearance.SetData(EmergencyLightVisuals.On, false);
-        }
-
-        private void TurnOn()
-        {
-            if (_entMan.TryGetComponent(Owner, out PointLightComponent? light))
-            {
-                light.Enabled = true;
-            }
-
-            if (_entMan.TryGetComponent(Owner, out AppearanceComponent? appearance))
-                appearance.SetData(EmergencyLightVisuals.On, true);
-        }
-
-#pragma warning disable 618
-        [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
-        public override void HandleMessage(ComponentMessage message, IComponent? component)
-#pragma warning restore 618
-        {
-#pragma warning disable 618
-            base.HandleMessage(message, component);
-#pragma warning restore 618
-            switch (message)
-            {
-                case PowerChangedMessage powerChanged:
-                    UpdateState(powerChanged);
-                    break;
-            }
-        }
-
-        void IExamine.Examine(FormattedMessage message, bool inDetailsRange)
-        {
-            message.AddMarkup(Loc.GetString("emergency-light-component-on-examine",("batteryStateText", Loc.GetString(BatteryStateText[State]))));
-        }
-
-        public enum EmergencyLightState
-        {
-            Charging,
-            Full,
-            Empty,
-            On
-        }
 
         public Dictionary<EmergencyLightState, string> BatteryStateText = new()
         {
@@ -170,13 +33,21 @@ namespace Content.Server.Light.Components
         };
     }
 
-    public sealed class EmergencyLightMessage : EntityEventArgs
+    public enum EmergencyLightState : byte
+    {
+        Charging,
+        Full,
+        Empty,
+        On
+    }
+
+    public sealed class EmergencyLightEvent : EntityEventArgs
     {
         public EmergencyLightComponent Component { get; }
 
-        public EmergencyLightComponent.EmergencyLightState State { get; }
+        public EmergencyLightState State { get; }
 
-        public EmergencyLightMessage(EmergencyLightComponent component, EmergencyLightComponent.EmergencyLightState state)
+        public EmergencyLightEvent(EmergencyLightComponent component, EmergencyLightState state)
         {
             Component = component;
             State = state;

Content.Server/Light/EntitySystems/EmergencyLightSystem.cs

@@ -1,10 +1,10 @@
-using System;
-using System.Collections.Generic;
 using Content.Server.Light.Components;
+using Content.Server.Power.Components;
+using Content.Shared.Examine;
 using Content.Shared.Light;
 using Content.Shared.Light.Component;
 using JetBrains.Annotations;
-using Robust.Shared.GameObjects;
+using Robust.Server.GameObjects;
 using Robust.Shared.GameStates;
 
 namespace Content.Server.Light.EntitySystems
@@ -17,16 +17,31 @@ namespace Content.Server.Light.EntitySystems
         public override void Initialize()
         {
             base.Initialize();
-            SubscribeLocalEvent<EmergencyLightMessage>(HandleEmergencyLightMessage);
+            SubscribeLocalEvent<EmergencyLightEvent>(HandleEmergencyLightMessage);
             SubscribeLocalEvent<EmergencyLightComponent, ComponentGetState>(GetCompState);
             SubscribeLocalEvent<EmergencyLightComponent, PointLightToggleEvent>(HandleLightToggle);
+            SubscribeLocalEvent<EmergencyLightComponent, ExaminedEvent>(OnEmergencyExamine);
+            SubscribeLocalEvent<EmergencyLightComponent, PowerChangedEvent>(OnEmergencyPower);
+        }
+
+        private void OnEmergencyPower(EntityUid uid, EmergencyLightComponent component, PowerChangedEvent args)
+        {
+            UpdateState(component);
+        }
+
+        private void OnEmergencyExamine(EntityUid uid, EmergencyLightComponent component, ExaminedEvent args)
+        {
+            args.PushMarkup(
+                Loc.GetString("emergency-light-component-on-examine",
+                    ("batteryStateText",
+                        Loc.GetString(component.BatteryStateText[component.State]))));
         }
 
         private void HandleLightToggle(EntityUid uid, EmergencyLightComponent component, PointLightToggleEvent args)
         {
             if (component.Enabled == args.Enabled) return;
             component.Enabled = args.Enabled;
-            component.Dirty();
+            Dirty(component);
         }
 
         private void GetCompState(EntityUid uid, EmergencyLightComponent component, ref ComponentGetState args)
@@ -34,29 +49,112 @@ namespace Content.Server.Light.EntitySystems
             args.State = new EmergencyLightComponentState(component.Enabled);
         }
 
-        private void HandleEmergencyLightMessage(EmergencyLightMessage message)
+        private void HandleEmergencyLightMessage(EmergencyLightEvent @event)
         {
-            switch (message.State)
+            switch (@event.State)
             {
-                case EmergencyLightComponent.EmergencyLightState.On:
+                case EmergencyLightState.On:
-                case EmergencyLightComponent.EmergencyLightState.Charging:
+                case EmergencyLightState.Charging:
-                    _activeLights.Add(message.Component);
+                    _activeLights.Add(@event.Component);
                     break;
-                case EmergencyLightComponent.EmergencyLightState.Full:
+                case EmergencyLightState.Full:
-                case EmergencyLightComponent.EmergencyLightState.Empty:
+                case EmergencyLightState.Empty:
-                    _activeLights.Remove(message.Component);
+                    _activeLights.Remove(@event.Component);
                     break;
                 default:
                     throw new ArgumentOutOfRangeException();
             }
         }
 
+        public void SetState(EmergencyLightComponent component, EmergencyLightState state)
+        {
+            if (component.State == state) return;
+
+            component.State = state;
+            RaiseLocalEvent(component.Owner, new EmergencyLightEvent(component, state));
+        }
+
         public override void Update(float frameTime)
         {
             foreach (var activeLight in _activeLights)
             {
-                activeLight.OnUpdate(frameTime);
+                Update(activeLight, frameTime);
             }
         }
+
+        private void Update(EmergencyLightComponent component, float frameTime)
+        {
+            if (!EntityManager.EntityExists(component.Owner) || !TryComp(component.Owner, out BatteryComponent? battery) || MetaData(component.Owner).EntityPaused)
+            {
+                return;
+            }
+
+            if (component.State == EmergencyLightState.On)
+            {
+                if (!battery.TryUseCharge(component.Wattage * frameTime))
+                {
+                    SetState(component, EmergencyLightState.Empty);
+                    TurnOff(component);
+                }
+            }
+            else
+            {
+                battery.CurrentCharge += component.ChargingWattage * frameTime * component.ChargingEfficiency;
+                if (battery.IsFullyCharged)
+                {
+                    if (TryComp(component.Owner, out ApcPowerReceiverComponent? receiver))
+                    {
+                        receiver.Load = 1;
+                    }
+
+                    SetState(component, EmergencyLightState.Full);
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Updates the light's power drain, battery drain, sprite and actual light state.
+        /// </summary>
+        public void UpdateState(EmergencyLightComponent component)
+        {
+            if (!TryComp(component.Owner, out ApcPowerReceiverComponent? receiver))
+            {
+                return;
+            }
+
+            if (receiver.Powered)
+            {
+                receiver.Load = (int) Math.Abs(component.Wattage);
+                TurnOff(component);
+                SetState(component, EmergencyLightState.Charging);
+            }
+            else
+            {
+                TurnOn(component);
+                SetState(component, EmergencyLightState.On);
+            }
+        }
+
+        private void TurnOff(EmergencyLightComponent component)
+        {
+            if (TryComp(component.Owner, out PointLightComponent? light))
+            {
+                light.Enabled = false;
+            }
+
+            if (TryComp(component.Owner, out AppearanceComponent? appearance))
+                appearance.SetData(EmergencyLightVisuals.On, false);
+        }
+
+        private void TurnOn(EmergencyLightComponent component)
+        {
+            if (TryComp(component.Owner, out PointLightComponent? light))
+            {
+                light.Enabled = true;
+            }
+
+            if (TryComp(component.Owner, out AppearanceComponent? appearance))
+                appearance.SetData(EmergencyLightVisuals.On, true);
+        }
     }
 }