Power Rework (#863)

Co-authored-by: py01 <pyronetics01@gmail.com>

Content.Server/GameObjects/Components/Power/ApcNetComponents/ApcComponent.cs

@@ -0,0 +1,161 @@
+using Content.Server.GameObjects.Components.Power.PowerNetComponents;
+using Content.Server.GameObjects.Components.NodeContainer.NodeGroups;
+using Content.Server.GameObjects.EntitySystems;
+using Content.Shared.GameObjects.Components.Power;
+using Robust.Server.GameObjects;
+using Robust.Server.GameObjects.Components.UserInterface;
+using Robust.Server.GameObjects.EntitySystems;
+using Robust.Server.Interfaces.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.GameObjects;
+using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.ViewVariables;
+using System;
+using Robust.Shared.IoC;
+using Robust.Shared.Interfaces.Timing;
+
+namespace Content.Server.GameObjects.Components.Power.ApcNetComponents
+{
+    [RegisterComponent]
+    [ComponentReference(typeof(IActivate))]
+    public class ApcComponent : BaseApcNetComponent, IActivate
+    {
+        public override string Name => "Apc";
+
+        [ViewVariables]
+        public BatteryComponent Battery { get; private set; }
+
+        public bool MainBreakerEnabled { get; private set; } = true;
+
+        private BoundUserInterface _userInterface;
+
+        private AppearanceComponent _appearance;
+
+        private ApcChargeState _lastChargeState;
+
+        private TimeSpan _lastChargeStateChange;
+
+        private ApcExternalPowerState _lastExternalPowerState;
+
+        private TimeSpan _lastExternalPowerStateChange;
+
+        private float _lastCharge = 0f;
+
+        private bool _uiDirty = true;
+
+        private const float HighPowerThreshold = 0.9f;
+
+        private const int VisualsChangeDelay = 1;
+
+#pragma warning disable 649
+        [Dependency] private readonly IGameTiming _gameTiming;
+#pragma warning restore 649
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            Battery = Owner.GetComponent<BatteryComponent>();
+            _appearance = Owner.GetComponent<AppearanceComponent>();
+            _userInterface = Owner.GetComponent<ServerUserInterfaceComponent>().GetBoundUserInterface(ApcUiKey.Key);
+            _userInterface.OnReceiveMessage += UserInterfaceOnReceiveMessage;
+            Update();
+        }
+
+        protected override void AddSelfToNet(IApcNet apcNet)
+        {
+            apcNet.AddApc(this);
+        }
+
+        protected override void RemoveSelfFromNet(IApcNet apcNet)
+        {
+            apcNet.RemoveApc(this);
+        }
+
+        private void UserInterfaceOnReceiveMessage(ServerBoundUserInterfaceMessage serverMsg)
+        {
+            if (serverMsg.Message is ApcToggleMainBreakerMessage)
+            {
+                MainBreakerEnabled = !MainBreakerEnabled;
+                _uiDirty = true;
+                EntitySystem.Get<AudioSystem>().PlayFromEntity("/Audio/machines/machine_switch.ogg", Owner, AudioParams.Default.WithVolume(-2f));
+            }
+        }
+
+        public void Update()
+        {
+            var newState = CalcChargeState();
+            if (newState != _lastChargeState && _lastChargeStateChange + TimeSpan.FromSeconds(VisualsChangeDelay) < _gameTiming.CurTime)
+            {
+                _lastChargeState = newState;
+                _lastChargeStateChange = _gameTiming.CurTime;
+                _appearance.SetData(ApcVisuals.ChargeState, newState);
+            }
+            var newCharge = Battery.CurrentCharge;
+            if (newCharge != _lastCharge)
+            {
+                _lastCharge = newCharge;
+                _uiDirty = true;
+            }
+            var extPowerState = CalcExtPowerState();
+            if (extPowerState != _lastExternalPowerState && _lastExternalPowerStateChange + TimeSpan.FromSeconds(VisualsChangeDelay) < _gameTiming.CurTime)
+            {
+                _lastExternalPowerState = extPowerState;
+                _lastExternalPowerStateChange = _gameTiming.CurTime;
+                _uiDirty = true;
+            }
+            if (_uiDirty)
+            {
+                _userInterface.SetState(new ApcBoundInterfaceState(MainBreakerEnabled, extPowerState, newCharge / Battery.MaxCharge));
+                _uiDirty = false;
+            }
+        }
+
+        private ApcChargeState CalcChargeState()
+        {
+            var chargeFraction = Battery.CurrentCharge / Battery.MaxCharge;
+            if (chargeFraction > HighPowerThreshold)
+            {
+                return ApcChargeState.Full;
+            }
+            var consumer = Owner.GetComponent<PowerConsumerComponent>();
+            if (consumer.DrawRate == consumer.ReceivedPower)
+            {
+                return ApcChargeState.Charging;
+            }
+            else
+            {
+                return ApcChargeState.Lack;
+            }
+        }
+
+        private ApcExternalPowerState CalcExtPowerState()
+        {
+            if (!Owner.TryGetComponent(out BatteryStorageComponent batteryStorage))
+            {
+                return ApcExternalPowerState.None;
+            }
+            var consumer = batteryStorage.Consumer;
+            if (consumer.ReceivedPower == 0 && consumer.DrawRate != 0)
+            {
+                return ApcExternalPowerState.None;
+            }
+            else if (consumer.ReceivedPower < consumer.DrawRate)
+            {
+                return ApcExternalPowerState.Low;
+            }
+            else
+            {
+                return ApcExternalPowerState.Good;
+            }
+        }
+
+        void IActivate.Activate(ActivateEventArgs eventArgs)
+        {
+            if (!eventArgs.User.TryGetComponent(out IActorComponent actor))
+            {
+                return;
+            }
+            _userInterface.Open(actor.playerSession);
+        }
+    }
+}

