From: DrSmugleaf Date: Wed, 17 Jan 2024 09:49:21 +0000 (-0800) Subject: Move rotting stages and examine to shared (#24183) X-Git-Url: https://git.smokeofanarchy.ru/gitweb.cgi?a=commitdiff_plain;h=890270127133884f5d1a9ddddb48f10ddb61412f;p=space-station-14.git Move rotting stages and examine to shared (#24183) --- diff --git a/Content.Client/Atmos/Rotting/RottingSystem.cs b/Content.Client/Atmos/Rotting/RottingSystem.cs new file mode 100644 index 0000000000..da030ed117 --- /dev/null +++ b/Content.Client/Atmos/Rotting/RottingSystem.cs @@ -0,0 +1,7 @@ +using Content.Shared.Atmos.Rotting; + +namespace Content.Client.Atmos.Rotting; + +public sealed class RottingSystem : SharedRottingSystem +{ +} diff --git a/Content.Server/Atmos/Rotting/RottingSystem.cs b/Content.Server/Atmos/Rotting/RottingSystem.cs index ff0ecaada4..365edf9e05 100644 --- a/Content.Server/Atmos/Rotting/RottingSystem.cs +++ b/Content.Server/Atmos/Rotting/RottingSystem.cs @@ -16,7 +16,7 @@ using Robust.Shared.Timing; namespace Content.Server.Atmos.Rotting; -public sealed class RottingSystem : EntitySystem +public sealed class RottingSystem : SharedRottingSystem { [Dependency] private readonly IGameTiming _timing = default!; [Dependency] private readonly AtmosphereSystem _atmosphere = default!; @@ -37,7 +37,6 @@ public sealed class RottingSystem : EntitySystem SubscribeLocalEvent(OnShutdown); SubscribeLocalEvent(OnRottingMobStateChanged); SubscribeLocalEvent(OnGibbed); - SubscribeLocalEvent(OnExamined); SubscribeLocalEvent(OnRejuvenate); SubscribeLocalEvent(OnTempIsRotting); @@ -45,12 +44,12 @@ public sealed class RottingSystem : EntitySystem private void OnPerishableMapInit(EntityUid uid, PerishableComponent component, MapInitEvent args) { - component.NextPerishUpdate = _timing.CurTime + component.PerishUpdateRate; + component.RotNextUpdate = _timing.CurTime + component.PerishUpdateRate; } private void OnPerishableUnpaused(EntityUid uid, PerishableComponent component, ref EntityUnpausedEvent args) { - component.NextPerishUpdate += args.PausedTime; + component.RotNextUpdate += args.PausedTime; } private void OnMobStateChanged(EntityUid uid, PerishableComponent component, MobStateChangedEvent args) @@ -62,7 +61,7 @@ public sealed class RottingSystem : EntitySystem return; component.RotAccumulator = TimeSpan.Zero; - component.NextPerishUpdate = _timing.CurTime + component.PerishUpdateRate; + component.RotNextUpdate = _timing.CurTime + component.PerishUpdateRate; } private void OnRottingUnpaused(EntityUid uid, RottingComponent component, ref EntityUnpausedEvent args) @@ -74,7 +73,7 @@ public sealed class RottingSystem : EntitySystem { if (TryComp(uid, out var perishable)) { - perishable.NextPerishUpdate = TimeSpan.Zero; + perishable.RotNextUpdate = TimeSpan.Zero; } } @@ -127,9 +126,8 @@ public sealed class RottingSystem : EntitySystem private void OnPerishableExamined(Entity perishable, ref ExaminedEvent args) { - int maxStages = 3; - int stage = PerishStage(perishable, maxStages); - if (stage < 1 || stage > maxStages) + int stage = PerishStage(perishable, MaxStages); + if (stage < 1 || stage > MaxStages) { // We dont push an examined string if it hasen't started "perishing" or it's already rotting return; @@ -150,29 +148,6 @@ public sealed class RottingSystem : EntitySystem return (int)(1 + maxStages * perishable.Comp.RotAccumulator.TotalSeconds / perishable.Comp.RotAfter.TotalSeconds); } - private void OnExamined(EntityUid uid, RottingComponent component, ExaminedEvent args) - { - var stage = RotStage(uid, component); - var description = stage switch - { - >= 2 => "rotting-extremely-bloated", - >= 1 => "rotting-bloated", - _ => "rotting-rotting" - }; - args.PushMarkup(Loc.GetString(description, ("target", Identity.Entity(uid, EntityManager)))); - } - - /// - /// Return the rot stage, usually from 0 to 2 inclusive. - /// - public int RotStage(EntityUid uid, RottingComponent? comp = null, PerishableComponent? perishable = null) - { - if (!Resolve(uid, ref comp, ref perishable)) - return 0; - - return (int) (comp.TotalRotTime.TotalSeconds / perishable.RotAfter.TotalSeconds); - } - private void OnRejuvenate(EntityUid uid, RottingComponent component, RejuvenateEvent args) { RemCompDeferred(uid); @@ -209,9 +184,16 @@ public sealed class RottingSystem : EntitySystem var perishQuery = EntityQueryEnumerator(); while (perishQuery.MoveNext(out var uid, out var perishable)) { - if (_timing.CurTime < perishable.NextPerishUpdate) + if (_timing.CurTime < perishable.RotNextUpdate) continue; - perishable.NextPerishUpdate += perishable.PerishUpdateRate; + perishable.RotNextUpdate += perishable.PerishUpdateRate; + + var stage = PerishStage((uid, perishable), MaxStages); + if (stage != perishable.Stage) + { + perishable.Stage = stage; + Dirty(uid, perishable); + } if (IsRotten(uid) || !IsRotProgressing(uid, perishable)) continue; diff --git a/Content.Shared/Atmos/Rotting/PerishableComponent.cs b/Content.Shared/Atmos/Rotting/PerishableComponent.cs index 5a984c39ff..1c5c4bc4ae 100644 --- a/Content.Shared/Atmos/Rotting/PerishableComponent.cs +++ b/Content.Shared/Atmos/Rotting/PerishableComponent.cs @@ -1,3 +1,4 @@ +using Robust.Shared.GameStates; using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom; namespace Content.Shared.Atmos.Rotting; @@ -6,39 +7,43 @@ namespace Content.Shared.Atmos.Rotting; /// This makes mobs eventually start rotting when they die. /// It may be expanded to food at some point, but it's just for mobs right now. /// -[RegisterComponent] +[RegisterComponent, NetworkedComponent, AutoGenerateComponentState] +[Access(typeof(SharedRottingSystem))] public sealed partial class PerishableComponent : Component { /// /// How long it takes after death to start rotting. /// - [DataField("rotAfter"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public TimeSpan RotAfter = TimeSpan.FromMinutes(10); /// /// How much rotting has occured /// - [DataField("rotAccumulator"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public TimeSpan RotAccumulator = TimeSpan.Zero; /// /// Gasses are released, this is when the next gas release update will be. /// - [DataField("rotNextUpdate", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)] - public TimeSpan NextPerishUpdate = TimeSpan.Zero; + [DataField(customTypeSerializer: typeof(TimeOffsetSerializer))] + public TimeSpan RotNextUpdate = TimeSpan.Zero; /// /// How often the rotting ticks. /// Feel free to tweak this if there are perf concerns. /// - [DataField("perishUpdateRate"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public TimeSpan PerishUpdateRate = TimeSpan.FromSeconds(5); /// /// How many moles of gas released per second, per unit of mass. /// - [DataField("molsPerSecondPerUnitMass"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public float MolsPerSecondPerUnitMass = 0.0025f; + + [DataField, AutoNetworkedField] + public int Stage; } diff --git a/Content.Shared/Atmos/Rotting/RottingComponent.cs b/Content.Shared/Atmos/Rotting/RottingComponent.cs index 4314d22440..d4ba79bb89 100644 --- a/Content.Shared/Atmos/Rotting/RottingComponent.cs +++ b/Content.Shared/Atmos/Rotting/RottingComponent.cs @@ -6,38 +6,40 @@ namespace Content.Shared.Atmos.Rotting; /// /// Tracking component for stuff that has started to rot. +/// Only the current stage is networked to the client. /// [RegisterComponent, NetworkedComponent] +[Access(typeof(SharedRottingSystem))] public sealed partial class RottingComponent : Component { /// /// Whether or not the rotting should deal damage /// - [DataField("dealDamage"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public bool DealDamage = true; /// /// When the next check will happen for rot progression + effects like damage and ammonia /// - [DataField("nextRotUpdate", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)] + [DataField(customTypeSerializer: typeof(TimeOffsetSerializer))] public TimeSpan NextRotUpdate = TimeSpan.Zero; /// /// How long in between each rot update. /// - [DataField("rotUpdateRate"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public TimeSpan RotUpdateRate = TimeSpan.FromSeconds(5); /// /// How long has this thing been rotting? /// - [DataField("totalRotTime"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public TimeSpan TotalRotTime = TimeSpan.Zero; /// /// The damage dealt by rotting. /// - [DataField("damage")] + [DataField] public DamageSpecifier Damage = new() { DamageDict = new() diff --git a/Content.Shared/Atmos/Rotting/SharedRottingSystem.cs b/Content.Shared/Atmos/Rotting/SharedRottingSystem.cs new file mode 100644 index 0000000000..e3db3fd5bc --- /dev/null +++ b/Content.Shared/Atmos/Rotting/SharedRottingSystem.cs @@ -0,0 +1,39 @@ +using Content.Shared.Examine; +using Content.Shared.IdentityManagement; + +namespace Content.Shared.Atmos.Rotting; + +public abstract class SharedRottingSystem : EntitySystem +{ + public const int MaxStages = 3; + + public override void Initialize() + { + base.Initialize(); + + SubscribeLocalEvent(OnExamined); + } + + /// + /// Return the rot stage, usually from 0 to 2 inclusive. + /// + public int RotStage(EntityUid uid, RottingComponent? comp = null, PerishableComponent? perishable = null) + { + if (!Resolve(uid, ref comp, ref perishable)) + return 0; + + return (int) (comp.TotalRotTime.TotalSeconds / perishable.RotAfter.TotalSeconds); + } + + private void OnExamined(EntityUid uid, RottingComponent component, ExaminedEvent args) + { + var stage = RotStage(uid, component); + var description = stage switch + { + >= 2 => "rotting-extremely-bloated", + >= 1 => "rotting-bloated", + _ => "rotting-rotting" + }; + args.PushMarkup(Loc.GetString(description, ("target", Identity.Entity(uid, EntityManager)))); + } +}