public GobletOfCelebration( BeverageType type )
     : base(type)
 {
     LootType = LootType.Blessed;
     Weight = 1.0;
     Hue = 1158;
 }

		public MurkyMilk( BeverageType type )
			: base( type )
		{
			Name = "Murky Milk";
			Weight = 1.0;
			Hue = 2306;
			LootType = LootType.Blessed;
		}

		public BeverageBuyInfo( string name, Type type, BeverageType content, int price, int amount, int itemID, int hue ) : base( name, type, price, amount, itemID, hue )
		{
			m_Content = content;

			if ( type == typeof( Pitcher ) )
				Name = (1048128 + (int)content).ToString();
			else if ( type == typeof( BeverageBottle ) )
				Name = (1042959 + (int)content).ToString();
			else if ( type == typeof( Jug ) )
				Name = (1042965 + (int)content).ToString();
		}

        /// <summary>
        /// Get Coffee given the Beverage Type
        /// Is Factory Method
        /// </summary>
        /// <param name="beverageType"></param>
        /// <returns></returns>
        public IBeverage GetCoffee(BeverageType beverageType)
        {
            IBeverage coffee = null;

            switch (beverageType)
            {
                case BeverageType.HouseBlend:
                    coffee = new SpecialHouseBlend();
                    break;

                case BeverageType.Roast:
                    coffee = new AmazonRoast();
                    break;
            }

            return coffee;
        }

        public IBeverage GetCoffee(StoreType storeType, BeverageType beverageType)
        {
            IBeverage coffee = null;

            switch(storeType)
            {
                case StoreType.RegularStore :

                    switch (beverageType)
                    {
                        case BeverageType.HouseBlend:
                            coffee = new HouseBlend();
                            break;

                        case BeverageType.Roast:
                            coffee = new DarkRoast();
                            break;
                    }
                    break;

                case StoreType.ExoticStore:

                    switch (beverageType)
                    {
                        case BeverageType.HouseBlend:
                            coffee = new SpecialHouseBlend();
                            break;

                        case BeverageType.Roast:
                            coffee = new AmazonRoast();
                            break;
                    }
                    break;
            }

            return coffee;
        }

 public FillableBvrge(int weight, Type type, BeverageType content)
     : base(weight, type)
 {
     this.m_Content = content;
 }

		public BeverageBottle( BeverageType type ) : base( type )
		{
			Weight = 1.0;
		}

		public GlassMug( BeverageType type ) : base( type )
		{
			Weight = 1.0;
		}

		public PewterMug( BeverageType type ) : base( type )
		{
			Weight = 1.0;
		}

		public Jug( BeverageType type ) : base( type )
		{
			Weight = 1.0;
		}

		public BaseBeverage( BeverageType type )
		{
			m_Content = type;
			m_Quantity = MaxQuantity;
			ItemID = ComputeItemID();
		}

 public BaseBeverage(BeverageType type)
 {
     this.m_Content = type;
     this.m_Quantity = this.MaxQuantity;
     this.ItemID = this.ComputeItemID();
 }

 /// <summary>
 /// Constructor for a beverage
 /// </summary>
 /// <param name="Ingredients"></param>
 /// <param name="Instructions"></param>
 /// <param name="Name"></param>
 /// <param name="Type"></param>
 public void Drink(List<Ingredient> Ingredients, List<string> Instructions, string Name, BeverageType Type)
 {
 }

		public GreenGlass( BeverageType type ) : base( type )
		{
			Weight = 1.0;
		}

		public static bool ConsumeTotal( Container pack, BeverageType content, int quantity )
		{
			return ConsumeTotal( pack, typeof( BaseBeverage ), content, quantity );
		}

		public static bool ConsumeTotal(Container pack, Type itemType, BeverageType content, int quantity)
		{
			Item[] items = pack.FindItemsByType(itemType);

			// First pass, compute total
			int total = items.OfType<BaseBeverage>()
							 .Where(bev => bev.Content == content && !bev.IsEmpty)
							 .Sum(bev => bev.Quantity);

			if (total >= quantity)
			{
				// We've enough, so consume it
				int need = quantity;

				foreach (BaseBeverage bev in items.OfType<BaseBeverage>())
				{
					if (bev.Content != content || bev.IsEmpty)
					{
						continue;
					}

					int theirQuantity = bev.Quantity;

					if (theirQuantity < need)
					{
						bev.Quantity = 0;
						need -= theirQuantity;
					}
					else
					{
						bev.Quantity -= need;
						return true;
					}
				}
			}

			return false;
		}

		public void Deserialize( GenericReader reader, bool read )
		{
			base.Deserialize( reader );

			if ( !read )
				return;

			int version = reader.ReadInt();

			switch ( version )
			{
				case 1:
				{
					m_Poisoner = reader.ReadMobile();
					goto case 0;
				}
				case 0:
				{
					m_Poison = Poison.Deserialize( reader );
					m_Content = (BeverageType)reader.ReadInt();
					m_Quantity = reader.ReadInt();
					break;
				}
			}
		}

		public override void Deserialize(GenericReader reader)
		{
			base.Deserialize(reader);

			int version = reader.ReadInt();

			switch (version)
			{
				case 4:
					ContentName = reader.ReadString();
					goto case 3;
				case 3:
				case 2:
					Kick = reader.ReadInt();
					goto case 1;
				case 1:
					Poisoner = reader.ReadMobile();
					goto case 0;
				case 0:
					{
						Poison = Poison.Deserialize(reader);
						_Content = (BeverageType)reader.ReadInt();
						_Quantity = reader.ReadInt();
					}
					break;
			}
		}

		public CeramicMug( BeverageType type ) : base( type )
		{
			Weight = 1.0;
		}

		//default constructor: set up one type, a name, and default 0 quantity
		public BeverageEntry( Type type, BeverageType beveragetype, string name ) : this( type, beveragetype, name, 0 )
		{
		}