Content.Server/GameObjects/Components/Power/ApcNetComponents/BaseApcNetComponent.cs

@@ -0,0 +1,9 @@
+using Content.Server.GameObjects.Components.NodeContainer.NodeGroups;
+
+namespace Content.Server.GameObjects.Components.Power.ApcNetComponents
+{
+    public abstract class BaseApcNetComponent : BaseNetConnectorComponent<IApcNet>
+    {
+        protected override IApcNet NullNet => ApcNetNodeGroup.NullNet;
+    }
+}

Content.Server/GameObjects/Components/Power/ApcNetComponents/PowerProviderComponent.cs

@@ -0,0 +1,131 @@
+using Content.Server.GameObjects.Components.NodeContainer.NodeGroups;
+using Robust.Server.Interfaces.GameObjects;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.Map;
+using Robust.Shared.IoC;
+using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Content.Server.GameObjects.Components.Power.ApcNetComponents
+{
+    /// <summary>
+    ///     Relays <see cref="PowerReceiverComponent"/>s in an area to a <see cref="IApcNet"/> so they can receive power.
+    /// </summary>
+    public interface IPowerProvider
+    {
+        void AddReceiver(PowerReceiverComponent receiver);
+
+        void RemoveReceiver(PowerReceiverComponent receiver);
+    }
+
+    [RegisterComponent]
+    public class PowerProviderComponent : BaseApcNetComponent, IPowerProvider
+    {
+        public override string Name => "PowerProvider";
+
+        /// <summary>
+        ///     The max distance this can transmit power to <see cref="PowerReceiverComponent"/>s from.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        public int PowerTransferRange { get => _powerTransferRange; set => SetPowerTransferRange(value); }
+        private int _powerTransferRange;
+
+        [ViewVariables]
+        public IReadOnlyList<PowerReceiverComponent> LinkedReceivers => _linkedReceivers;
+        private List<PowerReceiverComponent> _linkedReceivers = new List<PowerReceiverComponent>();
+
+        /// <summary>
+        ///     If <see cref="PowerReceiverComponent"/>s should consider connecting to this.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        public bool Connectable { get; private set; } = true;
+
+        public static readonly IPowerProvider NullProvider = new NullPowerProvider();
+
+        public void AddReceiver(PowerReceiverComponent receiver)
+        {
+            _linkedReceivers.Add(receiver);
+            Net.UpdatePowerProviderReceivers(this);
+        }
+
+        public void RemoveReceiver(PowerReceiverComponent receiver)
+        {
+            _linkedReceivers.Remove(receiver);
+            Net.UpdatePowerProviderReceivers(this);
+        }
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            base.ExposeData(serializer);
+            serializer.DataField(ref _powerTransferRange, "powerTransferRange", 3);
+        }
+
+        protected override void Startup()
+        {
+            base.Startup();
+            foreach (var receiver in FindAvailableReceivers())
+            {
+                receiver.Provider = this;
+            }
+        }
+
+        public override void OnRemove()
+        {
+            Connectable = false;
+            var receivers = _linkedReceivers.ToArray();
+            foreach (var receiver in receivers)
+            {
+                receiver.ClearProvider();
+            }
+            _linkedReceivers = new List<PowerReceiverComponent>();
+            Net.UpdatePowerProviderReceivers(this);
+            foreach (var receiver in receivers)
+            {
+                receiver.TryFindAndSetProvider();
+            }
+            base.OnRemove();
+        }
+
+        private List<PowerReceiverComponent> FindAvailableReceivers()
+        {
+            var mapManager = IoCManager.Resolve<IMapManager>();
+            var nearbyEntities = IoCManager.Resolve<IServerEntityManager>()
+                .GetEntitiesInRange(Owner, PowerTransferRange);
+            return nearbyEntities.Select(entity => entity.TryGetComponent<PowerReceiverComponent>(out var receiver) ? receiver : null)
+                .Where(receiver => receiver != null)
+                .Where(receiver => receiver.NeedsProvider)
+                .Where(receiver => receiver.Owner.Transform.GridPosition.Distance(mapManager, Owner.Transform.GridPosition) < Math.Min(PowerTransferRange, receiver.PowerReceptionRange))
+                .ToList();
+        }
+
+        protected override void AddSelfToNet(IApcNet apcNet)
+        {
+            apcNet.AddPowerProvider(this);
+        }
+
+        protected override void RemoveSelfFromNet(IApcNet apcNet)
+        {
+            apcNet.RemovePowerProvider(this);
+        }
+
+        private void SetPowerTransferRange(int newPowerTransferRange)
+        {
+            foreach (var receiver in _linkedReceivers)
+            {
+                receiver.ClearProvider();
+            }
+            _powerTransferRange = newPowerTransferRange;
+            _linkedReceivers = FindAvailableReceivers();
+            Net.UpdatePowerProviderReceivers(this);
+        }
+
+        private class NullPowerProvider : IPowerProvider
+        {
+            public void AddReceiver(PowerReceiverComponent receiver) { }
+            public void RemoveReceiver(PowerReceiverComponent receiver) { }
+        }
+    }
+}

