CircuitBoxMouseDragSnapshotHandler.cs

#nullable enable
 
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using Microsoft.Xna.Framework;
 
namespace Barotrauma
{
    internal sealed class CircuitBoxMouseDragSnapshotHandler
    {
        public IEnumerable<CircuitBoxNode> Nodes
        {
            get
            {
                var cb = circuitBoxUi.CircuitBox;
 
                foreach (var label in cb.Labels) { yield return label; }
                foreach (var component in cb.Components) { yield return component; }
                foreach (var node in cb.InputOutputNodes) { yield return node; }
            }
        }
 
        private IReadOnlyList<CircuitBoxWire> Wires => circuitBoxUi.CircuitBox.Wires;
 
        // List of all connections in the circuit box
        private ImmutableArray<CircuitBoxConnection> connections = ImmutableArray<CircuitBoxConnection>.Empty;
 
                                                 // Nodes that were under cursor when dragging started
        private ImmutableHashSet<CircuitBoxNode> lastNodesUnderCursor = ImmutableHashSet<CircuitBoxNode>.Empty,
                                                 // Nodes that were selected when dragging started
                                                 lastSelectedComponents = ImmutableHashSet<CircuitBoxNode>.Empty,
                                                 // Nodes that should be moved when dragging
                                                 moveAffectedComponents = ImmutableHashSet<CircuitBoxNode>.Empty;
 
        public Option<(CircuitBoxResizeDirection, CircuitBoxNode)> LastResizeAffectedNode = Option.None;
 
        public ImmutableHashSet<CircuitBoxNode> GetLastComponentsUnderCursor() => lastNodesUnderCursor;
        public ImmutableHashSet<CircuitBoxNode> GetMoveAffectedComponents() => moveAffectedComponents;
 
        public Option<CircuitBoxConnection> LastConnectorUnderCursor = Option.None;
        public Option<CircuitBoxWire> LastWireUnderCursor = Option.None;
 
        public bool IsDragging { get; private set; }
 
        public bool IsWiring { get; private set; }
 
        public bool IsResizing { get; private set; }
 
        private Vector2 startClick = Vector2.Zero;
        private readonly CircuitBoxUI circuitBoxUi;
 
        private const float dragTreshold = 16f;
 
        public CircuitBoxMouseDragSnapshotHandler(CircuitBoxUI ui)
        {
            circuitBoxUi = ui;
        }
 
        public void StartDragging()
        {
            Vector2 cursorPos = circuitBoxUi.GetCursorPosition();
            SnapshotNodesUnderCursor(cursorPos);
            SnapshotSelectedNodes();
            SnapshotMoveAffectedNodes();
            startClick = cursorPos;
        }
        
        public void ClearSnapshot()
        {
            lastNodesUnderCursor = ImmutableHashSet<CircuitBoxNode>.Empty;
            lastSelectedComponents = ImmutableHashSet<CircuitBoxNode>.Empty;
            moveAffectedComponents = ImmutableHashSet<CircuitBoxNode>.Empty;
            LastConnectorUnderCursor = Option.None;
            LastWireUnderCursor = Option.None;
            LastResizeAffectedNode = Option.None;
        }
 
        public void UpdateConnections()
        {
            var builder = ImmutableArray.CreateBuilder<CircuitBoxConnection>();
 
            builder.AddRange(circuitBoxUi.CircuitBox.Inputs);
            builder.AddRange(circuitBoxUi.CircuitBox.Outputs);
 
            foreach (var node in Nodes)
            {
                builder.AddRange(node.Connectors);
            }
 
            connections = builder.ToImmutable();
        }
 
        public Option<CircuitBoxConnection> FindConnectorUnderCursor(Vector2 cursorPos)
        {
            foreach (var connection in connections)
            {
                if (connection.Contains(cursorPos))
                {
                    return Option.Some(connection);
                }
            }
 
            return Option.None;
        }
 
        public Option<CircuitBoxWire> FindWireUnderCursor(Vector2 cursorPos)
        {
            foreach (CircuitBoxWire wire in Wires)
            {
                if (wire is { IsSelected: true, IsSelectedByMe: false }) { continue; }
                if (wire.Renderer.Contains(cursorPos))
                {
                    return Option.Some(wire);
                }
            }
 
            return Option.None;
        }
 
        public ImmutableHashSet<CircuitBoxNode> FindNodesUnderCursor(Vector2 cursorPos)
        {
            var builder = ImmutableHashSet.CreateBuilder<CircuitBoxNode>();
            foreach (var node in Nodes)
            {
                if (node is { IsSelected: true, IsSelectedByMe: false }) { continue; }
                if (node.Rect.Contains(cursorPos))
                {
                    builder.Add(node);
                }
            }
 
            return builder.ToImmutable();
        }
 
