tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ECS emergency lights (#7230)

Browse Source
This commit is contained in:
metalgearsloth
2022-03-28 15:02:57 +11:00
committed by GitHub
parent 97b9cb6003
commit 9cccc6da99
2 changed files with 132 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

169
Content.Server/Light/Components/EmergencyLightComponent.cs
View File

@@ -1,165 +1,28 @@
using System;
using System.Collections.Generic;
using Content.Server.Power.Components;
using Content.Shared.Examine;
using Content.Server.Light.EntitySystems;
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]
#pragma warning disable 618
public sealed class EmergencyLightComponent : SharedEmergencyLightComponent, IExamine
#pragma warning restore 618
[RegisterComponent, Friend(typeof(EmergencyLightSystem))]
public sealed class EmergencyLightComponent : SharedEmergencyLightComponent
{
[Dependency] private readonly IEntityManager _entMan = default!;
[ViewVariables]
private 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;
public EmergencyLightState State;
[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;
/// <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 float ChargingEfficiency = 0.85f;
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;

126
Content.Server/Light/EntitySystems/EmergencyLightSystem.cs
View File

@@ -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 EmergencyLightComponent.EmergencyLightState.Charging:
_activeLights.Add(message.Component);
case EmergencyLightState.On:
case EmergencyLightState.Charging:
_activeLights.Add(@event.Component);
break;
case EmergencyLightComponent.EmergencyLightState.Full:
case EmergencyLightComponent.EmergencyLightState.Empty:
_activeLights.Remove(message.Component);
case EmergencyLightState.Full:
case EmergencyLightState.Empty:
_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);
}
}
}