Game backpack system, "inventory Pro plug-in", research and learning ----- mom doesn't have to worry that I won't make a backpack anymore (unity3d)

Recommended reading

• CSDN Home page

• GitHub Open source address

• Unity3D Plug in sharing

• Jane book address

• My personal blog

• QQ Group ：1040082875

One 、 Preface

I like to study these plug-ins , Why? , Because it's convenient . There is basically no need to study how the source code is implemented , As long as there will be . however , This alone is not enough , It's still necessary to see how the underlying code is implemented , There is also how other people's framework is built . Or else Unity3D It's easy to get started , It's hard to improve , Because promotion depends on hard work , Study the underlying code . Forget it , Stop talking

Two 、 Reference article

Unity3D  Equipment system learning Inventory Pro 2.1.2  summary

Unity3D  Equipment system learning Inventory Pro 2.1.2  The basic chapter

3、 ... and 、 Text

Let's start with an effect picture

Download link ：

https://github.com/764424567/Unity-plugin/tree/master/Menu/Unity3D-S-Inventory

If it doesn't work, remember to tell the blogger

1、 The overall structure

Item related

• Not UI relevant InventoryItem  Goods system , For example, equipment , consumables , Store items, etc

• UI relevant InventoryUIItemWrapper  Goods system

• UIItem Of UI Packaged Item Inheritance system

• ItemCollection Such a class , Because simple increase 、 Deletion and modification are inevitable , Complex as exchange , Exchange between containers and other operations

UI Window related

• UIWindow Window class of the system , Specific roles , Bank , Skill , Shops and other windows

• InventoryUIDialog Dialog class under the system , There is a confirmation box , business , General tips

• Special window （ Non inheritance system window ）, Menu above and below , Notification window, etc

Management related classes

• Configuration Management

• InvertoryManager

• ItemManger

• Database operation

Other

Should be some auxiliary classes , Yes UI Part of the , Event assistance , Define interfaces and so on , This part has not been read in depth. It should also be very complicated

The rest

Some third-party plug-ins ,Unity3D Characteristics and Edit Expansion, etc

Specific class diagram

2、 Use the tutorial

Demonstration projects

In your Assets/Demos/Scenes  You will find these demonstration scenes , These demonstration scenarios will contain all the features , Be sure to look carefully

Build a new project

• choice 1（ Automatically ） Open the setup wizard , It can be found in Tools/Inventory Pro/Setup wizard For mistakes “ There are no objects found by managers ”; Click the OK button and a management object named "_managers" Will be automatically added to your scene .

• choice 2（ Manual ） Creating an empty GameObject will inventorymanager form , You can find it in   stock / The manager / inventorymanager You will get several manager components including inventorymanager,inventorysettingsmanager And more , We don't need now .

Database establishment

itemmanager Project database containing all projects , You can create and manage each scenario , And use different databases , Every scene .

1.  Go to your project window , Find a place , You want to create a project database .

2.  Right click （ Or click Create , Or create /  Inventory parent  / Project database ） To create a new project database .

3.  Once created, the database will be selected in your project .

4.  Drag the item to itemmanager Test question database slot . Now let's also create   Language database  , Do exactly the same thing , And assign it to inventorymanager Of  lang .

Configuration settings

First open the main editor, and you can find it in   Tools / Inventory parent / Editor in chief . When you open the editor, it will give you an error message for the first time （ See the picture below ）.

This is because the inventory Pro needs to know that it should save new items . single click “ Set up ” Button , Choose a folder   Your project in the folder .

Now let's open the integration manager and see again that we have to configure .

The first tab “UI” Contains for rendering UI The basic elements of . In order to do this, at least 2 Project   Item button preset  Item Button Prefab and  UIROOT.

This item button preset is the preset of  / The slot contains items . The root contains all user interface windows UI canvas .

Several demonstrators can be used to get started quickly . You can stock / demonstration / assets / The user interface / ui_prefabs / ui_item_pfb Find the default wrapper

And build a new UGUI, hold UI Canvas  Assign a value to  GUI ROOT.

3、Demo analysis

GettingStarted.unity

First of all Demo1 The function of , In fact, it's very simple, mainly to establish Inventory Pro Operating environment , First of all, the project Demo yes 3d So when creating a project , Choice is 3D engineering .

Operating environment , Use the standard plug-in library to create a role followed by a third-party perspective , Characters can be in Panel Free movement, running and jumping ; Then it is Inventroy Pro The basic configuration of , Mainly to introduce Setting, stay Setting Some basic configurations are carried out in .