Content.Server/GameObjects/Components/Power/ApcNetComponents/PowerReceiverComponent.cs

@@ -0,0 +1,198 @@
+using Content.Server.GameObjects.Components.NodeContainer.NodeGroups;
+using Content.Shared.GameObjects.Components.Power;
+using Robust.Server.GameObjects;
+using Robust.Server.Interfaces.GameObjects;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.Map;
+using Robust.Shared.IoC;
+using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
+using System;
+
+namespace Content.Server.GameObjects.Components.Power.ApcNetComponents
+{
+    /// <summary>
+    ///     Attempts to link with a nearby <see cref="IPowerProvider"/>s so that it can receive power from a <see cref="IApcNet"/>.
+    /// </summary>
+    [RegisterComponent]
+    public class PowerReceiverComponent : Component
+    {
+        public override string Name => "PowerReceiver";
+
+        public event EventHandler<PowerStateEventArgs> OnPowerStateChanged;
+
+        [ViewVariables]
+        public bool Powered => (HasApcPower || !NeedsPower) && !PowerDisabled;
+
+        [ViewVariables]
+        public bool HasApcPower { get => _hasApcPower; set => SetHasApcPower(value); }
+        private bool _hasApcPower;
+
+        /// <summary>
+        ///     The max distance from a <see cref="PowerProviderComponent"/> that this can receive power from.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        public int PowerReceptionRange { get => _powerReceptionRange; set => SetPowerReceptionRange(value); }
+        private int _powerReceptionRange;
+
+        [ViewVariables]
+        public IPowerProvider Provider { get => _provider; set => SetProvider(value); }
+        private IPowerProvider _provider = PowerProviderComponent.NullProvider;
+
+        [ViewVariables]
+        public bool NeedsProvider { get; private set; } = true;
+
+        /// <summary>
+        ///     Amount of charge this needs from an APC per second to function.
+        /// </summary>
+        [ViewVariables]
+        public int Load { get => _load; set => SetLoad(value); }
+        private int _load;
+
+        /// <summary>
+        ///     When true, causes this to appear powered even if not receiving power from an Apc.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        public bool NeedsPower { get => _needsPower; set => SetNeedsPower(value); }
+        private bool _needsPower;
+
+        /// <summary>
+        ///     When true, causes this to never appear powered.
+        /// </summary>
+        public bool PowerDisabled { get => _powerDisabled; set => SetPowerDisabled(value); }
+        private bool _powerDisabled;
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            base.ExposeData(serializer);
+            serializer.DataField(ref _powerReceptionRange, "powerReceptionRange", 3);
+            serializer.DataField(ref _load, "powerLoad", 5);
+            serializer.DataField(ref _needsPower, "needsPower", true);
+            serializer.DataField(ref _powerDisabled, "powerDisabled", false);
+        }
+
+        protected override void Startup()
+        {
+            base.Startup();
+            if (NeedsProvider)
+            {
+                TryFindAndSetProvider();
+            }
+        }
+
+        public override void OnRemove()
+        {
+            _provider.RemoveReceiver(this);
+            base.OnRemove();
+        }
+
+        public void TryFindAndSetProvider()
+        {
+            if (TryFindAvailableProvider(out var provider))
+            {
+                Provider = provider;
+            }
+        }
+
+        private bool TryFindAvailableProvider(out IPowerProvider foundProvider)
+        {
+            var nearbyEntities = IoCManager.Resolve<IServerEntityManager>()
+                .GetEntitiesInRange(Owner, PowerReceptionRange);
+            var mapManager = IoCManager.Resolve<IMapManager>();
+            foreach (var entity in nearbyEntities)
+            {
+                if (entity.TryGetComponent<PowerProviderComponent>(out var provider))
+                {
+                    if (provider.Connectable)
+                    {
+                        var distanceToProvider = provider.Owner.Transform.GridPosition.Distance(mapManager, Owner.Transform.GridPosition);
+                        if (distanceToProvider < Math.Min(PowerReceptionRange, provider.PowerTransferRange))
+                        {
+                            foundProvider = provider;
+                            return true;
+                        }
+                    }
+                }
+            }
+            foundProvider = default;
+            return false;
+        }
+
+        public void ClearProvider()
+        {
+            _provider.RemoveReceiver(this);
+            _provider = PowerProviderComponent.NullProvider;
+            NeedsProvider = true;
+            HasApcPower = false;
+        }
+
+        private void SetProvider(IPowerProvider newProvider)
+        {
+            _provider.RemoveReceiver(this);
+            _provider = newProvider;
+            newProvider.AddReceiver(this);
+            NeedsProvider = false;
+        }
+
+        private void SetHasApcPower(bool newHasApcPower)
+        {
+            var oldPowered = Powered;
+            _hasApcPower = newHasApcPower;
+            if (oldPowered != Powered)
+            {
+                OnNewPowerState();
+            }
+        }
+
+        private void SetPowerReceptionRange(int newPowerReceptionRange)
+        {
+            ClearProvider();
+            _powerReceptionRange = newPowerReceptionRange;
+            TryFindAndSetProvider();
+        }
+
+        private void SetLoad(int newLoad)
+        {
+            _load = newLoad;
+        }
+
+        private void SetNeedsPower(bool newNeedsPower)
+        {
+            var oldPowered = Powered;
+            _needsPower = newNeedsPower;
+            if (oldPowered != Powered)
+            {
+                OnNewPowerState();
+            }
+        }
+
+        private void SetPowerDisabled(bool newPowerDisabled)
+        {
+            var oldPowered = Powered;
+            _powerDisabled = newPowerDisabled;
+            if (oldPowered != Powered)
+            {
+                OnNewPowerState();
+            }
+        }
+
+        private void OnNewPowerState()
+        {
+            OnPowerStateChanged?.Invoke(this, new PowerStateEventArgs(Powered));
+            if (Owner.TryGetComponent(out AppearanceComponent appearance))
+            {
+                appearance.SetData(PowerDeviceVisuals.Powered, Powered);
+            }
+        }
+    }
+
+    public class PowerStateEventArgs : EventArgs
+    {
+        public readonly bool Powered;
+
+        public PowerStateEventArgs(bool powered)
+        {
+            Powered = powered;
+        }
+    }
+}

