【UGUI】背包案例(四)

这篇主要实现背包内的道具拖拽功能

创建一个Prpo类，用来实现拖拽功能，

1. 首先要继承三个接口 IBeginDragHandler, IDragHandler, IEndDragHandler
   拖拽开始：IBeginDragHandler、拖拽中：IDragHandler、拖拽结束：IEndDragHandler
   

2. 实现接口
   

3. 在方法内填写逻辑代码
   先定义这几个私有变量，用来记录信息
   

	/// <summary>
    /// IBeginDragHandler,开始拖拽
    /// </summary>
    /// <param name="eventData"></param>
    public void OnBeginDrag(PointerEventData eventData)
    {
        //计算鼠标位置和UI位置的偏移量
        offset= Input.mousePosition - transform.position;
        //记录下道具拖拽前的所属格子，在拖拽功能不满足时，复位在此节点
        parent = transform.GetComponentInParent<Grid>().transform;
        //将父物体设置为Canvas，这是UI在层级列表最下面，不会被别的UI挡住；
        transform.SetParent(PrpoManager.instance.m_canvas.transform);
        isDrag = true;
    }
    
    /// <summary>
    /// IDragHandler,拖拽中
    /// </summary>
    /// <param name="eventData"></param>
    public void OnDrag(PointerEventData eventData)
    {
        //拖拽中，UI位置等于鼠标位置加上偏移量
        transform.position = Input.mousePosition - offset;
        //将UI设置为可穿透，这样鼠标就不会被挡住，可以获得我们目标位置的信息
        m_image.raycastTarget = false;

    }

4. 当拖拽结束放松鼠标时，我们要对目标点进行判断，先罗列一下会遇到的情况
   目标点是空Null —— 复位
   目标点是没意义的UI —— 复位
   目标点是背包内别的道具 —— 交换位置
   目标点是背包内同杨的道具 —— 数字相加，位置到目标点
   目标点是商城 —— 出售
   目标点是玩家 —— 穿戴或使用
   目标点是出售按钮 —— 出售
   目标点是丢弃 —— 删除

写好后大致是这个样子，实现了拖拽、交换、合并
装备和出售等功能，我会写在专门的背包class中，这边调用就行了

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;

public class Prpo : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler
{
    Grid.GridType prpoType;

    void Start()
    {
        m_image = GetComponent<Image>();

        prpoType = GetComponentInParent<Grid>().gridType;
    }
    /// <summary>
    /// 自身的Image组件
    /// </summary>
    Image m_image;
    /// <summary>
    /// 记录偏移量
    /// </summary>
    Vector3 offset;
    /// <summary>
    /// 记录父节点
    /// </summary>
    Transform parent;
    /// <summary>
    /// 是否在拖拽
    /// </summary>
    bool isDrag;

    /// <summary>
    /// IBeginDragHandler,开始拖拽
    /// </summary>
    /// <param name="eventData"></param>
    public void OnBeginDrag(PointerEventData eventData)
    {
        //计算鼠标位置和UI位置的偏移量
        offset = Input.mousePosition - transform.position;
        //记录下道具拖拽前的所属格子，在拖拽功能不满足时，复位在此节点
        parent = transform.GetComponentInParent<Grid>().transform;
        //将父物体设置为Canvas，这是UI在层级列表最下面，不会被别的UI挡住；
        transform.SetParent(PrpoManager.instance.m_canvas.transform);
        isDrag = true;
    }
    /// <summary>
    /// IDragHandler,拖拽中
    /// </summary>
    /// <param name="eventData"></param>
    public void OnDrag(PointerEventData eventData)
    {
        //拖拽中，UI位置等于鼠标位置加上偏移量
        transform.position = Input.mousePosition - offset;
        //将UI设置为可穿透，这样鼠标就不会被挡住，可以获得我们目标位置的信息
        m_image.raycastTarget = false;

    }
    /// <summary>
    /// IEndDragHandler，拖拽结束
    /// </summary>
    /// <param name="eventData"></param>
    public void OnEndDrag(PointerEventData eventData)
    {
        isDrag = false;
        m_image.raycastTarget = true;

        //目标位置信息获取
        GameObject tager = eventData.pointerEnter;
        //目标位置为空
        if (!tager)
        {
            //复位
            ResetPoint();
            return;
        }
        //目标位置既不是空位，也不是道具
        else if (!tager.GetComponent<Prpo>() && !tager.GetComponent<Grid>())
        {
            //复位
            ResetPoint();
            return;
        }

        //目标点为道具
        else if (tager.GetComponent<Prpo>())
        {
            //属于同一界面的道具
            if (prpoType == tager.GetComponent<Prpo>().prpoType)
            {
                if (prpoType == Grid.GridType.KNAPSACK)
                {
                    //道具相同
                    if (tager.GetComponent<Image>().sprite== GetComponent<Image>().sprite)
                    {
                        Merge(tager.transform);
                    }
                    else
                    {
                        Interchange(tager.transform);
                    }
                }
                else
                {
                    ResetPoint();
                }
            }
            else
            {
                switch (prpoType)
                {
                    case Grid.GridType.KNAPSACK:
                        if (tager.GetComponent<Prpo>().prpoType == Grid.GridType.SHOP)
                        {
                            //出售
                        }
                        else if (tager.GetComponent<Prpo>().prpoType == Grid.GridType.PLAYER)
                        {
                            //判断是否可以装备
                        }
                        break;
                    case Grid.GridType.SHOP:
                        //购买
                        break;
                    case Grid.GridType.PLAYER:
                        //脱下，并且排序到背包各自中
                        break;
                    default:
                        break;
                }
            }
        }

        //目标点为格子
        else if (tager.GetComponent<Grid>())
        {
            //属于同一界面的道具
            if (prpoType == tager.GetComponent<Grid>().gridType)
            {
                if (prpoType == Grid.GridType.KNAPSACK)
                {
                    if (tager.transform.childCount == 0)
                    {
                        transform.SetParent(tager.transform);
                        transform.localPosition = Vector3.zero;
                    }
                    //格子下本身有道具
                    else
                    {
                        tager = tager.transform.GetChild(0).gameObject;
                        if (tager.GetComponent<Image>().sprite == GetComponent<Image>().sprite)
                        {
                            Merge(tager.transform);
                        }
                        else
                        {
                            Interchange(tager.transform);
                        }
                    }
                }
                else
                {
                    ResetPoint();
                }
            }
        }

        else
        {
            ResetPoint();
        }
    }

    /// <summary>
    /// 复位，返回原格子下
    /// </summary>
    private void ResetPoint()
    {
        transform.SetParent(parent);

        transform.localPosition = Vector3.zero;

        transform.localScale = Vector3.one;
    }
    /// <summary>
    /// 交换位置
    /// </summary>
    private void Interchange(Transform tager)
    {
        transform.SetParent(tager.transform.parent);
        transform.localPosition = Vector3.zero;
        tager.transform.SetParent(parent);
        tager.transform.localPosition = Vector3.zero;
        parent = transform.parent;
    }
    private void Merge(Transform tager)
    {
        int quantity = int.Parse(GetComponentInChildren<Text>().text) + int.Parse(tager.GetComponentInChildren<Text>().text);
        tager.GetComponentInChildren<Text>().text = quantity.ToString();
        Destroy(gameObject);
    }
}