NLDClient-yudde/ProjectNLD/Assets/Code/Scripts/Framework/UI/ButtonUpDrag.cs

using System;
using Framework;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

public class ButtonUpDrag: MonoBehaviour, IPointerDownHandler, IPointerUpHandler
{
    private bool _isPressed;
    private bool _isLastFramePressed;
    private float _pressedTime;
    private const float MinDelta = 0.01f;
    private const float MinLongPressTime = 0.35f;
    public static float MinUpDelta = 50f * (Screen.height / 1080f);

    private float _maxHorDelta = 0f;
    
    private bool _bUpDrag;
    private bool _bLongPress;
    private bool _bOnClick;
    public delegate void OnUpDrag();
    public delegate void OnLongPress();
    public delegate void OnClick();
    public delegate void OnLongPressCancel();

    public delegate void OnPointUp();
    public delegate void OnPointDown();
    public OnPointUp onPointUp;
    public OnPointDown onPointDown;
    
    public OnUpDrag onUpDrag;
    public OnLongPress onLongPress;
    public OnLongPressCancel onLongPressCancel;
    public OnClick onClick;

    /// <summary>
    /// 在 InputManager 判定触点已抬起且本组件曾处于按下时调用（与 Unity OnPointerUp 可能不同步，避免误触）。
    /// </summary>
    private Action onPressEndedByInput;

    private Vector2 _startPos;
    private Vector2 _curPos;

    /// <summary>
    /// 非空时：仅当触点移出该 Rect 的屏幕范围才取消长按；为空时沿用 MinDelta 位移判定。
    /// </summary>
    private RectTransform _longPressCancelBounds;
    
    public void AddPointerUp(Action action)
    {
        onPointUp += () =>
        {
            action?.Invoke();
        };
    }
    
    public void AddPointerDown(Action action)
    {
        onPointDown += () =>
        {
            action?.Invoke();
        };
    }

    public void AddLongPress(OnLongPress action)
    {
        onLongPress += action;
    }
    
    public void AddLongPress<T>(Action<T> action, T param)
    {
        onLongPress += () =>
        {
            action?.Invoke(param);
        };
    }

    public void AddLongPressCancel(Action action)
    {
        onLongPressCancel += () =>
        {
            action?.Invoke();
        };
    }

    public void SetLongPressCancelBounds(RectTransform bounds)
    {
        _longPressCancelBounds = bounds;
    }

    public void AddPressEndedByInput(Action action)
    {
        onPressEndedByInput += action;
    }
    
    public void AddUpDrag(Action action)
    {
        onUpDrag += () =>
        {
            action?.Invoke();
        };
    }
    
    public void AddUpDrag<T>(Action<T> action, T param)
    {
        onUpDrag += () =>
        {
            action?.Invoke(param);
        };
    }

    public void OnPointerDown(PointerEventData eventData)
    {
        _isPressed = true;
        _bLongPress = true;
        _bUpDrag = true;
        _startPos = eventData.pressPosition;

        onPointDown?.Invoke();
    }
    
    public void OnPointerUp(PointerEventData eventData)
    {
        // _isPressed = false;
        // _bLongPress = true;
        // _bUpDrag = true;

        onPointUp?.Invoke();
    }
    
    
    private void Awake()
    {
        InputManager.Instance.OnFingerUpUI += _OnPutUp;
        InputManager.Instance.OnFingerUp += _OnPutUp;
    }

    private void OnDestroy()
    {
        if (InputManager.Instance)
        {
            InputManager.Instance.OnFingerUpUI -= _OnPutUp;
            InputManager.Instance.OnFingerUp -= _OnPutUp;
        }
    }

    private void Update()
    {
        if (!_isPressed)
        {
            _bOnClick = false;
            _isLastFramePressed = false;
            _pressedTime = 0f;
            _maxHorDelta = 0f;
            return;
        }

        if (_isPressed)
        {
            _curPos = InputManager.Instance.GetTouchPosition();
            //长按
            if (_bLongPress)
            {
                bool cancelByBounds = _longPressCancelBounds != null &&
                    !IsScreenPointInsideRect(_longPressCancelBounds, _curPos);
                bool cancelByDelta = _longPressCancelBounds == null &&
                    (_curPos - _startPos).sqrMagnitude > MinDelta;

                if (cancelByBounds || cancelByDelta)
                {
                    _bLongPress = false;
                    _bOnClick = false;
                    onLongPressCancel?.Invoke();
                }
                else if (_pressedTime > MinLongPressTime)
                {
                    onLongPress?.Invoke();
                    _bLongPress = false;
                }
            }
            
            //上滑
            if (!_bLongPress && _bUpDrag)
            {
                var disSqrY = Mathf.Sqrt(Mathf.Pow(_curPos.y - _startPos.y, 2));
                var disSqrX = Mathf.Sqrt(Mathf.Pow(_curPos.x - _startPos.x, 2));
                //防止拖过去拖回来少算
                if (_maxHorDelta < disSqrX)
                {
                    _maxHorDelta = disSqrX;
                }
                //调节水平拖动敏感程度
                if (_maxHorDelta < MinUpDelta * 4)
                {
                    if (disSqrY > MinUpDelta)
                    {
                        onUpDrag?.Invoke();
                        _bUpDrag = false;
                    }
                }
            }

            _pressedTime += Time.deltaTime;
            if (!_isLastFramePressed)
            {
                _isLastFramePressed = true;
            }
            
        }
    }

    private void _OnPutUp(Vector2 pos)
    {
        if (_isPressed)
        {
            onPressEndedByInput?.Invoke();
            _isPressed = false;
            _bLongPress = true;
            _bUpDrag = true;
        }
    }
    
    public void RemoveAll()
    {
        onLongPress = null;
        onPointDown = null;
        onPointUp = null;
        onClick = null;
        onUpDrag = null;
        onPressEndedByInput = null;
    }

    private static bool IsScreenPointInsideRect(RectTransform rt, Vector2 screenPoint)
    {
        if (rt == null) return true;
        Canvas canvas = rt.GetComponentInParent<Canvas>();
        Camera cam = null;
        if (canvas != null && canvas.renderMode != RenderMode.ScreenSpaceOverlay)
            cam = canvas.worldCamera;
        return RectTransformUtility.RectangleContainsScreenPoint(rt, screenPoint, cam);
    }
}