C# InventoryItemBase类代码示例

 public virtual void ShowDialog(string title, string description, string yes, string no, int minValue, int maxValue, InventoryItemBase item, ItemBuySellDialogAction action, VendorTriggerer vendor, IntValDialogCallback yesCallback, IntValDialogCallback noCallback)
 {
     // Don't call base class going directly to this.ShowDialog()
     inventoryItem = item;
     this.action = action;
     this.vendor = vendor;
     ShowDialog(string.Format(string.Format(title, item.name, item.description)), string.Format(description, item.name, item.description), yes, no, minValue, maxValue, yesCallback, noCallback);
 }

 public void OnBoughtItemBackFromVendor(InventoryItemBase item, uint amount, VendorTriggerer vendor)
 {
     if (onBoughtItemBackFromVendor.Count > 0)
     {
         RunEvents(onBoughtItemBackFromVendor,
             new plyEventArg("item", item),
             new plyEventArg("itemID", (int)item.ID),
             new plyEventArg("amount", (int)amount),
             new plyEventArg("vendor", vendor));
     }
 }

 public void CharacterOnUnEquippedItem(InventoryItemBase item, uint itemID, uint slot, uint amount)
 {
     if (onUnEquippedItemEvents.Count > 0)
     {
         RunEvents(onUnEquippedItemEvents,
             new plyEventArg("item", item),
             new plyEventArg("itemID", (int)itemID),
             new plyEventArg("slot", (int)slot),
             new plyEventArg("amount", (int)amount));
     }
 }

 public void OnCraftSuccess(InventoryCraftingCategory category, InventoryCraftingBlueprint blueprint, InventoryItemBase result)
 {
     if (onCraftingSuccess.Count > 0)
     {
         RunEvents(onCraftingSuccess,
             new plyEventArg("item", result),
             new plyEventArg("itemID", (int)result.ID),
             new plyEventArg("category", category),
             new plyEventArg("categoryID", (int)category.ID),
             new plyEventArg("blueprint", blueprint),
             new plyEventArg("blueprintID", (int)blueprint.ID));
     }
 }

 public InventoryItemBase GetInventoryItem(InventoryItemBase item)
 {
     System.Console.WriteLine("[HGrid] GetInventory " + item.ID + " from " + ServerURL);
     try
     {
         item = SynchronousRestSessionObjectPoster<Guid, InventoryItemBase>.BeginPostObject("POST", ServerURL + "/GetItem/", item.ID.Guid, "", "");
         return item;
     }
     catch (Exception e)
     {
         System.Console.WriteLine("[HGrid]: Exception posting to inventory: " + e);
     }
     return null;
 }

        public void GetInventoryItemAsync(InventoryItemBase item, ReturnResponse<InventoryItemBase> callBack)
        {
            System.Console.WriteLine("[HGrid] GetInventory from " + ServerURL);
            try
            {
                RestSessionObjectPosterResponse<InventoryItemBase, InventoryItemBase> requester
                        = new RestSessionObjectPosterResponse<InventoryItemBase, InventoryItemBase>();
                requester.ResponseCallback = callBack;

                requester.BeginPostObject(ServerURL + "/GetItem/", item, string.Empty, string.Empty);
            }
            catch (Exception e)
            {
                System.Console.WriteLine("[HGrid]: Exception posting to inventory: " + e);
            }
        }

        /// <summary>
        ///   Deserialize item
        /// </summary>
        /// <param name = "serializedSettings"></param>
        /// <returns></returns>
        /// <exception cref = "System.Xml.XmlException"></exception>
        public static InventoryItemBase Deserialize(byte[] serialization)
        {
            InventoryItemBase item = new InventoryItemBase();

            StringReader reader = new StringReader(Encoding.ASCII.GetString(serialization, 0, serialization.Length));
            XmlReader xtr = XmlReader.Create(reader);
            //Uses byte[] directly... should be used once issues with it are fixed
            //MemoryStream mr = new MemoryStream (serialization);
            //StreamReader sr = new StreamReader (mr, Encoding.ASCII);
            //XmlReader xtr = XmlTextReader.Create (sr);
            xtr.ReadStartElement("InventoryItem");

            item.Name = xtr.ReadElementString("Name");
            item.ID = UUID.Parse(xtr.ReadElementString("ID"));
            item.InvType = Convert.ToInt32(xtr.ReadElementString("InvType"));
            item.CreatorId = xtr.ReadElementString("CreatorUUID");
            try
            {
                item.CreatorData = xtr.ReadElementString("CreatorData");
            }
            catch
            {
            }
            item.CreationDate = Convert.ToInt32(xtr.ReadElementString("CreationDate"));
            item.Owner = UUID.Parse(xtr.ReadElementString("Owner"));
            item.Description = xtr.ReadElementString("Description");
            item.AssetType = Convert.ToInt32(xtr.ReadElementString("AssetType"));
            item.AssetID = UUID.Parse(xtr.ReadElementString("AssetID"));
            item.SaleType = Convert.ToByte(xtr.ReadElementString("SaleType"));
            item.SalePrice = Convert.ToInt32(xtr.ReadElementString("SalePrice"));
            item.BasePermissions = Convert.ToUInt32(xtr.ReadElementString("BasePermissions"));
            item.CurrentPermissions = Convert.ToUInt32(xtr.ReadElementString("CurrentPermissions"));
            item.EveryOnePermissions = Convert.ToUInt32(xtr.ReadElementString("EveryOnePermissions"));
            item.NextPermissions = Convert.ToUInt32(xtr.ReadElementString("NextPermissions"));
            item.Flags = Convert.ToUInt32(xtr.ReadElementString("Flags"));
            item.GroupID = UUID.Parse(xtr.ReadElementString("GroupID"));
            item.GroupOwned = Convert.ToBoolean(xtr.ReadElementString("GroupOwned"));

            xtr.ReadEndElement();

            xtr.Close();

            return item;
        }

 public InventoryItemBase CreateItem(UUID inventoryID, UUID assetID, string name, string description,
                                     int assetType, int invType, UUID parentFolderID)
 {
     InventoryItemBase item = new InventoryItemBase();
     item.Owner = libOwner;
     item.CreatorId = libOwner.ToString();
     item.ID = inventoryID;
     item.AssetID = assetID;
     item.Description = description;
     item.Name = name;
     item.AssetType = assetType;
     item.InvType = invType;
     item.Folder = parentFolderID;
     item.BasePermissions = 0x7FFFFFFF;
     item.EveryOnePermissions = 0x7FFFFFFF;
     item.CurrentPermissions = 0x7FFFFFFF;
     item.NextPermissions = 0x7FFFFFFF;
     return item;
 }

 public override OSDArray GetLLSDItems(string[] fields, string[] vals)
 {
     string query = "";
     for (int i = 0; i < fields.Length; i++)
     {
         query += String.Format("where {0} = '{1}' and ", fields[i], vals[i]);
         i++;
     }
     query = query.Remove(query.Length - 5);
     if (fields[0] == "inventoryID")
     {
         IInventoryService invService = m_registry.RequestModuleInterface<IInventoryService>();
         if (invService != null)
         {
             InventoryItemBase baseItem = new InventoryItemBase(UUID.Parse(vals[0]));
             return BuildLLSDInventoryItems(invService.GetItem(baseItem));
         }
     }
     
     return null;
 }

        private void SetLootableItemsClients(string itemIDsString, PhotonMessageInfo info)
        {
            if (itemIDsString == "")
            {
                lootable.items = new InventoryItemBase[0];
                return;
            }

            string[] itemIDs = itemIDsString.Split(',');

            UnityEngine.Debug.Log("Received message from server to set items for lootable: " + itemIDs.Length);
            var items = new InventoryItemBase[itemIDs.Length];

            for (int i = 0; i < itemIDs.Length; i++)
            {
                var item = UnityEngine.Object.Instantiate<InventoryItemBase>(ItemManager.instance.items[int.Parse(itemIDs[i])]);
                item.gameObject.SetActive(false);
                item.transform.SetParent(transform);
                items[i] = item;
            }

            lootable.items = items; // Set the lootable items for this object.
        }

        private AvatarAppearance CopyWearablesAndAttachments(UUID destination, UUID source,
            AvatarAppearance avatarAppearance,
            InventoryFolderBase destinationFolder, UUID agentid,
            OSDMap itemsMap,
            out List<InventoryItemBase> items)
        {
            if (destinationFolder == null)
                throw new Exception("Cannot locate folder(s)");
            items = new List<InventoryItemBase>();

            List<InventoryItemBase> litems = new List<InventoryItemBase>();
            foreach (KeyValuePair<string, OSD> kvp in itemsMap)
            {
                InventoryItemBase item = new InventoryItemBase();
                item.FromOSD((OSDMap)kvp.Value);
                MainConsole.Instance.Info("[AvatarArchive]: Loading item " + item.ID.ToString());
                litems.Add(item);
            }

            // Wearables
            AvatarWearable[] wearables = avatarAppearance.Wearables;

            for (int i = 0; i < wearables.Length; i++)
            {
                AvatarWearable wearable = wearables[i];
                for (int ii = 0; ii < wearable.Count; ii++)
                {
                    if (wearable[ii].ItemID != UUID.Zero)
                    {
                        // Get inventory item and copy it
                        InventoryItemBase item = InventoryService.GetItem(UUID.Zero, wearable[ii].ItemID);

                        if (item == null)
                        {
                            //Attempt to get from the map if it doesn't already exist on the grid
                            item = litems.First((itm) => itm.ID == wearable[ii].ItemID);
                        }
                        if (item != null)
                        {
                            InventoryItemBase destinationItem = InventoryService.InnerGiveInventoryItem(destination,
                                                                                                        destination,
                                                                                                        item,
                                                                                                        destinationFolder
                                                                                                            .ID,
                                                                                                        false, false);
                            items.Add(destinationItem);
                            MainConsole.Instance.DebugFormat("[RADMIN]: Added item {0} to folder {1}",
                                                             destinationItem.ID, destinationFolder.ID);

                            // Wear item
                            AvatarWearable newWearable = new AvatarWearable();
                            newWearable.Wear(destinationItem.ID, destinationItem.AssetID);
                            avatarAppearance.SetWearable(i, newWearable);
                        }
                        else
                        {
                            MainConsole.Instance.WarnFormat("[RADMIN]: Error transferring {0} to folder {1}",
                                                            wearable[ii].ItemID, destinationFolder.ID);
                        }
                    }
                }
            }

            // Attachments
            List<AvatarAttachment> attachments = avatarAppearance.GetAttachments();

            foreach (AvatarAttachment attachment in attachments)
            {
                int attachpoint = attachment.AttachPoint;
                UUID itemID = attachment.ItemID;

                if (itemID != UUID.Zero)
                {
                    // Get inventory item and copy it
                    InventoryItemBase item = InventoryService.GetItem(UUID.Zero, itemID);

                    if (item != null)
                    {
                        InventoryItemBase destinationItem = InventoryService.InnerGiveInventoryItem(destination,
                                                                                                    destination, item,
                                                                                                    destinationFolder.ID,
                                                                                                    false, false);
                        items.Add(destinationItem);
                        MainConsole.Instance.DebugFormat("[RADMIN]: Added item {0} to folder {1}", destinationItem.ID,
                                                         destinationFolder.ID);

                        // Attach item
                        avatarAppearance.SetAttachment(attachpoint, destinationItem.ID, destinationItem.AssetID);
                        MainConsole.Instance.DebugFormat("[RADMIN]: Attached {0}", destinationItem.ID);
                    }
                    else
                    {
                        MainConsole.Instance.WarnFormat("[RADMIN]: Error transferring {0} to folder {1}", itemID,
                                                        destinationFolder.ID);
                    }
                }
            }
            return avatarAppearance;
        }

 public void ModifyAndMoveItem(InventoryItemBase item, UUID folderID)
 {
     IInventoryProviderSelector selector = ProviderRegistry.Instance.Get<IInventoryProviderSelector>();
     ICheckedInventoryStorage provider = selector.GetCheckedProvider(m_userProfile.ID);
     provider.ModifyAndMoveItem(m_userProfile.ID, item, folderID);
 }

 private void OnRemovedItemPly(InventoryItemBase item, uint itemID, uint slot, uint amount)
 {
     if (eventHandler != null)
         eventHandler.CharacterOnUnEquippedItem(item, itemID, slot, amount);
 }

 /// <summary>
 /// Update an item in the user's inventory
 /// </summary>
 /// <param name="userID"></param>
 /// <param name="itemInfo"></param>
 public void UpdateItem(InventoryItemBase item)
 {
     if (m_hasReceivedInventory)
     {
         m_InventoryService.UpdateItem(item);
     }
     else
     {
         AddRequest(
             new InventoryRequest(
                 Delegate.CreateDelegate(typeof(UpdateItemDelegate), this, "UpdateItem"),
                 new object[] { item }));
     }
 }

        /// <summary>
        /// Callback invoked when an item is received from an async request to the inventory service.
        ///
        /// We're assuming here that items are always received after all the folders
        /// received.
        /// If folder is null, we will search for it starting from RootFolder (an O(n) operation),
        /// otherwise we'll just put it into folder
        /// </summary>
        /// <param name="folderInfo"></param>
        private void ItemReceive(InventoryItemBase itemInfo, InventoryFolderImpl folder)
        {
            //            m_log.DebugFormat(
            //                "[INVENTORY CACHE]: Received item {0} {1} for user {2}",
            //                itemInfo.Name, itemInfo.ID, userID);

            if (folder == null && RootFolder != null)
                folder = RootFolder.FindFolder(itemInfo.Folder);

            if (null == folder)
            {
                m_log.WarnFormat(
                    "Received item {0} {1} but its folder {2} does not exist",
                    itemInfo.Name, itemInfo.ID, itemInfo.Folder);

                return;
            }

            lock (folder.Items)
            {
                folder.Items[itemInfo.ID] = itemInfo;
            }

            if (OnItemReceived != null)
                OnItemReceived(itemInfo.ID);
        }