The specific interface after operation is shown in the figure below

Set up a character

The first step is Scene Add a Panel, Then set it larger , Otherwise, the character will fall

The second step , Find the role in the figure prefab Then drag it directly into the scene ,reset Then you can.

The third-party camera follows

The third-party camera follows , It is also carried out according to the standard process

1, Delete the original MainCarmar The camera

2, from Asset Drag and drop what we need Prefab Come to the scene

The third step , Set up the camera Target For our controlling role , Drag here

Finally, equipment system configuration creation

The basic environment is created , Now we need to create our own basic environment of the equipment system , It's about Srcript,Manage Four basic classes in the folder

Equipment system configuration class ,

Equipment system management

Item Management category （ The factory may not be accurate , Welcome to correct ）

Equipment data Asset class

Demo1 In fact, there are only two steps to achieve

First step , Create an empty game object , To configure InventorySetting class

The second step , Initialize the game Item data Asset

4、 example

Demo1： Use plug-ins to implement an equipment window

The function point ：

• 1、 Two windows are implemented , By clicking on the keyboard I Come on , Open or close the window, that is Toggle function

• 2、 The number of spaces in the item column in the equipment window is dynamically generated and controllable , You can configure it manually in the properties window

• 3、 The window has drag and drop function

• 4、 Window items have drag , And drag between windows

• 5、 You can use the function of the object in the window , Items have consumption sector display function

The specific effect picture is as follows ：

The plug-in USES

1、 Specific in UGUI  Medium Canvas Create a InventoryWindow

2、 stay InventoryWindow Create an empty GameObject And name Container, give Grid LayOut  plug-in unit

3、 to InventoryWindow add to InventoryUI Components , The plug-in will be automatically added WindowUI That is, the general window auxiliary plug-in

4、 Add drag and drop function components DraggableWindow, In this way, the window has the drag and drop function

So far, simply click I Key to open and close the equipment window

5、 summary

Finally, summarize the three classes that implement general windows , Namely WindowHelper Under folder ,UIWindow,UIWindowPage and DraggableWindow

1、DraggableWindow There are components that drag and drop windows , It's better here , It is also a simple example of plug-in programming , I learned it here UGui All students know to realize the drag function IBeginDragHandler and IDargHandler Interface can , The principle is simple ,  Source code is as follows

using UnityEngine;
using System.Collections;
using UnityEngine.EventSystems;
 
namespace Devdog.InventorySystem
{
 [AddComponentMenu("InventorySystem/UI Helpers/DraggableWindow")]
 public partial class DraggableWindow : MonoBehaviour, IBeginDragHandler, IDragHandler
 {
 public float dragSpeed = 1.0f;
 
 private Vector2 dragOffset;
 
 
 public void OnBeginDrag(PointerEventData eventData)
 {
 if (InventorySettingsManager.instance.isUIWorldSpace)
 dragOffset = transform.position - eventData.worldPosition; 
 else
 dragOffset = new Vector2(transform.position.x, transform.position.y) - eventData.position;
 }
 
 void IDragHandler.OnDrag(PointerEventData eventData)
 {
 transform.position = new Vector3(eventData.position.x + dragOffset.x * dragSpeed, eventData.position.y + dragOffset.y * dragSpeed, 0.0f);
 }
 }
}


2、UIWindow This class is the public class of the window , First, the main function points of the class diagram are marked on the class diagram , There is no nonsense here , The main thing is to close the display of the control window , And the difficulty of combining animation effect is to realize the function similar to the combined window （ This part will be carefully analyzed later ）

The source code is not all , The highlights of the above points are as follows ：

public virtual void Hide()
{
 if (isVisible == false)
 return;
 
 isVisible = false;
 
 if (OnHide != null)
 OnHide();
 
 if (hideAudioClip != null)
 InventoryUIUtility.AudioPlayOneShot(hideAudioClip);
 
 if (hideAnimation != null)
 {
 animator.enabled = true;
 animator.Play(hideAnimation.name);
 
 if (hideCoroutine != null)
 {
 StopCoroutine(hideCoroutine); 
 }
 
 hideCoroutine = _Hide(hideAnimation);
 StartCoroutine(hideCoroutine);
 }
 else
 {
 animator.enabled = false;
 SetChildrenActive(false);
 }
}
 
 
/// <summary>
/// Hides object after animation is completed.
/// </summary>
/// <param name=&quot;animation&quot;></param>
/// <returns></returns>
protected virtual IEnumerator _Hide(AnimationClip animation)
{
 yield return new WaitForSeconds(animation.length + 0.1f);
 
 // Maybe it got visible in the time we played the animation?
 if (isVisible == false)
 {
 SetChildrenActive(false);
 animator.enabled = false;
 }
}


