[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;
}
--- /dev/null
+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);
+}
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);
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;
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!;
[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;
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);
}
}
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)
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;
}
}
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;
}
}
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)
- {
- var (uid, comp) = ent;
- if (args.Key != null && !comp.KeysIn.Contains(args.Key))
- return;
-
- var target = comp.TargetUser ? args.User : uid;
-
- if (target == null)
- return;
+public sealed class ExplosionOnTriggerSystem : XOnTriggerSystem<ExplosionOnTriggerComponent>
+{
+ [Dependency] private readonly SharedExplosionSystem _explosion = default!;
- _explosion.QueueExplosion(target.Value,
- comp.ExplosionType,
- comp.TotalIntensity,
- comp.IntensitySlope,
- comp.MaxTileIntensity,
- comp.TileBreakScale,
- comp.MaxTileBreak,
- comp.CanCreateVacuum,
- args.User);
+ 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;
}
}
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;
}
}
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;
}
}
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;
}
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;
}
}
/// <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,
- ent.Comp.UserIsRecipient ? args.User : ent.Owner,
- ent.Comp.PopupType);
+ 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,
- args.User.Value,
- ent.Comp.PopupType);
+ 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,
- ent.Comp.UserIsRecipient ? args.User : ent.Owner,
- ent.Comp.PopupType);
+ Loc.GetString(ent.Comp.OtherText ?? ent.Comp.Text),
+ target,
+ ent.Comp.UserIsRecipient ? args.User : ent.Owner,
+ ent.Comp.PopupType);
+ }
else
+ {
_popup.PopupEntity(Loc.GetString(ent.Comp.OtherText ?? ent.Comp.Text),
- target.Value,
- ent.Comp.PopupType);
+ target,
+ ent.Comp.PopupType);
+ }
}
}
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;
}
}
-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;
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!;
{
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.
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;
}
}
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;
}
-
}
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);
-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;
}
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();
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;
}
}
/// <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()
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)
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
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)
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);
}
}
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();
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);
}
}
/// <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()
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)
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
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)
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);
}
}
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()
{
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)
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)
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)
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);
}
}
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();
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);
}
}
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();
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);
}
}
/// <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()
{
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)
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)
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);
}
}
}
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()
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)
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>
/// <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()
{
// 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);
}
}
}
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();
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);
}
}
/// 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();
// 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
}
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();
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);
}
}
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();
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);
}
}
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();
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
});
}
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))
- 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)
+ if (!TryComp<CuffableComponent>(target, 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;
}
}
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
{
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
projects / space-station-14.git / commitdiff