博主cc最近用UGUI实现了一个拼图游戏，类似于背包系统（缺少背包系统中数据部分），包含了物品的拖拉拽，物品交换等操作
物品交换操作原理：

1. 脚本实现 IBeginDragHandler, IDragHandler, IEndDragHandler中的方法，进行物品移动的操作
2. 结束拖拽时，判断鼠标下面是否有物品，如果有就交换（交换父物体，并重置），否则物品归回原位置
3. 难点：物品拖拽时，若其他物品先渲染，会遮挡住正在拖拽的物体；解决方法：拖拽时，将物体父级设置为Canvas，结束拖拽后再设为原父级。

ImageLoad：用来加载图片

using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;

public class ImageLoad : MonoBehaviour
{
    public GameObject gridItemPrefab;
    private List<Item> itemList;

    void Start()
    {
        itemList = new List<Item>();
        InitItems();
    }

    //检测是否游戏成功
    private void OnItemEndDrag()
    {
        bool isSuccess = true;
        foreach (Item item in itemList)
        {
            if (item.IsPositionRight == false)
            {
                isSuccess = false;
                break;
            }
        }

        if (isSuccess)
        {
            Debug.Log("拼图成功！");
        }
        else
        {
            Debug.Log("图片还未拼成功！");
        }
    }

    private void InitItems()
    {
        Sprite[] imgArr = Resources.LoadAll<Sprite>("Image/testImg");

        int length = imgArr.Length;

        //保存实际的realIndex
        int[] realIndexArr = new int[length];
        for (int i = 0; i < length; i++)
        {
            realIndexArr[i] = i;
        }

        //打乱顺序
        for (int i = 0; i < length; i++)
        {
            int numRandom = Random.Range(0, length);
            Sprite tempSprite = imgArr[i];
            imgArr[i] = imgArr[numRandom];
            imgArr[numRandom] = tempSprite;

            int tempIndex = realIndexArr[i];
            realIndexArr[i] = realIndexArr[numRandom];
            realIndexArr[numRandom] = tempIndex;
        }

        for (int i = 0; i < length; i++)
        {
            Transform gridItem = GameObject.Instantiate(gridItemPrefab, transform).transform;
            Transform item = gridItem.Find("Item");
            item.tag = "ItemGrid";
            item.GetComponent<Image>().sprite = imgArr[i];
            Item tempItem = item.GetComponent<Item>();
            tempItem.SetIndex(realIndexArr[i], i);
            tempItem.AddEndDragListener(OnItemEndDrag);
            itemList.Add(tempItem);
        }
    }
}

Item：用来控制物品的交换

using UnityEngine;
using UnityEngine.EventSystems;
using System;

public class Item : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler
{
    private Vector3 offset;         //偏移量
    private Vector3 originPosition;  //拖拽前的位置
    private Transform canvasTransform;
    private Transform originParentTransform;   //父对象
    private CanvasGroup group;

    private int realIndex;  //实际的index
    [HideInInspector]
    public int curIndex;   //当前的index

    public bool IsPositionRight
    {
        get
        {
            if(realIndex != curIndex)
            {
                Debug.Log("实际位置：" + realIndex + "，当前位置：" + curIndex);
            }
            return realIndex == curIndex;
        }
    }

    private event Action EndDragEvent;

    void Awake()
    {
        canvasTransform = GameObject.Find("Canvas").transform;
        group = transform.GetComponent<CanvasGroup>();
    }

    public void SetIndex(int realIndex, int curIndex)
    {
        this.realIndex = realIndex;
        this.curIndex = curIndex;
    }

    public void AddEndDragListener(Action method)
    {
        EndDragEvent += method;
    }

    public void OnBeginDrag(PointerEventData eventData)
    {
        originParentTransform = transform.parent;
        offset = transform.position - Input.mousePosition;
        originPosition = transform.position;
        transform.SetParent(canvasTransform);
        group.blocksRaycasts = false;
    }

    public void OnDrag(PointerEventData eventData)
    {
        transform.position = Input.mousePosition + offset;
    }

    public void OnEndDrag(PointerEventData eventData)
    {
        GameObject tempGameObject = eventData.pointerCurrentRaycast.gameObject;
        if (tempGameObject != null && tempGameObject.tag == "ItemGrid")
        {
            transform.SetParent(tempGameObject.transform.parent);

            tempGameObject.transform.SetParent(originParentTransform);
            tempGameObject.GetComponent<RectTransform>().anchoredPosition = Vector2.zero;

            Item tempItem = tempGameObject.GetComponent<Item>();

            int tempCurIndex = tempItem.curIndex;
            tempItem.curIndex = this.curIndex;
            this.curIndex = tempCurIndex;
        }
        else
        {
            transform.SetParent(originParentTransform);
        }
        transform.GetComponent<RectTransform>().anchoredPosition = Vector2.zero;
        group.blocksRaycasts = true;

        if (EndDragEvent != null)
        {
            EndDragEvent();
        }
    }

}