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

Split Respirator into ThermalRegulator and Respirator and ECSes both (#5603)

Browse Source
This commit is contained in:
mirrorcult
2021-11-28 19:25:42 -07:00
committed by GitHub
parent 9075cf6163
commit fc4a950257
19 changed files with 415 additions and 371 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Content.Server/Body/Components/BloodstreamComponent.cs
View File

@@ -1,6 +1,7 @@
using System;
using Content.Server.Atmos;
using Content.Server.Atmos.EntitySystems;
using Content.Server.Body.Systems;
using Content.Server.Chemistry.EntitySystems;
using Content.Shared.Atmos;
using Content.Shared.Body.Components;
@@ -73,6 +74,7 @@ namespace Content.Server.Body.Components
public void PumpToxins(GasMixture to)
{
var atmosphereSystem = EntitySystem.Get<AtmosphereSystem>();
var respiratorSystem = EntitySystem.Get<RespiratorSystem>();
if (!Owner.TryGetComponent(out RespiratorComponent? metabolism))
{
@@ -81,7 +83,7 @@ namespace Content.Server.Body.Components
return;
}
var toxins = metabolism.Clean(this);
var toxins = respiratorSystem.Clean(OwnerUid, metabolism, this);
var toOld = new float[to.Moles.Length];
Array.Copy(to.Moles, toOld, toOld.Length);

221
Content.Server/Body/Components/BodyPartComponent.cs Normal file
View File

@@ -0,0 +1,221 @@
using System.Collections.Generic;
using System.Threading.Tasks;
using Content.Server.UserInterface;
using Content.Shared.Body.Components;
using Content.Shared.Body.Part;
using Content.Shared.Body.Surgery;
using Content.Shared.Interaction;
using Content.Shared.Popups;
using Content.Shared.Random.Helpers;
using Content.Shared.Verbs;
using Robust.Server.Console;
using Robust.Server.GameObjects;
using Robust.Server.Player;
using Robust.Shared.Containers;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Log;
using Robust.Shared.ViewVariables;
namespace Content.Server.Body.Components
{
[RegisterComponent]
[ComponentReference(typeof(SharedBodyPartComponent))]
public class BodyPartComponent : SharedBodyPartComponent, IAfterInteract
{
private readonly Dictionary<int, object> _optionsCache = new();
private SharedBodyComponent? _owningBodyCache;
private int _idHash;
private IEntity? _surgeonCache;
private Container _mechanismContainer = default!;
[ViewVariables] private BoundUserInterface? UserInterface => Owner.GetUIOrNull(SurgeryUIKey.Key);
public override bool CanAddMechanism(SharedMechanismComponent mechanism)
{
return base.CanAddMechanism(mechanism) &&
_mechanismContainer.CanInsert(mechanism.Owner);
}
protected override void OnAddMechanism(SharedMechanismComponent mechanism)
{
base.OnAddMechanism(mechanism);
_mechanismContainer.Insert(mechanism.Owner);
}
protected override void OnRemoveMechanism(SharedMechanismComponent mechanism)
{
base.OnRemoveMechanism(mechanism);
_mechanismContainer.Remove(mechanism.Owner);
mechanism.Owner.RandomOffset(0.25f);
}
protected override void Initialize()
{
base.Initialize();
_mechanismContainer = Owner.EnsureContainer<Container>($"{Name}-{nameof(BodyPartComponent)}");
// This is ran in Startup as entities spawned in Initialize
// are not synced to the client since they are assumed to be
// identical on it
foreach (var mechanismId in MechanismIds)
{
var entity = Owner.EntityManager.SpawnEntity(mechanismId, Owner.Transform.MapPosition);
if (!entity.TryGetComponent(out SharedMechanismComponent? mechanism))
{
Logger.Error($"Entity {mechanismId} does not have a {nameof(SharedMechanismComponent)} component.");
continue;
}
TryAddMechanism(mechanism, true);
}
}
protected override void Startup()
{
base.Startup();
if (UserInterface != null)
{
UserInterface.OnReceiveMessage += OnUIMessage;
}
foreach (var mechanism in Mechanisms)
{
mechanism.Dirty();
}
}
async Task<bool> IAfterInteract.AfterInteract(AfterInteractEventArgs eventArgs)
{
// TODO BODY
if (eventArgs.Target == null)
{
return false;
}
CloseAllSurgeryUIs();
_optionsCache.Clear();
_surgeonCache = null;
_owningBodyCache = null;
if (eventArgs.Target.TryGetComponent(out SharedBodyComponent? body))
{
SendSlots(eventArgs, body);
}
return true;
}
private void SendSlots(AfterInteractEventArgs eventArgs, SharedBodyComponent body)
{
// Create dictionary to send to client (text to be shown : data sent back if selected)
var toSend = new Dictionary<string, int>();
// Here we are trying to grab a list of all empty BodySlots adjacent to an existing BodyPart that can be
// attached to. i.e. an empty left hand slot, connected to an occupied left arm slot would be valid.
foreach (var slot in body.EmptySlots)
{
if (slot.PartType != PartType)
{
continue;
}
foreach (var connection in slot.Connections)
{
if (connection.Part == null ||
!connection.Part.CanAttachPart(this))
{
continue;
}
_optionsCache.Add(_idHash, slot);
toSend.Add(slot.Id, _idHash++);
}
}
if (_optionsCache.Count > 0)
{
OpenSurgeryUI(eventArgs.User.GetComponent<ActorComponent>().PlayerSession);
BodyPartSlotRequest(eventArgs.User.GetComponent<ActorComponent>().PlayerSession,
toSend);
_surgeonCache = eventArgs.User;
_owningBodyCache = body;
}
else // If surgery cannot be performed, show message saying so.
{
eventArgs.Target?.PopupMessage(eventArgs.User,
Loc.GetString("bodypart-component-no-way-to-install-message", ("partName", Owner)));
}
}
/// <summary>
/// Called after the client chooses from a list of possible
/// BodyPartSlots to install the limb on.
/// </summary>
private void ReceiveBodyPartSlot(int key)
{
if (_surgeonCache == null ||
!_surgeonCache.TryGetComponent(out ActorComponent? actor))
{
return;
}
CloseSurgeryUI(actor.PlayerSession);
if (_owningBodyCache == null)
{
return;
}
// TODO: sanity checks to see whether user is in range, user is still able-bodied, target is still the same, etc etc
if (!_optionsCache.TryGetValue(key, out var targetObject))
{
_owningBodyCache.Owner.PopupMessage(_surgeonCache,
Loc.GetString("bodypart-component-no-way-to-attach-message", ("partName", Owner)));
}
var target = (string) targetObject!;
var message = _owningBodyCache.TryAddPart(target, this)
? Loc.GetString("bodypart-component-attach-success-message",("partName", Owner))
: Loc.GetString("bodypart-component-attach-fail-message",("partName", Owner));
_owningBodyCache.Owner.PopupMessage(_surgeonCache, message);
}
private void OpenSurgeryUI(IPlayerSession session)
{
UserInterface?.Open(session);
}
private void BodyPartSlotRequest(IPlayerSession session, Dictionary<string, int> options)
{
UserInterface?.SendMessage(new RequestBodyPartSlotSurgeryUIMessage(options), session);
}
private void CloseSurgeryUI(IPlayerSession session)
{
UserInterface?.Close(session);
}
private void CloseAllSurgeryUIs()
{
UserInterface?.CloseAll();
}
private void OnUIMessage(ServerBoundUserInterfaceMessage message)
{
switch (message.Message)
{
case ReceiveBodyPartSlotSurgeryUIMessage msg:
ReceiveBodyPartSlot(msg.SelectedOptionId);
break;
}
}
}
}

62
Content.Server/Body/Components/BodyScannerComponent.cs Normal file
View File

@@ -0,0 +1,62 @@
using Content.Server.UserInterface;
using Content.Shared.Body.Components;
using Content.Shared.Interaction;
using Robust.Server.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.ViewVariables;
namespace Content.Server.Body.Components
{
[RegisterComponent]
[ComponentReference(typeof(IActivate))]
[ComponentReference(typeof(SharedBodyScannerComponent))]
public class BodyScannerComponent : SharedBodyScannerComponent, IActivate
{
[ViewVariables] private BoundUserInterface? UserInterface => Owner.GetUIOrNull(BodyScannerUiKey.Key);
void IActivate.Activate(ActivateEventArgs eventArgs)
{
if (!eventArgs.User.TryGetComponent(out ActorComponent? actor))
{
return;
}
var session = actor.PlayerSession;
if (session.AttachedEntity == null)
{
return;
}
if (session.AttachedEntity.TryGetComponent(out SharedBodyComponent? body))
{
var state = InterfaceState(body);
UserInterface?.SetState(state);
}
UserInterface?.Open(session);
}
protected override void Initialize()
{
base.Initialize();
Owner.EnsureComponentWarn<ServerUserInterfaceComponent>();
if (UserInterface != null)
{
UserInterface.OnReceiveMessage += UserInterfaceOnOnReceiveMessage;
}
}
private void UserInterfaceOnOnReceiveMessage(ServerBoundUserInterfaceMessage serverMsg) { }
/// <summary>
/// Copy BodyTemplate and BodyPart data into a common data class that the client can read.
/// </summary>
private BodyScannerUIState InterfaceState(SharedBodyComponent body)
{
return new(body.Owner.Uid);
}
}
}

343
Content.Server/Body/Components/RespiratorComponent.cs
View File

@@ -6,6 +6,7 @@ using Content.Server.Alert;
using Content.Server.Atmos;
using Content.Server.Atmos.EntitySystems;
using Content.Server.Body.Behavior;
using Content.Server.Body.Systems;
using Content.Server.Temperature.Components;
using Content.Server.Temperature.Systems;
using Content.Shared.ActionBlocker;
@@ -17,6 +18,7 @@ using Content.Shared.Damage;
using Content.Shared.Database;
using Content.Shared.MobState.Components;
using Content.Shared.Popups;
using Robust.Shared.Analyzers;
using Robust.Shared.GameObjects;
using Robust.Shared.Localization;
using Robust.Shared.Serialization.Manager.Attributes;
@@ -24,70 +26,24 @@ using Robust.Shared.ViewVariables;
namespace Content.Server.Body.Components
{
[RegisterComponent]
[RegisterComponent, Friend(typeof(RespiratorSystem))]
public class RespiratorComponent : Component
{
[ComponentDependency] private readonly SharedBodyComponent? _body = default!;
public override string Name => "Respirator";
private float _accumulatedFrameTime;
[ViewVariables] [DataField("needsGases")] public Dictionary<Gas, float> NeedsGases { get; set; } = new();
[ViewVariables] [DataField("producesGases")] public Dictionary<Gas, float> ProducesGases { get; set; } = new();
[ViewVariables] [DataField("deficitGases")] public Dictionary<Gas, float> DeficitGases { get; set; } = new();
/// <summary>
/// Heat generated due to metabolism. It's generated via metabolism
/// </summary>
[ViewVariables]
[DataField("metabolismHeat")]
public float MetabolismHeat { get; private set; }
[DataField("needsGases")]
public Dictionary<Gas, float> NeedsGases { get; set; } = new();
/// <summary>
/// Heat output via radiation.
/// </summary>
[ViewVariables]
[DataField("radiatedHeat")]
public float RadiatedHeat { get; private set; }
[DataField("producesGases")]
public Dictionary<Gas, float> ProducesGases { get; set; } = new();
/// <summary>
/// Maximum heat regulated via sweat
/// </summary>
[ViewVariables]
[DataField("sweatHeatRegulation")]
public float SweatHeatRegulation { get; private set; }
[DataField("deficitGases")]
public Dictionary<Gas, float> DeficitGases { get; set; } = new();
/// <summary>
/// Maximum heat regulated via shivering
/// </summary>
[ViewVariables]
[DataField("shiveringHeatRegulation")]
public float ShiveringHeatRegulation { get; private set; }
/// <summary>
/// Amount of heat regulation that represents thermal regulation processes not
/// explicitly coded.
/// </summary>
[DataField("implicitHeatRegulation")]
public float ImplicitHeatRegulation { get; private set; }
/// <summary>
/// Normal body temperature
/// </summary>
[ViewVariables]
[DataField("normalBodyTemperature")]
public float NormalBodyTemperature { get; private set; }
/// <summary>
/// Deviation from normal temperature for body to start thermal regulation
/// </summary>
[DataField("thermalRegulationTemperatureThreshold")]
public float ThermalRegulationTemperatureThreshold { get; private set; }
[ViewVariables] public bool Suffocating { get; private set; }
[ViewVariables] public bool Suffocating { get; set; }
[DataField("damage", required: true)]
[ViewVariables(VVAccess.ReadWrite)]
@@ -97,283 +53,6 @@ namespace Content.Server.Body.Components
[ViewVariables(VVAccess.ReadWrite)]
public DamageSpecifier DamageRecovery = default!;
private Dictionary<Gas, float> NeedsAndDeficit(float frameTime)
{
var needs = new Dictionary<Gas, float>(NeedsGases);
foreach (var (gas, amount) in DeficitGases)
{
var newAmount = (needs.GetValueOrDefault(gas) + amount) * frameTime;
needs[gas] = newAmount;
}
return needs;
}
private void ClampDeficit()
{
var deficitGases = new Dictionary<Gas, float>(DeficitGases);
foreach (var (gas, deficit) in deficitGases)
{
if (!NeedsGases.TryGetValue(gas, out var need))
{
DeficitGases.Remove(gas);
continue;
}
if (deficit > need)
{
DeficitGases[gas] = need;
}
}
}
private float SuffocatingPercentage()
{
var total = 0f;
foreach (var (gas, deficit) in DeficitGases)
{
var lack = 1f;
if (NeedsGases.TryGetValue(gas, out var needed))
{
lack = deficit / needed;
}
total += lack / Atmospherics.TotalNumberOfGases;
}
return total;
}
private float GasProducedMultiplier(Gas gas, float usedAverage)
{
if (!ProducesGases.TryGetValue(gas, out var produces))
{
return 0;
}
if (!NeedsGases.TryGetValue(gas, out var needs))
{
needs = 1;
}
return needs * produces * usedAverage;
}
private Dictionary<Gas, float> GasProduced(float usedAverage)
{
return ProducesGases.ToDictionary(pair => pair.Key, pair => GasProducedMultiplier(pair.Key, usedAverage));
}
private void ProcessGases(float frameTime)
{
if (!Owner.TryGetComponent(out BloodstreamComponent? bloodstream))
{
return;
}
if (_body == null)
{
return;
}
var lungs = _body.GetMechanismBehaviors<LungBehavior>().ToArray();
var needs = NeedsAndDeficit(frameTime);
var used = 0f;
foreach (var (gas, amountNeeded) in needs)
{
var bloodstreamAmount = bloodstream.Air.GetMoles(gas);
var deficit = 0f;
if (bloodstreamAmount < amountNeeded)
{
if (!Owner.GetComponent<MobStateComponent>().IsCritical())
{
// Panic inhale
foreach (var lung in lungs)
{
lung.Gasp();
}
}
bloodstreamAmount = bloodstream.Air.GetMoles(gas);
deficit = Math.Max(0, amountNeeded - bloodstreamAmount);
if (deficit > 0)
{
bloodstream.Air.SetMoles(gas, 0);
}
else
{
bloodstream.Air.AdjustMoles(gas, -amountNeeded);
}
}
else
{
bloodstream.Air.AdjustMoles(gas, -amountNeeded);
}
DeficitGases[gas] = deficit;
used += (amountNeeded - deficit) / amountNeeded;
}
var produced = GasProduced(used / needs.Count);
foreach (var (gas, amountProduced) in produced)
{
bloodstream.Air.AdjustMoles(gas, amountProduced);
}
ClampDeficit();
}
/// <summary>
/// Process thermal regulation
/// </summary>
/// <param name="frameTime"></param>
private void ProcessThermalRegulation(float frameTime)
{
var temperatureSystem = EntitySystem.Get<TemperatureSystem>();
if (!Owner.TryGetComponent(out TemperatureComponent? temperatureComponent)) return;
float totalMetabolismTempChange = MetabolismHeat - RadiatedHeat;
// implicit heat regulation
var tempDiff = Math.Abs(temperatureComponent.CurrentTemperature - NormalBodyTemperature);
var targetHeat = tempDiff * temperatureComponent.HeatCapacity;
if (temperatureComponent.CurrentTemperature > NormalBodyTemperature)
{
totalMetabolismTempChange -= Math.Min(targetHeat, ImplicitHeatRegulation);
}
else
{
totalMetabolismTempChange += Math.Min(targetHeat, ImplicitHeatRegulation);
}
temperatureSystem.ChangeHeat(Owner.Uid, totalMetabolismTempChange, true, temperatureComponent);
// recalc difference and target heat
tempDiff = Math.Abs(temperatureComponent.CurrentTemperature - NormalBodyTemperature);
targetHeat = tempDiff * temperatureComponent.HeatCapacity;
// if body temperature is not within comfortable, thermal regulation
// processes starts
if (tempDiff > ThermalRegulationTemperatureThreshold)
return;
var actionBlocker = EntitySystem.Get<ActionBlockerSystem>();
if (temperatureComponent.CurrentTemperature > NormalBodyTemperature)
{
if (!actionBlocker.CanSweat(OwnerUid)) return;
temperatureSystem.ChangeHeat(OwnerUid, -Math.Min(targetHeat, SweatHeatRegulation), true, temperatureComponent);
}
else
{
if (!actionBlocker.CanShiver(OwnerUid)) return;
temperatureSystem.ChangeHeat(OwnerUid, Math.Min(targetHeat, ShiveringHeatRegulation), true, temperatureComponent);
}
}
/// <summary>
/// Processes gases in the bloodstream.
/// </summary>
/// <param name="frameTime">
/// The time since the last metabolism tick in seconds.
/// </param>
public void Update(float frameTime)
{
if (!Owner.TryGetComponent<MobStateComponent>(out var state) ||
state.IsDead())
{
return;
}
_accumulatedFrameTime += frameTime;
if (_accumulatedFrameTime < 1)
{
return;
}
ProcessGases(_accumulatedFrameTime);
ProcessThermalRegulation(_accumulatedFrameTime);
_accumulatedFrameTime -= 1;
if (SuffocatingPercentage() > 0)
{
TakeSuffocationDamage();
return;
}
StopSuffocation();
}
private void TakeSuffocationDamage()
{
if (!Suffocating)
EntitySystem.Get<AdminLogSystem>().Add(LogType.Asphyxiation, $"{Owner} started suffocating");
Suffocating = true;
if (Owner.TryGetComponent(out ServerAlertsComponent? alertsComponent))
{
alertsComponent.ShowAlert(AlertType.LowOxygen);
}
EntitySystem.Get<DamageableSystem>().TryChangeDamage(Owner.Uid, Damage, true, false);
}
private void StopSuffocation()
{
if (Suffocating)
EntitySystem.Get<AdminLogSystem>().Add(LogType.Asphyxiation, $"{Owner} stopped suffocating");
Suffocating = false;
if (Owner.TryGetComponent(out ServerAlertsComponent? alertsComponent))
{
alertsComponent.ClearAlert(AlertType.LowOxygen);
}
EntitySystem.Get<DamageableSystem>().TryChangeDamage(Owner.Uid, DamageRecovery, true);
}
public GasMixture Clean(BloodstreamComponent bloodstream)
{
var gasMixture = new GasMixture(bloodstream.Air.Volume)
{
Temperature = bloodstream.Air.Temperature
};
for (Gas gas = 0; gas < (Gas) Atmospherics.TotalNumberOfGases; gas++)
{
float amount;
var molesInBlood = bloodstream.Air.GetMoles(gas);
if (!NeedsGases.TryGetValue(gas, out var needed))
{
amount = molesInBlood;
}
else
{
var overflowThreshold = needed * 5f;
amount = molesInBlood > overflowThreshold
? molesInBlood - overflowThreshold
: 0;
}
gasMixture.AdjustMoles(gas, amount);
bloodstream.Air.AdjustMoles(gas, -amount);
}
return gasMixture;
}
public float AccumulatedFrametime;
}
}

19
Content.Server/Body/Components/RespiratorSystem.cs
View File

@@ -1,19 +0,0 @@
using JetBrains.Annotations;
using Robust.Shared.GameObjects;
namespace Content.Server.Body.Components
{
[UsedImplicitly]
public class RespiratorSystem : EntitySystem
{
public override void Update(float frameTime)
{
base.Update(frameTime);
foreach (var respirator in EntityManager.EntityQuery<RespiratorComponent>(false))
{
respirator.Update(frameTime);
}
}
}
}

64
Content.Server/Body/Components/ThermalRegulatorComponent.cs Normal file
View File

@@ -0,0 +1,64 @@
using Content.Server.Body.Systems;
using Robust.Shared.Analyzers;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.ViewVariables;
namespace Content.Server.Body.Components;
[RegisterComponent, ComponentProtoName("ThermalRegulator")]
[Friend(typeof(ThermalRegulatorSystem))]
public class ThermalRegulatorComponent : Component
{
public override string Name => "ThermalRegulator";
/// <summary>
/// Heat generated due to metabolism. It's generated via metabolism
/// </summary>
[ViewVariables]
[DataField("metabolismHeat")]
public float MetabolismHeat { get; private set; }
/// <summary>
/// Heat output via radiation.
/// </summary>
[ViewVariables]
[DataField("radiatedHeat")]
public float RadiatedHeat { get; private set; }
/// <summary>
/// Maximum heat regulated via sweat
/// </summary>
[ViewVariables]
[DataField("sweatHeatRegulation")]
public float SweatHeatRegulation { get; private set; }
/// <summary>
/// Maximum heat regulated via shivering
/// </summary>
[ViewVariables]
[DataField("shiveringHeatRegulation")]
public float ShiveringHeatRegulation { get; private set; }
/// <summary>
/// Amount of heat regulation that represents thermal regulation processes not
/// explicitly coded.
/// </summary>
[DataField("implicitHeatRegulation")]
public float ImplicitHeatRegulation { get; private set; }
/// <summary>
/// Normal body temperature
/// </summary>
[ViewVariables]
[DataField("normalBodyTemperature")]
public float NormalBodyTemperature { get; private set; }
/// <summary>
/// Deviation from normal temperature for body to start thermal regulation
/// </summary>
[DataField("thermalRegulationTemperatureThreshold")]
public float ThermalRegulationTemperatureThreshold { get; private set; }
public float AccumulatedFrametime;
}