The above part is the code of animation closing window with delay effect realized through the collaborative process , It's representative .

3、UIWindowPage class , This category is UIWindow Subclasses of , stay UIWindow There is one Page The set of is used for combined display UIWindowPage, This piece of Demo1 It is not involved in this function, so I won't analyze it carefully , Wait until the following examples appear , The highlight code is as follows ：

/// <summary>
/// Container that olds the items, if any.
/// </summary>
public RectTransform itemContainer;
public UIWindow windowParent { get; set; }
 
public override void Awake()
{
 base.Awake();
 
 windowParent = transform.parent.GetComponentInParent<UIWindow>();
 if (windowParent == null)
 Debug.LogWarning(&quot;No UIWindow found in parents&quot;, gameObject);
 
 // Register our page with the window parent
 windowParent.AddPage(this);
}
 
public override void Show()
{
 if(isEnabled == false)
 {
 Debug.LogWarning(&quot;Trying to show a disabled UIWindowPage&quot;);
 return;
 }
 
 base.Show();
 
 windowParent.NotifyPageShown(this);
}


here UIWindow and UIWindowPage  Itself is an inheritance relationship , However, they quote each other , The readability of the code is a little poor , The author here passes Page Class Awake and Show To initialize and call the parent class , It's also a way , I think it's OK （ Ask a master to pat the bricks ）.

Generally speaking, the current UIWinow and UIWindowPage More like a container Panel perhaps Group It's not like a window , Wait for later Demo There are complex relearning .

4、 How to invoke the window through the keyboard

This is relatively simple to use U3D I / O module , The key codes are as follows ：

/// <summary>
/// Keys to toggle this window
/// </summary>
public KeyCode[] keyCombination;
 
public virtual void Update()
{
 if (keyCombination.Length == 0)
 return;
 
 bool allDown = true;
 foreach (var key in keyCombination)
 {
 if (Input.GetKeyDown(key) == false)
 {
 allDown = false;
 }
 }
 
 if (allDown)
 Toggle();
 
}


Demo2： Specific implementation of general window

The function point ：

• 1、 Two windows are implemented , By clicking on the keyboard I Come on , Open or close the window, that is Toggle function

• 2、 The number of spaces in the item column in the equipment window is dynamically generated and controllable , You can configure it manually in the properties window

• 3、 The window has drag and drop function

• 4、 Window items have drag , And drag between windows

• 5、 You can use the function of the object in the window , Items have consumption sector display function

• 6、 Class architecture of general window

The specific use and functions of plug-ins have been described in the previous article, so I won't say more here

1、 This article focuses on  6 Class architecture of general window , The class organization and class diagram are as follows ：

The inheritance architecture of classes is discussed here , In the first article, you can check it by yourself

Class reference relationship 、 The core fields and methods are clearly marked in the class diagram , In a few simple words , Each grid in the equipment window is provided with a background by an empty grid UIItem and InventoryItemBase Model Composed of , The whole equipment window is a InventoryUI, This class inherits ItemCollectionBase class , That is to say, it has a set UIItem Equipment collection window , add UIWindow Components 、DraggableWindow It has the functions of dragging and moving ordinary windows and closing the display .

2、 The number of spaces in the item column in the equipment window is dynamically generated and controllable , You can configure it manually in the properties window

How to realize dynamic equipment window mainly has two core technologies ： One is UI Adaptive permutation in , That is to say Grid layout Group Components ; One is U3D Of prefab Instantiation Technology

dynamic initialization Cell The data core code is as follows

protected virtual void FillUI()
 {
 if (manuallyDefineCollection == false)
 {
 items = new InventoryUIItemWrapperBase[initialCollectionSize];

 // Fill the container on startup, can add / remove later on
 for (uint i = 0; i < initialCollectionSize; i++)
 {
 items[i] = CreateUIItem<InventoryUIItemWrapper>(i, itemButtonPrefab != null ? itemButtonPrefab : InventorySettingsManager.instance.itemButtonPrefab);
 }
 }
 else
 {
 for (uint i = 0; i < items.Length; i++)
 {
 items[i].itemCollection = this;
 items[i].index = i;
 }
 }
 }

 protected T CreateUIItem<T>(uint i, GameObject prefab) where T : InventoryUIItemWrapperBase
 {
 T item = GameObject.Instantiate<GameObject>(prefab).GetComponent<T>();
 item.transform.SetParent(container);
 item.transform.localPosition = new Vector3(item.transform.localPosition.x, item.transform.localPosition.y, 0.0f);
 item.itemCollection = this;
 item.transform.localScale = Vector3.one;
 item.index = i;
 
 return item;
 }