Content.Server/GameObjects/Components/Power/ApcNetComponents/PowerReceiverUsers/BaseCharger.cs

@@ -0,0 +1,282 @@
+using System;
+using Content.Server.GameObjects.Components.Power.ApcNetComponents;
+using Content.Server.GameObjects.Components.Weapon.Ranged.Barrels;
+using Content.Server.GameObjects.EntitySystems;
+using Content.Shared.GameObjects;
+using Content.Shared.GameObjects.Components.Power;
+using Content.Shared.GameObjects.EntitySystems;
+using Content.Shared.Interfaces;
+using Robust.Server.GameObjects;
+using Robust.Server.GameObjects.Components.Container;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Localization;
+using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Server.GameObjects.Components.Power.Chargers
+{
+    [ComponentReference(typeof(IActivate))]
+    [ComponentReference(typeof(IInteractUsing))]
+    public abstract class BaseCharger : Component, IActivate, IInteractUsing
+    {
+        [ViewVariables]
+        private BatteryComponent _heldBattery;
+
+        [ViewVariables]
+        private ContainerSlot _container;
+
+        [ViewVariables]
+        private PowerReceiverComponent _powerReceiver;
+
+        [ViewVariables]
+        private CellChargerStatus _status;
+
+        private AppearanceComponent _appearanceComponent;
+
+        [ViewVariables]
+        private int _chargeRate;
+
+        [ViewVariables]
+        private float _transferEfficiency;
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            base.ExposeData(serializer);
+            serializer.DataField(ref _chargeRate, "chargeRate", 100);
+            serializer.DataField(ref _transferEfficiency, "transferEfficiency", 0.85f);
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            _powerReceiver = Owner.GetComponent<PowerReceiverComponent>();
+            _container = ContainerManagerComponent.Ensure<ContainerSlot>($"{Name}-powerCellContainer", Owner);
+            _appearanceComponent = Owner.GetComponent<AppearanceComponent>();
+            // Default state in the visualizer is OFF, so when this gets powered on during initialization it will generally show empty
+            _powerReceiver.OnPowerStateChanged += PowerUpdate;
+        }
+
+        public override void OnRemove()
+        {
+            _powerReceiver.OnPowerStateChanged -= PowerUpdate;
+            base.OnRemove();
+        }
+
+        bool IInteractUsing.InteractUsing(InteractUsingEventArgs eventArgs)
+        {
+            var result = TryInsertItem(eventArgs.Using);
+            if (!result)
+            {
+                var localizationManager = IoCManager.Resolve<ILocalizationManager>();
+                eventArgs.User.PopupMessage(Owner, localizationManager.GetString("Unable to insert capacitor"));
+            }
+
+            return result;
+        }
+
+        void IActivate.Activate(ActivateEventArgs eventArgs)
+        {
+            RemoveItem(eventArgs.User);
+        }
+
+        /// <summary>
+        /// This will remove the item directly into the user's hand / floor
+        /// </summary>
+        /// <param name="user"></param>
+        private void RemoveItem(IEntity user)
+        {
+            var heldItem = _container.ContainedEntity;
+            if (heldItem == null)
+            {
+                return;
+            }
+
+            _container.Remove(heldItem);
+            _heldBattery = null;
+            if (user.TryGetComponent(out HandsComponent handsComponent))
+            {
+                handsComponent.PutInHandOrDrop(heldItem.GetComponent<ItemComponent>());
+            }
+
+            if (heldItem.TryGetComponent(out ServerBatteryBarrelComponent batteryBarrelComponent))
+            {
+                batteryBarrelComponent.UpdateAppearance();
+            }
+            
+            UpdateStatus();
+        }
+
+        private void PowerUpdate(object sender, PowerStateEventArgs eventArgs)
+        {
+            UpdateStatus();
+        }
+
+        [Verb]
+        private sealed class InsertVerb : Verb<BaseCharger>
+        {
+            protected override void GetData(IEntity user, BaseCharger component, VerbData data)
+            {
+                if (!ActionBlockerSystem.CanInteract(user))
+                {
+                    data.Visibility = VerbVisibility.Invisible;
+                    return;
+                }
+                if (!user.TryGetComponent(out HandsComponent handsComponent))
+                {
+                    data.Visibility = VerbVisibility.Invisible;
+                    return;
+                }
+
+                if (component._container.ContainedEntity != null || handsComponent.GetActiveHand == null)
+                {
+                    data.Visibility = VerbVisibility.Disabled;
+                    data.Text = "Insert";
+                    return;
+                }
+
+                data.Text = $"Insert {handsComponent.GetActiveHand.Owner.Name}";
+            }
+
+            protected override void Activate(IEntity user, BaseCharger component)
+            {
+                if (!user.TryGetComponent(out HandsComponent handsComponent))
+                {
+                    return;
+                }
+
+                if (handsComponent.GetActiveHand == null)
+                {
+                    return;
+                }
+                var userItem = handsComponent.GetActiveHand.Owner;
+                handsComponent.Drop(userItem);
+                component.TryInsertItem(userItem);
+            }
+        }
+
+        [Verb]
+        private sealed class EjectVerb : Verb<BaseCharger>
+        {
+            protected override void GetData(IEntity user, BaseCharger component, VerbData data)
+            {
+                if (!ActionBlockerSystem.CanInteract(user))
+                {
+                    data.Visibility = VerbVisibility.Invisible;
+                    return;
+                }
+                if (component._container.ContainedEntity == null)
+                {
+                    data.Text = "Eject";
+                    data.Visibility = VerbVisibility.Disabled;
+                    return;
+                }
+
+                data.Text = $"Eject {component._container.ContainedEntity.Name}";
+            }
+
+            protected override void Activate(IEntity user, BaseCharger component)
+            {
+                component.RemoveItem(user);
+            }
+        }
+
+        private CellChargerStatus GetStatus()
+        {
+            if (!_powerReceiver.Powered)
+            {
+                return CellChargerStatus.Off;
+            }
+            if (_container.ContainedEntity == null)
+            {
+                return CellChargerStatus.Empty;
+            }
+            if (_heldBattery != null && Math.Abs(_heldBattery.MaxCharge - _heldBattery.CurrentCharge) < 0.01)
+            {
+                return CellChargerStatus.Charged;
+            }
+            return CellChargerStatus.Charging;
+        }
+
+        private bool TryInsertItem(IEntity entity)
+        {
+            if (!IsEntityCompatible(entity) || _container.ContainedEntity != null)
+            {
+                return false;
+            }
+            if (!_container.Insert(entity))
+            {
+                return false;
+            }
+            _heldBattery = GetBatteryFrom(entity);
+            UpdateStatus();
+            return true;
+        }
+
+        /// <summary>
+        ///     If the supplied entity should fit into the charger.
+        /// </summary>
+        protected abstract bool IsEntityCompatible(IEntity entity);
+
+        protected abstract BatteryComponent GetBatteryFrom(IEntity entity);
+
+        private void UpdateStatus()
+        {
+            // Not called UpdateAppearance just because it messes with the load
+            var status = GetStatus();
+            if (_status == status)
+            {
+                return;
+            }
+            _status = status;
+            switch (_status)
+            {
+                // Update load just in case
+                case CellChargerStatus.Off:
+                    _powerReceiver.Load = 0;
+                    _appearanceComponent?.SetData(CellVisual.Light, CellChargerStatus.Off);
+                    break;
+                case CellChargerStatus.Empty:
+                    _powerReceiver.Load = 0;
+                    _appearanceComponent?.SetData(CellVisual.Light, CellChargerStatus.Empty); ;
+                    break;
+                case CellChargerStatus.Charging:
+                    _powerReceiver.Load = (int) (_chargeRate / _transferEfficiency);
+                    _appearanceComponent?.SetData(CellVisual.Light, CellChargerStatus.Charging);
+                    break;
+                case CellChargerStatus.Charged:
+                    _powerReceiver.Load = 0;
+                    _appearanceComponent?.SetData(CellVisual.Light, CellChargerStatus.Charged);
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+            _appearanceComponent?.SetData(CellVisual.Occupied, _container.ContainedEntity != null);
+        }
+
+        public void OnUpdate(float frameTime) //todo: make single system for this
+        {
+            if (_status == CellChargerStatus.Empty || _status == CellChargerStatus.Charged || _container.ContainedEntity == null)
+            {
+                return;
+            }
+            TransferPower(frameTime);
+        }
+
+        private void TransferPower(float frameTime)
+        {
+            if (!_powerReceiver.Powered)
+            {
+                return;
+            }
+            _heldBattery.CurrentCharge += _chargeRate * frameTime;
+            // Just so the sprite won't be set to 99.99999% visibility
+            if (_heldBattery.MaxCharge - _heldBattery.CurrentCharge < 0.01)
+            {
+                _heldBattery.CurrentCharge = _heldBattery.MaxCharge;
+            }
+            UpdateStatus();
+        }
+    }
+}

