C# Container.FindItemsByType方法代码示例

		public static bool ContainsKey( Container cont, uint keyValue )
		{
			if ( cont == null )
				return false;

			Item[] items = cont.FindItemsByType( new Type[] { typeof( Key ), typeof( KeyRing ) } );

			foreach ( Item item in items )
			{
				if ( item is Key )
				{
					Key key = (Key) item;

					if ( key.KeyValue == keyValue )
						return true;
				}
				else
				{
					KeyRing keyRing = (KeyRing) item;

					if ( keyRing.ContainsKey( keyValue ) )
						return true;
				}
			}

			return false;
		}

		private bool ContainsDeed( Container cont )
		{
			List<HouseRaffleDeed> deeds = cont.FindItemsByType<HouseRaffleDeed>();

			for ( int i = 0; i < deeds.Count; ++i )
			{
				if ( deeds[i] == m_Stone.Deed )
					return true;
			}

			return false;
		}

		public static void RemoveKeys( Container cont, uint keyValue )
		{
			if ( cont == null || keyValue == 0 )
				return;

			Item[] items = cont.FindItemsByType( new Type[] { typeof( Key ), typeof( KeyRing ) } );

			foreach ( Item item in items )
			{
				if ( item is Key )
				{
					Key key = (Key) item;

					if ( key.KeyValue == keyValue )
						key.Delete();
				}
				else
				{
					KeyRing keyRing = (KeyRing) item;

					keyRing.RemoveKeys( keyValue );
				}
			}
		}

			public static int GETAMOUNTINCONTAINER(TriggerObject trigObject, Container container, object typeObjectOrString)
			{
				if (container == null || container.Deleted)
				{
					return 0;
				}

				Type type = TYPE(trigObject, typeObjectOrString);

				if (type == null)
				{
					throw new UberScriptException(
						"GETAMOUNTINCONTAINER typeString " + typeObjectOrString + " did not match any available types!");
				}

				return container.FindItemsByType(type).Sum(t => t.Amount);
			}

        private static int GetHouseDeedsInContainer(Container c, ref int count)
        {
            int iGold = 0;

            Item[] deeds = c.FindItemsByType(typeof(Server.Multis.Deeds.HouseDeed), true);
            foreach (Item i in deeds)
            {
                Server.Multis.Deeds.HouseDeed housedeed = i as Server.Multis.Deeds.HouseDeed;
				// don't count tents as they cannot be redeemed for cash
				if (housedeed != null && housedeed is SiegeTentBag == false && housedeed is TentBag == false)
                {
                    count++;
                    iGold += RealEstateBroker.ComputePriceFor(housedeed);
                }
            }

            Item[] BUCdeeds = c.FindItemsByType(typeof(BaseUpgradeContract), true);
            foreach (Item i in BUCdeeds)
            {
                BaseUpgradeContract budeed = i as BaseUpgradeContract;
                if (budeed != null)
                {
                    count++;
                    iGold += (int)budeed.Price;
                }
            }

            
            return iGold;
        }

		public int GetQuantity( Container cont, Type[] types )
		{
			Item[] items = cont.FindItemsByType( types, true );

			int amount = 0;

			for ( int i = 0; i < items.Length; ++i )
			{
				IHasQuantity hq = items[i] as IHasQuantity;

				if ( hq == null )
				{
					amount += items[i].Amount;
				}
				else
				{
					if ( hq is BaseBeverage && ((BaseBeverage)hq).Content != BeverageType.Water )
						continue;

					amount += hq.Quantity;
				}
			}

			return amount;
		}

 public static List<SoftenedReeds> GetReeds( Container cont, PlantHue hue )
 {
     return GetReeds( cont.FindItemsByType<SoftenedReeds>(), hue );
 }

        /// <summary>
        /// Tries to consume the given amount out of the total amount of currency in the provided container.
        /// Automatically redistributes coins.
        /// </summary>
        /// <param name="cont">the container to consume from</param>
        /// <param name="currencyType">the target currency to consume from</param>
        /// <param name="amount">the amount of the target currency to consume</param>
        /// <returns>true if the container has the exact amount of the currencyType, or if the container has enough total monies</returns>
        public static bool Consume( Container cont, Type currencyType, int amount )
        {
            if( cont == null )
                return false;

            if( cont.ConsumeTotal(currencyType, amount) )
                return true;

            int availableCopper = 0;
            Item[] coins = cont.FindItemsByType(AllCurrencies);

            //calculate monies as copper total
            for( int i = 0; i < coins.Length; i++ )
                availableCopper += ConvertTo(FindType(coins[i].GetType()), CurrencyType.Copper, coins[i].Amount);

            //if we have enough to pay...
            if( availableCopper >= amount )
            {
                //delete all the coins
                for( int i = 0; i < coins.Length; i++ )
                    coins[i].Consume(coins[i].Amount);

                availableCopper -= amount;

                //if we should still have money, redistribute
                if( availableCopper > 0 )
                    DistributeCoins(cont, Compress(availableCopper, 0, 0));

                return true;
            }

            return false;
        }

        public override bool OnDeath( Mobile mob, Container corpse )
        {
            Mobile killer = mob.FindMostRecentDamager( false );

            bool hadFlag = false;

            Item[] flags = corpse.FindItemsByType( typeof( CTFFlag ), false );

            for ( int i = 0; i < flags.Length; ++i )
                ( flags[i] as CTFFlag ).DropTo( mob, killer );

            hadFlag = ( hadFlag || flags.Length > 0 );

            if ( mob.Backpack != null )
            {
                flags = mob.Backpack.FindItemsByType( typeof( CTFFlag ), false );

                for ( int i = 0; i < flags.Length; ++i )
                    ( flags[i] as CTFFlag ).DropTo( mob, killer );

                hadFlag = ( hadFlag || flags.Length > 0 );
            }

            if ( killer != null && killer.Player )
            {
                CTFTeamInfo teamInfo = GetTeamInfo( killer );
                CTFTeamInfo victInfo = GetTeamInfo( mob );

                if ( teamInfo != null && teamInfo != victInfo )
                {
                    CTFPlayerInfo playerInfo = teamInfo[killer];

                    if ( playerInfo != null )
                    {
                        playerInfo.Kills += 1;
                        playerInfo.Score += 1; // base frag

                        if ( hadFlag )
                            playerInfo.Score += 4; // fragged flag carrier

                        if ( mob.InRange( teamInfo.Origin, 24 ) && mob.Map == this.Facet )
                            playerInfo.Score += 1; // fragged in base -- guarding

                        for ( int i = 0; i < m_Controller.TeamInfo.Length; ++i )
                        {
                            if ( m_Controller.TeamInfo[i] == teamInfo )
                                continue;

                            Mobile ourFlagCarrier = null;

                            if ( m_Controller.TeamInfo[i].Flag != null )
                                ourFlagCarrier = m_Controller.TeamInfo[i].Flag.RootParent as Mobile;

                            if ( ourFlagCarrier != null && GetTeamInfo( ourFlagCarrier ) == teamInfo )
                            {
                                for ( int j = 0; j < ourFlagCarrier.Aggressors.Count; ++j )
                                {
                                    AggressorInfo aggr = ourFlagCarrier.Aggressors[j];

                                    if ( aggr == null || aggr.Defender != ourFlagCarrier || aggr.Attacker != mob )
                                        continue;

                                    playerInfo.Score += 2; // helped defend guy capturing enemy flag
                                    break;
                                }

                                if ( mob.Map == ourFlagCarrier.Map && ourFlagCarrier.InRange( mob, 12 ) )
                                    playerInfo.Score += 1; // helped defend guy capturing enemy flag
                            }
                        }
                    }
                }
            }

            mob.CloseGump( typeof( CTFBoardGump ) );
            mob.SendGump( new CTFBoardGump( mob, this ) );

            m_Context.Requip( mob, corpse );
            DelayBounce( TimeSpan.FromSeconds( 30.0 ), mob, corpse );

            return false;
        }

        public int GetCommodityType(Container c, Type type)
        {
            if (c == null)
                return 0;

            Item[] items = c.FindItemsByType(typeof(CommodityDeed));
            int amt = 0;

            foreach (Item item in items)
            {
                if (item is CommodityDeed && ((CommodityDeed)item).Commodity != null && ((CommodityDeed)item).Commodity.GetType() == type)
                    amt += ((CommodityDeed)item).Commodity.Amount;
            }

            return amt;
        }

		private void TakeItems(Container c, Type type, ref int amount)
		{
            if (c == null)
                return;

			Item[] items = c.FindItemsByType(type);
			List<Item> toSell = new List<Item>();
			
			foreach(Item item in items)
			{
				if(amount <= 0)
					break;
					
				if(item.Amount <= amount)
				{
					toSell.Add(item);
					amount -= item.Amount;
				}
				else
				{
					Item newItem = Loot.Construct(type);
					newItem.Amount = amount;
					item.Amount -= amount;
					toSell.Add(newItem);
					amount = 0;
				}
			}
			
			foreach(Item item in toSell)
			{
				AddInventory(null, item);
			}
		}

		private void TakeCommodities(Container c, Type type, ref int amount)
		{
            if (c == null)
                return;

			Item[] items = c.FindItemsByType(typeof(CommodityDeed));
			List<Item> toSell = new List<Item>();
			
			foreach(Item item in items)
			{
                CommodityDeed commodityDeed = item as CommodityDeed;

                if (commodityDeed != null && commodityDeed.Commodity != null && commodityDeed.Commodity.GetType() == type)
				{
					Item commodity = commodityDeed.Commodity;

                    if (commodity.Amount <= amount)
					{
						toSell.Add(item);
                        amount -= commodity.Amount;
					}
					else
					{
						CommodityDeed newDeed = new CommodityDeed();
						Item newItem = Loot.Construct(type);
						newItem.Amount = amount;
						newDeed.SetCommodity(newItem);
						
						commodity.Amount -= amount;
						commodityDeed.InvalidateProperties();
						toSell.Add(newDeed);
						amount = 0;
					}
				}
			}
			
			foreach(Item item in toSell)
			{
				AddInventory(null, item);
			}
		}

        public static void TransferGold(Mobile m, Container c, GoldLedger ledger, string nametitle)
        {
            Item[] items = c.FindItemsByType(typeof(Gold));

            foreach (Gold ngold in items)
            {
                Gold gold = ngold as Gold;

                if (gold != null)
                {
                    if (ledger.Gold < 999999999)
                    {
                        double maxWeight = (WeightOverloading.GetMaxWeight(m));
                        if ((Mobile.BodyWeight + m.TotalWeight) < (maxWeight))
                        {
                            int golda = gold.Amount;
                            if ((gold.Amount + ledger.Gold) > 999999999)
                                golda = (999999999 - ledger.Gold);
                            double maxgold = golda;
                            if (ledger.d_WeightScale > 0)
                                maxgold = ((maxWeight - ((double)Mobile.BodyWeight + (double)m.TotalWeight)) / ledger.d_WeightScale);
                            if (golda > maxgold)
                                golda = (int)maxgold;
                            int GoldID = 0;
                            if (golda == 1)
                                GoldID = gold.ItemID;
                            else if (golda > 1 && golda < 6)
                                GoldID = gold.ItemID + 1;
                            else if (golda >= 6)
                                GoldID = gold.ItemID + 2;
                            if (golda < gold.Amount)
                                gold.Amount -= golda;
                            else
                                gold.Delete();
                            ledger.Gold += golda;
                            if (ledger.b_open && golda > 0)
                            {
                                m.CloseGump(typeof(GoldLedgerGump));
                                m.SendGump(new GoldLedgerGump(ledger));
                            }

                            if (golda > 0)
                            {
                                m.SendMessage(2125, "You loot {0} gold from {1} and deposit it into your gold ledger.", golda.ToString("#,0"), nametitle);
                                Effects.SendMovingEffect(c, m, GoldID, 5, 50, true, false);
                                m.PlaySound(0x2E6);
                            }
                        }
                    }
                }
            }
        }

		private static int GetGoldInContainer(Container c)
		{
			int iGold = 0;

			Item[] golds = c.FindItemsByType(typeof(Gold), true);
			foreach(Item g in golds)
			{
				iGold += g.Amount;
			}
			Item[] checks = c.FindItemsByType(typeof(BankCheck), true);
			foreach(Item i in checks)
			{
				BankCheck bc = (BankCheck)i;
				iGold += bc.Worth;
			}	
	
			return iGold;
		}

			public static void DELETEFROMCONTAINER(
				TriggerObject trigObject, Container container, object typeObjectOrString, int amount)
			{
				Type type = TYPE(trigObject, typeObjectOrString);

				if (type == null)
				{
					throw new UberScriptException(
						"DELETEFROMCONTAINER typeObjectOrString " + typeObjectOrString + " did not match any available types!");
				}

				var list = container.FindItemsByType(type);

				for (int i = 0; amount > 0 && i < list.Length; i++)
				{
					int consume = Math.Min(list[i].Amount, amount);

					list[i].Consume(consume);
					amount -= consume;
				}
			}