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

Reduce Triggers Boilerplate. (#41086)

Browse Source 
* Push 1

* cleanup + master merge

* launchontrigger

* A crumb of cleanup

---------

Co-authored-by: Princess Cheeseballs <66055347+Pronana@users.noreply.github.com>
This commit is contained in:
Princess Cheeseballs
2025-10-24 17:00:55 -07:00
committed by GitHub
parent 891f5a8f6b
commit c01ec294d0
38 changed files with 223 additions and 513 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Content.Shared/Trigger/Components/Effects/LaunchOnTriggerComponent.cs
View File

@@ -9,6 +9,9 @@ namespace Content.Shared.Trigger.Components.Effects;
[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
public sealed partial class LaunchOnTriggerComponent : BaseXOnTriggerComponent
{
/// <summary>
/// A linear impulse applied to the target, measured in kg * m / s
/// </summary>
[DataField, AutoNetworkedField]
public float Speed = 10.0f;
public float Impulse = 10.0f;
}

41
Content.Shared/Trigger/SharedTriggerSystems.cs Normal file
View File

@@ -0,0 +1,41 @@
using Content.Shared.Trigger.Components.Effects;
using Content.Shared.Trigger.Systems;
namespace Content.Shared.Trigger;
/// <summary>
/// This is a base Trigger system which handles all the boilerplate for triggers automagically!
/// </summary>
public abstract class TriggerOnXSystem : EntitySystem
{
[Dependency] protected readonly TriggerSystem Trigger = default!;
}
/// <summary>
/// This is a base Trigger system which handles all the boilerplate for triggers automagically!
/// </summary>
public abstract class XOnTriggerSystem<T> : EntitySystem where T : BaseXOnTriggerComponent
{
/// <inheritdoc/>
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<T, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<T> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target is not { } uid)
return;
OnTrigger(ent, uid, ref args);
}
protected abstract void OnTrigger(Entity<T> ent, EntityUid target, ref TriggerEvent args);
}

55
Content.Shared/Trigger/Systems/ComponentsOnTriggerSystem.cs
View File