Content.Server/GameObjects/Components/Power/ApcNetComponents/PowerReceiverUsers/LightBulbComponent.cs

@@ -0,0 +1,136 @@
+using System;
+using Content.Server.GameObjects.EntitySystems;
+using Content.Shared.Audio;
+using Robust.Server.GameObjects;
+using Robust.Server.GameObjects.EntitySystems;
+using Robust.Shared.GameObjects;
+using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.Interfaces.Random;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
+using Robust.Shared.Utility;
+
+namespace Content.Server.GameObjects.Components.Power
+{
+    public enum LightBulbState
+    {
+        Normal,
+        Broken,
+        Burned,
+    }
+
+    public enum LightBulbType
+    {
+        Bulb,
+        Tube,
+    }
+
+    /// <summary>
+    ///     Component that represents a light bulb. Can be broken, or burned, which turns them mostly useless.
+    /// </summary>
+    [RegisterComponent]
+    public class LightBulbComponent : Component, ILand
+    {
+
+#pragma warning disable 649
+        [Dependency] private readonly IPrototypeManager _prototypeManager;
+        [Dependency] private readonly IRobustRandom _random;
+#pragma warning restore 649
+
+        /// <summary>
+        ///     Invoked whenever the state of the light bulb changes.
+        /// </summary>
+        public event EventHandler<EventArgs> OnLightBulbStateChange;
+        public event EventHandler<EventArgs> OnLightColorChange;
+
+        private Color _color = Color.White;
+
+        [ViewVariables(VVAccess.ReadWrite)] public Color Color
+        {
+            get { return _color; }
+            set
+            {
+                _color = value;
+                OnLightColorChange?.Invoke(this, null);
+                UpdateColor();
+            }
+        }
+
+        public override string Name => "LightBulb";
+
+        public LightBulbType Type = LightBulbType.Tube;
+
+        private int _burningTemperature;
+        public int BurningTemperature => _burningTemperature;
+
+        private int _powerUse;
+        public int PowerUse => _powerUse;
+
+        /// <summary>
+        ///     The current state of the light bulb. Invokes the OnLightBulbStateChange event when set.
+        ///     It also updates the bulb's sprite accordingly.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)] public LightBulbState State
+        {
+            get { return _state; }
+            set
+            {
+                var sprite = Owner.GetComponent<SpriteComponent>();
+                OnLightBulbStateChange?.Invoke(this, EventArgs.Empty);
+                _state = value;
+                switch (value)
+                {
+                    case LightBulbState.Normal:
+                        sprite.LayerSetState(0, "normal");
+                        break;
+                    case LightBulbState.Broken:
+                        sprite.LayerSetState(0, "broken");
+                        break;
+                    case LightBulbState.Burned:
+                        sprite.LayerSetState(0, "burned");
+                        break;
+                }
+            }
+        }
+
+        private LightBulbState _state = LightBulbState.Normal;
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            serializer.DataField(ref Type, "bulb", LightBulbType.Tube);
+            serializer.DataField(ref _color, "color", Color.White);
+            serializer.DataFieldCached(ref _burningTemperature, "BurningTemperature", 1400);
+            serializer.DataFieldCached(ref _powerUse, "PowerUse", 40);
+        }
+
+        public void UpdateColor()
+        {
+            var sprite = Owner.GetComponent<SpriteComponent>();
+            sprite.Color = Color;
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            UpdateColor();
+        }
+
+        public void Land(LandEventArgs eventArgs)
+        {
+            if (State == LightBulbState.Broken)
+                return;
+
+            var soundCollection = _prototypeManager.Index<SoundCollectionPrototype>("glassbreak");
+            var file = _random.Pick(soundCollection.PickFiles);
+
+            EntitySystem.Get<AudioSystem>().PlayFromEntity(file, Owner);
+
+            State = LightBulbState.Broken;
+        }
+    }
+}