        private void SnapshotNodesUnderCursor(Vector2 cursorPos)
        {
            lastNodesUnderCursor = FindNodesUnderCursor(cursorPos);
            LastConnectorUnderCursor = FindConnectorUnderCursor(cursorPos);
            LastWireUnderCursor = FindWireUnderCursor(cursorPos);
            LastResizeAffectedNode = FindResizeBorderUnderCursor(lastNodesUnderCursor, cursorPos);
        }
 
        private Option<(CircuitBoxResizeDirection, CircuitBoxNode)> FindResizeBorderUnderCursor(ImmutableHashSet<CircuitBoxNode> nodes, Vector2 cursorPos)
        {
            if (!nodes.Any()) { return Option.None; }
 
            var node = circuitBoxUi.GetTopmostNode(nodes);
            if (node is null || !node.IsResizable) { return Option.None; }
 
            const float borderSize = 32f;
 
            var rect = node.Rect;
            RectangleF bottomBorder = new(rect.X, rect.Top, rect.Width, borderSize);
            RectangleF rightBorder = new(rect.Right - borderSize, rect.Y, borderSize, rect.Height);
            RectangleF leftBorder = new(rect.X, rect.Y, borderSize, rect.Height);
 
            bool hoverBottom = bottomBorder.Contains(cursorPos),
                 hoverRight = rightBorder.Contains(cursorPos),
                 hoverLeft = leftBorder.Contains(cursorPos);
 
            var dir = CircuitBoxResizeDirection.None;
 
            if (hoverBottom) { dir |= CircuitBoxResizeDirection.Down; }
            if (hoverRight) { dir |= CircuitBoxResizeDirection.Right; }
            if (hoverLeft) { dir |= CircuitBoxResizeDirection.Left; }
 
            if (dir is CircuitBoxResizeDirection.None)
            {
                return Option.None;
            }
 
            return Option.Some((dir, node));
        }
 
        private void SnapshotSelectedNodes()
        {
            lastSelectedComponents = Nodes.Where(static n => n is { IsSelected: true, IsSelectedByMe: true }).ToImmutableHashSet();
        }
 
        private void SnapshotMoveAffectedNodes()
        {
            bool moveSelection = lastNodesUnderCursor.Any(node => lastSelectedComponents.Contains(node));
 
            /*
             * If the user is dragging a selection, we should move all selected nodes (true).
             * 
             * But for convenience, if the user is dragging a single node that is not part of the selection,
             * we should move that node only instead and leave the selection alone. (false)
             */
            moveAffectedComponents = moveSelection switch
            {
                true => lastSelectedComponents,
                false => circuitBoxUi.GetTopmostNode(lastNodesUnderCursor) switch
                {
                    null => ImmutableHashSet<CircuitBoxNode>.Empty,
                    var node => ImmutableHashSet.Create(node)
                }
            };
        }
 
        public Vector2 GetDragAmount(Vector2 mousePos) => mousePos - startClick;
 
        public void EndDragging()
        {
            startClick = Vector2.Zero;
            IsDragging = false;
            IsWiring = false;
            IsResizing = false;
            lastNodesUnderCursor = ImmutableHashSet<CircuitBoxNode>.Empty;
        }
 
        public void UpdateDrag(Vector2 cursorPos)
        {
            // if there are no connectors under cursor, we can't be wiring anything
            if (LastConnectorUnderCursor.IsNone())
            {
                IsWiring = false;
            }
 
            // if there are no nodes under cursor, we can't be dragging anything
            if (lastNodesUnderCursor.IsEmpty)
            {
                IsDragging = false;
            }
 
            if (LastResizeAffectedNode.IsNone())
            {
                IsResizing = false;
            }
 
            // startClick is set to zero when the user releases the mouse button, so we should be neither dragging nor wiring in this state
            if (startClick == Vector2.Zero)
            {
                IsDragging = false;
                IsWiring = false;
                IsResizing = false;
                return;
            }
 
            if (circuitBoxUi.Locked) { return; }
            bool isDragThresholdExceeded = Vector2.DistanceSquared(startClick, cursorPos) > dragTreshold * dragTreshold;
 
            if (LastConnectorUnderCursor.IsSome())
            {
                IsWiring |= isDragThresholdExceeded;
            }
            else if (LastResizeAffectedNode.IsSome())
            {
                IsResizing |= isDragThresholdExceeded;
            }
            else
            {
                IsDragging |= isDragThresholdExceeded;
            }
        }
    }
}