Adds portable flasher (#4523)

Co-authored-by: Paul Ritter <ritter.paul1@googlemail.com>
Co-authored-by: metalgearsloth <comedian_vs_clown@hotmail.com>
Co-authored-by: metalgearsloth <31366439+metalgearsloth@users.noreply.github.com>

Content.Client/Entry/IgnoredComponents.cs

@@ -78,6 +78,7 @@ namespace Content.Client.Entry
             "BodyScanner",
             "Stunbaton",
             "Tool",
+            "TriggerOnProximity",
             "TilePrying",
             "RandomSpriteColor",
             "ConditionalSpawner",

Content.Client/Trigger/ProximityTriggerVisualizer.cs

@@ -0,0 +1,96 @@
+using System;
+using Content.Shared.Trigger;
+using Robust.Client.Animations;
+using Robust.Client.GameObjects;
+using Robust.Shared.Animations;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Serialization.Manager.Attributes;
+
+namespace Content.Client.Trigger
+{
+    public sealed class ProximityTriggerVisualizer : AppearanceVisualizer
+    {
+        [DataField("animationState")]
+        private string? _animationState;
+
+        [DataField("duration")]
+        private float _animationDuration = 0.3f;
+
+        private const string AnimKey = "proximity";
+
+        private static Animation _animation = default!;
+
+        public override void InitializeEntity(EntityUid entityUid)
+        {
+
+            base.InitializeEntity(entityUid);
+
+            if (_animationState == null) return;
+
+            IoCManager.Resolve<IEntityManager>().EnsureComponent<AnimationPlayerComponent>(entityUid);
+
+            _animation = new Animation
+            {
+                Length = TimeSpan.FromSeconds(_animationDuration),
+                AnimationTracks = {new AnimationTrackSpriteFlick
+                {
+                    LayerKey = ProximityTriggerVisualLayers.Base,
+                    KeyFrames = { new AnimationTrackSpriteFlick.KeyFrame(_animationState, 0f)}
+
+                },
+                new AnimationTrackComponentProperty()
+                {
+                    ComponentType = typeof(PointLightComponent),
+                    InterpolationMode = AnimationInterpolationMode.Nearest,
+                    Property = nameof(PointLightComponent.Radius),
+                    KeyFrames =
+                    {
+                        new AnimationTrackProperty.KeyFrame(0.1f, 0),
+                        new AnimationTrackProperty.KeyFrame(3f, 0.1f),
+                        new AnimationTrackProperty.KeyFrame(0.1f, 0.5f)
+                    }
+                }
+                }
+            };
+        }
+
+        public override void OnChangeData(AppearanceComponent component)
+        {
+            base.OnChangeData(component);
+            var entityManager = IoCManager.Resolve<IEntityManager>();
+            if (!entityManager.TryGetComponent(component.Owner, out SpriteComponent spriteComponent)) return;
+
+            var animSystem = EntitySystem.Get<AnimationPlayerSystem>();
+            entityManager.TryGetComponent(component.Owner, out AnimationPlayerComponent? player);
+            component.TryGetData(ProximityTriggerVisualState.State, out ProximityTriggerVisuals state);
+
+            switch (state)
+            {
+                case ProximityTriggerVisuals.Inactive:
+                    if (player != null)
+                        animSystem.Stop(player, AnimKey);
+
+                    spriteComponent.LayerSetState(ProximityTriggerVisualLayers.Base, "on");
+                    break;
+                case ProximityTriggerVisuals.Active:
+                    /* TODO: Waiting on ECS OnChangeData so we can actually subscribe to the animation finishing properly.
+                    if (_animationState == null || player == null ||
+                        animSystem.HasRunningAnimation(player, AnimKey)) return;
+
+                    animSystem.Play(player, _animation, AnimKey);
+                    */
+                    break;
+                case ProximityTriggerVisuals.Off:
+                default:
+                    spriteComponent.LayerSetState(ProximityTriggerVisualLayers.Base, "off");
+                    break;
+            }
+        }
+    }
+
+    public enum ProximityTriggerVisualLayers : byte
+    {
+        Base,
+    }
+}

Content.Server/Explosion/Components/TriggerOnProximityComponent.cs

@@ -0,0 +1,64 @@
+using Content.Server.Explosion.EntitySystems;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Physics.Collision.Shapes;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
+using System.Collections.Generic;
+
+namespace Content.Server.Explosion.Components
+{
+
+    /// <summary>
+    /// Raises a <see cref="TriggerEvent"/> whenever an entity collides with a fixture attached to the owner of this component.
+    /// </summary>
+    [RegisterComponent]
+    public sealed class TriggerOnProximityComponent : Component
+    {
+        public const string FixtureID  = "trigger-on-proximity-fixture";
+
+        public HashSet<PhysicsComponent> Colliding = new();
+
+        [DataField("shape", required: true)]
+        public IPhysShape Shape { get; set; } = new PhysShapeCircle {Radius = 2};
+
+        /// <summary>
+        /// How long the the proximity trigger animation plays for.
+        /// </summary>
+        [ViewVariables]
+        [DataField("animationDuration")]
+        public float AnimationDuration = 0.3f;
+
+        /// <summary>
+        /// Whether the entity needs to be anchored for the proximity to work.
+        /// </summary>
+        [ViewVariables]
+        [DataField("requiresAnchored")]
+        public bool RequiresAnchored { get; set; } = true;
+
+        [ViewVariables]
+        [DataField("enabled")]
+        public bool Enabled = true;
+
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("cooldown")]
+        public float Cooldown { get; set; } = 5f;
+
+        /// <summary>
+        /// How much cooldown has elapsed (if relevant).
+        /// </summary>
+        public float Accumulator = 0f;
+
+        /// <summary>
+        /// What speed should the other object be moving at to trigger the proximity fixture?
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("triggerSpeed")]
+        public float TriggerSpeed { get; set; } = 3.5f;
+
+        /// <summary>
+        /// If this proximity is triggered should we continually repeat it?
+        /// </summary>
+        [DataField("repeating")]
+        internal bool Repeating = true;
+    }
+}