@@ -2,71 +2,44 @@ using Content.Shared.Trigger.Components.Effects;
namespace Content.Shared.Trigger.Systems;
public sealed partial class ComponentsOnTriggerSystem : EntitySystem
public sealed partial class AddComponentsOnTriggerSystem : XOnTriggerSystem<AddComponentsOnTriggerComponent>
{
public override void Initialize()
protected override void OnTrigger(Entity<AddComponentsOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<AddComponentsOnTriggerComponent, TriggerEvent>(HandleAddTrigger);
SubscribeLocalEvent<RemoveComponentsOnTriggerComponent, TriggerEvent>(HandleRemoveTrigger);
SubscribeLocalEvent<ToggleComponentsOnTriggerComponent, TriggerEvent>(HandleToggleTrigger);
}
private void HandleAddTrigger(Entity<AddComponentsOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
if (ent.Comp.TriggerOnce && ent.Comp.Triggered)
return;
EntityManager.AddComponents(target.Value, ent.Comp.Components, ent.Comp.RemoveExisting);
EntityManager.AddComponents(target, ent.Comp.Components, ent.Comp.RemoveExisting);
ent.Comp.Triggered = true;
Dirty(ent);
args.Handled = true;
}
}
private void HandleRemoveTrigger(Entity<RemoveComponentsOnTriggerComponent> ent, ref TriggerEvent args)
public sealed partial class RemoveComponentsOnTriggerSystem : XOnTriggerSystem<RemoveComponentsOnTriggerComponent>
{
protected override void OnTrigger(Entity<RemoveComponentsOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
if (ent.Comp.TriggerOnce && ent.Comp.Triggered)
return;
EntityManager.RemoveComponents(target.Value, ent.Comp.Components);
EntityManager.RemoveComponents(target, ent.Comp.Components);
ent.Comp.Triggered = true;
Dirty(ent);
args.Handled = true;
}
}
private void HandleToggleTrigger(Entity<ToggleComponentsOnTriggerComponent> ent, ref TriggerEvent args)
public sealed partial class ToggleComponentsOnTriggerSystem : XOnTriggerSystem<ToggleComponentsOnTriggerComponent>
{
protected override void OnTrigger(Entity<ToggleComponentsOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
if (!ent.Comp.ComponentsAdded)
EntityManager.AddComponents(target.Value, ent.Comp.Components, ent.Comp.RemoveExisting);
EntityManager.AddComponents(target, ent.Comp.Components, ent.Comp.RemoveExisting);
else
EntityManager.RemoveComponents(target.Value, ent.Comp.Components);
EntityManager.RemoveComponents(target, ent.Comp.Components);
ent.Comp.ComponentsAdded = !ent.Comp.ComponentsAdded;
Dirty(ent);

21
Content.Shared/Trigger/Systems/DamageOnTriggerSystem.cs
View File

@@ -3,29 +3,14 @@ using Content.Shared.Trigger.Components.Effects;
namespace Content.Shared.Trigger.Systems;
public sealed class DamageOnTriggerSystem : EntitySystem
public sealed class DamageOnTriggerSystem : XOnTriggerSystem<DamageOnTriggerComponent>
{
[Dependency] private readonly DamageableSystem _damageableSystem = default!;
public override void Initialize()
protected override void OnTrigger(Entity<DamageOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<DamageOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<DamageOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
var damage = new DamageSpecifier(ent.Comp.Damage);
var ev = new BeforeDamageOnTriggerEvent(damage, target.Value);
var ev = new BeforeDamageOnTriggerEvent(damage, target);
RaiseLocalEvent(ent.Owner, ref ev);
args.Handled |= _damageableSystem.TryChangeDamage(target, ev.Damage, ent.Comp.IgnoreResistances, origin: ent.Owner) is not null;

37
Content.Shared/Trigger/Systems/DnaScrambleOnTriggerSystem.cs
View File

@@ -9,7 +9,7 @@ using Robust.Shared.Network;
namespace Content.Shared.Trigger.Systems;
public sealed class DnaScrambleOnTriggerSystem : EntitySystem
public sealed class DnaScrambleOnTriggerSystem : XOnTriggerSystem<DnaScrambleOnTriggerComponent>
{
[Dependency] private readonly MetaDataSystem _metaData = default!;
[Dependency] private readonly SharedHumanoidAppearanceSystem _humanoidAppearance = default!;
@@ -18,23 +18,8 @@ public sealed class DnaScrambleOnTriggerSystem : EntitySystem
[Dependency] private readonly SharedPopupSystem _popup = default!;
[Dependency] private readonly INetManager _net = default!;
public override void Initialize()
protected override void OnTrigger(Entity<DnaScrambleOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<DnaScrambleOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<DnaScrambleOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
if (!TryComp<HumanoidAppearanceComponent>(target, out var humanoid))
return;
@@ -46,21 +31,21 @@ public sealed class DnaScrambleOnTriggerSystem : EntitySystem
return;
var newProfile = HumanoidCharacterProfile.RandomWithSpecies(humanoid.Species);
_humanoidAppearance.LoadProfile(target.Value, newProfile, humanoid);
_metaData.SetEntityName(target.Value, newProfile.Name, raiseEvents: false); // raising events would update ID card, station record, etc.
_humanoidAppearance.LoadProfile(target, newProfile, humanoid);
_metaData.SetEntityName(target, newProfile.Name, raiseEvents: false); // raising events would update ID card, station record, etc.
// If the entity has the respective components, then scramble the dna and fingerprint strings.
_forensics.RandomizeDNA(target.Value);
_forensics.RandomizeFingerprint(target.Value);
_forensics.RandomizeDNA(target);
_forensics.RandomizeFingerprint(target);
RemComp<DetailExaminableComponent>(target.Value); // remove MRP+ custom description if one exists
_identity.QueueIdentityUpdate(target.Value); // manually queue identity update since we don't raise the event
RemComp<DetailExaminableComponent>(target); // remove MRP+ custom description if one exists
_identity.QueueIdentityUpdate(target); // manually queue identity update since we don't raise the event
// Can't use PopupClient or PopupPredicted because the trigger might be unpredicted.
_popup.PopupEntity(Loc.GetString("scramble-on-trigger-popup"), target.Value, target.Value);
_popup.PopupEntity(Loc.GetString("scramble-on-trigger-popup"), target, target);
var ev = new DnaScrambledEvent(target.Value);
RaiseLocalEvent(target.Value, ref ev, true);
var ev = new DnaScrambledEvent(target);
RaiseLocalEvent(target, ref ev, true);
}
}

21
Content.Shared/Trigger/Systems/EmitSoundOnTriggerSystem.cs
View File

@@ -4,29 +4,14 @@ using Robust.Shared.Network;
namespace Content.Shared.Trigger.Systems;
public sealed class EmitSoundOnTriggerSystem : EntitySystem
public sealed class EmitSoundOnTriggerSystem : XOnTriggerSystem<EmitSoundOnTriggerComponent>
{
[Dependency] private readonly INetManager _netMan = default!;
[Dependency] private readonly SharedAudioSystem _audio = default!;
public override void Initialize()
protected override void OnTrigger(Entity<EmitSoundOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<EmitSoundOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<EmitSoundOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
args.Handled |= TryEmitSound(ent, target.Value, args.User);
args.Handled |= TryEmitSound(ent, target, args.User);
}
private bool TryEmitSound(Entity<EmitSoundOnTriggerComponent> ent, EntityUid target, EntityUid? user = null)

21
Content.Shared/Trigger/Systems/EmpOnTriggerSystem.cs
View File

@@ -3,28 +3,13 @@ using Content.Shared.Trigger.Components.Effects;
namespace Content.Shared.Trigger.Systems;
public sealed class EmpOnTriggerSystem : EntitySystem
public sealed class EmpOnTriggerSystem : XOnTriggerSystem<EmpOnTriggerComponent>
{
[Dependency] private readonly SharedEmpSystem _emp = default!;
public override void Initialize()
protected override void OnTrigger(Entity<EmpOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<EmpOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<EmpOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
_emp.EmpPulse(Transform(target.Value).Coordinates, ent.Comp.Range, ent.Comp.EnergyConsumption, ent.Comp.DisableDuration, args.User);
_emp.EmpPulse(Transform(target).Coordinates, ent.Comp.Range, ent.Comp.EnergyConsumption, ent.Comp.DisableDuration, args.User);
args.Handled = true;
}
}

21
Content.Shared/Trigger/Systems/EntityEffectOnTriggerSystem.cs
View File

@@ -3,28 +3,13 @@ using Content.Shared.Trigger.Components.Effects;
namespace Content.Shared.Trigger.Systems;
public sealed class EntityEffectOnTriggerSystem : EntitySystem
public sealed class EntityEffectOnTriggerSystem : XOnTriggerSystem<EntityEffectOnTriggerComponent>
{
[Dependency] private readonly SharedEntityEffectsSystem _effects = default!;
public override void Initialize()
protected override void OnTrigger(Entity<EntityEffectOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<EntityEffectOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<EntityEffectOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
_effects.ApplyEffects(target.Value, ent.Comp.Effects, ent.Comp.Scale);
_effects.ApplyEffects(target, ent.Comp.Effects, ent.Comp.Scale);
args.Handled = true;
}
}

52
Content.Shared/Trigger/Systems/ExplodeOnTriggerSystem.cs
View File

@@ -3,51 +3,31 @@ using Content.Shared.Trigger.Components.Effects;
namespace Content.Shared.Trigger.Systems;
public sealed class ExplodeOnTriggerSystem : EntitySystem
public sealed class ExplodeOnTriggerSystem : XOnTriggerSystem<ExplodeOnTriggerComponent>
{
[Dependency] private readonly SharedExplosionSystem _explosion = default!;
public override void Initialize()
protected override void OnTrigger(Entity<ExplodeOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<ExplodeOnTriggerComponent, TriggerEvent>(OnExplodeTrigger);
SubscribeLocalEvent<ExplosionOnTriggerComponent, TriggerEvent>(OnQueueExplosionTrigger);
}
private void OnExplodeTrigger(Entity<ExplodeOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
_explosion.TriggerExplosive(target.Value, user: args.User);
_explosion.TriggerExplosive(target, user: args.User);
args.Handled = true;
}
}
private void OnQueueExplosionTrigger(Entity<ExplosionOnTriggerComponent> ent, ref TriggerEvent args)
public sealed class ExplosionOnTriggerSystem : XOnTriggerSystem<ExplosionOnTriggerComponent>
{
var (uid, comp) = ent;
if (args.Key != null && !comp.KeysIn.Contains(args.Key))
return;
[Dependency] private readonly SharedExplosionSystem _explosion = default!;
var target = comp.TargetUser ? args.User : uid;
if (target == null)
return;
_explosion.QueueExplosion(target.Value,
comp.ExplosionType,
comp.TotalIntensity,
comp.IntensitySlope,
comp.MaxTileIntensity,
comp.TileBreakScale,
comp.MaxTileBreak,
comp.CanCreateVacuum,
protected override void OnTrigger(Entity<ExplosionOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
_explosion.QueueExplosion(target,
ent.Comp.ExplosionType,
ent.Comp.TotalIntensity,
ent.Comp.IntensitySlope,
ent.Comp.MaxTileIntensity,
ent.Comp.TileBreakScale,
ent.Comp.MaxTileBreak,
ent.Comp.CanCreateVacuum,
args.User);
args.Handled = true;
}

21
Content.Shared/Trigger/Systems/FlashOnTriggerSystem.cs
View File

@@ -3,28 +3,13 @@ using Content.Shared.Trigger.Components.Effects;
namespace Content.Shared.Trigger.Systems;
public sealed class FlashOnTriggerSystem : EntitySystem
public sealed class FlashOnTriggerSystem : XOnTriggerSystem<FlashOnTriggerComponent>
{
[Dependency] private readonly SharedFlashSystem _flash = default!;
public override void Initialize()
protected override void OnTrigger(Entity<FlashOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<FlashOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<FlashOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
_flash.FlashArea(target.Value, args.User, ent.Comp.Range, ent.Comp.Duration, probability: ent.Comp.Probability);
_flash.FlashArea(target, args.User, ent.Comp.Range, ent.Comp.Duration, probability: ent.Comp.Probability);
args.Handled = true;
}
}

24
Content.Shared/Trigger/Systems/GibOnTriggerSystem.cs
View File

@@ -4,37 +4,23 @@ using Content.Shared.Trigger.Components.Effects;
namespace Content.Shared.Trigger.Systems;
public sealed class GibOnTriggerSystem : EntitySystem
public sealed class GibOnTriggerSystem : XOnTriggerSystem<GibOnTriggerComponent>
{
[Dependency] private readonly SharedBodySystem _body = default!;
[Dependency] private readonly InventorySystem _inventory = default!;
public override void Initialize()
protected override void OnTrigger(Entity<GibOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<GibOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<GibOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
if (ent.Comp.DeleteItems)
{
var items = _inventory.GetHandOrInventoryEntities(target.Value);
var items = _inventory.GetHandOrInventoryEntities(target);
foreach (var item in items)
{
PredictedQueueDel(item);
}
}
_body.GibBody(target.Value, true);
_body.GibBody(target, true);
args.Handled = true;
}
}

27
Content.Shared/Trigger/Systems/LaunchOnTriggerSystem.cs
View File

@@ -5,43 +5,26 @@ using Robust.Shared.Physics.Systems;
namespace Content.Shared.Trigger.Systems;
public sealed class LaunchOnTriggerSystem : EntitySystem
public sealed class LaunchOnTriggerSystem : XOnTriggerSystem<LaunchOnTriggerComponent>
{
[Dependency] private readonly SharedTransformSystem _transform = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;
public override void Initialize()
protected override void OnTrigger(Entity<LaunchOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<LaunchOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<LaunchOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target is null)
return;
if (!TryComp(target, out PhysicsComponent? phys))
return;
var linearVelocity = _physics.GetMapLinearVelocity(target.Value);
var linearVelocity = _physics.GetMapLinearVelocity(target);
// If the linear velocity is length 0, this means it's not moving. Given we want to move it in some direction...
if (linearVelocity.IsLengthZero())
// An object that isn't moving is launched in the direction its facing, not the direction it's rotated (objects face away from their rotation).
linearVelocity = _transform.GetWorldRotation(target.Value).RotateVec(Vector2.UnitY) * -1;
linearVelocity = _transform.GetWorldRotation(target).RotateVec(Vector2.UnitY) * -1;
// When triggered, take the direction the target is moving in (the normalized vector) and multiply it by the speed.
// Then apply an impulse to the target on the new vector.
// (If the target is moving NE at 10 m/s, this impulses it NE at speed m/s)
_physics.ApplyLinearImpulse(target.Value,
linearVelocity.Normalized() * ent.Comp.Speed,
body: phys);
_physics.ApplyLinearImpulse(target, linearVelocity.Normalized() * ent.Comp.Impulse, body: phys);
args.Handled = true;
}

22
Content.Shared/Trigger/Systems/LockOnTriggerSystem.cs
View File

@@ -3,37 +3,25 @@ using Content.Shared.Trigger.Components.Effects;
namespace Content.Shared.Trigger.Systems;
public sealed class LockOnTriggerSystem : EntitySystem
public sealed class LockOnTriggerSystem : XOnTriggerSystem<LockOnTriggerComponent>
{
[Dependency] private readonly LockSystem _lock = default!;
public override void Initialize()
protected override void OnTrigger(Entity<LockOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<LockOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<LockOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (!TryComp<LockComponent>(target, out var lockComp))
return; // prevent the Resolve in Lock/Unlock/ToggleLock from logging errors in case the user does not have the component
switch (ent.Comp.LockMode)
{
case LockAction.Lock:
_lock.Lock(target.Value, args.User, lockComp);
_lock.Lock(target, args.User, lockComp);
break;
case LockAction.Unlock:
_lock.Unlock(target.Value, args.User, lockComp);
_lock.Unlock(target, args.User, lockComp);
break;
case LockAction.Toggle:
_lock.ToggleLock(target.Value, args.User, lockComp);
_lock.ToggleLock(target, args.User, lockComp);
break;
}
}

36
Content.Shared/Trigger/Systems/PopupOnTriggerSystem.cs
View File

@@ -6,57 +6,49 @@ namespace Content.Shared.Trigger.Systems;
/// <summary>
/// This handles <see cref="PopupOnTriggerComponent"/>
/// </summary>
public sealed class PopupOnTriggerSystem : EntitySystem
public sealed class PopupOnTriggerSystem : XOnTriggerSystem<PopupOnTriggerComponent>
{
[Dependency] private readonly SharedPopupSystem _popup = default!;
/// <inheritdoc/>
public override void Initialize()
protected override void OnTrigger(Entity<PopupOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<PopupOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<PopupOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
// Popups only play for one entity
if (ent.Comp.Quiet)
{
if (ent.Comp.Predicted)
{
_popup.PopupClient(Loc.GetString(ent.Comp.Text),
target.Value,
target,
ent.Comp.UserIsRecipient ? args.User : ent.Owner,
ent.Comp.PopupType);
}
else if (args.User != null)
{
_popup.PopupEntity(Loc.GetString(ent.Comp.OtherText ?? ent.Comp.Text),
target.Value,
target,
args.User.Value,
ent.Comp.PopupType);
}
return;
}
// Popups play for all entities
if (ent.Comp.Predicted)
{
_popup.PopupPredicted(Loc.GetString(ent.Comp.Text),
Loc.GetString(ent.Comp.OtherText ?? ent.Comp.Text),
target.Value,
target,
ent.Comp.UserIsRecipient ? args.User : ent.Owner,
ent.Comp.PopupType);
}
else
{
_popup.PopupEntity(Loc.GetString(ent.Comp.OtherText ?? ent.Comp.Text),
target.Value,
target,
ent.Comp.PopupType);
}
}
}

21
Content.Shared/Trigger/Systems/RejuvenateOnTriggerSystem.cs
View File

@@ -3,28 +3,13 @@ using Content.Shared.Trigger.Components.Effects;
namespace Content.Shared.Trigger.Systems;
public sealed class RejuvenateOnTriggerSystem : EntitySystem
public sealed class RejuvenateOnTriggerSystem : XOnTriggerSystem<RejuvenateOnTriggerComponent>
{
[Dependency] private readonly RejuvenateSystem _rejuvenate = default!;
public override void Initialize()
protected override void OnTrigger(Entity<RejuvenateOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<RejuvenateOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<RejuvenateOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
_rejuvenate.PerformRejuvenate(target.Value);
_rejuvenate.PerformRejuvenate(target);
args.Handled = true;
}
}

22
Content.Shared/Trigger/Systems/RepulseAttractOnTriggerSystem.cs
View File

@@ -1,32 +1,16 @@
using Content.Shared.Trigger;
using Content.Shared.Trigger.Components.Effects;
using Content.Shared.RepulseAttract;
namespace Content.Shared.Trigger.Systems;
public sealed class RepulseAttractOnTriggerSystem : EntitySystem
public sealed class RepulseAttractOnTriggerSystem : XOnTriggerSystem<RepulseAttractOnTriggerComponent>
{
[Dependency] private readonly RepulseAttractSystem _repulse = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
public override void Initialize()
protected override void OnTrigger(Entity<RepulseAttractOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<RepulseAttractOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<RepulseAttractOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
var position = _transform.GetMapCoordinates(target.Value);
var position = _transform.GetMapCoordinates(target);
_repulse.TryRepulseAttract(position, args.User, ent.Comp.Speed, ent.Comp.Range, ent.Comp.Whitelist, ent.Comp.CollisionMask);
args.Handled = true;

20
Content.Shared/Trigger/Systems/ScramOnTriggerSystem.cs
View File

@@ -14,7 +14,7 @@ using Robust.Shared.Random;
namespace Content.Shared.Trigger.Systems;
public sealed class ScramOnTriggerSystem : EntitySystem
public sealed class ScramOnTriggerSystem : XOnTriggerSystem<ScramOnTriggerComponent>
{
[Dependency] private readonly PullingSystem _pulling = default!;
[Dependency] private readonly EntityLookupSystem _lookup = default!;
@@ -31,24 +31,14 @@ public sealed class ScramOnTriggerSystem : EntitySystem
{
base.Initialize();
SubscribeLocalEvent<ScramOnTriggerComponent, TriggerEvent>(OnTrigger);
_physicsQuery = GetEntityQuery<PhysicsComponent>();
}
private void OnTrigger(Entity<ScramOnTriggerComponent> ent, ref TriggerEvent args)
protected override void OnTrigger(Entity<ScramOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
// We need stop the user from being pulled so they don't just get "attached" with whoever is pulling them.
// This can for example happen when the user is cuffed and being pulled.
if (TryComp<PullableComponent>(target, out var pull) && _pulling.IsPulled(target.Value, pull))
if (TryComp<PullableComponent>(target, out var pull) && _pulling.IsPulled(target, pull))
_pulling.TryStopPull(ent, pull);
// Check if the user is pulling anything, and drop it if so.
@@ -61,12 +51,12 @@ public sealed class ScramOnTriggerSystem : EntitySystem
if (_net.IsClient)
return;
var xform = Transform(target.Value);
var xform = Transform(target);
var targetCoords = SelectRandomTileInRange(xform, ent.Comp.TeleportRadius);
if (targetCoords != null)
{
_transform.SetCoordinates(target.Value, targetCoords.Value);
_transform.SetCoordinates(target, targetCoords.Value);
args.Handled = true;
}
}

27
Content.Shared/Trigger/Systems/ShockOnTriggerSystem.cs
View File

@@ -4,41 +4,24 @@ using Robust.Shared.Containers;
namespace Content.Shared.Trigger.Systems;
public sealed class ShockOnTriggerSystem : EntitySystem
public sealed class ShockOnTriggerSystem : XOnTriggerSystem<ShockOnTriggerComponent>
{
[Dependency] private readonly SharedContainerSystem _container = default!;
[Dependency] private readonly SharedElectrocutionSystem _electrocution = default!;
public override void Initialize()
protected override void OnTrigger(Entity<ShockOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<ShockOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<ShockOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
EntityUid? target;
// Override the normal target if we target the container
if (ent.Comp.TargetContainer)
{
// shock whoever is wearing this clothing item
if (!_container.TryGetContainingContainer(ent.Owner, out var container))
return;
target = container.Owner;
}
else
{
target = ent.Comp.TargetUser ? args.User : ent.Owner;
}
if (target == null)
return;
_electrocution.TryDoElectrocution(target.Value, null, ent.Comp.Damage, ent.Comp.Duration, true, ignoreInsulation: true);
_electrocution.TryDoElectrocution(target, null, ent.Comp.Damage, ent.Comp.Duration, true, ignoreInsulation: true);
args.Handled = true;
}
}

22
Content.Shared/Trigger/Systems/SolutionTriggerSystem.cs
View File

@@ -1,31 +1,15 @@
using Content.Shared.Trigger.Components.Effects;
using Robust.Shared.Containers;
using Content.Shared.Chemistry.EntitySystems;
namespace Content.Shared.Trigger.Systems;
public sealed class SolutionTriggerSystem : EntitySystem
public sealed class SolutionTriggerSystem : XOnTriggerSystem<AddSolutionOnTriggerComponent>
{
[Dependency] private readonly SharedSolutionContainerSystem _solutionContainer = default!;
public override void Initialize()
protected override void OnTrigger(Entity<AddSolutionOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<AddSolutionOnTriggerComponent, TriggerEvent>(OnTriggered);
}
private void OnTriggered(Entity<AddSolutionOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
if (!_solutionContainer.TryGetSolution(target.Value, ent.Comp.Solution, out var solutionRef, out _))
if (!_solutionContainer.TryGetSolution(target, ent.Comp.Solution, out var solutionRef, out _))
return;
_solutionContainer.AddSolution(solutionRef.Value, ent.Comp.AddedSolution);

24
Content.Shared/Trigger/Systems/StaminaDamageOnTriggerSystem.cs
View File

@@ -1,34 +1,18 @@
using Content.Shared.Damage;
using Content.Shared.Damage.Systems;
using Content.Shared.Trigger.Components.Effects;
namespace Content.Shared.Trigger.Systems;
public sealed class StaminaDamageOnTriggerSystem : EntitySystem
public sealed class StaminaDamageOnTriggerSystem : XOnTriggerSystem<StaminaDamageOnTriggerComponent>
{
[Dependency] private readonly SharedStaminaSystem _stamina = default!;
public override void Initialize()
protected override void OnTrigger(Entity<StaminaDamageOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<StaminaDamageOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<StaminaDamageOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
var ev = new BeforeStaminaDamageOnTriggerEvent(ent.Comp.Stamina, target.Value);
var ev = new BeforeStaminaDamageOnTriggerEvent(ent.Comp.Stamina, target);
RaiseLocalEvent(ent.Owner, ref ev);
_stamina.TakeStaminaDamage(target.Value, ev.Stamina, source: args.User, with: ent.Owner, ignoreResist: ent.Comp.IgnoreResistances);
_stamina.TakeStaminaDamage(target, ev.Stamina, source: args.User, with: ent.Owner, ignoreResist: ent.Comp.IgnoreResistances);
args.Handled = true;
}

6
Content.Shared/Trigger/Systems/TriggerOnActivateImplantSystem.cs
View File

@@ -3,10 +3,8 @@ using Content.Shared.Trigger.Components.Triggers;
namespace Content.Shared.Trigger.Systems;
public sealed partial class TriggerOnActivateImplantSystem : EntitySystem
public sealed partial class TriggerOnActivateImplantSystem : TriggerOnXSystem
{
[Dependency] private readonly TriggerSystem _trigger = default!;
public override void Initialize()
{
base.Initialize();
@@ -16,7 +14,7 @@ public sealed partial class TriggerOnActivateImplantSystem : EntitySystem
private void OnActivateImplant(Entity<TriggerOnActivateImplantComponent> ent, ref ActivateImplantEvent args)
{
_trigger.Trigger(ent.Owner, args.Performer, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Performer, ent.Comp.KeyOut);
args.Handled = true;
}
}

11
Content.Shared/Trigger/Systems/TriggerOnContainerInteractionSystem.cs
View File

@@ -7,9 +7,8 @@ namespace Content.Shared.Trigger.Systems;
/// <summary>
/// System for creating triggers when entities are inserted into or removed from containers.
/// </summary>
public sealed class TriggerOnContainerInteractionSystem : EntitySystem
public sealed class TriggerOnContainerInteractionSystem : TriggerOnXSystem
{
[Dependency] private readonly TriggerSystem _trigger = default!;
[Dependency] private readonly IGameTiming _timing = default!;
public override void Initialize()
@@ -31,7 +30,7 @@ public sealed class TriggerOnContainerInteractionSystem : EntitySystem
if (ent.Comp.ContainerId != null && ent.Comp.ContainerId != args.Container.ID)
return;
_trigger.Trigger(ent.Owner, args.Entity, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Entity, ent.Comp.KeyOut);
}
private void OnRemovedFromContainer(Entity<TriggerOnRemovedFromContainerComponent> ent, ref EntRemovedFromContainerMessage args)
@@ -42,7 +41,7 @@ public sealed class TriggerOnContainerInteractionSystem : EntitySystem
if (ent.Comp.ContainerId != null && ent.Comp.ContainerId != args.Container.ID)
return;
_trigger.Trigger(ent.Owner, args.Entity, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Entity, ent.Comp.KeyOut);
}
// Used by entities to trigger when they are inserted into or removed from a container
@@ -54,7 +53,7 @@ public sealed class TriggerOnContainerInteractionSystem : EntitySystem
if (ent.Comp.ContainerId != null && ent.Comp.ContainerId != args.Container.ID)
return;
_trigger.Trigger(ent.Owner, args.Container.Owner, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Container.Owner, ent.Comp.KeyOut);
}
private void OnGotRemovedFromContainer(Entity<TriggerOnGotRemovedFromContainerComponent> ent, ref EntGotRemovedFromContainerMessage args)
@@ -65,6 +64,6 @@ public sealed class TriggerOnContainerInteractionSystem : EntitySystem
if (ent.Comp.ContainerId != null && ent.Comp.ContainerId != args.Container.ID)
return;
_trigger.Trigger(ent.Owner, args.Container.Owner, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Container.Owner, ent.Comp.KeyOut);
}
}

6
Content.Shared/Trigger/Systems/TriggerOnEmptyGunshotSystem.cs
View File

@@ -2,10 +2,8 @@ using Content.Shared.Trigger.Components.Triggers;
using Content.Shared.Weapons.Ranged.Events;
namespace Content.Shared.Trigger.Systems;
public sealed partial class TriggerOnEmptyGunshotSystem : EntitySystem
public sealed partial class TriggerOnEmptyGunshotSystem : TriggerOnXSystem
{
[Dependency] private readonly TriggerSystem _trigger = default!;
public override void Initialize()
{
base.Initialize();
@@ -15,6 +13,6 @@ public sealed partial class TriggerOnEmptyGunshotSystem : EntitySystem
private void OnEmptyGunShot(Entity<TriggerOnEmptyGunshotComponent> ent, ref OnEmptyGunShotEvent args)
{
_trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
}
}

11
Content.Shared/Trigger/Systems/TriggerOnEquipmentSystem.cs
View File

@@ -7,9 +7,8 @@ namespace Content.Shared.Trigger.Systems;
/// <summary>
/// System for creating triggers when entities are equipped or unequipped from inventory slots.
/// </summary>
public sealed class TriggerOnEquipmentSystem : EntitySystem
public sealed class TriggerOnEquipmentSystem : TriggerOnXSystem
{
[Dependency] private readonly TriggerSystem _trigger = default!;
[Dependency] private readonly IGameTiming _timing = default!;
public override void Initialize()
@@ -31,7 +30,7 @@ public sealed class TriggerOnEquipmentSystem : EntitySystem
if ((ent.Comp.SlotFlags & args.SlotFlags) == 0)
return;
_trigger.Trigger(ent.Owner, args.Equipment, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Equipment, ent.Comp.KeyOut);
}
private void OnDidUnequip(Entity<TriggerOnDidUnequipComponent> ent, ref DidUnequipEvent args)
@@ -42,7 +41,7 @@ public sealed class TriggerOnEquipmentSystem : EntitySystem
if ((ent.Comp.SlotFlags & args.SlotFlags) == 0)
return;
_trigger.Trigger(ent.Owner, args.Equipment, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Equipment, ent.Comp.KeyOut);
}
// Used by entities when they get equipped or unequipped
@@ -54,7 +53,7 @@ public sealed class TriggerOnEquipmentSystem : EntitySystem
if ((ent.Comp.SlotFlags & args.SlotFlags) == 0)
return;
_trigger.Trigger(ent.Owner, args.Equipee, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Equipee, ent.Comp.KeyOut);
}
private void OnGotUnequipped(Entity<TriggerOnGotUnequippedComponent> ent, ref GotUnequippedEvent args)
@@ -65,6 +64,6 @@ public sealed class TriggerOnEquipmentSystem : EntitySystem
if ((ent.Comp.SlotFlags & args.SlotFlags) == 0)
return;
_trigger.Trigger(ent.Owner, args.Equipee, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Equipee, ent.Comp.KeyOut);
}
}

13
Content.Shared/Trigger/Systems/HandTriggerSystem.cs → Content.Shared/Trigger/Systems/TriggerOnHandSystem.cs
View File

@@ -5,10 +5,9 @@ using Robust.Shared.Timing;
namespace Content.Shared.Trigger.Systems;
public sealed partial class HandTriggerSystem : EntitySystem
public sealed partial class HandTriggerSystem : TriggerOnXSystem
{
[Dependency] private readonly IGameTiming _timing = default!;
[Dependency] private readonly TriggerSystem _trigger = default!;
public override void Initialize()
{
@@ -29,7 +28,7 @@ public sealed partial class HandTriggerSystem : EntitySystem
if (_timing.ApplyingState)
return;
_trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
}
private void OnGotUnequipped(Entity<TriggerOnGotUnequippedHandComponent> ent, ref GotUnequippedHandEvent args)
@@ -37,7 +36,7 @@ public sealed partial class HandTriggerSystem : EntitySystem
if (_timing.ApplyingState)
return;
_trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
}
private void OnDidEquip(Entity<TriggerOnDidEquipHandComponent> ent, ref DidEquipHandEvent args)
@@ -45,7 +44,7 @@ public sealed partial class HandTriggerSystem : EntitySystem
if (_timing.ApplyingState)
return;
_trigger.Trigger(ent.Owner, args.Equipped, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Equipped, ent.Comp.KeyOut);
}
private void OnDidUnequip(Entity<TriggerOnDidUnequipHandComponent> ent, ref DidUnequipHandEvent args)
@@ -53,12 +52,12 @@ public sealed partial class HandTriggerSystem : EntitySystem
if (_timing.ApplyingState)
return;
_trigger.Trigger(ent.Owner, args.Unequipped, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Unequipped, ent.Comp.KeyOut);
}
private void OnDropped(Entity<TriggerOnDroppedComponent> ent, ref DroppedEvent args)
{
// We don't need the guard statement here because this one is not a container event, but raised directly when interacting.
_trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
}
}

8
Content.Shared/Trigger/Systems/TriggerOnHitscanSystem.cs
View File

@@ -3,10 +3,8 @@ using Content.Shared.Weapons.Hitscan.Events;
namespace Content.Shared.Trigger.Systems;
public sealed class TriggerOnHitscanSystem : EntitySystem
public sealed class TriggerOnHitscanSystem : TriggerOnXSystem
{
[Dependency] private readonly TriggerSystem _trigger = default!;
public override void Initialize()
{
base.Initialize();
@@ -20,11 +18,11 @@ public sealed class TriggerOnHitscanSystem : EntitySystem
if (args.Data.HitEntity == null)
return;
_trigger.Trigger(ent.Owner, args.Data.HitEntity, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Data.HitEntity, ent.Comp.KeyOut);
}
private void OnFired(Entity<TriggerOnHitscanFiredComponent> ent, ref HitscanRaycastFiredEvent args)
{
_trigger.Trigger(ent.Owner, args.Data.Shooter, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Data.Shooter, ent.Comp.KeyOut);
}
}

6
Content.Shared/Trigger/Systems/TriggerOnLandSystem.cs
View File

@@ -3,10 +3,8 @@ using Content.Shared.Trigger.Components.Triggers;
namespace Content.Shared.Trigger.Systems;
public sealed partial class TriggerOnLandSystem : EntitySystem
public sealed partial class TriggerOnLandSystem : TriggerOnXSystem
{
[Dependency] private readonly TriggerSystem _trigger = default!;
public override void Initialize()
{
base.Initialize();
@@ -16,6 +14,6 @@ public sealed partial class TriggerOnLandSystem : EntitySystem
private void OnLand(Entity<TriggerOnLandComponent> ent, ref LandEvent args)
{
_trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
}
}

12
Content.Shared/Trigger/Systems/MeleeTriggerSystem.cs → Content.Shared/Trigger/Systems/TriggerOnMeleeSystem.cs
View File

@@ -6,10 +6,8 @@ namespace Content.Shared.Trigger.Systems;
/// <summary>
/// Trigger system for melee related triggers.
/// </summary>
public sealed class MeleeTriggerSystem : EntitySystem
public sealed class TriggerOnMeleeTriggerSystem : TriggerOnXSystem
{
[Dependency] private readonly TriggerSystem _trigger = default!;
/// <inheritdoc/>
public override void Initialize()
{
@@ -23,7 +21,7 @@ public sealed class MeleeTriggerSystem : EntitySystem
private void OnMissTrigger(Entity<TriggerOnMeleeMissComponent> ent, ref MeleeHitEvent args)
{
if (args.HitEntities.Count == 0)
_trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
}
private void OnSwingTrigger(Entity<TriggerOnMeleeSwingComponent> ent, ref MeleeHitEvent args)
@@ -34,7 +32,7 @@ public sealed class MeleeTriggerSystem : EntitySystem
else
target = ent.Comp.TargetIsUser ? args.HitEntities[0] : args.User;
_trigger.Trigger(ent.Owner, target, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, target, ent.Comp.KeyOut);
}
private void OnHitTrigger(Entity<TriggerOnMeleeHitComponent> ent, ref MeleeHitEvent args)
@@ -45,14 +43,14 @@ public sealed class MeleeTriggerSystem : EntitySystem
if (!ent.Comp.TriggerEveryHit)
{
var target = ent.Comp.TargetIsUser ? args.HitEntities[0] : args.User;
_trigger.Trigger(ent.Owner, target, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, target, ent.Comp.KeyOut);
return;
}
// if TriggerEveryHit
foreach (var target in args.HitEntities)
{
_trigger.Trigger(ent.Owner, ent.Comp.TargetIsUser ? target : args.User, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, ent.Comp.TargetIsUser ? target : args.User, ent.Comp.KeyOut);
}
}
}

7
Content.Shared/Trigger/Systems/TriggerOnMobstateChangeSystem.cs
View File

@@ -6,9 +6,8 @@ using Content.Shared.Trigger.Components.Triggers;
namespace Content.Shared.Trigger.Systems;
public sealed partial class TriggerOnMobstateChangeSystem : EntitySystem
public sealed partial class TriggerOnMobstateChangeSystem : TriggerOnXSystem
{
[Dependency] private readonly TriggerSystem _trigger = default!;
[Dependency] private readonly SharedPopupSystem _popup = default!;
public override void Initialize()
@@ -27,7 +26,7 @@ public sealed partial class TriggerOnMobstateChangeSystem : EntitySystem
if (!component.MobState.Contains(args.NewMobState))
return;
_trigger.Trigger(uid, component.TargetMobstateEntity ? uid : args.Origin, component.KeyOut);
Trigger.Trigger(uid, component.TargetMobstateEntity ? uid : args.Origin, component.KeyOut);
}
private void OnMobStateRelay(EntityUid uid, TriggerOnMobstateChangeComponent component, ImplantRelayEvent<MobStateChangedEvent> args)
@@ -35,7 +34,7 @@ public sealed partial class TriggerOnMobstateChangeSystem : EntitySystem
if (!component.MobState.Contains(args.Event.NewMobState))
return;
_trigger.Trigger(uid, component.TargetMobstateEntity ? args.ImplantedEntity : args.Event.Origin, component.KeyOut);
Trigger.Trigger(uid, component.TargetMobstateEntity ? args.ImplantedEntity : args.Event.Origin, component.KeyOut);
}
/// <summary>

6
Content.Shared/Trigger/Systems/TriggerOnRoundEndSystem.cs
View File

@@ -6,10 +6,8 @@ namespace Content.Shared.Trigger.Systems;
/// <summary>
/// System for creating a trigger when the round ends.
/// </summary>
public sealed class TriggerOnRoundEndSystem : EntitySystem
public sealed class TriggerOnRoundEndSystem : TriggerOnXSystem
{
[Dependency] private readonly TriggerSystem _trigger = default!;
/// <inheritdoc/>
public override void Initialize()
{
@@ -25,7 +23,7 @@ public sealed class TriggerOnRoundEndSystem : EntitySystem
// trigger everything with the component
while (triggerQuery.MoveNext(out var uid, out var comp))
{
_trigger.Trigger(uid, null, comp.KeyOut);
Trigger.Trigger(uid, null, comp.KeyOut);
}
}
}

6
Content.Shared/Trigger/Systems/TriggerOnSlipSystem.cs
View File

@@ -3,10 +3,8 @@ using Content.Shared.Trigger.Components.Triggers;
namespace Content.Shared.Trigger.Systems;
public sealed partial class TriggerOnSlipSystem : EntitySystem
public sealed partial class TriggerOnSlipSystem : TriggerOnXSystem
{
[Dependency] private readonly TriggerSystem _trigger = default!;
public override void Initialize()
{
base.Initialize();
@@ -16,6 +14,6 @@ public sealed partial class TriggerOnSlipSystem : EntitySystem
private void OnSlip(Entity<TriggerOnSlipComponent> ent, ref SlipEvent args)
{
_trigger.Trigger(ent.Owner, args.Slipped, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Slipped, ent.Comp.KeyOut);
}
}

12
Content.Shared/Trigger/Systems/TriggerOnStrappedOrBuckledSystem.cs
View File

@@ -8,10 +8,8 @@ namespace Content.Shared.Trigger.Systems;
/// The users of strap components are the objects having an entity strapped to them (IE: Chairs)
/// The users of buckle components are entities being buckled to an object. (IE: Mobs and players)
/// </summary>
public sealed partial class TriggerOnStrappedOrBuckledSystem : EntitySystem
public sealed partial class TriggerOnStrappedOrBuckledSystem : TriggerOnXSystem
{
[Dependency] private readonly TriggerSystem _trigger = default!;
public override void Initialize()
{
base.Initialize();
@@ -27,23 +25,23 @@ public sealed partial class TriggerOnStrappedOrBuckledSystem : EntitySystem
// Called by objects entities can be buckled to. (Chairs, surgical tables/)
private void OnStrapped(Entity<TriggerOnStrappedComponent> ent, ref StrappedEvent args)
{
_trigger.Trigger(ent.Owner, args.Strap, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Strap, ent.Comp.KeyOut);
}
private void OnUnstrapped(Entity<TriggerOnUnstrappedComponent> ent, ref UnstrappedEvent args)
{
_trigger.Trigger(ent.Owner, args.Strap, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Strap, ent.Comp.KeyOut);
}
// Called by entities that are buckled to an object. (Mobs, players.)
private void OnBuckled(Entity<TriggerOnBuckledComponent> ent, ref BuckledEvent args)
{
_trigger.Trigger(ent.Owner, args.Buckle, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Buckle, ent.Comp.KeyOut);
}
private void OnUnbuckled(Entity<TriggerOnUnbuckledComponent> ent, ref UnbuckledEvent args)
{
_trigger.Trigger(ent.Owner, args.Buckle, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.Buckle, ent.Comp.KeyOut);
}
#endregion
}

6
Content.Shared/Trigger/Systems/TriggerOnStuckSystem.cs
View File

@@ -3,10 +3,8 @@ using Content.Shared.Trigger.Components.Triggers;
namespace Content.Shared.Trigger.Systems;
public sealed class TriggerOnStuckSystem : EntitySystem
public sealed class TriggerOnStuckSystem : TriggerOnXSystem
{
[Dependency] private readonly TriggerSystem _trigger = default!;
public override void Initialize()
{
base.Initialize();
@@ -16,6 +14,6 @@ public sealed class TriggerOnStuckSystem : EntitySystem
private void OnStuck(Entity<TriggerOnStuckComponent> ent, ref EntityStuckEvent args)
{
_trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
}
}

6
Content.Shared/Trigger/Systems/TriggerOnToolUseSystem.cs
View File

@@ -3,10 +3,8 @@ using Content.Shared.Trigger.Components.Triggers;
namespace Content.Shared.Trigger.Systems;
public sealed class TriggerOnToolUseSystem : EntitySystem
public sealed class TriggerOnToolUseSystem : TriggerOnXSystem
{
[Dependency] private readonly TriggerSystem _trigger = default!;
public override void Initialize()
{
base.Initialize();
@@ -16,6 +14,6 @@ public sealed class TriggerOnToolUseSystem : EntitySystem
private void OnToolUse(Entity<TriggerOnSimpleToolUsageComponent> ent, ref SimpleToolDoAfterEvent args)
{
_trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
Trigger.Trigger(ent.Owner, args.User, ent.Comp.KeyOut);
}
}

6
Content.Shared/Trigger/Systems/TriggerOnVerbSystem.cs
View File

@@ -3,10 +3,8 @@ using Content.Shared.Trigger.Components.Triggers;
namespace Content.Shared.Trigger.Systems;
public sealed partial class TriggerOnVerbSystem : EntitySystem
public sealed partial class TriggerOnVerbSystem : TriggerOnXSystem
{
[Dependency] private readonly TriggerSystem _trigger = default!;
public override void Initialize()
{
base.Initialize();
@@ -24,7 +22,7 @@ public sealed partial class TriggerOnVerbSystem : EntitySystem
args.Verbs.Add(new AlternativeVerb
{
Text = Loc.GetString(ent.Comp.Text),
Act = () => _trigger.Trigger(ent.Owner, user, ent.Comp.KeyOut),
Act = () => Trigger.Trigger(ent.Owner, user, ent.Comp.KeyOut),
Priority = 2 // should be above any timer settings
});
}

23
Content.Shared/Trigger/Systems/UncuffOnTriggerSystem.cs
View File

@@ -4,31 +4,16 @@ using Content.Shared.Trigger.Components.Effects;
namespace Content.Shared.Trigger.Systems;
public sealed class UncuffOnTriggerSystem : EntitySystem
public sealed class UncuffOnTriggerSystem : XOnTriggerSystem<UncuffOnTriggerComponent>
{
[Dependency] private readonly SharedCuffableSystem _cuffable = default!;
public override void Initialize()
protected override void OnTrigger(Entity<UncuffOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<UncuffOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<UncuffOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
if (!TryComp<CuffableComponent>(target, out var cuffs) || cuffs.Container.ContainedEntities.Count < 1)
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
if (!TryComp<CuffableComponent>(target.Value, out var cuffs) || cuffs.Container.ContainedEntities.Count < 1)
return;
_cuffable.Uncuff(target.Value, args.User, cuffs.LastAddedCuffs);
_cuffable.Uncuff(target, args.User, cuffs.LastAddedCuffs);
args.Handled = true;
}
}

21
Content.Shared/Trigger/Systems/WeatherTriggerSystem.cs
View File

@@ -5,30 +5,15 @@ using Robust.Shared.Timing;
namespace Content.Shared.Trigger.Systems;
public sealed class WeatherTriggerSystem : EntitySystem
public sealed class WeatherTriggerSystem : XOnTriggerSystem<WeatherOnTriggerComponent>
{
[Dependency] private readonly IGameTiming _timing = default!;
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
[Dependency] private readonly SharedWeatherSystem _weather = default!;
public override void Initialize()
protected override void OnTrigger(Entity<WeatherOnTriggerComponent> ent, EntityUid target, ref TriggerEvent args)
{
base.Initialize();
SubscribeLocalEvent<WeatherOnTriggerComponent, TriggerEvent>(OnTrigger);
}
private void OnTrigger(Entity<WeatherOnTriggerComponent> ent, ref TriggerEvent args)
{
if (args.Key != null && !ent.Comp.KeysIn.Contains(args.Key))
return;
var target = ent.Comp.TargetUser ? args.User : ent.Owner;
if (target == null)
return;
var xform = Transform(target.Value);
var xform = Transform(target);
if (ent.Comp.Weather == null) //Clear weather if nothing is set
{

2
Resources/Prototypes/Entities/Objects/Fun/toys.yml
View File

@@ -537,7 +537,7 @@
description: Someone's drawn ">:3c" on the side of this beach ball in indelible ink.
components:
- type: LaunchOnTrigger
speed: 100.0
impulse: 100.0
keysIn:
- OnCollide
- type: StaminaDamageOnTrigger