protected Rectangle GetSlotPosition(InventorySlot slot)
 {
     switch (slot)
     {
         case InventorySlot.Head:
             return new Rectangle(48, 8, 34, 34);
         case InventorySlot.Necklace:
             return new Rectangle(8, 30, 34, 34);
         case InventorySlot.Backpack:
             return new Rectangle(88, 30, 34, 34);
         case InventorySlot.Armor:
             return new Rectangle(48, 50, 34, 34);
         case InventorySlot.Right:
             return new Rectangle(88, 70, 34, 34);
         case InventorySlot.Left:
             return new Rectangle(8, 70, 34, 34);
         case InventorySlot.Legs:
             return new Rectangle(48, 90, 34, 34);
         case InventorySlot.Feet:
             return new Rectangle(48, 130, 34, 34);
         case InventorySlot.Ring:
             return new Rectangle(8, 110, 34, 34);
         case InventorySlot.Ammo:
             return new Rectangle(88, 110, 34, 34);
     }
     return new Rectangle();
 }

    /// <summary>
    /// Utilise le consommable ou équipe l'arme du slot de raccourci envoyé en paramètres
    /// </summary>
    /// <param name="slot"></param>
    public void UseShortcutSlotItem(InventorySlot slot)
    {
        if (slot.IsEmpty)
            return;

        if (slot.Item.Type.Equals(ItemType.weapon))             // S'il s'agit d'une arme, on l'équipe
        {
            if (Inventory.leftHand.IsEmpty)
                Inventory.MoveOrMergeItem(slot, Inventory.leftHand, false);
            else
                Inventory.ExchangeItems(slot, Inventory.leftHand);

            LoadPlayingShortcutsSlots();
            return;
        }

        if (isBoostActive || !slot.Item.Type.Equals(ItemType.consumable))
            return;

        Inventory.UseConsumable(slot.Item, ref boostTimer, false);
        isBoostActive = true;

        boostItem = slot.Item;      // conservation pour enlever les bonus à la fin du temps de boost
        slot.Amount--;
        if (slot.Amount <= 0)       // On en enlève un en quantité, et supprime s'il s'agissait du dernier
        {
            slot.IsEmpty = true;
            slot.Item = new Item();
        }

        LoadPlayingShortcutsSlots();
    }

    ResourceItem CreateNewSplittedResource(InventorySlot slotScript, int times = -1)
    {
        int id = this._splitSlot._inventoryRef._itemInfoList[this._splitSlot._slotNum - 1]._itemInfo._uniqueItemID;
        ResourceItem resource = slotScript._inventoryRef._itemContainerObject.GetComponent<ItemContainer>().GetItem(id).GetComponent<ResourceItem>();
        int firstPopID = resource.PopStack();
        int splitCount = 0;
        if (times == -1)
        {
            splitCount = this._splitCount - 1;
        }
        else
        {
            splitCount = times - 1;
        }
        GameObject splitResource = this._splitSlot._inventoryRef._itemContainerObject.GetComponent<ItemContainer>().GetItem(firstPopID);
        ResourceItem splitResourceScript = splitResource.GetComponent<ResourceItem>();
        splitResourceScript.MaintainStack();

        for (int i = 0; i < splitCount; i++)
        {
            int idToAdd = this._splitSlot._inventoryRef._itemContainerObject.GetComponent<ItemContainer>().GetItem(resource.PopStack()).GetComponent<ResourceItem>()._uniqueItemID;
            splitResourceScript.AddToStack(idToAdd);
        }
        return splitResourceScript;
    }

 public static PacketWriter DropInventoryItem(InventorySlot slot, byte amount)
 {
     var pw = GetWriter(ClientPacketID.DropInventoryItem);
     pw.Write(slot);
     pw.Write(amount);
     return pw;
 }

        public HUDInventory()
        {
            InventorySlot.Width = InventorySlot.Size / Engine.Singleton.Camera.AspectRatio;
            Slots = new InventorySlot[SlotsCount];
            for (int i = 0; i < SlotsCount; i++)
                Slots[i] = new InventorySlot(SlotsSpacing, SlotsSpacing + i * (InventorySlot.Size + SlotsSpacing));

            SelectQuad = Engine.Singleton.Labeler.NewSimpleQuad("HighlightMaterial", SlotsSpacing, SlotsSpacing, InventorySlot.Width, InventorySlot.Size, new ColourValue(1, 1, 1), 4);

            DescriptionBg = Engine.Singleton.Labeler.NewSimpleQuad("QuadMaterial", 0.2f, 0.5f, 0.6f, 0.45f, ColourValue.White, 1);
            SelectedPicture = Engine.Singleton.Labeler.NewSimpleQuad("QuadMaterial",
                0.21f,
                0.58f,
                0.3f / Engine.Singleton.Camera.AspectRatio,
                0.3f, ColourValue.White, 2);
            DescriptionLabel = Engine.Singleton.Labeler.NewTextLabel("Primitive", 0.03f, new ColourValue(0.7f, 0.4f, 0), new ColourValue(1, 1.0f, 0.6f), 2);
            DescriptionLabel.SetPosition(0.45f, 0.51f);

            GoldBg = Engine.Singleton.Labeler.NewSimpleQuad("QuadMaterial", 0.7f, 0.1f, 0.2f, 0.1f, new ColourValue(1, 1, 1), 1);
            GoldLabel = Engine.Singleton.Labeler.NewTextLabel("Primitive", 0.05f, new ColourValue(0.7f, 0.4f, 0), new ColourValue(1, 1.0f, 0.6f), 2);
            GoldLabel.SetPosition(0.71f, 0.13f);

            InventoryBg = Engine.Singleton.Labeler.NewSimpleQuad("InventoryBgMaterial", 0.01f, 0.01f, 0.98f, 0.98f, new ColourValue(1, 1, 1), 0);
            CharacterPicture = Engine.Singleton.Labeler.NewSimpleQuad("Default", 0.4f, 0.1f, 0.2f / Engine.Singleton.Camera.AspectRatio, 0.2f, new ColourValue(1, 1, 1), 1);

            IsVisible = false;
        }

 public void RemoveItem(InventorySlot iS)
 {
     if (iS != null)
     {
         iS.UnHighlight();
         iS.m_currentHeldItem = null;
     }
 }

	public void OnBeginDrag (PointerEventData eventData)
	{
		homeSlot = GetComponentInParent<InventorySlot> ();
		transform.SetParent (GetComponentInParent<Canvas> ().transform);
		GameManager.InventoryManager.Select (gameObject);
		GameManager.TakeTag (HasTag);
		GameManager.GiveTag (HoldTag);
		GetComponent<CanvasGroup> ().blocksRaycasts = false;
	}

 public void PlaceItemInSlot(InventoryItem iI, InventorySlot iS)
 {
     iI.transform.position = iS.transform.position;
     iI.InventorySlot = iS;
     iS.m_currentHeldItem = iI;
     if (QuestManager.Instance.IsThisItemRequired(iI.gameObject))
     {
         iS.Highlight();
         QuestManager.Instance.PickedUpObject();
     }
 }

        /// <summary>
        /// Updates the client with the changes that have been made to the UserInventory.
        /// </summary>
        public void Update()
        {
            // Don't actually grab the PacketWriter from the pool until we know we will need it
            PacketWriter pw = null;

            try
            {
                // Loop through all slots
                for (var slot = 0; slot < GameData.MaxInventorySize; slot++)
                {
                    // Skip unchanged slots
                    if (!_slotChanged[slot])
                        continue;

                    // Get the item in the slot
                    var invSlot = new InventorySlot(slot);
                    var item = UserInventory[invSlot];

                    // Get the values to send, which depends on if the slot is empty (item == null) or not
                    GrhIndex sendItemGraphic;
                    byte sendItemAmount;

                    if (item == null)
                    {
                        sendItemGraphic = GrhIndex.Invalid;
                        sendItemAmount = 0;
                    }
                    else
                    {
                        sendItemGraphic = item.GraphicIndex;
                        sendItemAmount = item.Amount;
                    }

                    // Grab the PacketWriter if we have not already, or clear it if we have
                    if (pw == null)
                        pw = ServerPacket.GetWriter();
                    else
                        pw.Reset();

                    // Pack the data and send it
                    ServerPacket.SetInventorySlot(pw, invSlot, sendItemGraphic, sendItemAmount);
                    OwnerUser.Send(pw, ServerMessageType.GUIItems);
                }
            }
            finally
            {
                // If we grabbed a PacketWriter, make sure we dispose of it!
                if (pw != null)
                    pw.Dispose();
            }

            // Changes complete
            _slotChanged.SetAll(false);
        }

        public override void Read(StreamHandler reader)
        {
            ContainerSlot = (InventorySlot)reader.ReadByte();
            Slot = (InventorySlot)reader.ReadByte();
            CastId = reader.ReadByte();
            SpellId = reader.ReadUInt32();
            ItemGuid = reader.ReadGuid();
            GlyphSlot = reader.ReadUInt32();
            UnkFlags = reader.ReadByte();

            TargetData.Read(reader);
        }

        public InventoryChangeInfo(ItemEntity item, ItemValueTracker oldValues, InventorySlot slot)
        {
            _slot = slot;
            _item = item;

            if (oldValues == null || oldValues.IsNull)
                _oldValues = null;
            else
                _oldValues = oldValues;

            Debug.Assert(_item != null || _oldValues != null,
                "item and oldValues can not both be null. " + "This would imply that the item changed from null to null.");
        }

    public void Resize( int size, InventorySlot c )
    {
        int cur = m_Slots.Count;
        if( size < cur )
            m_Slots.RemoveRange( size, cur - size );
        else if( size > cur )
        {
            if( size > m_Slots.Capacity )//this bit is purely an optimisation, to avoid multiple automatic capacity changes.
                m_Slots.Capacity = size;

            m_Slots.AddRange( Enumerable.Repeat( c, size - cur ) );
        }
    }

 public void ActivateSplit(GameObject splitObj, Sprite sprite)
 {
     if (this._splitItem == null)
     {
         this._splitItem = splitObj;
         this._splitSlot = splitObj.transform.parent.GetComponent<InventorySlot>();
         this._splitItemSprite = sprite;
         this.transform.GetChild(0).GetComponent<Image>().sprite = this._splitItemSprite;
         this._splitSlotNum = this._splitItem.transform.parent.GetComponent<InventorySlot>()._slotNum;
         this.gameObject.SetActive(true);
     }
     this._splitCount++;
     this.transform.GetChild(0).GetChild(0).GetComponent<Text>().text = this._splitCount.ToString();
 }

    public void HandleDrop(InventorySlot slot)
    {
        if (Inventory == null)
        {
            Debug.LogError("AlchemyCircleUI has no Inventory reference");
            return;
        }

        if (Inventory.SelectedItem != null &&
            !HasItem(Inventory.SelectedItem.ID))
        {
            slot.Item = Inventory.SelectedItem;
            Inventory.SelectedItem = null;
        }
    }

	/// <summary>
	/// Moves the item to the specified slot. If that slot is full, tries to move to an unoccupied slot. If there aren't any, does nothing.
	/// </summary>
	/// <param name="slot">Slot.</param>
	public void MoveTo(InventorySlot slot){
		if (!slot.Contents) {
			homeSlot = slot;
			transform.SetParent (slot.transform);
			transform.position = slot.transform.position;
			GetComponent<CanvasGroup> ().blocksRaycasts = true;
			GameManager.GiveTag (HasTag);
			GameManager.InventoryManager.Deselect ();
		} else if (GameManager.InventoryManager.FirstEmptySlot) {
			MoveTo (GameManager.InventoryManager.FirstEmptySlot);
		} else {
			#if (DEBUG)
			Debug.Log("Cannot put " + gameObject.name + " into inventory. There are no empty slots.");
			#endif
		}
	}

    public override void Start() {
        base.Start();
        new ValueTracker<InventorySlot>(v => inventorySlot = v, () => inventorySlot);
        new ValueTracker<bool>(v => {
            ghostForm = v;
            SetSemitransparent(ghostForm);
            if (thrower != null) {
                Extensions.IgnoreCollision(thrower, this, v);
            }
        }, () => ghostForm);
        new ValueTracker<Unit>(v => thrower = v, () => thrower);

        bool ghost = GetComponent<NotCollidePlayer>() != null;
        if (ghost) {
            GhostFor(FindObjectOfType<Unit>());
        } else {
            SetSemitransparent(false);
        }
    }

        /// <summary>
        /// Gets an inventory item.
        /// </summary>
        /// <param name="slot">Index of the inventory item slot.</param>
        /// <returns>Item in the specified inventory slot, or null if the slot is empty or invalid</returns>
        public ItemEntity this[InventorySlot slot]
        {
            get
            {
                // Check for a valid index
                if (!slot.IsLegalValue())
                {
                    const string errmsg = "Tried to get invalid inventory slot `{0}`.";
                    if (log.IsErrorEnabled)
                        log.ErrorFormat(errmsg, slot);
                    Debug.Fail(string.Format(errmsg, slot));
                    return null;
                }

                // If the item has an amount of 0, return null
                var item = _buffer[(int)slot];
                if (item != null && item.Amount == 0)
                    return null;

                // Item is either null or valid
                return _buffer[(int)slot];
            }

            private set
            {
                // Check for a valid index
                if (!slot.IsLegalValue())
                {
                    const string errmsg = "Tried to set invalid inventory slot `{0}`.";
                    if (log.IsErrorEnabled)
                        log.ErrorFormat(errmsg, slot);
                    Debug.Fail(string.Format(errmsg, slot));
                    return;
                }

                _buffer[(int)slot] = value;
            }
        }

        /// <summary>
        /// Drops an item from the inventory onto the ground. If the user has just one item in the given <paramref name="slot"/>,
        /// then it is dropped. If they have multiple items in the <paramref name="slot"/>, then they are presented with an
        /// <see cref="InputBox"/> so they can enter in how much to drop.
        /// </summary>
        /// <param name="slot">The slot of the item to drop.</param>
        /// <param name="guiManager">The <see cref="IGUIManager"/> to use to create the <see cref="InputBox"/> if it is needed.</param>
        public void Drop(InventorySlot slot, IGUIManager guiManager)
        {
            // Check for a valid item
            var item = this[slot];
            if (item == null)
                return;

            // Check the amount
            if (item.Amount > 1)
            {
                // Create an InputBox to ask how much to drop
                const string text = "Drop item";
                const string message = "How much of the item do you wish to drop?\n(Enter a value from 1 to {0})";

                var inBox = InputBox.CreateNumericInputBox(guiManager, text, string.Format(message, item.Amount));
                inBox.Tag = slot;
                inBox.OptionSelected += DropInputBox_OptionSelected;
            }
            else
            {
                // Auto-drop if there is just one of the item
                Drop(slot, 1);
            }
        }

            /// <summary>
            /// Initializes a new instance of the <see cref="InventoryItemPB"/> class.
            /// </summary>
            /// <param name="parent">The parent.</param>
            /// <param name="pos">The relative position of the control.</param>
            /// <param name="slot">The <see cref="InventorySlot"/>.</param>
            /// <exception cref="ArgumentNullException"><paramref name="parent" /> is <c>null</c>.</exception>
            public InventoryItemPB(InventoryForm parent, Vector2 pos, InventorySlot slot) : base(parent, pos, _itemSize)
            {
                if (parent == null)
                    throw new ArgumentNullException("parent");

                _slot = slot;
                Tooltip = _tooltipHandler;
            }

 /// <summary>
 /// Invokes the <see cref="RequestUseItem"/> event.
 /// </summary>
 /// <param name="slot">The <see cref="InventorySlot"/> to use.</param>
 public void InvokeRequestUseItem(InventorySlot slot)
 {
     if (RequestUseItem != null)
         RequestUseItem.Raise(this, EventArgsHelper.Create(slot));
 }