181 lines
8.8 KiB
C#
181 lines
8.8 KiB
C#
using System;
|
|
using Robust.Client.GameObjects;
|
|
using Robust.Client.Graphics;
|
|
using Robust.Client.Utility;
|
|
using Robust.Shared.GameObjects;
|
|
using Robust.Shared.IoC;
|
|
using Robust.Shared.Maths;
|
|
using Robust.Shared.Serialization.Manager.Attributes;
|
|
using Robust.Shared.ViewVariables;
|
|
using static Robust.Client.GameObjects.SpriteComponent;
|
|
|
|
namespace Content.Client.Clickable
|
|
{
|
|
[RegisterComponent]
|
|
public sealed class ClickableComponent : Component
|
|
{
|
|
[Dependency] private readonly IClickMapManager _clickMapManager = default!;
|
|
[Dependency] private readonly IEyeManager _eyeManager = default!;
|
|
[Dependency] private readonly IEntityManager _entMan = default!;
|
|
|
|
[ViewVariables] [DataField("bounds")] private DirBoundData? Bounds;
|
|
|
|
/// <summary>
|
|
/// Used to check whether a click worked. Will first check if the click falls inside of some explicit bounding
|
|
/// boxes (see <see cref="Bounds"/>). If that fails, attempts to use automatically generated click maps.
|
|
/// </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 (!_entMan.TryGetComponent(Owner, out ISpriteComponent? sprite) || !sprite.Visible)
|
|
{
|
|
drawDepth = default;
|
|
renderOrder = default;
|
|
return false;
|
|
}
|
|
|
|
drawDepth = sprite.DrawDepth;
|
|
renderOrder = sprite.RenderOrder;
|
|
|
|
var transform = _entMan.GetComponent<TransformComponent>(Owner);
|
|
var worldRot = transform.WorldRotation;
|
|
|
|
// We need to convert world angle to a positive value. between 0 and 2pi. This is important for
|
|
// CalcRectWorldAngle to get the right angle. Otherwise can get incorrect results for sprites at angles like
|
|
// -135 degrees (seems highly specific, but AI actors & other entities can snap to those angles while
|
|
// moving). As to why we treat world-angle like this, but not eye angle or world+eye, it is just because
|
|
// thats what sprite-rendering does.
|
|
worldRot = worldRot.Reduced();
|
|
|
|
if (worldRot.Theta < 0)
|
|
worldRot = new Angle(worldRot.Theta + Math.Tau);
|
|
|
|
var invSpriteMatrix = Matrix3.CreateTransform(Vector2.Zero, -sprite.Rotation, (1,1)/sprite.Scale);
|
|
var relativeRotation = worldRot + _eyeManager.CurrentEye.Rotation;
|
|
|
|
// localPos is the clicked location in the entity's coordinate frame, but with the sprite offset removed.
|
|
var localPos = transform.InvWorldMatrix.Transform(worldPos) - sprite.Offset;
|
|
|
|
// Check explicitly defined click-able bounds
|
|
if (CheckDirBound(sprite, relativeRotation, localPos, invSpriteMatrix))
|
|
return true;
|
|
|
|
// Next check each individual sprite layer using automatically computed click maps.
|
|
foreach (var spriteLayer in sprite.AllLayers)
|
|
{
|
|
if (!spriteLayer.Visible || spriteLayer is not Layer layer)
|
|
continue;
|
|
|
|
// How many orientations does this rsi have?
|
|
var dirCount = sprite.GetLayerDirectionCount(layer);
|
|
|
|
// If the sprite does not actually rotate we need to fix the rotation that was added to localPos via invSpriteMatrix
|
|
var modAngle = Angle.Zero;
|
|
if (sprite.NoRotation)
|
|
modAngle += CalcRectWorldAngle(relativeRotation, dirCount);
|
|
|
|
// Check the layer's texture, if it has one
|
|
if (layer.Texture != null)
|
|
{
|
|
// Convert to sprite-coordinates. This includes sprite matrix (scale, rotation), and noRot corrections (modAngle)
|
|
// Recall that the sprite offset was already removed
|
|
var spritePos = invSpriteMatrix.Transform(modAngle.RotateVec(localPos));
|
|
|
|
// Convert to image coordinates
|
|
var imagePos = (Vector2i) (spritePos * EyeManager.PixelsPerMeter * (1, -1) + layer.Texture.Size / 2f);
|
|
|
|
if (_clickMapManager.IsOccluding(layer.Texture, imagePos))
|
|
return true;
|
|
}
|
|
|
|
// As the texture failed, we check the RSI next
|
|
if (layer.State == null || layer.ActualRsi is not RSI rsi || !rsi.TryGetState(layer.State, out var state))
|
|
continue;
|
|
|
|
// Get the sprite direction, in the absence of any direction offset or override. this is just for
|
|
// determining the angle-snapping correction for directional sprites.
|
|
var dir = relativeRotation.ToRsiDirection(state.Directions);
|
|
|
|
// Add the correction to the sprite angle due to the fact that it is a directional sprite. This is some
|
|
// multiple of 90 or 45 degrees for 4/8 directional sprites, or 0 for one-directional sprites.
|
|
modAngle += dir.Convert().ToAngle();
|
|
|
|
// TODO SPRITE LAYER ROTATION
|
|
// Currently this doesn't support layers with scale & rotation. Whenever/if-ever that should be added,
|
|
// this needs fixing. See also Layer.CalculateBoundingBox and other engine code with similar warnings.
|
|
|
|
// Convert to sprite-coordinates. This is the same as for the texture check, but now also includes
|
|
// directional angle-snapping corrections in modAngle (+ the previous NoRot stuff)
|
|
var layerPos = invSpriteMatrix.Transform(modAngle.RotateVec(localPos));
|
|
|
|
// Convert to image coordinates
|
|
var layerImagePos = (Vector2i) (layerPos * EyeManager.PixelsPerMeter * (1, -1) + layer.ActualRsi.Size / 2f);
|
|
|
|
// Next, to get the right click map we need the "direction" of this layer that is actually being used to draw the sprite on the screen.
|
|
// This **can** differ from the dir defined before, but can also just be the same.
|
|
if (sprite.EnableDirectionOverride)
|
|
dir = sprite.DirectionOverride.Convert(state.Directions);;
|
|
dir = dir.OffsetRsiDir(layer.DirOffset);
|
|
|
|
if (_clickMapManager.IsOccluding(layer.ActualRsi, layer.State, dir, layer.AnimationFrame, layerImagePos))
|
|
return true;
|
|
}
|
|
|
|
drawDepth = default;
|
|
renderOrder = default;
|
|
return false;
|
|
}
|
|
|
|
public bool CheckDirBound(ISpriteComponent sprite, Angle relativeRotation, Vector2 localPos, Matrix3 spriteMatrix)
|
|
{
|
|
if (Bounds == null)
|
|
return false;
|
|
|
|
// Here we get sprite orientation, either from an explicit override or just from the relative rotation
|
|
var direction = relativeRotation.GetCardinalDir();
|
|
|
|
// Assuming the sprite snaps to 4 orientations we need to adjust our localPos relative to the entity by 90
|
|
// degree steps. Effectively, this accounts for the fact that the entity's world rotation + sprite rotation
|
|
// does not match the **actual** drawn rotation.
|
|
var modAngle = direction.ToAngle();
|
|
|
|
// If our sprite does not rotate at all, we shouldn't have been bothering with all that rotation logic,
|
|
// but it sorta came for free with the matrix transform, but we gotta undo that now.
|
|
if (sprite.NoRotation)
|
|
modAngle += CalcRectWorldAngle(relativeRotation, 4);
|
|
|
|
var spritePos = spriteMatrix.Transform(modAngle.RotateVec(localPos));
|
|
|
|
// First, check the bounding box that is valid for all orientations
|
|
if (Bounds.All.Contains(spritePos))
|
|
return true;
|
|
|
|
// Next, get and check the appropriate bounding box for the current sprite orientation
|
|
var boundsForDir = (sprite.EnableDirectionOverride ? sprite.DirectionOverride : direction) switch
|
|
{
|
|
Direction.East => Bounds.East,
|
|
Direction.North => Bounds.North,
|
|
Direction.South => Bounds.South,
|
|
Direction.West => Bounds.West,
|
|
_ => throw new InvalidOperationException()
|
|
};
|
|
|
|
return boundsForDir.Contains(spritePos);
|
|
}
|
|
|
|
[DataDefinition]
|
|
public sealed class DirBoundData
|
|
{
|
|
[ViewVariables] [DataField("all")] public Box2 All;
|
|
[ViewVariables] [DataField("north")] public Box2 North;
|
|
[ViewVariables] [DataField("south")] public Box2 South;
|
|
[ViewVariables] [DataField("east")] public Box2 East;
|
|
[ViewVariables] [DataField("west")] public Box2 West;
|
|
}
|
|
}
|
|
}
|