Cinka/OldThink
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

Pow3r: stage 1 (#4208)

Browse Source 
Co-authored-by: 20kdc <asdd2808@gmail.com>
This commit is contained in:
Pieter-Jan Briers
2021-07-04 18:11:52 +02:00
committed by GitHub
parent ea60a81fdf
commit 103bc19508
212 changed files with 8584 additions and 4426 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
Content.Server/Power/EntitySystems/BatterySystem.cs Normal file
View File

@@ -0,0 +1,42 @@
#nullable enable
using Content.Server.Power.Components;
using JetBrains.Annotations;
using Robust.Shared.GameObjects;
namespace Content.Server.Power.EntitySystems
{
[UsedImplicitly]
public class BatterySystem : EntitySystem
{
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<BatteryComponent, NetworkBatteryPreSync>(PreSync);
SubscribeLocalEvent<BatteryComponent, NetworkBatteryPostSync>(PostSync);
}
private void PreSync(EntityUid uid, BatteryComponent component, NetworkBatteryPreSync args)
{
var networkBattery = ComponentManager.GetComponent<PowerNetworkBatteryComponent>(uid);
networkBattery.NetworkBattery.Capacity = component.MaxCharge;
networkBattery.NetworkBattery.CurrentStorage = component.CurrentCharge;
}
private void PostSync(EntityUid uid, BatteryComponent component, NetworkBatteryPostSync args)
{
var networkBattery = ComponentManager.GetComponent<PowerNetworkBatteryComponent>(uid);
component.CurrentCharge = networkBattery.NetworkBattery.CurrentStorage;
}
public override void Update(float frameTime)
{
foreach (var comp in ComponentManager.EntityQuery<BatteryComponent>())
{
comp.OnUpdate(frameTime);
}
}
}
}

85
Content.Server/Power/EntitySystems/CableVisSystem.cs Normal file
View File

@@ -0,0 +1,85 @@
using System.Collections.Generic;
using Content.Server.NodeContainer;
using Content.Server.NodeContainer.EntitySystems;
using Content.Server.Power.Components;
using Content.Server.Power.Nodes;
using Content.Shared.Wires;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Map;
namespace Content.Server.Power.EntitySystems
{
[UsedImplicitly]
public sealed class CableVisSystem : EntitySystem
{
[Dependency] private readonly IMapManager _mapManager = default!;
private readonly HashSet<EntityUid> _toUpdate = new();
public void QueueUpdate(EntityUid uid)
{
_toUpdate.Add(uid);
}
public override void Initialize()
{
base.Initialize();
UpdatesAfter.Add(typeof(NodeGroupSystem));
}
public override void Update(float frameTime)
{
base.Update(frameTime);
foreach (var uid in _toUpdate)
{
if (!ComponentManager.TryGetComponent(uid, out NodeContainerComponent? nodeContainer)
|| !ComponentManager.TryGetComponent(uid, out CableVisComponent? cableVis)
|| !ComponentManager.TryGetComponent(uid, out AppearanceComponent? appearance))
{
continue;
}
if (cableVis.Node == null)
continue;
var mask = WireVisDirFlags.None;
var transform = ComponentManager.GetComponent<ITransformComponent>(uid);
var grid = _mapManager.GetGrid(transform.GridID);
var tile = grid.TileIndicesFor(transform.Coordinates);
var node = nodeContainer.GetNode<CableNode>(cableVis.Node);
foreach (var reachable in node.ReachableNodes)
{
if (reachable is not CableNode)
continue;
var otherTransform = reachable.Owner.Transform;
if (otherTransform.GridID != grid.Index)
continue;
var otherTile = grid.TileIndicesFor(otherTransform.Coordinates);
var diff = otherTile - tile;
mask |= diff switch
{
(0, 1) => WireVisDirFlags.North,
(0, -1) => WireVisDirFlags.South,
(1, 0) => WireVisDirFlags.East,
(-1, 0) => WireVisDirFlags.West,
_ => WireVisDirFlags.None
};
}
appearance.SetData(WireVisVisuals.ConnectedMask, mask);
}
_toUpdate.Clear();
}
}
}

26
Content.Server/Power/EntitySystems/PowerApcSystem.cs Normal file
View File