Content.Server/GameObjects/Components/Power/ApcNetComponents/PowerReceiverUsers/PowerCellChargerComponent.cs

@@ -0,0 +1,27 @@
+using Content.Server.GameObjects.EntitySystems;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.GameObjects;
+
+namespace Content.Server.GameObjects.Components.Power.Chargers
+{
+    /// <summary>
+    /// Recharges an entity with a <see cref="BatteryComponent"/>.
+    /// </summary>
+    [RegisterComponent]
+    [ComponentReference(typeof(IActivate))]
+    [ComponentReference(typeof(BaseCharger))]
+    public sealed class PowerCellChargerComponent : BaseCharger
+    {
+        public override string Name => "PowerCellCharger";
+
+        protected override bool IsEntityCompatible(IEntity entity)
+        {
+            return entity.HasComponent<BatteryComponent>();
+        }
+
+        protected override BatteryComponent GetBatteryFrom(IEntity entity)
+        {
+            return entity.GetComponent<BatteryComponent>();
+        }
+    }
+}

Content.Server/GameObjects/Components/Power/ApcNetComponents/PowerReceiverUsers/PoweredLightComponent.cs

@@ -0,0 +1,226 @@
+using System;
+using Content.Server.GameObjects.Components.Power.ApcNetComponents;
+using Content.Server.GameObjects.Components.Sound;
+using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Utility;
+using Content.Shared.GameObjects;
+using Robust.Server.GameObjects;
+using Robust.Server.GameObjects.Components.Container;
+using Robust.Server.GameObjects.EntitySystems;
+using Robust.Shared.Audio;
+using Robust.Shared.GameObjects;
+using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.Interfaces.Timing;
+using Robust.Shared.IoC;
+using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Server.GameObjects.Components.Power
+{
+    /// <summary>
+    ///     Component that represents a wall light. It has a light bulb that can be replaced when broken.
+    /// </summary>
+    [RegisterComponent]
+    public class PoweredLightComponent : Component, IInteractHand, IInteractUsing
+    {
+        public override string Name => "PoweredLight";
+
+        private static readonly TimeSpan _thunkDelay = TimeSpan.FromSeconds(2);
+
+        private TimeSpan _lastThunk;
+
+
+        private LightBulbType BulbType = LightBulbType.Tube;
+
+        [ViewVariables] private ContainerSlot _lightBulbContainer;
+
+        [ViewVariables]
+        private LightBulbComponent LightBulb
+        {
+            get
+            {
+                if (_lightBulbContainer.ContainedEntity == null) return null;
+
+                _lightBulbContainer.ContainedEntity.TryGetComponent(out LightBulbComponent bulb);
+
+                return bulb;
+            }
+        }
+
+        public bool InteractUsing(InteractUsingEventArgs eventArgs)
+        {
+            return InsertBulb(eventArgs.Using);
+        }
+
+        public bool InteractHand(InteractHandEventArgs eventArgs)
+        {
+            if (!eventArgs.User.TryGetComponent(out DamageableComponent damageableComponent))
+            {
+                Eject();
+                return false;
+            }
+            if(eventArgs.User.TryGetComponent(out HeatResistanceComponent heatResistanceComponent))
+            {
+                if(CanBurn(heatResistanceComponent.GetHeatResistance()))
+                {
+                    Burn();
+                    return true;
+                }
+            }
+            Eject();
+            return true;
+
+            bool CanBurn(int heatResistance)
+            {
+                return _lightState && heatResistance < LightBulb.BurningTemperature;
+            }
+
+            void Burn()
+            {
+                damageableComponent.TakeDamage(DamageType.Heat, 20, Owner);
+                var audioSystem = EntitySystem.Get<AudioSystem>();
+                audioSystem.PlayFromEntity("/Audio/effects/lightburn.ogg", Owner);
+            }
+
+            void Eject()
+            {
+                EjectBulb(eventArgs.User);
+                UpdateLight();
+            }
+        }
+
+        /// <summary>
+        ///     Inserts the bulb if possible.
+        /// </summary>
+        /// <returns>True if it could insert it, false if it couldn't.</returns>
+        private bool InsertBulb(IEntity bulb)
+        {
+            if (LightBulb != null) return false;
+            if (!bulb.TryGetComponent(out LightBulbComponent lightBulb)) return false;
+            if (lightBulb.Type != BulbType) return false;
+
+            var inserted = _lightBulbContainer.Insert(bulb);
+
+            lightBulb.OnLightBulbStateChange += UpdateLight;
+            lightBulb.OnLightColorChange += UpdateLight;
+
+            UpdateLight();
+
+            return inserted;
+        }
+
+        /// <summary>
+        ///     Ejects the bulb to a mob's hand if possible.
+        /// </summary>
+        private void EjectBulb(IEntity user)
+        {
+            if (LightBulb == null) return;
+
+            var bulb = LightBulb;
+
+            bulb.OnLightBulbStateChange -= UpdateLight;
+            bulb.OnLightColorChange -= UpdateLight;
+
+            if (!_lightBulbContainer.Remove(bulb.Owner)) return;
+
+            if (!user.TryGetComponent(out HandsComponent hands)
+                || !hands.PutInHand(bulb.Owner.GetComponent<ItemComponent>()))
+                bulb.Owner.Transform.GridPosition = user.Transform.GridPosition;
+        }
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            serializer.DataField(ref BulbType, "bulb", LightBulbType.Tube);
+        }
+
+        /// <summary>
+        ///     For attaching UpdateLight() to events.
+        /// </summary>
+        public void UpdateLight(object sender, EventArgs e)
+        {
+            UpdateLight();
+        }
+
+        private bool _lightState => Owner.GetComponent<PointLightComponent>().Enabled;
+
+        /// <summary>
+        ///     Updates the light's power drain, sprite and actual light state.
+        /// </summary>
+        public void UpdateLight()
+        {
+            var powerReceiver = Owner.GetComponent<PowerReceiverComponent>();
+            var sprite = Owner.GetComponent<SpriteComponent>();
+            var light = Owner.GetComponent<PointLightComponent>();
+            if (LightBulb == null) // No light bulb.
+            {
+                powerReceiver.Load = 0;
+                sprite.LayerSetState(0, "empty");
+                light.Enabled = false;
+                return;
+            }
+
+            switch (LightBulb.State)
+            {
+                case LightBulbState.Normal:
+                    powerReceiver.Load = LightBulb.PowerUse;
+                    if (powerReceiver.Powered)
+                    {
+                        sprite.LayerSetState(0, "on");
+                        light.Enabled = true;
+                        light.Color = LightBulb.Color;
+                        var time = IoCManager.Resolve<IGameTiming>().CurTime;
+                        if (time > _lastThunk + _thunkDelay)
+                        {
+                            _lastThunk = time;
+                            EntitySystem.Get<AudioSystem>().PlayFromEntity("/Audio/machines/light_tube_on.ogg", Owner, AudioParams.Default.WithVolume(-10f));
+                        }
+                    }
+                    else
+                    {
+                        sprite.LayerSetState(0, "off");
+                        light.Enabled = false;
+                    }
+                    break;
+                case LightBulbState.Broken:
+                    powerReceiver.Load = 0;
+                    sprite.LayerSetState(0, "broken");
+                    light.Enabled = false;
+                    break;
+                case LightBulbState.Burned:
+                    powerReceiver.Load = 0;
+                    sprite.LayerSetState(0, "burned");
+                    light.Enabled = false;
+                    break;
+            }
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            Owner.GetComponent<PowerReceiverComponent>().OnPowerStateChanged += UpdateLight;
+
+            _lightBulbContainer = ContainerManagerComponent.Ensure<ContainerSlot>("light_bulb", Owner, out var existed);
+
+            if (!existed) // Insert a light tube if there wasn't any.
+            {
+                switch (BulbType)
+                {
+                    case LightBulbType.Tube:
+                        _lightBulbContainer.Insert(Owner.EntityManager.SpawnEntity("LightTube", Owner.Transform.GridPosition));
+                        break;
+                    case LightBulbType.Bulb:
+                        _lightBulbContainer.Insert(Owner.EntityManager.SpawnEntity("LightBulb", Owner.Transform.GridPosition));
+                        break;
+                }
+            }
+        }
+
+        public override void OnRemove()
+        {
+            Owner.GetComponent<PowerReceiverComponent>().OnPowerStateChanged -= UpdateLight;
+            base.OnRemove();
+        }
+    }
+}

Content.Server/GameObjects/Components/Power/ApcNetComponents/PowerReceiverUsers/WeaponCapacitorChargerComponent.cs

@@ -0,0 +1,28 @@
+using Content.Server.GameObjects.Components.Weapon.Ranged.Barrels;
+using Content.Server.GameObjects.EntitySystems;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.GameObjects;
+
+namespace Content.Server.GameObjects.Components.Power.Chargers
+{
+    /// <summary>
+    /// Recharges the battery in a <see cref="ServerBatteryBarrelComponent"/>.
+    /// </summary>
+    [RegisterComponent]
+    [ComponentReference(typeof(IActivate))]
+    [ComponentReference(typeof(BaseCharger))]
+    public sealed class WeaponCapacitorChargerComponent : BaseCharger
+    {
+        public override string Name => "WeaponCapacitorCharger";
+
+        protected override bool IsEntityCompatible(IEntity entity)
+        {
+            return entity.HasComponent<ServerBatteryBarrelComponent>();
+        }
+
+        protected override BatteryComponent GetBatteryFrom(IEntity entity)
+        {
+            return entity.GetComponent<ServerBatteryBarrelComponent>().PowerCell;
+        }
+    }
+}