public EarringsOfProtection( AosElementAttribute element )
            : base(0x1087, Layer.Earrings)
        {
            Resistances[ ( (AosElementAttribute)element ) ] = 2;

            m_Attribute = element;
            LootType = LootType.Regular;
        }

        public EarringsOfProtection(AosElementAttribute element)
            : base(0x1087, Layer.Earrings)
        {
            this.Resistances[((AosElementAttribute)element)] = 2;

            this.m_Attribute = element;
            this.LootType = LootType.Blessed;
        }

		private static void ApplyAttribute( AosElementAttributes attrs, int min, int max, AosElementAttribute attr, int low, int high )
		{
			attrs[attr] = Scale( min, max, low, high );
		}

		public int this[AosElementAttribute attribute]
		{
			get { return GetValue( (int)attribute ); }
			set { SetValue( (int)attribute, value ); }
		}

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

            int version = reader.ReadInt();
            m_Attribute = (AosElementAttribute)reader.ReadInt();
        }

        public static int GetItemData( AosElementAttribute element, bool label )
        {
            switch( element )
            {
                case AosElementAttribute.Physical: return ( label ) ? 1071091 : 0;         // Earring of Protection (Physical)  1071091
                case AosElementAttribute.Fire:     return ( label ) ? 1071092 : 0x4ec;     // Earring of Protection (Fire)      1071092
                case AosElementAttribute.Cold:     return ( label ) ? 1071093 : 0x4f2;     // Earring of Protection (Cold)      1071093
                case AosElementAttribute.Poison:   return ( label ) ? 1071094 : 0x4f8;     // Earring of Protection (Poison)    1071094
                case AosElementAttribute.Energy:   return ( label ) ? 1071095 : 0x4fe;     // Earring of Protection (Energy)    1071095

                default: return -1;
            }
        }

 public static void ApplyAttribute( AosElementAttributes attrs, AosElementAttribute attr, int amount )
 {
     attrs[attr] += amount;
 }

		private static int AssignElementalDamage( BaseWeapon weapon, AosElementAttribute attr, int totalDamage )
		{
			if( totalDamage <= 0 )
				return 0;

			int random = Utility.Random( (int)(totalDamage/10) + 1 ) * 10;
			weapon.AosElementDamages[attr] = random;

			return (totalDamage - random);
		}

 public ElementAttributeInfo(AosElementAttribute attribute, string name, AttributeCategory category, int xp, int maxvalue)
 {
     this.m_Attribute = attribute;
     this.m_Name = name;
     this.m_Category = category;
     this.m_XP = xp;
     this.m_MaxValue = maxvalue;
 }

 public static int[] GetPropRange(AosElementAttribute attr)
 {
     return new int[] { 1, 15 };
 }

		public static bool HasAttribute(this Item item, AosElementAttribute attr, out int value)
		{
			return (HasAttribute(item, "Resistances", (ulong)attr, out value) /*||
					HasAttribute(item, "AosElementDamages", (ulong)attr, out value)*/);
		}

        public static int GetModForAttribute(AosElementAttribute type)
        {
            switch (type)
            {
                case AosElementAttribute.Physical: return 51;
                case AosElementAttribute.Fire: return 52;
                case AosElementAttribute.Cold: return 53;
                case AosElementAttribute.Poison: return 54;
                case AosElementAttribute.Energy: return 55;
            }

            return -1;
        }

 public BonusAttribute( AosElementAttribute attr, int amount )
     : this((object)attr, amount)
 {
 }

 public static void RemoveAttribute( AosElementAttributes attrs, AosElementAttribute attr, int amount )
 {
     attrs[attr] = Math.Max( attrs[attr] - amount, 0 );
 }

        private static int GetElementAttributeValue(BaseWeapon weapon, AosElementAttribute element)
        {
            int phys, fire, cold, pois, nrgy, chao, direct;
            weapon.GetDamageTypes(null, out phys, out fire, out cold, out pois, out nrgy, out chao, out direct);

            switch (element)
            {
                case AosElementAttribute.Physical:
                    return phys;
                case AosElementAttribute.Fire:
                    return fire;
                case AosElementAttribute.Cold:
                    return cold;
                case AosElementAttribute.Poison:
                    return pois;
                case AosElementAttribute.Energy:
                    return nrgy;
                case AosElementAttribute.Direct:
                    return direct;
            }
            return -1;
        }

		public static void GetElementalDamages( BaseWeapon weapon, bool randomizeOrder )
		{
			int fire, phys, cold, nrgy, pois;

			weapon.GetDamageTypes( null, out phys, out fire, out cold, out pois, out nrgy );

			int totalDamage = phys;

			AosElementAttribute[] attrs = new AosElementAttribute[]
			{
				AosElementAttribute.Cold,
				AosElementAttribute.Energy,
				AosElementAttribute.Fire,
				AosElementAttribute.Poison
			};

			if( randomizeOrder )
			{
				for( int i = 0; i < attrs.Length; i++ )
				{
					int rand = Utility.Random( attrs.Length );
					AosElementAttribute temp = attrs[i];

					attrs[i] = attrs[rand];
					attrs[rand] = temp;
				}
			}


			/*
			totalDamage = AssignElementalDamage( weapon, AosElementAttribute.Cold,		totalDamage );
			totalDamage = AssignElementalDamage( weapon, AosElementAttribute.Energy,	totalDamage );
			totalDamage = AssignElementalDamage( weapon, AosElementAttribute.Fire,		totalDamage );
			totalDamage = AssignElementalDamage( weapon, AosElementAttribute.Poison,	totalDamage );

			weapon.AosElementDamages[AosElementAttribute.Physical] = 100 - totalDamage;
			 * */

			for( int i = 0; i < attrs.Length; i++ )
				totalDamage = AssignElementalDamage( weapon, attrs[i], totalDamage );


			//Order is Cold, Energy, Fire, Poison -> Physical left
			//Cannot be looped, AoselementAttribute is 'out of order'

			weapon.Hue = weapon.GetElementalDamageHue();
		}

 public int this[AosElementAttribute attribute]
 {
     get
     {
         return this.ExtendedGetValue((int)attribute);
     }
     set
     {
         this.SetValue((int)attribute, value);
     }
 }

 public static void ApplyResistance(Item item, int value, AosElementAttribute attribute)
 {
     if(item is BaseJewel)
         ((BaseJewel)item).Resistances[attribute] = value;
     else if (item is BaseClothing)
         ((BaseClothing)item).Resistances[attribute] = value;
     else
     {
         switch (attribute)
         {
             default:
             case AosElementAttribute.Physical:
                 if (item is BaseArmor) ((BaseArmor)item).PhysicalBonus = value;
                 else if (item is BaseWeapon) ((BaseWeapon)item).WeaponAttributes.ResistPhysicalBonus = value;
                 break;
             case AosElementAttribute.Fire:
                 if (item is BaseArmor) ((BaseArmor)item).FireBonus = value;
                 else if (item is BaseWeapon) ((BaseWeapon)item).WeaponAttributes.ResistFireBonus = value;
                 break;
             case AosElementAttribute.Cold:
                 if (item is BaseArmor) ((BaseArmor)item).ColdBonus = value;
                 else if (item is BaseWeapon) ((BaseWeapon)item).WeaponAttributes.ResistColdBonus = value; 
                 break;
             case AosElementAttribute.Poison:
                 if (item is BaseArmor) ((BaseArmor)item).PoisonBonus = value;
                 else if (item is BaseWeapon) ((BaseWeapon)item).WeaponAttributes.ResistPoisonBonus = value; 
                 break;
             case AosElementAttribute.Energy:
                 if (item is BaseArmor) ((BaseArmor)item).EnergyBonus = value;
                 else if (item is BaseWeapon) ((BaseWeapon)item).WeaponAttributes.ResistEnergyBonus = value; 
                 break;
         }
     }
 }

 public static void ApplyAttribute( Mobile from, BookOfSpellCrafts book, int craftId, BaseJewel jewel, AosElementAttribute attribute, int minimum, int maximum )
 {
     CheckItem( from, jewel, ( jewel.Resistances[ attribute ] == 0 ) );
     UseMagicJewels( from, book, jewel, SpellCraftConfig.MagicJewelRequirements[craftId] );
     int scalar = ComputeSkillScalar( from );
     ApplyAttribute( jewel.Resistances, SpellCraftConfig.MinimumIntensity * scalar, SpellCraftConfig.MaximumIntensity * scalar, attribute, minimum, maximum );
 }