Content.Server/Explosion/EntitySystems/TriggerSystem.Proximity.cs

@@ -0,0 +1,158 @@
+using System.Collections.Generic;
+using Content.Server.Explosion.Components;
+using Content.Shared.Physics;
+using Content.Shared.Trigger;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Physics.Dynamics;
+using Robust.Shared.Utility;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+public sealed partial class TriggerSystem
+{
+    /// <summary>
+    /// Anything that has stuff touching it (to check speed) or is on cooldown.
+    /// </summary>
+    private HashSet<TriggerOnProximityComponent> _activeProximities = new();
+
+    private void InitializeProximity()
+    {
+        SubscribeLocalEvent<TriggerOnProximityComponent, StartCollideEvent>(OnProximityStartCollide);
+        SubscribeLocalEvent<TriggerOnProximityComponent, EndCollideEvent>(OnProximityEndCollide);
+        SubscribeLocalEvent<TriggerOnProximityComponent, ComponentStartup>(OnProximityStartup);
+        SubscribeLocalEvent<TriggerOnProximityComponent, ComponentShutdown>(OnProximityShutdown);
+        SubscribeLocalEvent<TriggerOnProximityComponent, AnchorStateChangedEvent>(OnProximityAnchor);
+    }
+
+    private void OnProximityAnchor(EntityUid uid, TriggerOnProximityComponent component, ref AnchorStateChangedEvent args)
+    {
+        component.Enabled = !component.RequiresAnchored ||
+                            args.Anchored;
+
+        SetProximityAppearance(uid, component);
+
+        if (!component.Enabled)
+        {
+            _activeProximities.Remove(component);
+            component.Colliding.Clear();
+        }
+        // Re-check for contacts as we cleared them.
+        else if (TryComp<PhysicsComponent>(uid, out var body))
+        {
+            _broadphase.RegenerateContacts(body);
+        }
+    }
+
+    private void OnProximityShutdown(EntityUid uid, TriggerOnProximityComponent component, ComponentShutdown args)
+    {
+        _activeProximities.Remove(component);
+        component.Colliding.Clear();
+    }
+
+    private void OnProximityStartup(EntityUid uid, TriggerOnProximityComponent component, ComponentStartup args)
+    {
+        component.Enabled = !component.RequiresAnchored ||
+                            EntityManager.GetComponent<TransformComponent>(uid).Anchored;
+
+        SetProximityAppearance(uid, component);
+
+        if (!TryComp<PhysicsComponent>(uid, out var body)) return;
+
+        _fixtures.CreateFixture(body, new Fixture(body, component.Shape)
+        {
+            // TODO: Should probably have these settable via datafield but I'm lazy and it's a pain
+            CollisionLayer = (int) (CollisionGroup.MobImpassable | CollisionGroup.SmallImpassable | CollisionGroup.VaultImpassable), Hard = false, ID = TriggerOnProximityComponent.FixtureID
+        });
+    }
+
+    private void OnProximityStartCollide(EntityUid uid, TriggerOnProximityComponent component, StartCollideEvent args)
+    {
+        if (args.OurFixture.ID != TriggerOnProximityComponent.FixtureID) return;
+
+        _activeProximities.Add(component);
+        component.Colliding.Add(args.OtherFixture.Body);
+    }
+
+    private void OnProximityEndCollide(EntityUid uid, TriggerOnProximityComponent component, EndCollideEvent args)
+    {
+        if (args.OurFixture.ID != TriggerOnProximityComponent.FixtureID) return;
+
+        component.Colliding.Remove(args.OtherFixture.Body);
+
+        if (component.Colliding.Count == 0)
+            _activeProximities.Remove(component);
+    }
+
+    private void SetProximityAppearance(EntityUid uid, TriggerOnProximityComponent component)
+    {
+        if (EntityManager.TryGetComponent(uid, out AppearanceComponent? appearanceComponent))
+        {
+            appearanceComponent.SetData(ProximityTriggerVisualState.State, component.Enabled ? ProximityTriggerVisuals.Inactive : ProximityTriggerVisuals.Off);
+        }
+    }
+
+    private void Activate(TriggerOnProximityComponent component)
+    {
+        DebugTools.Assert(component.Enabled);
+
+        if (!component.Repeating)
+        {
+            component.Enabled = false;
+            _activeProximities.Remove(component);
+            component.Colliding.Clear();
+        }
+        else
+        {
+            component.Accumulator = component.Cooldown;
+        }
+
+        SetProximityAppearance(component.Owner, component);
+        Trigger(component.Owner);
+    }
+
+    private void UpdateProximity(float frameTime)
+    {
+        var toRemove = new RemQueue<TriggerOnProximityComponent>();
+
+        foreach (var comp in _activeProximities)
+        {
+            if (!comp.Enabled)
+            {
+                toRemove.Add(comp);
+                continue;
+            }
+
+            MetaDataComponent? metadata = null;
+
+            if (Deleted(comp.Owner, metadata))
+            {
+                toRemove.Add(comp);
+                continue;
+            }
+
+            if (Paused(comp.Owner, metadata)) continue;
+
+            comp.Accumulator -= frameTime;
+
+            if (comp.Accumulator > 0f) continue;
+
+            // Alright now that we have no cd check everything in range.
+
+            foreach (var colliding in comp.Colliding)
+            {
+                if (Deleted(colliding.Owner)) continue;
+
+                if (colliding.LinearVelocity.Length < comp.TriggerSpeed) continue;
+
+                // Trigger!
+                Activate(comp);
+                break;
+            }
+        }
+
+        foreach (var prox in toRemove)
+        {
+            _activeProximities.Remove(prox);
+        }
+    }
+}

