【UGUI】背包案例(四)_ibegindraghandler

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

创建一个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;

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201