@@ -0,0 +1,26 @@
#nullable enable
using Content.Server.Power.Components;
using JetBrains.Annotations;
using Robust.Shared.GameObjects;
namespace Content.Server.Power.EntitySystems
{
[UsedImplicitly]
internal sealed class PowerApcSystem : EntitySystem
{
public override void Initialize()
{
base.Initialize();
UpdatesAfter.Add(typeof(PowerNetSystem));
}
public override void Update(float frameTime)
{
foreach (var apc in ComponentManager.EntityQuery<ApcComponent>())
{
apc.Update();
}
}
}
}

337
Content.Server/Power/EntitySystems/PowerNetSystem.cs
View File

@@ -1,20 +1,351 @@
#nullable enable
using System.Collections.Generic;
using Content.Server.NodeContainer.EntitySystems;
using Content.Server.Power.Components;
using Content.Server.Power.NodeGroups;
using Content.Server.Power.Pow3r;
using JetBrains.Annotations;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Maths;
namespace Content.Server.Power.EntitySystems
{
/// <summary>
/// Manages power networks, power state, and all power components.
/// </summary>
[UsedImplicitly]
public class PowerNetSystem : EntitySystem
{
[Dependency] private readonly IPowerNetManager _powerNetManager = default!;
private readonly PowerState _powerState = new();
private readonly HashSet<PowerNet> _powerNetReconnectQueue = new();
private readonly HashSet<ApcNet> _apcNetReconnectQueue = new();
private int _nextId = 1;
private readonly BatteryRampPegSolver _solver = new();
public override void Initialize()
{
base.Initialize();
UpdatesAfter.Add(typeof(NodeGroupSystem));
SubscribeLocalEvent<ApcPowerReceiverComponent, ComponentInit>(ApcPowerReceiverInit);
SubscribeLocalEvent<ApcPowerReceiverComponent, ComponentShutdown>(ApcPowerReceiverShutdown);
SubscribeLocalEvent<ApcPowerReceiverComponent, EntityPausedEvent>(ApcPowerReceiverPaused);
SubscribeLocalEvent<PowerNetworkBatteryComponent, ComponentInit>(BatteryInit);
SubscribeLocalEvent<PowerNetworkBatteryComponent, ComponentShutdown>(BatteryShutdown);
SubscribeLocalEvent<PowerNetworkBatteryComponent, EntityPausedEvent>(BatteryPaused);
SubscribeLocalEvent<PowerConsumerComponent, ComponentInit>(PowerConsumerInit);
SubscribeLocalEvent<PowerConsumerComponent, ComponentShutdown>(PowerConsumerShutdown);
SubscribeLocalEvent<PowerConsumerComponent, EntityPausedEvent>(PowerConsumerPaused);
SubscribeLocalEvent<PowerSupplierComponent, ComponentInit>(PowerSupplierInit);
SubscribeLocalEvent<PowerSupplierComponent, ComponentShutdown>(PowerSupplierShutdown);
SubscribeLocalEvent<PowerSupplierComponent, EntityPausedEvent>(PowerSupplierPaused);
}
private void ApcPowerReceiverInit(EntityUid uid, ApcPowerReceiverComponent component, ComponentInit args)
{
AllocLoad(component.NetworkLoad);
}
private void ApcPowerReceiverShutdown(EntityUid uid, ApcPowerReceiverComponent component,
ComponentShutdown args)
{
_powerState.Loads.Remove(component.NetworkLoad.Id);
}
private static void ApcPowerReceiverPaused(
EntityUid uid,
ApcPowerReceiverComponent component,
EntityPausedEvent args)
{
component.NetworkLoad.Paused = args.Paused;
}
private void BatteryInit(EntityUid uid, PowerNetworkBatteryComponent component, ComponentInit args)
{
AllocBattery(component.NetworkBattery);
}
private void BatteryShutdown(EntityUid uid, PowerNetworkBatteryComponent component, ComponentShutdown args)
{
_powerState.Batteries.Remove(component.NetworkBattery.Id);
}
private static void BatteryPaused(EntityUid uid, PowerNetworkBatteryComponent component, EntityPausedEvent args)
{
component.NetworkBattery.Paused = args.Paused;
}
private void PowerConsumerInit(EntityUid uid, PowerConsumerComponent component, ComponentInit args)
{
AllocLoad(component.NetworkLoad);
}
private void PowerConsumerShutdown(EntityUid uid, PowerConsumerComponent component, ComponentShutdown args)
{
_powerState.Loads.Remove(component.NetworkLoad.Id);
}
private static void PowerConsumerPaused(EntityUid uid, PowerConsumerComponent component, EntityPausedEvent args)
{
component.NetworkLoad.Paused = args.Paused;
}
private void PowerSupplierInit(EntityUid uid, PowerSupplierComponent component, ComponentInit args)
{
AllocSupply(component.NetworkSupply);
}
private void PowerSupplierShutdown(EntityUid uid, PowerSupplierComponent component, ComponentShutdown args)
{
_powerState.Supplies.Remove(component.NetworkSupply.Id);
}
private static void PowerSupplierPaused(EntityUid uid, PowerSupplierComponent component, EntityPausedEvent args)
{
component.NetworkSupply.Paused = args.Paused;
}
public void InitPowerNet(PowerNet powerNet)
{
AllocNetwork(powerNet.NetworkNode);
}
public void DestroyPowerNet(PowerNet powerNet)
{
_powerState.Networks.Remove(powerNet.NetworkNode.Id);
}
public void QueueReconnectPowerNet(PowerNet powerNet)
{
_powerNetReconnectQueue.Add(powerNet);
}
public void InitApcNet(ApcNet apcNet)
{
AllocNetwork(apcNet.NetworkNode);
}
public void DestroyApcNet(ApcNet apcNet)
{
_powerState.Networks.Remove(apcNet.NetworkNode.Id);
}
public void QueueReconnectApcNet(ApcNet apcNet)
{
_apcNetReconnectQueue.Add(apcNet);
}
public PowerStatistics GetStatistics()
{
return new()
{
CountBatteries = _powerState.Batteries.Count,
CountLoads = _powerState.Loads.Count,
CountNetworks = _powerState.Networks.Count,
CountSupplies = _powerState.Supplies.Count
};
}
public override void Update(float frameTime)
{
base.Update(frameTime);
_powerNetManager.Update(frameTime);
// Reconnect networks.
{
foreach (var apcNet in _apcNetReconnectQueue)
{
if (apcNet.Removed)
continue;
DoReconnectApcNet(apcNet);
}
_apcNetReconnectQueue.Clear();
foreach (var powerNet in _powerNetReconnectQueue)
{
if (powerNet.Removed)
continue;
DoReconnectPowerNet(powerNet);
}
_powerNetReconnectQueue.Clear();
}
// Synchronize batteries
foreach (var battery in ComponentManager.EntityQuery<PowerNetworkBatteryComponent>())
{
RaiseLocalEvent(battery.Owner.Uid, new NetworkBatteryPreSync());
}
// Run power solver.
_solver.Tick(frameTime, _powerState);
// Synchronize batteries, the other way around.
foreach (var battery in ComponentManager.EntityQuery<PowerNetworkBatteryComponent>())
{
RaiseLocalEvent(battery.Owner.Uid, new NetworkBatteryPostSync());
}
// Send events where necessary.
{
foreach (var apcReceiver in ComponentManager.EntityQuery<ApcPowerReceiverComponent>())
{
var recv = apcReceiver.NetworkLoad.ReceivingPower;
ref var last = ref apcReceiver.LastPowerReceived;
if (!MathHelper.CloseTo(recv, last))
{
last = recv;
apcReceiver.ApcPowerChanged();
}
}
foreach (var consumer in ComponentManager.EntityQuery<PowerConsumerComponent>())
{
var newRecv = consumer.NetworkLoad.ReceivingPower;
ref var lastRecv = ref consumer.LastReceived;
if (!MathHelper.CloseTo(lastRecv, newRecv))
{
lastRecv = newRecv;
var msg = new PowerConsumerReceivedChanged(newRecv, consumer.DrawRate);
RaiseLocalEvent(consumer.Owner.Uid, msg);
}
}
}
}
private void AllocLoad(PowerState.Load load)
{
load.Id = AllocId();
_powerState.Loads.Add(load.Id, load);
}
private void AllocSupply(PowerState.Supply supply)
{
supply.Id = AllocId();
_powerState.Supplies.Add(supply.Id, supply);
}
private void AllocBattery(PowerState.Battery battery)
{
battery.Id = AllocId();
_powerState.Batteries.Add(battery.Id, battery);
}
private void AllocNetwork(PowerState.Network network)
{
network.Id = AllocId();
_powerState.Networks.Add(network.Id, network);
}
private static void DoReconnectApcNet(ApcNet net)
{
var netNode = net.NetworkNode;
netNode.Loads.Clear();
netNode.BatteriesDischarging.Clear();
netNode.BatteriesCharging.Clear();
netNode.Supplies.Clear();
foreach (var provider in net.Providers)
{
foreach (var receiver in provider.LinkedReceivers)
{
netNode.Loads.Add(receiver.NetworkLoad.Id);
receiver.NetworkLoad.LinkedNetwork = netNode.Id;
}
}
foreach (var apc in net.Apcs)
{
var netBattery = apc.Owner.GetComponent<PowerNetworkBatteryComponent>();
netNode.BatteriesDischarging.Add(netBattery.NetworkBattery.Id);
netBattery.NetworkBattery.LinkedNetworkDischarging = netNode.Id;
}
}
private static void DoReconnectPowerNet(PowerNet net)
{
var netNode = net.NetworkNode;
netNode.Loads.Clear();
netNode.Supplies.Clear();
netNode.BatteriesCharging.Clear();
netNode.BatteriesDischarging.Clear();
foreach (var consumer in net.Consumers)
{
netNode.Loads.Add(consumer.NetworkLoad.Id);
consumer.NetworkLoad.LinkedNetwork = netNode.Id;
}
foreach (var supplier in net.Suppliers)
{
netNode.Supplies.Add(supplier.NetworkSupply.Id);
supplier.NetworkSupply.LinkedNetwork = netNode.Id;
}
foreach (var charger in net.Chargers)
{
var battery = charger.Owner.GetComponent<PowerNetworkBatteryComponent>();
netNode.BatteriesCharging.Add(battery.NetworkBattery.Id);
battery.NetworkBattery.LinkedNetworkCharging = netNode.Id;
}
foreach (var discharger in net.Dischargers)
{
var battery = discharger.Owner.GetComponent<PowerNetworkBatteryComponent>();
netNode.BatteriesDischarging.Add(battery.NetworkBattery.Id);
battery.NetworkBattery.LinkedNetworkDischarging = netNode.Id;
}
}
private PowerState.NodeId AllocId()
{
return new(_nextId++);
}
}
/// <summary>
/// Raised before power network simulation happens, to synchronize battery state from
/// components like <see cref="BatteryComponent"/> into <see cref="PowerNetworkBatteryComponent"/>.
/// </summary>
public sealed class NetworkBatteryPreSync : EntityEventArgs
{
}
/// <summary>
/// Raised after power network simulation happens, to synchronize battery charge changes from
/// <see cref="PowerNetworkBatteryComponent"/> to components like <see cref="BatteryComponent"/>.
/// </summary>
public sealed class NetworkBatteryPostSync : EntityEventArgs
{
}
/// <summary>
/// Raised when the amount of receiving power on a <see cref="PowerConsumerComponent"/> changes.
/// </summary>
public sealed class PowerConsumerReceivedChanged : EntityEventArgs
{
public float ReceivedPower { get; }
public float DrawRate { get; }
public PowerConsumerReceivedChanged(float receivedPower, float drawRate)
{
ReceivedPower = receivedPower;
DrawRate = drawRate;
}
}
public struct PowerStatistics
{
public int CountNetworks;
public int CountLoads;
public int CountSupplies;
public int CountBatteries;
}
}

4
Content.Server/Power/EntitySystems/PowerReceiverSystem.cs
View File

@@ -9,12 +9,12 @@ namespace Content.Server.Power.EntitySystems
{
base.Initialize();
SubscribeLocalEvent<PowerReceiverComponent, PhysicsBodyTypeChangedEvent>(BodyTypeChanged);
SubscribeLocalEvent<ApcPowerReceiverComponent, PhysicsBodyTypeChangedEvent>(BodyTypeChanged);
}
private static void BodyTypeChanged(
EntityUid uid,
PowerReceiverComponent component,
ApcPowerReceiverComponent component,
PhysicsBodyTypeChangedEvent args)
{
component.AnchorUpdate();