Is it simple  initailCollectionSize yes InventoryUI A common of base classes field That is to say, the number of this equipment grid , This can be set manually according to the equipment window designed by yourself , Then call according to this loop CreateUIItem<T> Generic methods pass ,GameObject.Instantiate Dynamically instantiate preset rig grid objects , And set up Parent And location

Demo3： The specific implementation of the general window can be dragged

Dragging objects between windows

I am in the process of learning , Although I read the source code and wrote the tutorial after a few days , Still a little unclear , Don't be familiar with cars （ This may be the difference between reading and writing ）, Ask yourself a few questions , Ask yourself a few questions before turning over the code again ：

• 1、 The initiator of drag and drop events should be of that kind ？

• 2、 Drag and drop events Drag How to determine the following UI Elemental ？

• 3、 Logical operation after dragging , Which class should undertake ？

• 4、 Drag and drop between windows , both Drag And then there is Drop, How to solve this problem more reasonably ？

• 5、 What is the logical process of dragging objects between windows and objects in the same window ？

A1  The initiator of drag and drop events should be of that kind ？： The initiator of dragging must be UI Element is necessary , Currently involved UI There are two kinds of elements. One is window container , A data equipment grid element , Obviously, the equipment grid element has more advantages , Because a layer of positioning logic judgment is missing ,Drag The event is directly initiated , You can also do Move Related logic of , here Inventory Pro2 It's really how to do it （ First contact here UGUI Students may want to learn about the relevant event system , Not much here ）, here InventoryUIItemWrapper It is the base class of equipment lattice , It's inherited here UGUI Correlation UI event ,IBeginDragHandler, IEndDragHandler, IDragHandler, IPointerUpHandler, IPointerDownHandler, IPointerEnterHandler, IPointerExitHandler, So many interfaces also indicate that the code is not simple

These are the interface implementation functions , If you understand them, you will understand how to realize dragging

A5  What is the logical process of dragging objects between windows and objects in the same window ？： It is reasonable to answer this question first , In the past winform There are not so many interfaces that can be implemented in the drag and drop of , But I believe that the logic of the drag operation itself should be unchanged , That is, a few steps ,

• 1） Click the left mouse button on the item （ Record the elements clicked by the mouse ）->

• 2） In mouse not up, And move The drag start is confirmed in the event （Drag event ） –>

• 3） mouse Move Get the element under the mouse in the event ->

• 4）mouse up  Events trigger Drop, Determine whether the mouse position and elements under the mouse can drop If it can be done Drop This is the logic , This drag operation ends

The technical prototype is so simple . Let's see below. Uintiy3d ugui Inventory Pro How is it realized , Read the code again , I feel deeply ,“ The principle is simple , The reality is cruel ”, It's still here ugui We did some packaging for the case , The functions involved here actually include 5 individual

• OnPointerEnter： OK, click that UI Elements , Corresponding 1）

• OnBeginDrag： Start dragging , Corresponding 2）

• OnDrag： Dragging , Corresponding 3）

• OnEndDrag： End drag , Corresponding 4）

• OnPointExit： Empty the selected element , Restore defaults

There are many specific codes, so I won't expand here , The good news here is ,Inventory Pro Encapsulate the dragging logic , stay InventoryUIItemWrapper In the interface implementation function , The main parameters are comfort , Mainly about UI The logic code of is encapsulated in InventoryUIUtility Class ,

The following is the code of the main interface implementation function

