Also includes some (non critical) changes to the solution file to re-organize the Roslyn components.
SubscribeLocalEvent<AnomalyGeneratorComponent, MaterialAmountChangedEvent>(OnGeneratorMaterialAmountChanged);
SubscribeLocalEvent<AnomalyGeneratorComponent, AnomalyGeneratorGenerateButtonPressedEvent>(OnGenerateButtonPressed);
SubscribeLocalEvent<AnomalyGeneratorComponent, PowerChangedEvent>(OnGeneratorPowerChanged);
- SubscribeLocalEvent<AnomalyGeneratorComponent, EntityUnpausedEvent>(OnGeneratorUnpaused);
SubscribeLocalEvent<GeneratingAnomalyGeneratorComponent, ComponentStartup>(OnGeneratingStartup);
- SubscribeLocalEvent<GeneratingAnomalyGeneratorComponent, EntityUnpausedEvent>(OnGeneratingUnpaused);
}
private void OnGeneratorPowerChanged(EntityUid uid, AnomalyGeneratorComponent component, ref PowerChangedEvent args)
TryGeneratorCreateAnomaly(uid, component);
}
- private void OnGeneratorUnpaused(EntityUid uid, AnomalyGeneratorComponent component, ref EntityUnpausedEvent args)
- {
- component.CooldownEndTime += args.PausedTime;
- }
-
public void UpdateGeneratorUi(EntityUid uid, AnomalyGeneratorComponent component)
{
var materialAmount = _material.GetMaterialAmount(uid, component.RequiredMaterial);
Appearance.SetData(uid, AnomalyGeneratorVisuals.Generating, true);
}
- private void OnGeneratingUnpaused(EntityUid uid, GeneratingAnomalyGeneratorComponent component, ref EntityUnpausedEvent args)
- {
- component.EndTime += args.PausedTime;
- }
-
private void OnGeneratingFinished(EntityUid uid, AnomalyGeneratorComponent component)
{
var xform = Transform(uid);
SubscribeLocalEvent<AnomalyVesselComponent, InteractUsingEvent>(OnVesselInteractUsing);
SubscribeLocalEvent<AnomalyVesselComponent, ExaminedEvent>(OnExamined);
SubscribeLocalEvent<AnomalyVesselComponent, ResearchServerGetPointsPerSecondEvent>(OnVesselGetPointsPerSecond);
- SubscribeLocalEvent<AnomalyVesselComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<AnomalyShutdownEvent>(OnShutdown);
SubscribeLocalEvent<AnomalyStabilityChangedEvent>(OnStabilityChanged);
}
args.Points += (int) (GetAnomalyPointValue(anomaly) * component.PointMultiplier);
}
- private void OnUnpaused(EntityUid uid, AnomalyVesselComponent component, ref EntityUnpausedEvent args)
- {
- component.NextBeep += args.PausedTime;
- }
-
private void OnVesselAnomalyShutdown(ref AnomalyShutdownEvent args)
{
var query = EntityQueryEnumerator<AnomalyVesselComponent>();
/// This is used for a machine that is able to generate
/// anomalies randomly on the station.
/// </summary>
-[RegisterComponent, Access(typeof(SharedAnomalySystem))]
+[RegisterComponent, Access(typeof(SharedAnomalySystem)), AutoGenerateComponentPause]
public sealed partial class AnomalyGeneratorComponent : Component
{
/// <summary>
/// The time at which the cooldown for generating another anomaly will be over
/// </summary>
[DataField("cooldownEndTime", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan CooldownEndTime = TimeSpan.Zero;
/// <summary>
/// they generate points for the selected server based on
/// the anomaly's stability and severity.
/// </summary>
-[RegisterComponent, Access(typeof(SharedAnomalySystem))]
+[RegisterComponent, Access(typeof(SharedAnomalySystem)), AutoGenerateComponentPause]
public sealed partial class AnomalyVesselComponent : Component
{
/// <summary>
/// When the next beep sound will play
/// </summary>
[DataField("nextBeep", customTypeSerializer:typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextBeep = TimeSpan.Zero;
/// <summary>
namespace Content.Server.Anomaly.Components;
-[RegisterComponent, Access(typeof(SharedAnomalySystem))]
+[RegisterComponent, Access(typeof(SharedAnomalySystem)), AutoGenerateComponentPause]
public sealed partial class GeneratingAnomalyGeneratorComponent : Component
{
/// <summary>
/// When the generating period will end.
/// </summary>
[DataField("endTime", customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan EndTime = TimeSpan.Zero;
public EntityUid? AudioStream;
base.Initialize();
SubscribeLocalEvent<PerishableComponent, MapInitEvent>(OnPerishableMapInit);
- SubscribeLocalEvent<PerishableComponent, EntityUnpausedEvent>(OnPerishableUnpaused);
SubscribeLocalEvent<PerishableComponent, MobStateChangedEvent>(OnMobStateChanged);
SubscribeLocalEvent<PerishableComponent, ExaminedEvent>(OnPerishableExamined);
- SubscribeLocalEvent<RottingComponent, EntityUnpausedEvent>(OnRottingUnpaused);
SubscribeLocalEvent<RottingComponent, ComponentShutdown>(OnShutdown);
SubscribeLocalEvent<RottingComponent, MobStateChangedEvent>(OnRottingMobStateChanged);
SubscribeLocalEvent<RottingComponent, BeingGibbedEvent>(OnGibbed);
component.RotNextUpdate = _timing.CurTime + component.PerishUpdateRate;
}
- private void OnPerishableUnpaused(EntityUid uid, PerishableComponent component, ref EntityUnpausedEvent args)
- {
- component.RotNextUpdate += args.PausedTime;
- }
-
private void OnMobStateChanged(EntityUid uid, PerishableComponent component, MobStateChangedEvent args)
{
if (args.NewMobState != MobState.Dead && args.OldMobState != MobState.Dead)
component.RotNextUpdate = _timing.CurTime + component.PerishUpdateRate;
}
- private void OnRottingUnpaused(EntityUid uid, RottingComponent component, ref EntityUnpausedEvent args)
- {
- component.NextRotUpdate += args.PausedTime;
- }
-
private void OnShutdown(EntityUid uid, RottingComponent component, ComponentShutdown args)
{
if (TryComp<PerishableComponent>(uid, out var perishable))
/// Something with limited charges that can be recharged automatically.
/// Requires LimitedChargesComponent to function.
/// </summary>
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
[Access(typeof(ChargesSystem))]
public sealed partial class AutoRechargeComponent : Component
{
/// The time when the next charge will be added
/// </summary>
[DataField("nextChargeTime", customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextChargeTime;
}
{
[Dependency] private readonly IGameTiming _timing = default!;
- public override void Initialize()
- {
- base.Initialize();
-
- SubscribeLocalEvent<AutoRechargeComponent, EntityUnpausedEvent>(OnUnpaused);
- }
-
public override void Update(float frameTime)
{
base.Update(frameTime);
}
}
- private void OnUnpaused(EntityUid uid, AutoRechargeComponent comp, ref EntityUnpausedEvent args)
- {
- comp.NextChargeTime += args.PausedTime;
- }
-
protected override void OnExamine(EntityUid uid, LimitedChargesComponent comp, ExaminedEvent args)
{
base.OnExamine(uid, comp, args);
/// <summary>
/// Causes an entity to automatically emote when taking damage.
/// </summary>
-[RegisterComponent, Access(typeof(EmoteOnDamageSystem))]
+[RegisterComponent, Access(typeof(EmoteOnDamageSystem)), AutoGenerateComponentPause]
public sealed partial class EmoteOnDamageComponent : Component
{
/// <summary>
/// The simulation time of the last emote preformed due to taking damage.
/// </summary>
[DataField("lastEmoteTime", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan LastEmoteTime = TimeSpan.Zero;
/// <summary>
{
base.Initialize();
- SubscribeLocalEvent<EmoteOnDamageComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<EmoteOnDamageComponent, DamageChangedEvent>(OnDamage);
}
- private void OnUnpaused(EntityUid uid, EmoteOnDamageComponent emoteOnDamage, ref EntityUnpausedEvent args)
- {
- emoteOnDamage.LastEmoteTime += args.PausedTime;
- }
-
private void OnDamage(EntityUid uid, EmoteOnDamageComponent emoteOnDamage, DamageChangedEvent args)
{
if (!args.DamageIncreased)
/// <summary>
/// Passively decreases a solution's quantity of reagent(s).
/// </summary>
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
[Access(typeof(SolutionPurgeSystem))]
public sealed partial class SolutionPurgeComponent : Component
{
/// The time when the next purge will occur.
/// </summary>
[DataField("nextPurgeTime", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan NextPurgeTime = TimeSpan.FromSeconds(0);
}
/// <summary>
/// Passively increases a solution's quantity of a reagent.
/// </summary>
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
[Access(typeof(SolutionRegenerationSystem))]
public sealed partial class SolutionRegenerationComponent : Component
{
/// The time when the next regeneration will occur.
/// </summary>
[DataField("nextChargeTime", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan NextRegenTime = TimeSpan.FromSeconds(0);
}
[Dependency] private readonly SolutionContainerSystem _solutionContainer = default!;
[Dependency] private readonly IGameTiming _timing = default!;
- public override void Initialize()
- {
- base.Initialize();
-
- SubscribeLocalEvent<SolutionPurgeComponent, EntityUnpausedEvent>(OnUnpaused);
- }
-
public override void Update(float frameTime)
{
base.Update(frameTime);
_solutionContainer.SplitSolutionWithout(solution.Value, purge.Quantity, purge.Preserve.ToArray());
}
}
-
- private void OnUnpaused(Entity<SolutionPurgeComponent> entity, ref EntityUnpausedEvent args)
- {
- entity.Comp.NextPurgeTime += args.PausedTime;
- }
}
[Dependency] private readonly SolutionContainerSystem _solutionContainer = default!;
[Dependency] private readonly IGameTiming _timing = default!;
- public override void Initialize()
- {
- base.Initialize();
-
- SubscribeLocalEvent<SolutionRegenerationComponent, EntityUnpausedEvent>(OnUnpaused);
- }
-
public override void Update(float frameTime)
{
base.Update(frameTime);
}
}
}
-
- private void OnUnpaused(Entity<SolutionRegenerationComponent> entity, ref EntityUnpausedEvent args)
- {
- entity.Comp.NextRegenTime += args.PausedTime;
- }
}
// Shouldn't need re-anchoring.
SubscribeLocalEvent<DisposalUnitComponent, AnchorStateChangedEvent>(OnAnchorChanged);
- SubscribeLocalEvent<DisposalUnitComponent, EntityUnpausedEvent>(OnUnpaused);
// TODO: Predict me when hands predicted
SubscribeLocalEvent<DisposalUnitComponent, ContainerRelayMovementEntityEvent>(OnMovement);
SubscribeLocalEvent<DisposalUnitComponent, PowerChangedEvent>(OnPowerChange);
GetNetEntityList(component.RecentlyEjected));
}
- private void OnUnpaused(EntityUid uid, SharedDisposalUnitComponent component, ref EntityUnpausedEvent args)
- {
- if (component.NextFlush != null)
- component.NextFlush = component.NextFlush.Value + args.PausedTime;
-
- component.NextPressurized += args.PausedTime;
- }
-
private void AddDisposalAltVerbs(EntityUid uid, SharedDisposalUnitComponent component, GetVerbsEvent<AlternativeVerb> args)
{
if (!args.CanAccess || !args.CanInteract)
public override void Initialize()
{
base.Initialize();
- SubscribeLocalEvent<EmpDisabledComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<EmpDisabledComponent, ExaminedEvent>(OnExamine);
SubscribeLocalEvent<EmpOnTriggerComponent, TriggerEvent>(HandleEmpTrigger);
}
}
- private void OnUnpaused(EntityUid uid, EmpDisabledComponent component, ref EntityUnpausedEvent args)
- {
- component.DisabledUntil += args.PausedTime;
- component.TargetTime += args.PausedTime;
- }
-
private void OnExamine(EntityUid uid, EmpDisabledComponent component, ExaminedEvent args)
{
args.PushMarkup(Loc.GetString("emp-disabled-comp-on-examine"));
/// <summary>
/// After being triggered applies the specified components and runs triggers again.
/// </summary>
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
public sealed partial class TwoStageTriggerComponent : Component
{
/// <summary>
public ComponentRegistry SecondStageComponents = new();
[DataField("nextTriggerTime", customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan? NextTriggerTime;
[DataField("triggered")]
/// <summary>
/// Raises a <see cref="TriggerEvent"/> whenever an entity collides with a fixture attached to the owner of this component.
/// </summary>
- [RegisterComponent]
+ [RegisterComponent, AutoGenerateComponentPause]
public sealed partial class TriggerOnProximityComponent : SharedTriggerOnProximityComponent
{
public const string FixtureID = "trigger-on-proximity-fixture";
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
[DataField("nextTrigger", customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextTrigger = TimeSpan.Zero;
/// <summary>
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
[DataField("nextVisualUpdate", customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextVisualUpdate = TimeSpan.Zero;
/// <summary>
SubscribeLocalEvent<TriggerOnProximityComponent, StartCollideEvent>(OnProximityStartCollide);
SubscribeLocalEvent<TriggerOnProximityComponent, EndCollideEvent>(OnProximityEndCollide);
SubscribeLocalEvent<TriggerOnProximityComponent, MapInitEvent>(OnMapInit);
- SubscribeLocalEvent<TriggerOnProximityComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<TriggerOnProximityComponent, ComponentShutdown>(OnProximityShutdown);
// Shouldn't need re-anchoring.
SubscribeLocalEvent<TriggerOnProximityComponent, AnchorStateChangedEvent>(OnProximityAnchor);
collisionLayer: component.Layer);
}
- private void OnUnpaused(EntityUid uid, TriggerOnProximityComponent component, ref EntityUnpausedEvent args)
- {
- component.NextTrigger += args.PausedTime;
- component.NextVisualUpdate += args.PausedTime;
- }
-
private void OnProximityStartCollide(EntityUid uid, TriggerOnProximityComponent component, ref StartCollideEvent args)
{
if (args.OurFixtureId != TriggerOnProximityComponent.FixtureID)
public override void Initialize()
{
base.Initialize();
- SubscribeLocalEvent<TwoStageTriggerComponent, EntityUnpausedEvent>(OnTriggerUnpaused);
SubscribeLocalEvent<TwoStageTriggerComponent, TriggerEvent>(OnTrigger);
}
- private void OnTriggerUnpaused(EntityUid uid, TwoStageTriggerComponent component, ref EntityUnpausedEvent args)
- {
- if (component.NextTriggerTime != null)
- component.NextTriggerTime = component.NextTriggerTime.Value + args.PausedTime;
- }
-
private void OnTrigger(EntityUid uid, TwoStageTriggerComponent component, TriggerEvent args)
{
if (component.Triggered)
SubscribeLocalEvent<SmokeComponent, ReactionAttemptEvent>(OnReactionAttempt);
SubscribeLocalEvent<SmokeComponent, SolutionRelayEvent<ReactionAttemptEvent>>(OnReactionAttempt);
SubscribeLocalEvent<SmokeComponent, SpreadNeighborsEvent>(OnSmokeSpread);
- SubscribeLocalEvent<SmokeAffectedComponent, EntityUnpausedEvent>(OnAffectedUnpaused);
}
/// <inheritdoc/>
RemComp(args.OtherEntity, smokeAffectedComponent);
}
- private void OnAffectedUnpaused(Entity<SmokeAffectedComponent> entity, ref EntityUnpausedEvent args)
- {
- entity.Comp.NextSecond += args.PausedTime;
- }
-
private void OnSmokeSpread(Entity<SmokeComponent> entity, ref SpreadNeighborsEvent args)
{
if (entity.Comp.SpreadAmount == 0 || !_solutionContainerSystem.ResolveSolution(entity.Owner, SmokeComponent.SolutionName, ref entity.Comp.Solution, out var solution))
/// <summary>
/// Controlling gateway that links to other gateway destinations on the server.
/// </summary>
-[RegisterComponent, Access(typeof(GatewaySystem))]
+[RegisterComponent, Access(typeof(GatewaySystem)), AutoGenerateComponentPause]
public sealed partial class GatewayComponent : Component
{
/// <summary>
/// The time at which the portal can next be opened.
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextReady;
}
/// <summary>
/// Generates gateway destinations at a regular interval.
/// </summary>
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
public sealed partial class GatewayGeneratorComponent : Component
{
/// <summary>
/// Next time another seed unlocks.
/// </summary>
[DataField(customTypeSerializer:typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextUnlock;
/// <summary>
public override void Initialize()
{
base.Initialize();
- SubscribeLocalEvent<GatewayGeneratorComponent, EntityUnpausedEvent>(OnGeneratorUnpaused);
SubscribeLocalEvent<GatewayGeneratorComponent, MapInitEvent>(OnGeneratorMapInit);
SubscribeLocalEvent<GatewayGeneratorComponent, ComponentShutdown>(OnGeneratorShutdown);
SubscribeLocalEvent<GatewayGeneratorDestinationComponent, AttemptGatewayOpenEvent>(OnGeneratorAttemptOpen);
}
}
- private void OnGeneratorUnpaused(Entity<GatewayGeneratorComponent> ent, ref EntityUnpausedEvent args)
- {
- ent.Comp.NextUnlock += args.PausedTime;
- }
-
private void OnGeneratorMapInit(EntityUid uid, GatewayGeneratorComponent generator, MapInitEvent args)
{
if (!_cfgManager.GetCVar(CCVars.GatewayGeneratorEnabled))
{
base.Initialize();
- SubscribeLocalEvent<GatewayComponent, EntityUnpausedEvent>(OnGatewayUnpaused);
SubscribeLocalEvent<GatewayComponent, ComponentStartup>(OnStartup);
SubscribeLocalEvent<GatewayComponent, ActivatableUIOpenAttemptEvent>(OnGatewayOpenAttempt);
SubscribeLocalEvent<GatewayComponent, BoundUIOpenedEvent>(UpdateUserInterface);
UpdateAllGateways();
}
- private void OnGatewayUnpaused(EntityUid uid, GatewayComponent component, ref EntityUnpausedEvent args)
- {
- component.NextReady += args.PausedTime;
- }
-
private void OnStartup(EntityUid uid, GatewayComponent comp, ComponentStartup args)
{
// no need to update ui since its just been created, just do portal
SubscribeLocalEvent<HandsComponent, BodyPartRemovedEvent>(HandleBodyPartRemoved);
SubscribeLocalEvent<HandsComponent, ComponentGetState>(GetComponentState);
- SubscribeLocalEvent<HandsComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<HandsComponent, BeforeExplodeEvent>(OnExploded);
args.State = new HandsComponentState(hands);
}
- private void OnUnpaused(Entity<HandsComponent> ent, ref EntityUnpausedEvent args)
- {
- ent.Comp.NextThrowTime += args.PausedTime;
- }
private void OnExploded(Entity<HandsComponent> ent, ref BeforeExplodeEvent args)
{
/// <summary>
/// Attached to a microwave that is currently in the process of cooking
/// </summary>
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
public sealed partial class ActiveMicrowaveComponent : Component
{
[ViewVariables(VVAccess.ReadWrite)]
[ViewVariables(VVAccess.ReadWrite)]
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan MalfunctionTime = TimeSpan.Zero;
[ViewVariables]
SubscribeLocalEvent<ActiveMicrowaveComponent, ComponentStartup>(OnCookStart);
SubscribeLocalEvent<ActiveMicrowaveComponent, ComponentShutdown>(OnCookStop);
- SubscribeLocalEvent<ActiveMicrowaveComponent, EntityUnpausedEvent>(OnEntityUnpaused);
SubscribeLocalEvent<ActiveMicrowaveComponent, EntInsertedIntoContainerMessage>(OnActiveMicrowaveInsert);
SubscribeLocalEvent<ActiveMicrowaveComponent, EntRemovedFromContainerMessage>(OnActiveMicrowaveRemove);
microwaveComponent.PlayingStream = _audio.Stop(microwaveComponent.PlayingStream);
}
- private void OnEntityUnpaused(Entity<ActiveMicrowaveComponent> ent, ref EntityUnpausedEvent args)
- {
- ent.Comp.MalfunctionTime += args.PausedTime;
- }
-
private void OnActiveMicrowaveInsert(Entity<ActiveMicrowaveComponent> ent, ref EntInsertedIntoContainerMessage args)
{
AddComp<ActivelyMicrowavedComponent>(args.Entity);
/// <summary>
/// After scanning, retrieves the target Uid to use with its related UI.
/// </summary>
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
[Access(typeof(HealthAnalyzerSystem), typeof(CryoPodSystem))]
public sealed partial class HealthAnalyzerComponent : Component
{
/// When should the next update be sent for the patient
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextUpdate = TimeSpan.Zero;
/// <summary>
/// <inheritdoc/>
public override void Initialize()
{
- SubscribeLocalEvent<DefibrillatorComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<DefibrillatorComponent, UseInHandEvent>(OnUseInHand);
SubscribeLocalEvent<DefibrillatorComponent, PowerCellSlotEmptyEvent>(OnPowerCellSlotEmpty);
SubscribeLocalEvent<DefibrillatorComponent, AfterInteractEvent>(OnAfterInteract);
SubscribeLocalEvent<DefibrillatorComponent, DefibrillatorZapDoAfterEvent>(OnDoAfter);
}
- private void OnUnpaused(EntityUid uid, DefibrillatorComponent component, ref EntityUnpausedEvent args)
- {
- if (component.NextZapTime == null)
- return;
-
- component.NextZapTime = component.NextZapTime.Value + args.PausedTime;
- }
-
private void OnUseInHand(EntityUid uid, DefibrillatorComponent component, UseInHandEvent args)
{
if (args.Handled || !TryComp(uid, out UseDelayComponent? useDelay) || _useDelay.IsDelayed((uid, useDelay)))
public override void Initialize()
{
- SubscribeLocalEvent<HealthAnalyzerComponent, EntityUnpausedEvent>(OnEntityUnpaused);
SubscribeLocalEvent<HealthAnalyzerComponent, AfterInteractEvent>(OnAfterInteract);
SubscribeLocalEvent<HealthAnalyzerComponent, HealthAnalyzerDoAfterEvent>(OnDoAfter);
SubscribeLocalEvent<HealthAnalyzerComponent, EntGotInsertedIntoContainerMessage>(OnInsertedIntoContainer);
}
}
- private void OnEntityUnpaused(Entity<HealthAnalyzerComponent> ent, ref EntityUnpausedEvent args)
- {
- ent.Comp.NextUpdate += args.PausedTime;
- }
-
/// <summary>
/// Trigger the doafter for scanning
/// </summary>
/// Tracking device, embedded in almost all uniforms and jumpsuits.
/// If enabled, will report to crew monitoring console owners position and status.
/// </summary>
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
[Access(typeof(SuitSensorSystem))]
public sealed partial class SuitSensorComponent : Component
{
/// Next time when sensor updated owners status
/// </summary>
[DataField("nextUpdate", customTypeSerializer:typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextUpdate = TimeSpan.Zero;
/// <summary>
base.Initialize();
SubscribeLocalEvent<PlayerSpawnCompleteEvent>(OnPlayerSpawn);
SubscribeLocalEvent<SuitSensorComponent, MapInitEvent>(OnMapInit);
- SubscribeLocalEvent<SuitSensorComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<SuitSensorComponent, GotEquippedEvent>(OnEquipped);
SubscribeLocalEvent<SuitSensorComponent, GotUnequippedEvent>(OnUnequipped);
SubscribeLocalEvent<SuitSensorComponent, ExaminedEvent>(OnExamine);
SubscribeLocalEvent<SuitSensorComponent, EmpDisabledRemoved>(OnEmpFinished);
}
- private void OnUnpaused(EntityUid uid, SuitSensorComponent component, ref EntityUnpausedEvent args)
- {
- component.NextUpdate += args.PausedTime;
- }
-
public override void Update(float frameTime)
{
base.Update(frameTime);
namespace Content.Server.NPC.Components;
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
public sealed partial class NPCJukeComponent : Component
{
[DataField("jukeType")]
public float JukeDuration = 0.5f;
[DataField("nextJuke", customTypeSerializer:typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextJuke;
[DataField("targetTile")]
/// <summary>
/// Added to NPCs that are moving.
/// </summary>
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
public sealed partial class NPCSteeringComponent : Component
{
#region Context Steering
/// Next time we can change our steering direction.
/// </summary>
[DataField("nextSteer", customTypeSerializer:typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextSteer = TimeSpan.Zero;
[DataField("lastSteerIndex")]
public EntityCoordinates LastStuckCoordinates;
[DataField("lastStuckTime", customTypeSerializer:typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan LastStuckTime;
public const float StuckDistance = 1f;
/// <summary>
/// Stores the relevant pathfinding data for grids.
/// </summary>
-[RegisterComponent, Access(typeof(PathfindingSystem))]
+[RegisterComponent, Access(typeof(PathfindingSystem)), AutoGenerateComponentPause]
public sealed partial class GridPathfindingComponent : Component
{
[ViewVariables]
/// Next time the graph is allowed to update.
/// </summary>
/// Removing this datafield is the lazy fix HOWEVER I want to purge this anyway and do pathfinding at runtime.
+ [AutoPausedField]
public TimeSpan NextUpdate;
[ViewVariables]
{
SubscribeLocalEvent<GridInitializeEvent>(OnGridInit);
SubscribeLocalEvent<GridRemovalEvent>(OnGridRemoved);
- SubscribeLocalEvent<GridPathfindingComponent, EntityUnpausedEvent>(OnGridPathPause);
SubscribeLocalEvent<GridPathfindingComponent, ComponentShutdown>(OnGridPathShutdown);
SubscribeLocalEvent<CollisionChangeEvent>(OnCollisionChange);
SubscribeLocalEvent<CollisionLayerChangeEvent>(OnCollisionLayerChange);
DirtyChunk(ev.Entity, Comp<MapGridComponent>(ev.Entity).GridTileToLocal(ev.NewTile.GridIndices));
}
- private void OnGridPathPause(EntityUid uid, GridPathfindingComponent component, ref EntityUnpausedEvent args)
- {
- component.NextUpdate += args.PausedTime;
- }
private void OnGridPathShutdown(EntityUid uid, GridPathfindingComponent component, ComponentShutdown args)
{
_npcRangedQuery = GetEntityQuery<NPCRangedCombatComponent>();
_physicsQuery = GetEntityQuery<PhysicsComponent>();
- SubscribeLocalEvent<NPCJukeComponent, EntityUnpausedEvent>(OnJukeUnpaused);
SubscribeLocalEvent<NPCJukeComponent, NPCSteeringEvent>(OnJukeSteering);
}
- private void OnJukeUnpaused(EntityUid uid, NPCJukeComponent component, ref EntityUnpausedEvent args)
- {
- component.NextJuke += args.PausedTime;
- }
-
private void OnJukeSteering(EntityUid uid, NPCJukeComponent component, ref NPCSteeringEvent args)
{
if (component.JukeType == JukeType.AdjacentTile)
Subs.CVar(_configManager, CCVars.NPCPathfinding, SetNPCPathfinding, true);
SubscribeLocalEvent<NPCSteeringComponent, ComponentShutdown>(OnSteeringShutdown);
- SubscribeLocalEvent<NPCSteeringComponent, EntityUnpausedEvent>(OnSteeringUnpaused);
SubscribeNetworkEvent<RequestNPCSteeringDebugEvent>(OnDebugRequest);
}
component.PathfindToken = null;
}
- private void OnSteeringUnpaused(EntityUid uid, NPCSteeringComponent component, ref EntityUnpausedEvent args)
- {
- component.LastStuckTime += args.PausedTime;
- component.NextSteer += args.PausedTime;
- }
-
/// <summary>
/// Adds the AI to the steering system to move towards a specific target
/// </summary>
/// <summary>
/// This is used for a machine that extracts hunger from entities and creates meat. Yum!
/// </summary>
-[RegisterComponent, Access(typeof(FatExtractorSystem))]
+[RegisterComponent, Access(typeof(FatExtractorSystem)), AutoGenerateComponentPause]
public sealed partial class FatExtractorComponent : Component
{
/// <summary>
/// When the next update will occur
/// </summary>
[DataField("nextUpdate", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan NextUpdate;
/// <summary>
/// <inheritdoc/>
public override void Initialize()
{
- SubscribeLocalEvent<ReproductiveComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<ReproductiveComponent, MindAddedMessage>(OnMindAdded);
- SubscribeLocalEvent<InfantComponent, EntityUnpausedEvent>(OnInfantUnpaused);
SubscribeLocalEvent<InfantComponent, ComponentStartup>(OnInfantStartup);
SubscribeLocalEvent<InfantComponent, ComponentShutdown>(OnInfantShutdown);
}
- private void OnUnpaused(EntityUid uid, ReproductiveComponent component, ref EntityUnpausedEvent args)
- {
- component.NextBreedAttempt += args.PausedTime;
- }
-
- private void OnInfantUnpaused(EntityUid uid, InfantComponent component, ref EntityUnpausedEvent args)
- {
- component.InfantEndTime += args.PausedTime;
- }
-
// we express EZ-pass terminate the pregnancy if a player takes the role
private void OnMindAdded(EntityUid uid, ReproductiveComponent component, MindAddedMessage args)
{
/// <inheritdoc/>
public override void Initialize()
{
- SubscribeLocalEvent<FatExtractorComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<FatExtractorComponent, GotEmaggedEvent>(OnGotEmagged);
SubscribeLocalEvent<FatExtractorComponent, StorageAfterCloseEvent>(OnClosed);
SubscribeLocalEvent<FatExtractorComponent, StorageAfterOpenEvent>(OnOpen);
SubscribeLocalEvent<FatExtractorComponent, PowerChangedEvent>(OnPowerChanged);
}
- private void OnUnpaused(EntityUid uid, FatExtractorComponent component, ref EntityUnpausedEvent args)
- {
- component.NextUpdate += args.PausedTime;
- }
-
private void OnGotEmagged(EntityUid uid, FatExtractorComponent component, ref GotEmaggedEvent args)
{
args.Handled = true;
/// <summary>
/// A component which makes its entity chasing entity with selected component.
/// </summary>
-[RegisterComponent, Access(typeof(ChasingWalkSystem))]
+[RegisterComponent, Access(typeof(ChasingWalkSystem)), AutoGenerateComponentPause]
public sealed partial class ChasingWalkComponent : Component
{
/// <summary>
/// The next moment in time when the entity is pushed toward its goal
/// </summary>
[DataField, ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan NextImpulseTime;
/// <summary>
/// The next change of direction time.
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan NextChangeVectorTime;
/// <summary>
base.Initialize();
SubscribeLocalEvent<ChasingWalkComponent, MapInitEvent>(OnChasingMapInit);
- SubscribeLocalEvent<ChasingWalkComponent, EntityUnpausedEvent>(OnChasingUnpaused);
}
private void OnChasingMapInit(EntityUid uid, ChasingWalkComponent component, MapInitEvent args)
component.NextChangeVectorTime = _gameTiming.CurTime;
}
- private void OnChasingUnpaused(EntityUid uid, ChasingWalkComponent component, ref EntityUnpausedEvent args)
- {
- component.NextImpulseTime += args.PausedTime;
- component.NextChangeVectorTime += args.PausedTime;
- }
-
public override void UpdateBeforeSolve(bool prediction, float frameTime)
{
base.UpdateBeforeSolve(prediction, frameTime);
}
}
- private void OnUnpaused(EntityUid uid, PowerCellDrawComponent component, ref EntityUnpausedEvent args)
- {
- component.NextUpdateTime += args.PausedTime;
- }
-
private void OnDrawChargeChanged(EntityUid uid, PowerCellDrawComponent component, ref ChargeChangedEvent args)
{
// Update the bools for client prediction.
SubscribeLocalEvent<PowerCellComponent, ExaminedEvent>(OnCellExamined);
SubscribeLocalEvent<PowerCellComponent, EmpAttemptEvent>(OnCellEmpAttempt);
- SubscribeLocalEvent<PowerCellDrawComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<PowerCellDrawComponent, ChargeChangedEvent>(OnDrawChargeChanged);
SubscribeLocalEvent<PowerCellDrawComponent, PowerCellChangedEvent>(OnDrawCellChanged);
/// <summary>
/// Absorbs power up to its capacity when anchored then explodes.
/// </summary>
- [RegisterComponent]
+ [RegisterComponent, AutoGenerateComponentPause]
public sealed partial class PowerSinkComponent : Component
{
/// <summary>
/// If explosion has been triggered, time at which to explode.
/// </summary>
[DataField("explosionTime", customTypeSerializer:typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public System.TimeSpan? ExplosionTime = null;
/// <summary>
base.Initialize();
SubscribeLocalEvent<PowerSinkComponent, ExaminedEvent>(OnExamine);
- SubscribeLocalEvent<PowerSinkComponent, EntityUnpausedEvent>(OnUnpaused);
}
private void OnExamine(EntityUid uid, PowerSinkComponent component, ExaminedEvent args)
);
}
- private void OnUnpaused(EntityUid uid, PowerSinkComponent component, ref EntityUnpausedEvent args)
- {
- if (component.ExplosionTime == null)
- return;
-
- component.ExplosionTime = component.ExplosionTime + args.PausedTime;
- }
-
public override void Update(float frameTime)
{
var toRemove = new RemQueue<(EntityUid Entity, PowerSinkComponent Sink)>();
/// <summary>
/// Designates this entity as holding a salvage expedition.
/// </summary>
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
public sealed partial class SalvageExpeditionComponent : SharedSalvageExpeditionComponent
{
public SalvageMissionParams MissionParams = default!;
/// When the expeditions ends.
/// </summary>
[ViewVariables(VVAccess.ReadWrite), DataField("endTime", customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan EndTime;
/// <summary>
SubscribeLocalEvent<SalvageExpeditionConsoleComponent, EntParentChangedMessage>(OnSalvageConsoleParent);
SubscribeLocalEvent<SalvageExpeditionConsoleComponent, ClaimSalvageMessage>(OnSalvageClaimMessage);
- SubscribeLocalEvent<SalvageExpeditionDataComponent, EntityUnpausedEvent>(OnDataUnpaused);
-
SubscribeLocalEvent<SalvageExpeditionComponent, ComponentShutdown>(OnExpeditionShutdown);
- SubscribeLocalEvent<SalvageExpeditionComponent, EntityUnpausedEvent>(OnExpeditionUnpaused);
SubscribeLocalEvent<SalvageExpeditionComponent, ComponentGetState>(OnExpeditionGetState);
SubscribeLocalEvent<SalvageStructureComponent, ExaminedEvent>(OnStructureExamine);
}
}
- private void OnDataUnpaused(EntityUid uid, SalvageExpeditionDataComponent component, ref EntityUnpausedEvent args)
- {
- component.NextOffer += args.PausedTime;
- }
-
- private void OnExpeditionUnpaused(EntityUid uid, SalvageExpeditionComponent component, ref EntityUnpausedEvent args)
- {
- component.EndTime += args.PausedTime;
- }
-
private void UpdateExpeditions()
{
var currentTime = _timing.CurTime;
namespace Content.Server.Shuttles.Components;
-[RegisterComponent, Access(typeof(ArrivalsSystem))]
+[RegisterComponent, Access(typeof(ArrivalsSystem)), AutoGenerateComponentPause]
public sealed partial class ArrivalsShuttleComponent : Component
{
[DataField("station")]
public EntityUid Station;
[DataField("nextTransfer", customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextTransfer;
[DataField("nextArrivalsTime", customTypeSerializer: typeof(TimeOffsetSerializer))]
/// <summary>
/// If added to a grid gets launched when the emergency shuttle launches.
/// </summary>
-[RegisterComponent, Access(typeof(EmergencyShuttleSystem))]
+[RegisterComponent, Access(typeof(EmergencyShuttleSystem)), AutoGenerateComponentPause]
public sealed partial class EscapePodComponent : Component
{
[DataField("launchTime", customTypeSerializer:typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan? LaunchTime;
}
SubscribeLocalEvent<StationArrivalsComponent, ComponentStartup>(OnArrivalsStartup);
SubscribeLocalEvent<ArrivalsShuttleComponent, ComponentStartup>(OnShuttleStartup);
- SubscribeLocalEvent<ArrivalsShuttleComponent, EntityUnpausedEvent>(OnShuttleUnpaused);
SubscribeLocalEvent<ArrivalsShuttleComponent, FTLTagEvent>(OnShuttleTag);
SubscribeLocalEvent<RoundStartingEvent>(OnRoundStarting);
EnsureComp<PreventPilotComponent>(uid);
}
- private void OnShuttleUnpaused(EntityUid uid, ArrivalsShuttleComponent component, ref EntityUnpausedEvent args)
- {
- component.NextTransfer += args.PausedTime;
- }
-
private bool TryGetArrivals(out EntityUid uid)
{
var arrivalsQuery = EntityQueryEnumerator<ArrivalsSourceComponent>();
SubscribeLocalEvent<EmergencyShuttleConsoleComponent, EmergencyShuttleRepealMessage>(OnEmergencyRepeal);
SubscribeLocalEvent<EmergencyShuttleConsoleComponent, EmergencyShuttleRepealAllMessage>(OnEmergencyRepealAll);
SubscribeLocalEvent<EmergencyShuttleConsoleComponent, ActivatableUIOpenAttemptEvent>(OnEmergencyOpenAttempt);
-
- SubscribeLocalEvent<EscapePodComponent, EntityUnpausedEvent>(OnEscapeUnpaused);
}
private void OnEmergencyOpenAttempt(EntityUid uid, EmergencyShuttleConsoleComponent component, ActivatableUIOpenAttemptEvent args)
EnsureComp<EmergencyShuttleComponent>(shuttle.Value);
}
- private void OnEscapeUnpaused(EntityUid uid, EscapePodComponent component, ref EntityUnpausedEvent args)
- {
- if (component.LaunchTime == null)
- return;
-
- component.LaunchTime = component.LaunchTime.Value + args.PausedTime;
- }
-
/// <summary>
/// Returns whether a target is escaping on the emergency shuttle, but only if evac has arrived.
/// </summary>
SubscribeLocalEvent<GhostComponent, EventHorizonAttemptConsumeEntityEvent>(PreventConsume);
SubscribeLocalEvent<StationDataComponent, EventHorizonAttemptConsumeEntityEvent>(PreventConsume);
SubscribeLocalEvent<EventHorizonComponent, MapInitEvent>(OnHorizonMapInit);
- SubscribeLocalEvent<EventHorizonComponent, EntityUnpausedEvent>(OnHorizonUnpaused);
SubscribeLocalEvent<EventHorizonComponent, StartCollideEvent>(OnStartCollide);
SubscribeLocalEvent<EventHorizonComponent, EntGotInsertedIntoContainerMessage>(OnEventHorizonContained);
SubscribeLocalEvent<EventHorizonContainedEvent>(OnEventHorizonContained);
component.NextConsumeWaveTime = _timing.CurTime;
}
- private void OnHorizonUnpaused(EntityUid uid, EventHorizonComponent component, ref EntityUnpausedEvent args)
- {
- component.NextConsumeWaveTime += args.PausedTime;
- }
-
public override void Shutdown()
{
var vvHandle = Vvm.GetTypeHandler<EventHorizonComponent>();
namespace Content.Server.Spreader;
-[RegisterComponent, Access(typeof(KudzuSystem))]
+[RegisterComponent, Access(typeof(KudzuSystem)), AutoGenerateComponentPause]
public sealed partial class GrowingKudzuComponent : Component
{
/// <summary>
/// The next time kudzu will try to tick its growth level.
/// </summary>
[DataField("nextTick", customTypeSerializer:typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextTick = TimeSpan.Zero;
}
{
SubscribeLocalEvent<KudzuComponent, ComponentStartup>(SetupKudzu);
SubscribeLocalEvent<KudzuComponent, SpreadNeighborsEvent>(OnKudzuSpread);
- SubscribeLocalEvent<GrowingKudzuComponent, EntityUnpausedEvent>(OnKudzuUnpaused);
SubscribeLocalEvent<KudzuComponent, DamageChangedEvent>(OnDamageChanged);
}
}
}
- private void OnKudzuUnpaused(EntityUid uid, GrowingKudzuComponent component, ref EntityUnpausedEvent args)
- {
- component.NextTick += args.PausedTime;
- }
-
private void SetupKudzu(EntityUid uid, KudzuComponent component, ComponentStartup args)
{
if (!EntityManager.TryGetComponent<AppearanceComponent>(uid, out var appearance))
/// <summary>
/// Defines basic data for a station event
/// </summary>
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
public sealed partial class StationEventComponent : Component
{
public const float WeightVeryLow = 0.0f;
/// When the station event starts.
/// </summary>
[DataField("startTime", customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan StartTime;
/// <summary>
/// When the station event ends.
/// </summary>
[DataField("endTime", customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan? EndTime;
}
_sawmill = Logger.GetSawmill("events");
Subs.CVar(_configurationManager, CCVars.EventsEnabled, SetEnabled, true);
-
- SubscribeLocalEvent<StationEventComponent, EntityUnpausedEvent>(OnUnpaused);
- }
-
- private void OnUnpaused(EntityUid uid, StationEventComponent component, ref EntityUnpausedEvent args)
- {
- component.StartTime += args.PausedTime;
- if (component.EndTime != null)
- component.EndTime = component.EndTime.Value + args.PausedTime;
}
/// <summary>
/// <summary>
/// Periodically fires electric arcs at surrounding objects.
/// </summary>
-[RegisterComponent, Access(typeof(LightningArcShooterSystem))]
+[RegisterComponent, Access(typeof(LightningArcShooterSystem)), AutoGenerateComponentPause]
public sealed partial class LightningArcShooterComponent : Component
{
/// <summary>
/// The time, upon reaching which the next batch of lightning bolts will be fired.
/// </summary>
[DataField, ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan NextShootTime;
/// <summary>
/// <summary>
/// The component changes the visual of an object after it is struck by lightning
/// </summary>
-[RegisterComponent, Access(typeof(LightningSparkingSystem))]
+[RegisterComponent, Access(typeof(LightningSparkingSystem)), AutoGenerateComponentPause]
public sealed partial class LightningSparkingComponent : Component
{
/// <summary>
/// When the spark visual should turn off.
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan LightningEndTime;
[DataField, ViewVariables(VVAccess.ReadWrite)]
{
base.Initialize();
SubscribeLocalEvent<LightningArcShooterComponent, MapInitEvent>(OnShooterMapInit);
- SubscribeLocalEvent<LightningArcShooterComponent, EntityUnpausedEvent>(OnShooterUnpaused);
}
private void OnShooterMapInit(EntityUid uid, LightningArcShooterComponent component, ref MapInitEvent args)
component.NextShootTime = _gameTiming.CurTime + TimeSpan.FromSeconds(component.ShootMaxInterval);
}
- private void OnShooterUnpaused(EntityUid uid, LightningArcShooterComponent component, ref EntityUnpausedEvent args)
- {
- component.NextShootTime += args.PausedTime;
- }
-
public override void Update(float frameTime)
{
base.Update(frameTime);
base.Initialize();
SubscribeLocalEvent<LightningSparkingComponent, HitByLightningEvent>(OnHitByLightning);
- SubscribeLocalEvent<LightningSparkingComponent, EntityUnpausedEvent>(OnLightningUnpaused);
- }
-
- private void OnLightningUnpaused(EntityUid uid, LightningSparkingComponent component, ref EntityUnpausedEvent args)
- {
- component.LightningEndTime += args.PausedTime;
}
private void OnHitByLightning(Entity<LightningSparkingComponent> uid, ref HitByLightningEvent args)
///
/// Anomalies and their related components were designed here: https://hackmd.io/@ss14-design/r1sQbkJOs
/// </summary>
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
[Access(typeof(SharedAnomalySystem))]
public sealed partial class AnomalyComponent : Component
{
/// <summary>
/// The time at which the next artifact pulse will occur.
/// </summary>
- [DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoNetworkedField]
+ [DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoNetworkedField, AutoPausedField]
[ViewVariables(VVAccess.ReadWrite)]
public TimeSpan NextPulseTime = TimeSpan.Zero;
/// <summary>
/// This component tracks anomalies that are currently pulsing
/// </summary>
-[RegisterComponent, Access(typeof(SharedAnomalySystem))]
+[RegisterComponent, Access(typeof(SharedAnomalySystem)), AutoGenerateComponentPause]
public sealed partial class AnomalyPulsingComponent : Component
{
/// <summary>
/// The time at which the pulse will be over.
/// </summary>
[DataField("endTime", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan EndTime;
/// <summary>
/// </summary>
[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
[Access(typeof(SharedAnomalySystem))]
+[AutoGenerateComponentPause]
public sealed partial class AnomalySupercriticalComponent : Component
{
/// <summary>
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoNetworkedField]
[ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan EndTime;
/// <summary>
SubscribeLocalEvent<AnomalyComponent, MeleeThrowOnHitStartEvent>(OnAnomalyThrowStart);
SubscribeLocalEvent<AnomalyComponent, MeleeThrowOnHitEndEvent>(OnAnomalyThrowEnd);
- SubscribeLocalEvent<AnomalyComponent, EntityUnpausedEvent>(OnAnomalyUnpause);
- SubscribeLocalEvent<AnomalyPulsingComponent, EntityUnpausedEvent>(OnPulsingUnpause);
- SubscribeLocalEvent<AnomalySupercriticalComponent, EntityUnpausedEvent>(OnSupercriticalUnpause);
-
_sawmill = Logger.GetSawmill("anomaly");
}
Popup.PopupEntity(Loc.GetString("anomaly-component-contact-damage"), target, target);
}
- private void OnAnomalyUnpause(EntityUid uid, AnomalyComponent component, ref EntityUnpausedEvent args)
- {
- component.NextPulseTime += args.PausedTime;
- Dirty(uid, component);
- }
-
- private void OnPulsingUnpause(EntityUid uid, AnomalyPulsingComponent component, ref EntityUnpausedEvent args)
- {
- component.EndTime += args.PausedTime;
- }
-
- private void OnSupercriticalUnpause(EntityUid uid, AnomalySupercriticalComponent component, ref EntityUnpausedEvent args)
- {
- component.EndTime += args.PausedTime;
- Dirty(uid, component);
- }
-
public void DoAnomalyPulse(EntityUid uid, AnomalyComponent? component = null)
{
if (!Resolve(uid, ref component))
/// 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.
/// </summary>
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
[Access(typeof(SharedRottingSystem))]
public sealed partial class PerishableComponent : Component
{
/// Gasses are released, this is when the next gas release update will be.
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan RotNextUpdate = TimeSpan.Zero;
/// <summary>
/// Tracking component for stuff that has started to rot.
/// Only the current stage is networked to the client.
/// </summary>
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentPause]
[Access(typeof(SharedRottingSystem))]
public sealed partial class RottingComponent : Component
{
/// When the next check will happen for rot progression + effects like damage and ammonia
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextRotUpdate = TimeSpan.Zero;
/// <summary>
/// This is used to track an entity that is currently being held in Cryostorage.
/// </summary>
[RegisterComponent, NetworkedComponent]
-[AutoGenerateComponentState]
+[AutoGenerateComponentState, AutoGenerateComponentPause]
public sealed partial class CryostorageContainedComponent : Component
{
/// <summary>
/// The time at which the cryostorage grace period ends.
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan? GracePeriodEndTime;
/// <summary>
SubscribeLocalEvent<CryostorageComponent, CanDropTargetEvent>(OnCanDropTarget);
SubscribeLocalEvent<CryostorageContainedComponent, EntGotRemovedFromContainerMessage>(OnRemovedContained);
- SubscribeLocalEvent<CryostorageContainedComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<CryostorageContainedComponent, ComponentShutdown>(OnShutdownContained);
SubscribeLocalEvent<RoundRestartCleanupEvent>(OnRoundRestart);
RemCompDeferred(ent, comp);
}
- private void OnUnpaused(Entity<CryostorageContainedComponent> ent, ref EntityUnpausedEvent args)
- {
- var comp = ent.Comp;
- if (comp.GracePeriodEndTime != null)
- comp.GracePeriodEndTime = comp.GracePeriodEndTime.Value + args.PausedTime;
- }
-
private void OnShutdownContained(Entity<CryostorageContainedComponent> ent, ref ComponentShutdown args)
{
var comp = ent.Comp;
SubscribeLocalEvent<SleepingComponent, SpeakAttemptEvent>(OnSpeakAttempt);
SubscribeLocalEvent<SleepingComponent, CanSeeAttemptEvent>(OnSeeAttempt);
SubscribeLocalEvent<SleepingComponent, PointAttemptEvent>(OnPointAttempt);
- SubscribeLocalEvent<SleepingComponent, EntityUnpausedEvent>(OnSleepUnpaused);
}
- private void OnSleepUnpaused(EntityUid uid, SleepingComponent component, ref EntityUnpausedEvent args)
- {
- component.CoolDownEnd += args.PausedTime;
- Dirty(uid, component);
- }
private void OnMapInit(EntityUid uid, SleepingComponent component, MapInitEvent args)
{
/// <summary>
/// Added to entities when they go to sleep.
/// </summary>
-[NetworkedComponent, RegisterComponent]
+[NetworkedComponent, RegisterComponent, AutoGenerateComponentPause(Dirty = true)]
public sealed partial class SleepingComponent : Component
{
/// <summary>
public TimeSpan Cooldown = TimeSpan.FromSeconds(1f);
[DataField("cooldownEnd", customTypeSerializer:typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan CoolDownEnd;
[DataField("wakeAction")] public EntityUid? WakeAction;
/// <summary>
/// Added to entities which have started falling into a chasm.
/// </summary>
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentPause]
public sealed partial class ChasmFallingComponent : Component
{
/// <summary>
public TimeSpan DeletionTime = TimeSpan.FromSeconds(1.8f);
[DataField("nextDeletionTime", customTypeSerializer:typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextDeletionTime = TimeSpan.Zero;
/// <summary>
SubscribeLocalEvent<ChasmComponent, StepTriggeredEvent>(OnStepTriggered);
SubscribeLocalEvent<ChasmComponent, StepTriggerAttemptEvent>(OnStepTriggerAttempt);
- SubscribeLocalEvent<ChasmFallingComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<ChasmFallingComponent, UpdateCanMoveEvent>(OnUpdateCanMove);
}
args.Continue = true;
}
- private void OnUnpaused(EntityUid uid, ChasmFallingComponent component, ref EntityUnpausedEvent args)
- {
- component.NextDeletionTime += args.PausedTime;
- }
-
private void OnUpdateCanMove(EntityUid uid, ChasmFallingComponent component, UpdateCanMoveEvent args)
{
args.Cancel();
/// This is used for entities which are currently being affected by smoke.
/// Manages the gradual metabolism every second.
/// </summary>
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentPause]
public sealed partial class SmokeAffectedComponent : Component
{
/// <summary>
/// The time at which the next smoke metabolism will occur.
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextSecond;
/// <summary>
namespace Content.Shared.Climbing.Components;
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
public sealed partial class ClimbingComponent : Component
{
/// <summary>
/// Whether the owner is being moved onto the climbed entity.
/// </summary>
[AutoNetworkedField, DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan? NextTransition;
/// <summary>
SubscribeLocalEvent<ClimbingComponent, ClimbDoAfterEvent>(OnDoAfter);
SubscribeLocalEvent<ClimbingComponent, EndCollideEvent>(OnClimbEndCollide);
SubscribeLocalEvent<ClimbingComponent, BuckleChangeEvent>(OnBuckleChange);
- SubscribeLocalEvent<ClimbingComponent, EntityUnpausedEvent>(OnClimbableUnpaused);
SubscribeLocalEvent<ClimbableComponent, CanDropTargetEvent>(OnCanDragDropOn);
SubscribeLocalEvent<ClimbableComponent, GetVerbsEvent<AlternativeVerb>>(AddClimbableVerb);
SubscribeLocalEvent<GlassTableComponent, ClimbedOnEvent>(OnGlassClimbed);
}
- private void OnClimbableUnpaused(EntityUid uid, ClimbingComponent component, ref EntityUnpausedEvent args)
- {
- if (component.NextTransition == null)
- return;
-
- component.NextTransition = component.NextTransition.Value + args.PausedTime;
- Dirty(uid, component);
- }
-
public override void UpdateBeforeSolve(bool prediction, float frameTime)
{
base.UpdateBeforeSolve(prediction, frameTime);
SubscribeLocalEvent<PacifiedComponent, BeforeThrowEvent>(OnBeforeThrow);
SubscribeLocalEvent<PacifiedComponent, AttackAttemptEvent>(OnAttackAttempt);
SubscribeLocalEvent<PacifiedComponent, ShotAttemptedEvent>(OnShootAttempt);
- SubscribeLocalEvent<PacifiedComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<PacifismDangerousAttackComponent, AttemptPacifiedAttackEvent>(OnPacifiedDangerousAttack);
}
- private void OnUnpaused(Entity<PacifiedComponent> ent, ref EntityUnpausedEvent args)
- {
- if (ent.Comp.NextPopupTime != null)
- ent.Comp.NextPopupTime = ent.Comp.NextPopupTime.Value + args.PausedTime;
- }
-
private bool PacifiedCanAttack(EntityUid user, EntityUid target, [NotNullWhen(false)] out string? reason)
{
var ev = new AttemptPacifiedAttackEvent(user);
///
/// If you want full-pacifism (no combat mode at all), you can simply set <see cref="DisallowAllCombat"/> before adding.
/// </summary>
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentPause]
[Access(typeof(PacificationSystem))]
public sealed partial class PacifiedComponent : Component
{
public TimeSpan PopupCooldown = TimeSpan.FromSeconds(3.0);
[DataField]
+ [AutoPausedField]
public TimeSpan? NextPopupTime = null;
/// <summary>
/// </summary>
[RegisterComponent, NetworkedComponent]
[Access(typeof(SharedFlatpackSystem))]
-[AutoGenerateComponentState]
+[AutoGenerateComponentState, AutoGenerateComponentPause]
public sealed partial class FlatpackCreatorComponent : Component
{
/// <summary>
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
[AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan PackEndTime;
/// <summary>
SubscribeLocalEvent<FlatpackComponent, ExaminedEvent>(OnFlatpackExamined);
SubscribeLocalEvent<FlatpackCreatorComponent, ContainerIsRemovingAttemptEvent>(OnCreatorRemovingAttempt);
- SubscribeLocalEvent<FlatpackCreatorComponent, EntityUnpausedEvent>(OnCreatorUnpaused);
}
private void OnFlatpackInteractUsing(Entity<FlatpackComponent> ent, ref InteractUsingEvent args)
args.Cancel();
}
- private void OnCreatorUnpaused(Entity<FlatpackCreatorComponent> ent, ref EntityUnpausedEvent args)
- {
- ent.Comp.PackEndTime += args.PausedTime;
- }
-
public void SetupFlatpack(Entity<FlatpackComponent?> ent, EntityUid? board)
{
if (!Resolve(ent, ref ent.Comp))
namespace Content.Shared.Damage.Components;
[RegisterComponent, NetworkedComponent]
-[AutoGenerateComponentState]
+[AutoGenerateComponentState, AutoGenerateComponentPause]
[Access(typeof(DamageOnHoldingSystem))]
public sealed partial class DamageOnHoldingComponent : Component
{
[DataField("nextDamage", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
[AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan NextDamage = TimeSpan.Zero;
}
/// <summary>
/// Add to an entity to paralyze it whenever it reaches critical amounts of Stamina DamageType.
/// </summary>
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(true)]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(true), AutoGenerateComponentPause]
public sealed partial class StaminaComponent : Component
{
/// <summary>
/// To avoid continuously updating our data we track the last time we updated so we can extrapolate our current stamina.
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan NextUpdate = TimeSpan.Zero;
}
public override void Initialize()
{
base.Initialize();
- SubscribeLocalEvent<DamageOnHoldingComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<DamageOnHoldingComponent, MapInitEvent>(OnMapInit);
}
}
}
- private void OnUnpaused(EntityUid uid, DamageOnHoldingComponent component, ref EntityUnpausedEvent args)
- {
- component.NextDamage += args.PausedTime;
- }
-
private void OnMapInit(EntityUid uid, DamageOnHoldingComponent component, MapInitEvent args)
{
component.NextDamage = _timing.CurTime;
component.NextDamage = _timing.CurTime + TimeSpan.FromSeconds(component.Interval);
}
}
-}
\ No newline at end of file
+}
InitializeModifier();
- SubscribeLocalEvent<StaminaComponent, EntityUnpausedEvent>(OnStamUnpaused);
SubscribeLocalEvent<StaminaComponent, ComponentStartup>(OnStartup);
SubscribeLocalEvent<StaminaComponent, ComponentShutdown>(OnShutdown);
SubscribeLocalEvent<StaminaComponent, AfterAutoHandleStateEvent>(OnStamHandleState);
SubscribeLocalEvent<StaminaDamageOnHitComponent, MeleeHitEvent>(OnMeleeHit);
}
- private void OnStamUnpaused(EntityUid uid, StaminaComponent component, ref EntityUnpausedEvent args)
- {
- component.NextUpdate += args.PausedTime;
- }
-
private void OnStamHandleState(EntityUid uid, StaminaComponent component, ref AfterAutoHandleStateEvent args)
{
if (component.Critical)
/// While entity has this component it is "disabled" by EMP.
/// Add desired behaviour in other systems
/// </summary>
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentPause]
[Access(typeof(SharedEmpSystem))]
public sealed partial class EmpDisabledComponent : Component
{
/// Moment of time when component is removed and entity stops being "disabled"
/// </summary>
[DataField("timeLeft", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan DisabledUntil;
[DataField("effectCoolDown"), ViewVariables(VVAccess.ReadWrite)]
/// <summary>
/// When next effect will be spawned
/// </summary>
+ [AutoPausedField]
public TimeSpan TargetTime = TimeSpan.Zero;
}
/// <summary>
/// Indicates this entity is shaking due to gravity changes.
/// </summary>
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
public sealed partial class GravityShakeComponent : Component
{
[ViewVariables(VVAccess.ReadWrite), DataField, AutoNetworkedField]
public int ShakeTimes;
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan NextShake;
}
protected const float GravityKick = 100.0f;
protected const float ShakeCooldown = 0.2f;
- private void InitializeShake()
- {
- SubscribeLocalEvent<GravityShakeComponent, EntityUnpausedEvent>(OnShakeUnpaused);
- }
-
- private void OnShakeUnpaused(EntityUid uid, GravityShakeComponent component, ref EntityUnpausedEvent args)
- {
- component.NextShake += args.PausedTime;
- }
-
private void UpdateShake()
{
var curTime = Timing.CurTime;
SubscribeLocalEvent<GravityChangedEvent>(OnGravityChange);
SubscribeLocalEvent<GravityComponent, ComponentGetState>(OnGetState);
SubscribeLocalEvent<GravityComponent, ComponentHandleState>(OnHandleState);
-
- InitializeShake();
}
public override void Update(float frameTime)
namespace Content.Shared.Hands.Components;
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentPause]
[Access(typeof(SharedHandsSystem))]
public sealed partial class HandsComponent : Component
{
/// The time at which throws will be allowed again.
/// </summary>
[DataField, ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan NextThrowTime;
/// <summary>
/// Tracker component for the process of reclaiming entities
/// <seealso cref="MaterialReclaimerComponent"/>
/// </summary>
-[RegisterComponent, NetworkedComponent, Access(typeof(SharedMaterialReclaimerSystem))]
+[RegisterComponent, NetworkedComponent, Access(typeof(SharedMaterialReclaimerSystem)), AutoGenerateComponentPause]
public sealed partial class ActiveMaterialReclaimerComponent : Component
{
/// <summary>
/// When the reclaiming process ends.
/// </summary>
[DataField("endTime", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan EndTime;
/// <summary>
namespace Content.Shared.Materials;
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
public sealed partial class InsertingMaterialStorageComponent : Component
{
/// <summary>
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoNetworkedField]
[ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan EndTime;
[ViewVariables, AutoNetworkedField]
/// This is a machine that handles converting entities
/// into the raw materials and chemicals that make them up.
/// </summary>
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
[Access(typeof(SharedMaterialReclaimerSystem))]
public sealed partial class MaterialReclaimerComponent : Component
{
/// When the next sound will be allowed to be played. Used to prevent spam.
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextSound;
/// <summary>
public override void Initialize()
{
SubscribeLocalEvent<MaterialReclaimerComponent, ComponentShutdown>(OnShutdown);
- SubscribeLocalEvent<MaterialReclaimerComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<MaterialReclaimerComponent, ExaminedEvent>(OnExamined);
SubscribeLocalEvent<MaterialReclaimerComponent, GotEmaggedEvent>(OnEmagged);
SubscribeLocalEvent<MaterialReclaimerComponent, MapInitEvent>(OnMapInit);
SubscribeLocalEvent<CollideMaterialReclaimerComponent, StartCollideEvent>(OnCollide);
SubscribeLocalEvent<ActiveMaterialReclaimerComponent, ComponentStartup>(OnActiveStartup);
- SubscribeLocalEvent<ActiveMaterialReclaimerComponent, EntityUnpausedEvent>(OnActiveUnpaused);
}
private void OnMapInit(EntityUid uid, MaterialReclaimerComponent component, MapInitEvent args)
_audio.Stop(component.Stream);
}
- private void OnUnpaused(EntityUid uid, MaterialReclaimerComponent component, ref EntityUnpausedEvent args)
- {
- component.NextSound += args.PausedTime;
- }
-
private void OnExamined(EntityUid uid, MaterialReclaimerComponent component, ExaminedEvent args)
{
args.PushMarkup(Loc.GetString("recycler-count-items", ("items", component.ItemsProcessed)));
component.ReclaimingContainer = Container.EnsureContainer<Container>(uid, ActiveReclaimerContainerId);
}
- private void OnActiveUnpaused(EntityUid uid, ActiveMaterialReclaimerComponent component, ref EntityUnpausedEvent args)
- {
- component.EndTime += args.PausedTime;
- }
-
/// <summary>
/// Tries to start processing an item via a <see cref="MaterialReclaimerComponent"/>.
/// </summary>
SubscribeLocalEvent<MaterialStorageComponent, MapInitEvent>(OnMapInit);
SubscribeLocalEvent<MaterialStorageComponent, InteractUsingEvent>(OnInteractUsing);
- SubscribeLocalEvent<InsertingMaterialStorageComponent, EntityUnpausedEvent>(OnUnpaused);
}
public override void Update(float frameTime)
_appearance.SetData(uid, MaterialStorageVisuals.Inserting, false);
}
- private void OnUnpaused(EntityUid uid, InsertingMaterialStorageComponent component, ref EntityUnpausedEvent args)
- {
- component.EndTime += args.PausedTime;
- }
-
/// <summary>
/// Gets the volume of a specified material contained in this storage.
/// </summary>
/// This is used for defibrillators; a machine that shocks a dead
/// person back into the world of the living.
/// </summary>
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentPause]
public sealed partial class DefibrillatorComponent : Component
{
/// <summary>
/// The time at which the zap cooldown will be completed
/// </summary>
[DataField("nextZapTime", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan? NextZapTime;
/// <summary>
/// As an implementation detail, dashing with katana is a suit action which isn't ideal.
/// </summary>
[RegisterComponent, NetworkedComponent, Access(typeof(SharedNinjaSuitSystem)), AutoGenerateComponentState]
+[AutoGenerateComponentPause]
public sealed partial class NinjaSuitComponent : Component
{
/// <summary>
/// Time at which we will be able to use our abilities again
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan DisableCooldown;
/// <summary>
base.Initialize();
SubscribeLocalEvent<NinjaSuitComponent, MapInitEvent>(OnMapInit);
- SubscribeLocalEvent<NinjaSuitComponent, EntityUnpausedEvent>(OnEntityUnpaused);
SubscribeLocalEvent<NinjaSuitComponent, GotEquippedEvent>(OnEquipped);
SubscribeLocalEvent<NinjaSuitComponent, GetItemActionsEvent>(OnGetItemActions);
Dirty(uid, component);
}
- private void OnEntityUnpaused(Entity<NinjaSuitComponent> ent, ref EntityUnpausedEvent args)
- {
- ent.Comp.DisableCooldown += args.PausedTime;
- }
-
/// <summary>
/// Call the shared and serverside code for when a ninja equips the suit.
/// </summary>
/// This is used for marking entities as infants.
/// Infants have half the size, visually, and cannot breed.
/// </summary>
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentPause]
public sealed partial class InfantComponent : Component
{
/// <summary>
/// When the entity will stop being an infant.
/// </summary>
[DataField("infantEndTime", customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan InfantEndTime;
/// <summary>
/// given they are next to a particular entity that fulfills a whitelist,
/// can create several "child" entities.
/// </summary>
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
public sealed partial class ReproductiveComponent : Component
{
/// <summary>
/// The next time when breeding will be attempted.
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan NextBreedAttempt;
/// <summary>
namespace Content.Shared.Nutrition.Components;
[RegisterComponent, NetworkedComponent, Access(typeof(HungerSystem))]
-[AutoGenerateComponentState]
+[AutoGenerateComponentState, AutoGenerateComponentPause]
public sealed partial class HungerComponent : Component
{
/// <summary>
/// </summary>
[DataField("nextUpdateTime", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
[AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan NextUpdateTime;
/// <summary>
namespace Content.Shared.Nutrition.Components;
[RegisterComponent, NetworkedComponent, Access(typeof(ThirstSystem))]
-[AutoGenerateComponentState]
+[AutoGenerateComponentState, AutoGenerateComponentPause]
public sealed partial class ThirstComponent : Component
{
// Base stuff
/// </summary>
[DataField("nextUpdateTime", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
[AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan NextUpdateTime;
/// <summary>
{
base.Initialize();
- SubscribeLocalEvent<HungerComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<HungerComponent, MapInitEvent>(OnMapInit);
SubscribeLocalEvent<HungerComponent, ComponentShutdown>(OnShutdown);
SubscribeLocalEvent<HungerComponent, RefreshMovementSpeedModifiersEvent>(OnRefreshMovespeed);
SubscribeLocalEvent<HungerComponent, RejuvenateEvent>(OnRejuvenate);
}
- private void OnUnpaused(EntityUid uid, HungerComponent component, ref EntityUnpausedEvent args)
- {
- component.NextUpdateTime += args.PausedTime;
- }
-
private void OnMapInit(EntityUid uid, HungerComponent component, MapInitEvent args)
{
var amount = _random.Next(
SubscribeLocalEvent<ThirstComponent, RefreshMovementSpeedModifiersEvent>(OnRefreshMovespeed);
SubscribeLocalEvent<ThirstComponent, MapInitEvent>(OnMapInit);
SubscribeLocalEvent<ThirstComponent, RejuvenateEvent>(OnRejuvenate);
- SubscribeLocalEvent<ThirstComponent, EntityUnpausedEvent>(OnUnpaused);
}
private void OnMapInit(EntityUid uid, ThirstComponent component, MapInitEvent args)
UpdateEffects(uid, thirst);
}
}
-
- private void OnUnpaused(EntityUid uid, ThirstComponent component, ref EntityUnpausedEvent args)
- {
- component.NextUpdateTime += args.PausedTime;
- }
}
/// <summary>
/// Indicates that the entity's ActivatableUI requires power or else it closes.
/// </summary>
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
public sealed partial class PowerCellDrawComponent : Component
{
#region Prediction
/// When the next automatic power draw will occur
/// </summary>
[DataField("nextUpdate", customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextUpdateTime;
}
/// <summary>
/// Added per station to store data on their available salvage missions.
/// </summary>
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
public sealed partial class SalvageExpeditionDataComponent : Component
{
/// <summary>
/// Nexy time salvage missions are offered.
/// </summary>
[ViewVariables(VVAccess.ReadWrite), DataField("nextOffer", customTypeSerializer:typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextOffer;
[ViewVariables]
/// <summary>
/// Marks an entity as pending being fultoned.
/// </summary>
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(true)]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(true), AutoGenerateComponentPause]
public sealed partial class FultonedComponent : Component
{
/// <summary>
/// When the fulton is travelling to the beacon.
/// </summary>
[ViewVariables(VVAccess.ReadWrite), DataField("nextFulton", customTypeSerializer:typeof(TimeOffsetSerializer)), AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan NextFulton;
[ViewVariables(VVAccess.ReadWrite), DataField("sound"), AutoNetworkedField]
SubscribeLocalEvent<FultonedDoAfterEvent>(OnFultonDoAfter);
- SubscribeLocalEvent<FultonedComponent, EntityUnpausedEvent>(OnFultonUnpaused);
SubscribeLocalEvent<FultonedComponent, GetVerbsEvent<InteractionVerb>>(OnFultonedGetVerbs);
SubscribeLocalEvent<FultonedComponent, ExaminedEvent>(OnFultonedExamine);
SubscribeLocalEvent<FultonedComponent, EntGotInsertedIntoContainerMessage>(OnFultonContainerInserted);
Audio.PlayPredicted(fulton.FultonSound, args.Target.Value, args.User);
}
- private void OnFultonUnpaused(EntityUid uid, FultonedComponent component, ref EntityUnpausedEvent args)
- {
- component.NextFulton += args.PausedTime;
- }
-
private void OnFultonInteract(EntityUid uid, FultonComponent component, AfterInteractEvent args)
{
if (args.Target == null || args.Handled || !args.CanReach)
/// Primarily managed by <see cref="SharedEventHorizonSystem"/> and its server/client versions.
/// </summary>
[Access(friends: typeof(SharedEventHorizonSystem))]
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentPause]
public sealed partial class EventHorizonComponent : Component
{
/// <summary>
/// The next time at which this consumed everything it overlapped with.
/// </summary>
[ViewVariables(VVAccess.ReadOnly), DataField("nextConsumeWaveTime", customTypeSerializer:typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextConsumeWaveTime;
#endregion Update Timing
namespace Content.Shared.Sound.Components;
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentPause]
public sealed partial class EmitSoundOnCollideComponent : BaseEmitSoundComponent
{
public static readonly TimeSpan CollideCooldown = TimeSpan.FromSeconds(0.2);
/// To avoid sound spam add a cooldown to it.
/// </summary>
[ViewVariables(VVAccess.ReadWrite), DataField("nextSound", customTypeSerializer: typeof(TimeOffsetSerializer))]
+ [AutoPausedField]
public TimeSpan NextSound;
}
SubscribeLocalEvent<EmitSoundOnPickupComponent, GotEquippedHandEvent>(OnEmitSoundOnPickup);
SubscribeLocalEvent<EmitSoundOnDropComponent, DroppedEvent>(OnEmitSoundOnDrop);
- SubscribeLocalEvent<EmitSoundOnCollideComponent, EntityUnpausedEvent>(OnEmitSoundUnpaused);
SubscribeLocalEvent<EmitSoundOnCollideComponent, StartCollideEvent>(OnEmitSoundOnCollide);
}
}
}
- private void OnEmitSoundUnpaused(EntityUid uid, EmitSoundOnCollideComponent component, ref EntityUnpausedEvent args)
- {
- component.NextSound += args.PausedTime;
- }
-
private void OnEmitSoundOnCollide(EntityUid uid, EmitSoundOnCollideComponent component, ref StartCollideEvent args)
{
if (!args.OurFixture.Hard ||
/// <summary>
/// Applies an ongoing pickup area around the attached entity.
/// </summary>
-[RegisterComponent]
+[RegisterComponent, AutoGenerateComponentPause]
public sealed partial class MagnetPickupComponent : Component
{
[ViewVariables(VVAccess.ReadWrite), DataField("nextScan")]
+ [AutoPausedField]
public TimeSpan NextScan = TimeSpan.Zero;
/// <summary>
base.Initialize();
_physicsQuery = GetEntityQuery<PhysicsComponent>();
SubscribeLocalEvent<MagnetPickupComponent, MapInitEvent>(OnMagnetMapInit);
- SubscribeLocalEvent<MagnetPickupComponent, EntityUnpausedEvent>(OnMagnetUnpaused);
- }
-
- private void OnMagnetUnpaused(EntityUid uid, MagnetPickupComponent component, ref EntityUnpausedEvent args)
- {
- component.NextScan += args.PausedTime;
}
private void OnMagnetMapInit(EntityUid uid, MagnetPickupComponent component, MapInitEvent args)
/// This is used for an entity that, when linked to another valid entity, allows the two to swap positions,
/// additionally swapping the positions of the parents.
/// </summary>
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
[Access(typeof(SwapTeleporterSystem))]
public sealed partial class SwapTeleporterComponent : Component
{
/// The time at which <see cref="Cooldown"/> ends and teleportation can occur again.
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan NextTeleportUse;
/// <summary>
SubscribeLocalEvent<SwapTeleporterComponent, ActivateInWorldEvent>(OnActivateInWorld);
SubscribeLocalEvent<SwapTeleporterComponent, ExaminedEvent>(OnExamined);
- SubscribeLocalEvent<SwapTeleporterComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<SwapTeleporterComponent, ComponentShutdown>(OnShutdown);
_xformQuery = GetEntityQuery<TransformComponent>();
}
}
- private void OnUnpaused(Entity<SwapTeleporterComponent> ent, ref EntityUnpausedEvent args)
- {
- ent.Comp.NextTeleportUse += args.PausedTime;
- }
-
private void OnShutdown(Entity<SwapTeleporterComponent> ent, ref ComponentShutdown args)
{
DestroyLink((ent, ent), null);
namespace Content.Shared.Throwing
{
- [RegisterComponent, NetworkedComponent, AutoGenerateComponentState(true)]
+ [RegisterComponent, NetworkedComponent, AutoGenerateComponentState(true), AutoGenerateComponentPause]
public sealed partial class ThrownItemComponent : Component
{
/// <summary>
/// Compared to <see cref="IGameTiming.CurTime"/> to land this entity, if any.
/// </summary>
[DataField, ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan? LandTime;
/// <summary>
SubscribeLocalEvent<ThrownItemComponent, StartCollideEvent>(HandleCollision);
SubscribeLocalEvent<ThrownItemComponent, PreventCollideEvent>(PreventCollision);
SubscribeLocalEvent<ThrownItemComponent, ThrownEvent>(ThrowItem);
- SubscribeLocalEvent<ThrownItemComponent, EntityUnpausedEvent>(OnThrownUnpaused);
SubscribeLocalEvent<PullStartedMessage>(HandlePullStarted);
}
_fixtures.TryCreateFixture(uid, shape, ThrowingFixture, hard: false, collisionMask: (int) CollisionGroup.ThrownItem, manager: fixturesComponent, body: body);
}
- private void OnThrownUnpaused(EntityUid uid, ThrownItemComponent component, ref EntityUnpausedEvent args)
- {
- if (component.LandTime != null)
- {
- component.LandTime = component.LandTime.Value + args.PausedTime;
- }
- }
-
private void HandleCollision(EntityUid uid, ThrownItemComponent component, ref StartCollideEvent args)
{
if (!args.OtherFixture.Hard)
/// Currently it only supports a single delay per entity, this means that for things that have two delay interactions they will share one timer, so this can cause issues. For example, the bible has a delay when opening the storage UI and when applying it's interaction effect, and they share the same delay.
/// </remarks>
[RegisterComponent]
-[NetworkedComponent, AutoGenerateComponentState]
+[NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
[Access(typeof(UseDelaySystem))]
public sealed partial class UseDelayComponent : Component
{
/// When the delay starts.
/// </summary>
[ViewVariables(VVAccess.ReadWrite), DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan DelayStartTime;
/// <summary>
/// When the delay ends.
/// </summary>
[ViewVariables(VVAccess.ReadWrite), DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan DelayEndTime;
/// <summary>
[Dependency] private readonly IGameTiming _gameTiming = default!;
[Dependency] private readonly MetaDataSystem _metadata = default!;
- public override void Initialize()
- {
- SubscribeLocalEvent<UseDelayComponent, EntityUnpausedEvent>(OnUnpaused);
- }
-
- private void OnUnpaused(Entity<UseDelayComponent> ent, ref EntityUnpausedEvent args)
- {
- // We got unpaused, resume the delay
- ent.Comp.DelayStartTime += args.PausedTime;
- ent.Comp.DelayEndTime += args.PausedTime;
- Dirty(ent);
- }
-
public void SetDelay(Entity<UseDelayComponent> ent, TimeSpan delay)
{
if (ent.Comp.Delay == delay)
/// Marks an entity to take additional damage
/// </summary>
[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, Access(typeof(SharedDamageMarkerSystem))]
+[AutoGenerateComponentPause]
public sealed partial class DamageMarkerComponent : Component
{
/// <summary>
public EntityUid Marker;
[ViewVariables(VVAccess.ReadWrite), DataField("endTime", customTypeSerializer:typeof(TimeOffsetSerializer)), AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan EndTime;
}
{
base.Initialize();
SubscribeLocalEvent<DamageMarkerOnCollideComponent, StartCollideEvent>(OnMarkerCollide);
- SubscribeLocalEvent<DamageMarkerComponent, EntityUnpausedEvent>(OnMarkerUnpaused);
SubscribeLocalEvent<DamageMarkerComponent, AttackedEvent>(OnMarkerAttacked);
}
}
}
- private void OnMarkerUnpaused(EntityUid uid, DamageMarkerComponent component, ref EntityUnpausedEvent args)
- {
- component.EndTime += args.PausedTime;
- }
-
private void OnMarkerCollide(EntityUid uid, DamageMarkerOnCollideComponent component, ref StartCollideEvent args)
{
if (!args.OtherFixture.Hard ||
/// <summary>
/// When given to a mob lets them do unarmed attacks, or when given to an item lets someone wield it to do attacks.
/// </summary>
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
public sealed partial class MeleeWeaponComponent : Component
{
// TODO: This is becoming bloated as shit.
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoNetworkedField]
[ViewVariables(VVAccess.ReadWrite)]
+ [AutoPausedField]
public TimeSpan NextAttack;
/// <summary>
{
base.Initialize();
- SubscribeLocalEvent<MeleeWeaponComponent, EntityUnpausedEvent>(OnMeleeUnpaused);
SubscribeLocalEvent<MeleeWeaponComponent, HandSelectedEvent>(OnMeleeSelected);
SubscribeLocalEvent<MeleeWeaponComponent, ShotAttemptedEvent>(OnMeleeShotAttempted);
SubscribeLocalEvent<MeleeWeaponComponent, GunShotEvent>(OnMeleeShot);
}
}
- private void OnMeleeUnpaused(EntityUid uid, MeleeWeaponComponent component, ref EntityUnpausedEvent args)
- {
- component.NextAttack += args.PausedTime;
- }
-
private void OnMeleeSelected(EntityUid uid, MeleeWeaponComponent component, HandSelectedEvent args)
{
var attackRate = GetAttackRate(uid, args.User, component);
namespace Content.Shared.Weapons.Ranged.Components;
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
[Access(typeof(SharedGunSystem))]
public sealed partial class GunComponent : Component
{
/// </summary>
[DataField(customTypeSerializer:typeof(TimeOffsetSerializer))]
[AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan NextFire = TimeSpan.Zero;
/// <summary>
/// <summary>
/// Responsible for handling recharging a basic entity ammo provider over time.
/// </summary>
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
public sealed partial class RechargeBasicEntityAmmoComponent : Component
{
[ViewVariables(VVAccess.ReadWrite)]
[ViewVariables(VVAccess.ReadWrite),
DataField("nextCharge", customTypeSerializer:typeof(TimeOffsetSerializer)),
AutoNetworkedField]
+ [AutoPausedField]
public TimeSpan? NextCharge;
}
{
base.Initialize();
- SubscribeLocalEvent<RechargeBasicEntityAmmoComponent, EntityUnpausedEvent>(OnUnpaused);
SubscribeLocalEvent<RechargeBasicEntityAmmoComponent, MapInitEvent>(OnInit);
SubscribeLocalEvent<RechargeBasicEntityAmmoComponent, ExaminedEvent>(OnExamined);
}
- private void OnUnpaused(EntityUid uid, RechargeBasicEntityAmmoComponent component, ref EntityUnpausedEvent args)
- {
- if (component.NextCharge == null)
- return;
-
- component.NextCharge = component.NextCharge.Value + args.PausedTime;
- }
-
public override void Update(float frameTime)
{
base.Update(frameTime);
SubscribeLocalEvent<GunComponent, ExaminedEvent>(OnExamine);
SubscribeLocalEvent<GunComponent, CycleModeEvent>(OnCycleMode);
SubscribeLocalEvent<GunComponent, HandSelectedEvent>(OnGunSelected);
- SubscribeLocalEvent<GunComponent, EntityUnpausedEvent>(OnGunUnpaused);
SubscribeLocalEvent<GunComponent, MapInitEvent>(OnMapInit);
}
}
}
- private void OnGunUnpaused(EntityUid uid, GunComponent component, ref EntityUnpausedEvent args)
- {
- component.NextFire += args.PausedTime;
- }
-
private void OnShootRequest(RequestShootEvent msg, EntitySessionEventArgs args)
{
var user = args.SenderSession.AttachedEntity;
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Robust.Analyzers.Tests", "RobustToolbox\Robust.Analyzers.Tests\Robust.Analyzers.Tests.csproj", "{83F510FE-9B50-4D96-AFAB-CC13998D6AFE}"
EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Roslyn", "Roslyn", "{7844DA69-B0F0-49FB-A05E-ECA37372277A}"
+ ProjectSection(SolutionItems) = preProject
+ RobustToolbox\Robust.Roslyn.Shared\Robust.Roslyn.Shared.props = RobustToolbox\Robust.Roslyn.Shared\Robust.Roslyn.Shared.props
+ EndProjectSection
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
{41B450C0-A361-4CD7-8121-7072B8995CFC} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
{7B9472D3-79D4-48D1-9B22-BCDE518FE842} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
{1FAE651D-29D8-437A-9864-47CE0D180016} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
- {3CFEB7DB-12C6-46F3-89FC-1450F3016FFA} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
{8922428F-17C3-47A7-BFE9-570DEB2464DA} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
{16F7DE32-0186-44B9-9345-0C20D1BF2422} = {AFF53804-115F-4E67-B81F-26265EA27880}
{AFF53804-115F-4E67-B81F-26265EA27880} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
{23F09C45-950E-4DB7-A465-E937450FF008} = {AFF53804-115F-4E67-B81F-26265EA27880}
{440426C1-8DCA-43F6-967F-94439B8DAF47} = {AFF53804-115F-4E67-B81F-26265EA27880}
- {88B0FC0F-7209-40E2-AF16-EB90AF727C5B} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
{A3C5B00A-D232-4A01-B82E-B0E58BFD5C12} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
{8A21C7CA-2EB8-40E5-8043-33582C06D139} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
{952AAF2A-DF63-4A7D-8094-3453893EBA80} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
{A965CB3B-FD31-44AF-8872-85ABA436098D} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
- {07CA34A1-1D37-4771-A2E3-495A1044AE0B} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
- {6FBF108E-5CB5-47DE-8D7E-B496ABA9E3E2} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
- {83F510FE-9B50-4D96-AFAB-CC13998D6AFE} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
+ {7844DA69-B0F0-49FB-A05E-ECA37372277A} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
+ {3CFEB7DB-12C6-46F3-89FC-1450F3016FFA} = {7844DA69-B0F0-49FB-A05E-ECA37372277A}
+ {6FBF108E-5CB5-47DE-8D7E-B496ABA9E3E2} = {7844DA69-B0F0-49FB-A05E-ECA37372277A}
+ {07CA34A1-1D37-4771-A2E3-495A1044AE0B} = {7844DA69-B0F0-49FB-A05E-ECA37372277A}
+ {88B0FC0F-7209-40E2-AF16-EB90AF727C5B} = {7844DA69-B0F0-49FB-A05E-ECA37372277A}
+ {83F510FE-9B50-4D96-AFAB-CC13998D6AFE} = {7844DA69-B0F0-49FB-A05E-ECA37372277A}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {AA37ED9F-F8D6-468E-A101-658AD605B09A}
projects / space-station-14.git / commitdiff