Sprite-based click detection.

Content.Client/GameObjects/Components/ClickableComponent.cs

@@ -0,0 +1,146 @@
+using System;
+using Robust.Client.Graphics.ClientEye;
+using Robust.Client.Interfaces.GameObjects.Components;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.Serialization;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
+
+#nullable enable
+
+namespace Content.Client.GameObjects.Components
+{
+    [RegisterComponent]
+    public sealed class ClickableComponent : Component
+    {
+        public override string Name => "Clickable";
+
+        [Dependency] private readonly IClickMapManager _clickMapManager = default!;
+
+        [ViewVariables] private DirBoundData _data = default!;
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            base.ExposeData(serializer);
+
+            serializer.DataField(ref _data, "bounds", DirBoundData.Default);
+        }
+
+        /// <summary>
+        /// Used to check whether a click worked.
+        /// </summary>
+        /// <param name="worldPos">The world position that was clicked.</param>
+        /// <param name="drawDepth">
+        /// The draw depth for the sprite that captured the click.
+        /// </param>
+        /// <returns>True if the click worked, false otherwise.</returns>
+        public bool CheckClick(Vector2 worldPos, out int drawDepth, out uint renderOrder)
+        {
+            if (!Owner.TryGetComponent(out ISpriteComponent sprite) || !sprite.Visible)
+            {
+                drawDepth = default;
+                renderOrder = default;
+                return false;
+            }
+
+            var localPos = Owner.Transform.InvWorldMatrix.Transform(worldPos);
+
+            var worldRotation = Owner.Transform.WorldRotation;
+            if (sprite.Directional)
+            {
+                localPos = new Angle(worldRotation).RotateVec(localPos);
+            }
+            else
+            {
+                localPos = new Angle(MathHelper.PiOver2).RotateVec(localPos);
+            }
+
+            var localOffset = localPos * EyeManager.PixelsPerMeter * (1, -1);
+
+            var found = false;
+
+            if (_data.All.Contains(localPos))
+            {
+                found = true;
+            }
+            else
+            {
+                // TODO: diagonal support?
+                var dir = sprite.Directional ? worldRotation.GetCardinalDir() : Direction.South;
+                var boundsForDir = dir switch
+                {
+                    Direction.East => _data.East,
+                    Direction.North => _data.North,
+                    Direction.South => _data.South,
+                    Direction.West => _data.West,
+                    _ => throw new InvalidOperationException()
+                };
+
+                if (boundsForDir.Contains(localPos))
+                {
+                    found = true;
+                }
+            }
+
+            if (!found)
+            {
+                foreach (var layer in sprite.AllLayers)
+                {
+                    if (layer.Texture != null)
+                    {
+                        if (_clickMapManager.IsOccluding(layer.Texture,
+                            (Vector2i) (localOffset + layer.Texture.Size / 2f)))
+                        {
+                            found = true;
+                            break;
+                        }
+                    }
+                    else if (layer.RsiState != default)
+                    {
+                        var rsi = layer.ActualRsi;
+                        if (rsi == null)
+                        {
+                            continue;
+                        }
+
+                        var (mX, mY) = localOffset + rsi.Size / 2;
+
+                        var dir = layer.EffectiveDirection(worldRotation);
+                        if (_clickMapManager.IsOccluding(rsi, layer.RsiState, dir,
+                            layer.AnimationFrame, ((int) mX, (int) mY)))
+                        {
+                            found = true;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            drawDepth = sprite.DrawDepth;
+            renderOrder = sprite.RenderOrder;
+            return found;
+        }
+
+        private sealed class DirBoundData : IExposeData
+        {
+            [ViewVariables] public Box2 All;
+            [ViewVariables] public Box2 North;
+            [ViewVariables] public Box2 South;
+            [ViewVariables] public Box2 East;
+            [ViewVariables] public Box2 West;
+
+            public static DirBoundData Default { get; } = new DirBoundData();
+
+            public void ExposeData(ObjectSerializer serializer)
+            {
+                serializer.DataField(ref All, "all", default);
+                serializer.DataField(ref North, "north", default);
+                serializer.DataField(ref South, "south", default);
+                serializer.DataField(ref East, "east", default);
+                serializer.DataField(ref West, "west", default);
+            }
+        }
+    }
+}