public virtual void OnBeginDrag(PointerEventData eventData)
 {
 if (itemCollection == null)
 return;

 if (item != null && eventData.button == PointerEventData.InputButton.Left && itemCollection.canDragInCollection)
 {
 // Create a copy
 var copy = GameObject.Instantiate<InventoryUIItemWrapper>(this);
 copy.index = index;
 copy.itemCollection = itemCollection;

 var copyComp = copy.GetComponent<RectTransform>();
 copyComp.SetParent(InventorySettingsManager.instance.guiRoot);
 copyComp.transform.localPosition = new Vector3(copyComp.transform.localPosition.x, copyComp.transform.localPosition.y, 0.0f);
 copyComp.sizeDelta = GetComponent<RectTransform>().sizeDelta;

 InventoryUIUtility.BeginDrag(copy, (uint)copy.index, itemCollection, eventData); // Make sure they're the same size, copy doesn't handle this.
 }
 }

 public virtual void OnDrag(PointerEventData eventData)
 {
 if (item != null && itemCollection != null && itemCollection.canDragInCollection) // Can only drag existing item
 InventoryUIUtility.Drag(this, index, itemCollection, eventData);
 }

 public virtual void OnEndDrag(PointerEventData eventData)
 {
 if (item != null && itemCollection != null && itemCollection.canDragInCollection)
 {
 var lookup = InventoryUIUtility.EndDrag(this, index, itemCollection, eventData);

 // Didn't end on a button or used wrong key.
 if (lookup == null)
 return;

 if (lookup.endOnButton)
 {
 // Place on a slot
 lookup.startItemCollection.SwapOrMerge((uint)lookup.startIndex, lookup.endItemCollection, (uint)lookup.endIndex);
 }
 else if (lookup.startItemCollection.useReferences)
 {
 lookup.startItemCollection.SetItem((uint)lookup.startIndex, null);
 lookup.startItemCollection[lookup.startIndex].Repaint();
 }
 else if(InventoryUIUtility.clickedUIElement == false)
 {
 TriggerDrop();
 }
 }
 }


Here are InventoryUIUtility Class encapsulated static function code

public static InventoryUIDragLookup BeginDrag(InventoryUIItemWrapper toDrag, uint startIndex, ItemCollectionBase collection, PointerEventData eventData)
 {
 if (draggingItem != null)
 {
 Debug.LogWarning("Item still attached to cursor, can only drag one item at a time", draggingItem.gameObject);
 return null; // Can only drag one item at a time
 }

 if (eventData.button != PointerEventData.InputButton.Left)
 return null;


 draggingItem = toDrag;
 //draggingButtonCollection = collection;

 // Canvas group allows object to ignore raycasts.
 CanvasGroup group = draggingItem.gameObject.GetComponent<CanvasGroup>();
 if(group == null)
 group = draggingItem.gameObject.AddComponent<CanvasGroup>();

 group.blocksRaycasts = false; // Allows rays to go through so we can hover over the empty slots.
 group.interactable = false;

 var lookup = new InventoryUIDragLookup();
 lookup.startIndex = (int)startIndex;
 lookup.startItemCollection = collection;

 return lookup;
 }

 public static void Drag(InventoryUIItemWrapper toDrag, uint startSlot, ItemCollectionBase handler, PointerEventData eventData)
 {
 if(eventData.button == PointerEventData.InputButton.Left)
 draggingItem.transform.position = new Vector3(eventData.position.x, eventData.position.y, 0.0f);
 }

 public static InventoryUIDragLookup EndDrag(InventoryUIItemWrapper toDrag, uint startSlot, ItemCollectionBase handler, PointerEventData eventData)
 {
 if(eventData.button == PointerEventData.InputButton.Left)
 {
 var lookup = new InventoryUIDragLookup();
 lookup.startIndex = (int)draggingItem.index;
 lookup.startItemCollection = draggingItem.itemCollection;

 if (hoveringItem != null)
 {
 lookup.endIndex = (int)hoveringItem.index;
 lookup.endItemCollection = hoveringItem.itemCollection;
 }

 Object.Destroy(draggingItem.gameObject); // No longer need it

 draggingItem = null;
 //draggingButtonCollection = null;

 return lookup;
 }

 return null;
 }

 /// <summary>
 /// When the cursor enters an item
 /// </summary>
 public static void EnterItem(InventoryUIItemWrapper item, uint slot, ItemCollectionBase handler, PointerEventData eventData)
 {
 hoveringItem = item;
 //hoveringItemCollection = handler;
 }

 /// <summary>
 /// When the cursor exits an item
 /// </summary>
 /// <param name=&quot;item&quot;></param>
 /// <param name=&quot;slot&quot;>The slot is the IButtonHandler index not the inventory index.</param>
 /// <param name=&quot;handler&quot;></param>
 /// <param name=&quot;eventData&quot;></param>
 public static void ExitItem(InventoryUIItemWrapper item, uint slot, ItemCollectionBase handler, PointerEventData eventData)
 {
 hoveringItem = null;
 //hoveringItemCollection = null;
 }


A2  Drag and drop events Drag How to determine the following UI Elemental ？

