C# InventorySlot类代码示例

 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
		}
	}