public void OnDrag(PointerEventData eventData)
 {
     Vector3 newPosition;
     newPosition = mainCam.ScreenToWorldPoint(eventData.position);
     newPosition.z = 0f;
     dragObject.transform.position = newPosition;
 }

        public void OnEndDrag(PointerEventData eventData)
        {
            try
            {
                if (inv.DragAndDropEnabled)
                {
                    GetComponent<CanvasGroup>().blocksRaycasts = true;
                    transform.GetComponent<RectTransform>().anchoredPosition3D = startPosition;

                    bool foundParent = false;
                    for (int i = 0; i < inv.SlotList.Count; i++)
                    {
                        if (transform.parent == inv.SlotList[i])
                        {
                            foundParent = true;
                        }
                    }
                    if (foundParent == false)
                    {
                        transform.SetParent(startParent);
                        transform.GetComponent<RectTransform>().anchoredPosition3D = startPosition;
                    }

                }
            }
            catch (Exception ex)
            {

            }
        }

	public void OnDrag(PointerEventData eventData) {
		//Debug.Log ("OnDrag");
		
		this.transform.position = eventData.position;

		if(placeholder.transform.parent != placeholderParent)
			placeholder.transform.SetParent(placeholderParent);

		int newSiblingIndex = placeholderParent.childCount;

		for(int i=0; i < placeholderParent.childCount; i++) {
			if(this.transform.position.x < placeholderParent.GetChild(i).position.x) {

				newSiblingIndex = i;

				if(placeholder.transform.GetSiblingIndex() < newSiblingIndex)
					newSiblingIndex--;

				break;
			}
		}

		placeholder.transform.SetSiblingIndex(newSiblingIndex);


	}

 public void OnPointerEnter(PointerEventData eventData)
 {
     if(OnPointerEnterButton != null)
     {
         OnPointerEnterButton(this);
     }
 }

 void OnUp( PointerEventData eventData , GameObject go , string[] args )
 {
     if (enabled)
     {
         UI_TweenScale.Begin(tweenTarget.gameObject , duration , mScale).from = pressed;
     }
 }

    public void OnEndDrag(PointerEventData eventData)
    {
        DroppingBirds sling = null;

        //We could look up hovered[0] for the sling, the loop is just a safety measure in case something obstructs the sling
        foreach (GameObject i in eventData.hovered)
        {
            if (i.name == "Sling")
            {
                sling = i.GetComponent<DroppingBirds>();
            }
        }
        //if (eventData.pointerEnter && eventData.pointerEnter.CompareTag("SlingCanvas"))
        //{
        //    sling = eventData.pointerEnter.GetComponent<DroppingBirds>();
        //}

        //If no sling was found in the hovered objects, delete the dragged bird sprite and end the function
        if (!sling)
        {
            Instantiate(explosion, dragObject.transform.position + explosionOffset, Quaternion.identity);
            Destroy(dragObject);
            return;
        }

        //We add one bird of type X to the slingshot. After that we destroy the dragged sprite.
        sling.birdList.Add(info.GetComponent<Bird>().prefab);
        Destroy(dragObject);

        //Now we update the canvas attached to the sling
        sling.UpdateCanvas();
    }

 //拖动
 public void OnDrag(PointerEventData evt)
 {
         if (listView != null)
     {
        // listView.OnScroll(evt);
     }
 }

 public void OnBeginDrag(PointerEventData eventData)
 {
     if (isSelectable) {
         attackController.SpawnMarker ();
         isDragging = true;
     }
 }

	public void OnPointerDown(PointerEventData eventData){
		if(!touched){
			touched = true;
			pointerID = eventData.pointerId;
			origin = eventData.position;
		}
	}

    public void OnDrag(PointerEventData eventData)
    {
        if (!cardIsMine) return;

        this.transform.position = eventData.position;

        if (placeholder.transform.parent != placeholderParent)
        {
            placeholder.transform.SetParent(placeholderParent);
        }

        int newSiblingIndex = placeholderParent.childCount;
        for(int i = 0; i < placeholderParent.childCount; i++)
        {
            if(this.transform.position.x < placeholderParent.GetChild(i).position.x)
            {
                newSiblingIndex = i;
                if(placeholder.transform.GetSiblingIndex() < newSiblingIndex)
                {
                    newSiblingIndex--;
                }

                break;
            }
        }

        placeholder.transform.SetSiblingIndex(newSiblingIndex);
    }

        public override void Raycast(PointerEventData eventData, List<RaycastResult> resultAppendList)
        {
            if (eventCamera == null)
                return;

            var ray = eventCamera.ScreenPointToRay(eventData.position);

            float dist = eventCamera.farClipPlane - eventCamera.nearClipPlane;

            var hits = Physics2D.RaycastAll(ray.origin, ray.direction, dist, finalEventMask);

            if (hits.Length != 0)
            {
                eventData.worldPosition = hits[0].point;
                eventData.worldNormal = hits[0].normal;
                for (int b = 0, bmax = hits.Length; b < bmax; ++b)
                {
                    SpriteRenderer sr = hits[b].collider.gameObject.GetComponent<SpriteRenderer>();

                    var result = new RaycastResult
                    {
                        gameObject = hits[b].collider.gameObject,
                        module = this,
                        distance = Vector3.Distance(eventCamera.transform.position, hits[b].transform.position),
                        index = resultAppendList.Count,
                        sortingLayer =  sr != null ? sr.sortingLayerID : 0,
                        sortingOrder = sr != null ? sr.sortingOrder : 0
                    };
                    resultAppendList.Add(result);
                }
            }
        }

 public void OnBeginDrag(PointerEventData eventData)
 {
     itemBeingDragged = gameObject;
     startPosition = transform.position;
     startParent = transform.parent;
     GetComponent<CanvasGroup> ().blocksRaycasts = false;
 }

	public void OnPointerEnter(PointerEventData e)
	{
        if (!isActive) return;

        tooltipController.SetTextsActive(title.Length > 0, desc.Length > 0);
		tooltipController.OnActivate(title, desc);
	}

 public void OnPointerUp(PointerEventData eventData)
 {
     foreach (var dpadAxis in DpadAxis)
     {
         dpadAxis.TryRelease(eventData.pointerId);
     }
 }

    public void OnPointerExit(PointerEventData data)
    {
        if (containerImage == null)
            return;

        containerImage.color = normalColor;
    }

    public void OnDrop(PointerEventData eventData)
    {
        if(!item) //Se o slot estiver vazio
        {
            if(!slotDescarte)
            {
                DragHandler.itemSendoArrastado.transform.SetParent(transform, false);

                //Se for slot de combinacao, adiciona ao vetor de ervilhas na pos especifica
                if(this.slotComb)
                    geneComb.vetorErvilhas[numSlotComb - 1] = DragHandler.itemSendoArrastado;

                if(!DragHandler.podeGerar)
                    Spawner.acabeiMover = true;

                //Se o slot do pai FOR de combinacao, apaga o antigo e sobrescreve o novo
                else
                {
                    geneComb.vetorErvilhas[numSlotComb - 1] = DragHandler.itemSendoArrastado;
                    geneComb.vetorErvilhas[numSlotCombPai - 1] = null;
                }
            }
            else
            {
                if(DragHandler.podeGerar)
                    Destroy(DragHandler.itemSendoArrastado);
            }
        }
    }

    private bool pressingButtonToSplit; //bool for pressing a item to split it

    #endregion Fields

    #region Methods

    //splitting the item now
    public void OnPointerDown(PointerEventData data)
    {
        inv = transform.parent.parent.parent.GetComponent<Inventory>();
        if (transform.parent.parent.parent.GetComponent<Hotbar>() == null && data.button == PointerEventData.InputButton.Left && pressingButtonToSplit && inv.stackable && (inv.ItemsInInventory.Count < (inv.height * inv.width))) //if you press leftclick and and keycode
        {
            ItemOnObject itemOnObject = GetComponent<ItemOnObject>();                                                   //we take the ItemOnObject script of the item in the slot

            if (itemOnObject.item.itemValue > 1)                                                                         //we split the item only when we have more than 1 in the stack
            {
                int splitPart = itemOnObject.item.itemValue;                                                           //we take the value and store it in there
                itemOnObject.item.itemValue = (int)itemOnObject.item.itemValue / 2;                                     //calculate the new value for the splitted item
                splitPart = splitPart - itemOnObject.item.itemValue;                                                   //take the different

                inv.addItemToInventory(itemOnObject.item.itemID, splitPart);                                            //and add a new item to the inventory
                inv.stackableSettings();

                if (GetComponent<ConsumeItem>().duplication != null)
                {
                    GameObject dup = GetComponent<ConsumeItem>().duplication;
                    dup.GetComponent<ItemOnObject>().item.itemValue = itemOnObject.item.itemValue;
                    dup.GetComponent<SplitItem>().inv.stackableSettings();
                }
                inv.updateItemList();

            }
        }
    }

	public void OnPointerUp(PointerEventData eventData){
		if(pointerID == eventData.pointerId){
			touched = false;
			direction = Vector2.zero;
			smoothDirection = Vector2.zero;
		}
	}

 public void OnEndDrag(PointerEventData eventData)
 {
     if (isSelectable) {
         Vector3 pointerPos = eventData.pointerCurrentRaycast.worldPosition;
         attackController.FlingMarker (pointerPos);
     }
 }

	public void OnBeginDrag (PointerEventData eventData)
	{
		//Debug.Log("begin dragging");
		currentParent = this.transform.parent;
		this.transform.SetParent(transferTransform);
		GetComponent<CanvasGroup>().blocksRaycasts = false;
	}