here DragDrop The elements in are composed of  OnPointerEnter  To trigger access （ It's kind of like Mouse Move event ）, Keep the details in InventoryUIUtility Class

public static InventoryUIItemWrapper hoveringItem { get; private set; }


A3  Logical operation after dragging , Which class should undertake ？

That is to say Drop Who will complete the operation of , First, recall your responsibilities InventoryUIItemWrapper Class is responsible for triggering events ,InventoryUIUtility Class responsible UI Related logic （ Choose , ray , Coordinate system ）

Look again. OnDragEnd function , Concrete Drop Logic has Drop Found after lookup Collection classes （ Equipment grid set base class ItemCollectionBase） To deal with , Specifically, there is exchange \ Merge two logics , The trigger code is as follows ：

if (lookup.endOnButton)
{
 // Place on a slot
 lookup.startItemCollection.SwapOrMerge((uint)lookup.startIndex, lookup.endItemCollection, (uint)lookup.endIndex);
}


Of course, there is a complex logic , Is the operation of throwing away items , This is specific Item Equipment model class （InventoryItemBase） To deal with it , The core code is TriggerDrop Method to call , As follows ：

public override void TriggerDrop(bool useRaycast = true)
 {
 if (item == null || itemCollection.canDropFromCollection == false)
 return;

 if(item.isDroppable == false)
 {
 InventoryManager.instance.lang.itemCannotBeDropped.Show(item.name, item.description);
 return;
 }

 Vector3 dropPosition = InventorySettingsManager.instance.playerObject.transform.position;
 Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
 RaycastHit hit;
 if (Physics.Raycast(ray, out hit, InventorySettingsManager.instance.maxDropDistance,
 InventorySettingsManager.instance.layersWhenDropping))
 {
 dropPosition = hit.point;
 }
 else
 {
 return; // Couldn't drop item
 }

 var s = InventorySettingsManager.instance;
 if (useRaycast && s.showConfirmationDialogWhenDroppingItem && s.showConfirmationDialogMinRarity.ID <= item.rarity.ID)
 {
 // Not on a button, drop it
 var tempItem = item; // Capture list stuff
 var msg = InventoryManager.instance.lang.confirmationDialogDrop;
 s.confirmationDialog.ShowDialog(msg.title, msg.message, s.defaultDialogPositiveButtonText, s.defaultDialogNegativeButtonText, item,
 (dialog) =>
 {
 ItemCollectionBase startCollection = tempItem.itemCollection;
 uint startIndex = tempItem.index;

 var d = tempItem.Drop(dropPosition);
 if (d != null)
 {
 startCollection[startIndex].Repaint();
 }
 },
 (dialog) =>
 {
 //Debug.Log(&quot;No clicked&quot;);
 });
 }
 else
 {
 var d = item.Drop(dropPosition);
 if (d != null)
 {
 Repaint();
 }
 }
 }


A4  Drag and drop between windows , both Drag And then there is Drop, How to solve this problem more reasonably ？

This question is rather round , In fact, it also involves problems 2, In fact, no matter how you drag, there are two things , One is the dragged object from, One is the place to put to, In fact, here are all grids in the window , As long as you have these two lattice classes from and to The container of , A special case is  from and to Two containers are equal , That is, drag and drop with the window , Specific to these objects InventoryUIUtilty Classes are encapsulated , The specific code is as follows ：

public class InventoryUIDragLookup
 {
 public int startIndex = -1;
 public ItemCollectionBase startItemCollection;

 public int endIndex = -1;
 public ItemCollectionBase endItemCollection;

 public bool endOnButton
 {
 get
 {
 return endItemCollection != null;
 }
 }
 }


 #region Variables 

 private static InventoryUIItemWrapper draggingItem;
 public static InventoryUIItemWrapper hoveringItem { get; private set; }
 public static bool isDraggingItem
 {
 get
 {
 return draggingItem != null;
 }
 }

 public static bool clickedUIElement
 {
 get
 {
 return EventSystem.current.IsPointerOverGameObject();
 }
 }


 public static bool isFocusedOnInput
 {
 get
 {
 if (EventSystem.current.currentSelectedGameObject != null)
 if (EventSystem.current.currentSelectedGameObject.GetComponent<UnityEngine.UI.InputField>() != null)
 return true;

 return false;
 }
 }

 #endregion


The complex drag and drop logic is summarized , It proves to us again , from helloworld How difficult it is to come to reality , The actual situation may be more complex, such as adding animation effects , Do network delay verification , Data synchronization and so on