Content.Server/Explosion/EntitySystems/TriggerSystem.cs

@@ -6,25 +6,29 @@ using Content.Server.Doors.Systems;
 using Content.Server.Explosion.Components;
 using Content.Server.Flash;
 using Content.Server.Flash.Components;
-using Content.Server.Projectiles.Components;
 using Content.Shared.Audio;
-using Content.Shared.Database;
 using Content.Shared.Doors;
-using Content.Shared.Throwing;
 using JetBrains.Annotations;
 using Robust.Shared.Audio;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
+using Robust.Shared.Physics;
 using Robust.Shared.Physics.Dynamics;
 using Robust.Shared.Player;
 using Robust.Shared.Timing;
+using System.Threading;
+using Content.Server.Construction.Components;
+using Content.Shared.Trigger;
+using Timer = Robust.Shared.Timing.Timer;
+using Content.Shared.Physics;
+using System.Collections.Generic;
 
 namespace Content.Server.Explosion.EntitySystems
 {
     /// <summary>
     /// Raised whenever something is Triggered on the entity.
     /// </summary>
-    public class TriggerEvent : HandledEntityEventArgs
+    public sealed class TriggerEvent : HandledEntityEventArgs
     {
         public EntityUid Triggered { get; }
         public EntityUid? User { get; }
@@ -40,16 +44,19 @@ namespace Content.Server.Explosion.EntitySystems
     public sealed partial class TriggerSystem : EntitySystem
     {
         [Dependency] private readonly ExplosionSystem _explosions = default!;
+        [Dependency] private readonly FixtureSystem _fixtures = default!;
         [Dependency] private readonly FlashSystem _flashSystem = default!;
         [Dependency] private readonly DoorSystem _sharedDoorSystem = default!;
+        [Dependency] private readonly SharedBroadphaseSystem _broadphase = default!;
 
         public override void Initialize()
         {
             base.Initialize();
 
+            InitializeProximity();
             InitializeOnUse();
 
-            SubscribeLocalEvent<TriggerOnCollideComponent, StartCollideEvent>(HandleCollide);
+            SubscribeLocalEvent<TriggerOnCollideComponent, StartCollideEvent>(OnTriggerCollide);
 
             SubscribeLocalEvent<DeleteOnTriggerComponent, TriggerEvent>(HandleDeleteTrigger);
             SubscribeLocalEvent<SoundOnTriggerComponent, TriggerEvent>(HandleSoundTrigger);
@@ -88,11 +95,8 @@ namespace Content.Server.Explosion.EntitySystems
         #region Flash
         private void HandleFlashTrigger(EntityUid uid, FlashOnTriggerComponent component, TriggerEvent args)
         {
-            if (component.Flashed) return;
-
             // TODO Make flash durations sane ffs.
             _flashSystem.FlashArea(uid, args.User, component.Range, component.Duration * 1000f);
-            component.Flashed = true;
         }
         #endregion
 
@@ -112,15 +116,9 @@ namespace Content.Server.Explosion.EntitySystems
             _sharedDoorSystem.TryToggleDoor(uid);
         }
 
-        private void HandleCollide(EntityUid uid, TriggerOnCollideComponent component, StartCollideEvent args)
+        private void OnTriggerCollide(EntityUid uid, TriggerOnCollideComponent component, StartCollideEvent args)
         {
-            EntityUid? user = null;
+            Trigger(component.Owner);
-            if (EntityManager.TryGetComponent(uid, out ProjectileComponent projectile))
-                user = projectile.Shooter;
-            else if (EntityManager.TryGetComponent(uid, out ThrownItemComponent thrown))
-                user = thrown.Thrower;
-
-            Trigger(component.Owner, user);
         }
 
 
@@ -144,5 +142,12 @@ namespace Content.Server.Explosion.EntitySystems
                 Trigger(triggered, user);
             });
         }
+
+        public override void Update(float frameTime)
+        {
+            base.Update(frameTime);
+
+            UpdateProximity(frameTime);
+        }
     }
 }

Content.Server/Flash/Components/FlashOnTriggerComponent.cs

@@ -11,7 +11,5 @@ namespace Content.Server.Flash.Components
     {
         [DataField("range")] internal float Range = 1.0f;
         [DataField("duration")] internal float Duration = 8.0f;
-
-        internal bool Flashed;
     }
 }

Content.Shared/Pulling/Systems/SharedPullingStateManagementSystem.cs

@@ -30,6 +30,7 @@ namespace Content.Shared.Pulling
     public class SharedPullingStateManagementSystem : EntitySystem
     {
         [Dependency] private readonly SharedJointSystem _jointSystem = default!;
+        [Dependency] private readonly SharedPhysicsSystem _physics = default!;
 
         public override void Initialize()
         {
@@ -116,7 +117,7 @@ namespace Content.Shared.Pulling
                 pullable.Puller = puller.Owner;
 
                 // Joint startup
-                var union = pullerPhysics.GetWorldAABB().Union(pullablePhysics.GetWorldAABB());
+                var union = _physics.GetHardAABB(pullerPhysics).Union(_physics.GetHardAABB(pullablePhysics));
                 var length = Math.Max(union.Size.X, union.Size.Y) * 0.75f;
 
                 pullable.PullJoint = _jointSystem.CreateDistanceJoint(pullablePhysics.Owner, pullerPhysics.Owner, id:$"pull-joint-{pullablePhysics.Owner}");

Content.Shared/Trigger/TriggerVisuals.cs

@@ -1,18 +1,29 @@
-using System;
+using Robust.Shared.Serialization;
-using Robust.Shared.Serialization;
 
 namespace Content.Shared.Trigger
 {
-    [NetSerializable]
+    [Serializable, NetSerializable]
-    [Serializable]
+    public enum ProximityTriggerVisuals : byte
-    public enum TriggerVisuals
+    {
+        Off,
+        Inactive,
+        Active,
+    }
+
+    [Serializable, NetSerializable]
+    public enum ProximityTriggerVisualState : byte
+    {
+        State,
+    }
+
+    [Serializable, NetSerializable]
+    public enum TriggerVisuals : byte
     {
         VisualState,
     }
 
-    [NetSerializable]
+    [Serializable, NetSerializable]
-    [Serializable]
+    public enum TriggerVisualState : byte
-    public enum TriggerVisualState
     {
         Primed,
         Unprimed,

Resources/Prototypes/Entities/Objects/Weapons/security.yml

@@ -49,3 +49,53 @@
       size: 2
       sprite: Objects/Weapons/Melee/flash.rsi
     - type: ItemCooldown
+
+- type: entity
+  name: portable flasher
+  parent: BaseStructure
+  id: Portableflasher
+  description: An ultrabright flashbulb with a proximity trigger, useful for making an area security-only.
+  components:
+    - type: SoundOnTrigger
+      sound:
+        path: /Audio/Weapons/flash.ogg
+    - type: FlashOnTrigger
+      repeating: true
+      range: 3
+    - type: TriggerOnProximity
+      enabled: true
+      cooldown: 5
+      shape:
+        !type:PhysShapeCircle
+          radius: 2
+    - type: Anchorable
+    - type: Sprite
+      netsync: false
+      sprite: Objects/Weapons/pflash.rsi
+      layers:
+        - state: "off"
+          map: ["enum.ProximityTriggerVisualLayers.Base"]
+    - type: InteractionOutline
+    - type: Physics
+    - type: Fixtures  
+      fixtures:
+      - shape:
+          !type:PhysShapeAabb
+            bounds: "-0.15,-0.3,0.15,0.3"
+        mask:
+        - Impassable
+        - VaultImpassable
+        - SmallImpassable
+        layer:
+        - MobImpassable
+        mass: 70
+    - type: Appearance
+      visuals:
+      - type: ProximityTriggerVisualizer
+        animationState: flashing
+    - type: PointLight
+      energy: 2.0
+      radius: 0
+      softness: 0
+      enabled: true
+

Resources/Textures/Objects/Weapons/pflash.rsi/meta.json

@@ -0,0 +1,30 @@
+{
+  "version": 1,
+  "license": "CC-BY-SA-3.0",
+  "copyright": "Taken from tgstation at commit https://github.com/tgstation/tgstation/commit/f349b842c84f500399bd5673e5e34a6bc45b001a",
+  "size": {
+    "x": 32,
+    "y": 32
+  },
+  "states": [
+    {
+      "name": "off"
+    },
+    {
+      "name": "on"
+    },
+    {
+      "name": "on-unlit"
+    },
+    {
+      "name": "flashing",
+      "delays": [
+        [
+          0.1,
+          0.1,
+          0.1
+        ]
+      ]
+    }
+  ]
+}