public static int NewRing(CLRScriptBase script, int maxValue)
 {
     List<int> potentialAbilities = new List<int>();
     foreach (KeyValuePair<int, int> ability in AvailableAbilities)
     {
         if (ability.Value <= maxValue)
         {
             potentialAbilities.Add(ability.Key);
         }
     }
     if (potentialAbilities.Count == 0)
     {
         return 0;
     }
     int selectedAbility = potentialAbilities[Generation.rand.Next(potentialAbilities.Count)];
     uint ring = script.CreateItemOnObject("nw_it_mring021", script.OBJECT_SELF, 1, "", FALSE);
     switch (selectedAbility)
     {
         #region Rings of Deflection
         case ITEM_PROPERTY_AC_BONUS:
             {
                 string name = AbilityNames[selectedAbility];
                 if (maxValue >= 50000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(5), ring, 0.0f);
                     script.SetFirstName(ring, name + " +5");
                     Pricing.CalculatePrice(script, ring);
                     return 50000;
                 }
                 else if (maxValue >= 32000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(4), ring, 0.0f);
                     script.SetFirstName(ring, name + " +4");
                     Pricing.CalculatePrice(script, ring);
                     return 32000;
                 }
                 else if (maxValue >= 18000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(3), ring, 0.0f);
                     script.SetFirstName(ring, name + " +3");
                     Pricing.CalculatePrice(script, ring);
                     return 18000;
                 }
                 else if (maxValue >= 8000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(2), ring, 0.0f);
                     script.SetFirstName(ring, name + " +2");
                     Pricing.CalculatePrice(script, ring);
                     return 8000;
                 }
                 else if (maxValue >= 2000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(1), ring, 0.0f);
                     script.SetFirstName(ring, name + " +1");
                     Pricing.CalculatePrice(script, ring);
                     return 2000;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
         #region Rings of Ability Scores
         case ITEM_PROPERTY_ABILITY_BONUS:
             {
                 int abilityScore = AvailableAbilityScores[Generation.rand.Next(AvailableAbilityScores.Count)];
                 string name = AbilityScoreNames[abilityScore];
                 if (maxValue >= 36000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 6), ring, 0.0f);
                     script.SetFirstName(ring, name + " +6");
                     Pricing.CalculatePrice(script, ring);
                     return 36000;
                 }
                 else if (maxValue >= 25000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 5), ring, 0.0f);
                     script.SetFirstName(ring, name + " +5");
                     Pricing.CalculatePrice(script, ring);
                     return 25000;
                 }
                 else if (maxValue >= 16000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 4), ring, 0.0f);
                     script.SetFirstName(ring, name + " +4");
                     Pricing.CalculatePrice(script, ring);
                     return 16000;
                 }
                 else if (maxValue >= 9000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 3), ring, 0.0f);
                     script.SetFirstName(ring, name + " +3");
                     Pricing.CalculatePrice(script, ring);
                     return 9000;
                 }
                 else if (maxValue >= 4000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 2), ring, 0.0f);
                     script.SetFirstName(ring, name + " +2");
                     Pricing.CalculatePrice(script, ring);
                     return 4000;
                 }
                 else if (maxValue >= 1000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 1), ring, 0.0f);
                     script.SetFirstName(ring, name + " +1");
                     Pricing.CalculatePrice(script, ring);
                     return 1000;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
         #region Rings with Bonus Feats
         case ITEM_PROPERTY_BONUS_FEAT:
             {
                 List<int> possibleFeats = new List<int>();
                 foreach (KeyValuePair<int, int> feat in AvailableFeats)
                 {
                     if (feat.Value <= maxValue)
                     {
                         possibleFeats.Add(feat.Key);
                     }
                 }
                 if (possibleFeats.Count == 0)
                 {
                     return 0;
                 }
                 int selectedFeat = possibleFeats[Generation.rand.Next(possibleFeats.Count)];
                 script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusFeat(selectedFeat), ring, 0.0f);
                 script.SetFirstName(ring, FeatNames[selectedFeat]);
                 Pricing.CalculatePrice(script, ring);
                 return AvailableFeats[selectedFeat];
             }
         #endregion
         #region Bonus Spell Slots
         case ITEM_PROPERTY_BONUS_SPELL_SLOT_OF_LEVEL_N:
             {
                 int bonusType = AvailableBonusSpells[Generation.rand.Next(AvailableBonusSpells.Count)];
                 string name = BonusSpellNames[bonusType];
                 if (maxValue >= 81000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_9), ring, 0.0f);
                     script.SetFirstName(ring, name + " IX");
                     Pricing.CalculatePrice(script, ring);
                     return 81000;
                 }
                 else if (maxValue >= 64000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_8), ring, 0.0f);
                     script.SetFirstName(ring, name + " VIII");
                     Pricing.CalculatePrice(script, ring);
                     return 64000;
                 }
                 else if (maxValue >= 49000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_7), ring, 0.0f);
                     script.SetFirstName(ring, name + " VII");
                     Pricing.CalculatePrice(script, ring);
                     return 49000;
                 }
                 else if (maxValue >= 36000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_6), ring, 0.0f);
                     script.SetFirstName(ring, name + " VI");
                     Pricing.CalculatePrice(script, ring);
                     return 36000;
                 }
                 else if (maxValue >= 25000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_5), ring, 0.0f);
                     script.SetFirstName(ring, name + " V");
                     Pricing.CalculatePrice(script, ring);
                     return 25000;
                 }
                 else if (maxValue >= 16000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_4), ring, 0.0f);
                     script.SetFirstName(ring, name + " IV");
                     Pricing.CalculatePrice(script, ring);
                     return 16000;
                 }
                 else if (maxValue >= 9000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_3), ring, 0.0f);
                     script.SetFirstName(ring, name + " III");
                     Pricing.CalculatePrice(script, ring);
                     return 9000;
                 }
                 else if (maxValue >= 4000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_2), ring, 0.0f);
                     script.SetFirstName(ring, name + " II");
                     Pricing.CalculatePrice(script, ring);
                     return 4000;
                 }
                 else if (maxValue >= 1000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_1), ring, 0.0f);
                     script.SetFirstName(ring, name + " I");
                     Pricing.CalculatePrice(script, ring);
                     return 1000;
                 }
                 else if (maxValue >= 500)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_0), ring, 0.0f);
                     script.SetFirstName(ring, name + " 0");
                     Pricing.CalculatePrice(script, ring);
                     return 500;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
         #region Damage Resistance
         case ITEM_PROPERTY_DAMAGE_RESISTANCE:
             {
                 int damageResistType = DamageResistances[Generation.rand.Next(DamageResistances.Count)];
                 if (damageResistType == IP_CONST_DAMAGETYPE_NEGATIVE &&
                     maxValue < 6000)
                 {
                     int attempts = 0;
                     while (damageResistType == IP_CONST_DAMAGETYPE_NEGATIVE)
                     {
                         damageResistType = DamageResistances[Generation.rand.Next(DamageResistances.Count)];
                         attempts++;
                         if (attempts == 10)
                         {
                             // something is wrong. Break out and just go with fire or something.
                             damageResistType = IP_CONST_DAMAGETYPE_FIRE;
                             break;
                         }
                     }
                 }
                 if (damageResistType == IP_CONST_DAMAGETYPE_NEGATIVE)
                 {
                     if (maxValue >= 66000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_30), ring, 0.0f);
                         script.SetFirstName(ring, DamageResistanceNames[damageResistType] + ", 30");
                         Pricing.CalculatePrice(script, ring);
                         return 66000;
                     }
                     else if (maxValue >= 54000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_25), ring, 0.0f);
                         script.SetFirstName(ring, DamageResistanceNames[damageResistType] + ", 25");
                         Pricing.CalculatePrice(script, ring);
                         return 54000;
                     }
                     else if (maxValue >= 42000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_20), ring, 0.0f);
                         script.SetFirstName(ring, DamageResistanceNames[damageResistType] + ", 20");
                         Pricing.CalculatePrice(script, ring);
                         return 42000;
                     }
                     else if (maxValue >= 30000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_15), ring, 0.0f);
                         script.SetFirstName(ring, DamageResistanceNames[damageResistType] + ", 15");
                         Pricing.CalculatePrice(script, ring);
                         return 30000;
                     }
                     else if (maxValue >= 18000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_10), ring, 0.0f);
                         script.SetFirstName(ring, DamageResistanceNames[damageResistType] + ", 10");
                         Pricing.CalculatePrice(script, ring);
                         return 18000;
                     }
                     else if (maxValue >= 6000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_5), ring, 0.0f);
                         script.SetFirstName(ring, DamageResistanceNames[damageResistType] + ", 5");
                         Pricing.CalculatePrice(script, ring);
                         return 6000;
                     }
                 }
                 else
                 {
                     if (maxValue >= 44000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_30), ring, 0.0f);
                         script.SetFirstName(ring, DamageResistanceNames[damageResistType] + ", 30");
                         Pricing.CalculatePrice(script, ring);
                         return 44000;
                     }
                     else if (maxValue >= 36000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_25), ring, 0.0f);
                         script.SetFirstName(ring, DamageResistanceNames[damageResistType] + ", 25");
                         Pricing.CalculatePrice(script, ring);
                         return 36000;
                     }
                     else if (maxValue >= 28000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_20), ring, 0.0f);
                         script.SetFirstName(ring, DamageResistanceNames[damageResistType] + ", 20");
                         Pricing.CalculatePrice(script, ring);
                         return 28000;
                     }
                     else if (maxValue >= 20000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_15), ring, 0.0f);
                         script.SetFirstName(ring, DamageResistanceNames[damageResistType] + ", 15");
                         Pricing.CalculatePrice(script, ring);
                         return 20000;
                     }
                     else if (maxValue >= 12000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_10), ring, 0.0f);
                         script.SetFirstName(ring, DamageResistanceNames[damageResistType] + ", 10");
                         Pricing.CalculatePrice(script, ring);
                         return 12000;
                     }
                     else if (maxValue >= 4000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_5), ring, 0.0f);
                         script.SetFirstName(ring, DamageResistanceNames[damageResistType] + ", 5");
                         Pricing.CalculatePrice(script, ring);
                         return 4000;
                     }
                 }
                 break;
             }
         #endregion
         #region Freedom of Movement
         case ITEM_PROPERTY_FREEDOM_OF_MOVEMENT:
             {
                 script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyFreeAction(), ring, 0.0f);
                 script.SetFirstName(ring, "Ring of Freedom");
                 Pricing.CalculatePrice(script, ring);
                 return 40000;
             }
         #endregion
         #region Immunities
         case ITEM_PROPERTY_IMMUNITY_MISCELLANEOUS:
             {
                 List<int> possibleImmunities = new List<int>();
                 foreach (KeyValuePair<int, int> immunity in AvailableImmunities)
                 {
                     if (immunity.Value <= maxValue)
                     {
                         possibleImmunities.Add(immunity.Key);
                     }
                 }
                 if (possibleImmunities.Count == 0)
                 {
                     return 0;
                 }
                 int selectedImmunity = possibleImmunities[Generation.rand.Next(possibleImmunities.Count)];
                 script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyImmunityMisc(selectedImmunity), ring, 0.0f);
                 script.SetFirstName(ring, ImmunityNames[selectedImmunity]);
                 Pricing.CalculatePrice(script, ring);
                 return AvailableImmunities[selectedImmunity];
             }
         #endregion
         #region Light
         case ITEM_PROPERTY_LIGHT:
             {
                 int lightColor = LightColors[Generation.rand.Next(LightColors.Count)]; ;
                 script.SetFirstName(ring, AbilityNames[selectedAbility]);
                 if (maxValue >= 400)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyLight(IP_CONST_LIGHTBRIGHTNESS_BRIGHT, lightColor), ring, 0.0f);
                     Pricing.CalculatePrice(script, ring);
                     return 400;
                 }
                 else if (maxValue >= 300)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyLight(IP_CONST_LIGHTBRIGHTNESS_NORMAL, lightColor), ring, 0.0f);
                     Pricing.CalculatePrice(script, ring);
                     return 300;
                 }
                 else if (maxValue >= 200)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyLight(IP_CONST_LIGHTBRIGHTNESS_LOW, lightColor), ring, 0.0f);
                     Pricing.CalculatePrice(script, ring);
                     return 200;
                 }
                 else if (maxValue >= 100)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyLight(IP_CONST_LIGHTBRIGHTNESS_DIM, lightColor), ring, 0.0f);
                     Pricing.CalculatePrice(script, ring);
                     return 100;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
         #region Saving Throws
         case ITEM_PROPERTY_SAVING_THROW_BONUS:
             {
                 if (maxValue >= 25000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL, 5), ring, 0.0f);
                     script.SetFirstName(ring, "Ring of Resistance +5");
                     Pricing.CalculatePrice(script, ring);
                     return 25000;
                 }
                 else if (maxValue >= 16000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL, 4), ring, 0.0f);
                     script.SetFirstName(ring, "Ring of Resistance +4");
                     Pricing.CalculatePrice(script, ring);
                     return 16000;
                 }
                 else if (maxValue >= 9000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL, 3), ring, 0.0f);
                     script.SetFirstName(ring, "Ring of Resistance +3");
                     Pricing.CalculatePrice(script, ring);
                     return 9000;
                 }
                 else if (maxValue >= 4000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL, 2), ring, 0.0f);
                     script.SetFirstName(ring, "Ring of Resistance +2");
                     Pricing.CalculatePrice(script, ring);
                     return 4000;
                 }
                 else if (maxValue >= 1000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL, 1), ring, 0.0f);
                     script.SetFirstName(ring, "Ring of Resistance +1");
                     Pricing.CalculatePrice(script, ring);
                     return 1000;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
         #region Saving Throws vs. Specific
         case ITEM_PROPERTY_SAVING_THROW_BONUS_SPECIFIC:
             {
                 int saveType = AvailableSaveTypes[Generation.rand.Next(AvailableSaveTypes.Count)];
                 script.SetFirstName(ring, SaveTypeNames[saveType]);
                 if (maxValue >= 6250)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 5), ring, 0.0f);
                     script.SetFirstName(ring, String.Format("{0} +5", script.GetName(ring)));
                     Pricing.CalculatePrice(script, ring);
                     return 6250;
                 }
                 else if (maxValue >= 4000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 4), ring, 0.0f);
                     script.SetFirstName(ring, String.Format("{0} +4", script.GetName(ring)));
                     Pricing.CalculatePrice(script, ring);
                     return 4000;
                 }
                 else if (maxValue >= 2250)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 3), ring, 0.0f);
                     script.SetFirstName(ring, String.Format("{0} +3", script.GetName(ring)));
                     Pricing.CalculatePrice(script, ring);
                     return 2250;
                 }
                 else if (maxValue >= 1000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 2), ring, 0.0f);
                     script.SetFirstName(ring, String.Format("{0} +2", script.GetName(ring)));
                     Pricing.CalculatePrice(script, ring);
                     return 1000;
                 }
                 else if (maxValue >= 250)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 1), ring, 0.0f);
                     script.SetFirstName(ring, String.Format("{0} +1", script.GetName(ring)));
                     Pricing.CalculatePrice(script, ring);
                     return 250;
                 }
                 break;
             }
         #endregion
         #region Skill Bonus
         case ITEM_PROPERTY_SKILL_BONUS:
             {
                 int skillBonus = AvailableSkills[Generation.rand.Next(AvailableSkills.Count)];
                 script.SetFirstName(ring, SkillNames[skillBonus]);
                 if (maxValue >= 10000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 10), ring, 0.0f);
                     script.SetFirstName(ring, script.GetName(ring) + " +10");
                     Pricing.CalculatePrice(script, ring);
                     return 10000;
                 }
                 else if (maxValue >= 8100)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 9), ring, 0.0f);
                     script.SetFirstName(ring, script.GetName(ring) + " +9");
                     Pricing.CalculatePrice(script, ring);
                     return 8100;
                 }
                 else if (maxValue >= 6400)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 8), ring, 0.0f);
                     script.SetFirstName(ring, script.GetName(ring) + " +8");
                     Pricing.CalculatePrice(script, ring);
                     return 6400;
                 }
                 else if (maxValue >= 4900)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 7), ring, 0.0f);
                     script.SetFirstName(ring, script.GetName(ring) + " +7");
                     Pricing.CalculatePrice(script, ring);
                     return 4900;
                 }
                 else if (maxValue >= 3600)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 6), ring, 0.0f);
                     script.SetFirstName(ring, script.GetName(ring) + " +6");
                     Pricing.CalculatePrice(script, ring);
                     return 3600;
                 }
                 else if (maxValue >= 2500)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 5), ring, 0.0f);
                     script.SetFirstName(ring, script.GetName(ring) + " +5");
                     Pricing.CalculatePrice(script, ring);
                     return 2500;
                 }
                 else if (maxValue >= 1600)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 4), ring, 0.0f);
                     script.SetFirstName(ring, script.GetName(ring) + " +4");
                     Pricing.CalculatePrice(script, ring);
                     return 1600;
                 }
                 else if (maxValue >= 900)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 3), ring, 0.0f);
                     script.SetFirstName(ring, script.GetName(ring) + " +3");
                     Pricing.CalculatePrice(script, ring);
                     return 900;
                 }
                 else if (maxValue >= 400)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 2), ring, 0.0f);
                     script.SetFirstName(ring, script.GetName(ring) + " +2");
                     Pricing.CalculatePrice(script, ring);
                     return 400;
                 }
                 else if (maxValue >= 100)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 1), ring, 0.0f);
                     script.SetFirstName(ring, script.GetName(ring) + " +1");
                     Pricing.CalculatePrice(script, ring);
                     return 100;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
         #region Spell Resistance
         case ITEM_PROPERTY_SPELL_RESISTANCE:
             {
                 if (maxValue >= 140000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_26), ring, 0.0f);
                     script.SetFirstName(ring, "Ring of Spell Resistance, 26");
                     Pricing.CalculatePrice(script, ring);
                     return 140000;
                 }
                 else if (maxValue >= 120000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_24), ring, 0.0f);
                     script.SetFirstName(ring, "Ring of Spell Resistance, 24");
                     Pricing.CalculatePrice(script, ring);
                     return 120000;
                 }
                 else if (maxValue >= 100000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_22), ring, 0.0f);
                     script.SetFirstName(ring, "Ring of Spell Resistance, 22");
                     Pricing.CalculatePrice(script, ring);
                     return 100000;
                 }
                 else if (maxValue >= 80000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_20), ring, 0.0f);
                     script.SetFirstName(ring, "Ring of Spell Resistance, 20");
                     Pricing.CalculatePrice(script, ring);
                     return 80000;
                 }
                 else if (maxValue >= 60000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_18), ring, 0.0f);
                     script.SetFirstName(ring, "Ring of Spell Resistance, 18");
                     Pricing.CalculatePrice(script, ring);
                     return 60000;
                 }
                 else if (maxValue >= 40000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_16), ring, 0.0f);
                     script.SetFirstName(ring, "Ring of Spell Resistance, 16");
                     Pricing.CalculatePrice(script, ring);
                     return 40000;
                 }
                 else if (maxValue >= 20000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_14), ring, 0.0f);
                     script.SetFirstName(ring, "Ring of Spell Resistance, 14");
                     Pricing.CalculatePrice(script, ring);
                     return 20000;
                 }
                 else if (maxValue >= 10000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_12), ring, 0.0f);
                     script.SetFirstName(ring, "Ring of Spell Resistance, 12");
                     Pricing.CalculatePrice(script, ring);
                     return 10000;
                 }
                 else if (maxValue >= 6000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_10), ring, 0.0f);
                     script.SetFirstName(ring, "Ring of Spell Resistance, 10");
                     Pricing.CalculatePrice(script, ring);
                     return 6000;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
     }
     script.DestroyObject(ring, 0.0f, FALSE);
     return 0;
 }
        public static int NewArmor(CLRScriptBase script, int maxValue)
        {
            #region Calculate Armor Type
            List<int> possibleBaseItems = new List<int>();
            foreach (int armorType in ArmorResRefs.Keys)
            {
                if (Pricing.ArmorRulesTypeValues[armorType] <= maxValue)
                {
                    possibleBaseItems.Add(armorType);
                }
            }
            if (possibleBaseItems.Count == 0)
            {
                // Can't afford any armor. What are we doing here?
                return 0;
            }
            int selectedArmorType = possibleBaseItems[Generation.rand.Next(possibleBaseItems.Count)];
            int armorValue = Pricing.ArmorRulesTypeValues[selectedArmorType];
            maxValue -= armorValue;
            uint armor = script.CreateItemOnObject(ArmorResRefs[selectedArmorType], script.OBJECT_SELF, 1, "", FALSE);
            #endregion

            #region Armor Appearance
            Generation.Theme armorTheme = Generation.GetEnchantmentTheme();
            if (script.GetBaseItemType(armor) == BASE_ITEM_ARMOR)
            {
                script.StoreCampaignObject(ACR_Items.ItemChangeDBName, ACR_Items.ModelChangeVarName, armor, script.OBJECT_SELF);
                ArmorSet set = null;
                switch (selectedArmorType)
                {
                    case ARMOR_RULES_TYPE_BANDED:
                        set = ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Banded][Generation.rand.Next(ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Banded].Count)];
                        break;
                    case ARMOR_RULES_TYPE_BREASTPLATE:
                        set = ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Breastplate][Generation.rand.Next(ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Breastplate].Count)];
                        break;
                    case ARMOR_RULES_TYPE_CHAIN_SHIRT:
                        set = ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.ChainShirt][Generation.rand.Next(ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.ChainShirt].Count)];
                        break;
                    case ARMOR_RULES_TYPE_CHAINMAIL:
                        set = ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Chainmail][Generation.rand.Next(ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Chainmail].Count)];
                        break;
                    case ARMOR_RULES_TYPE_CLOTH:
                        set = ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Cloth][Generation.rand.Next(ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Cloth].Count)];
                        break;
                    case ARMOR_RULES_TYPE_FULL_PLATE:
                        set = ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.FullPlate][Generation.rand.Next(ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.FullPlate].Count)];
                        break;
                    case ARMOR_RULES_TYPE_HALF_PLATE:
                        set = ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.HalfPlate][Generation.rand.Next(ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.HalfPlate].Count)];
                        break;
                    case ARMOR_RULES_TYPE_HIDE:
                        set = ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Hide][Generation.rand.Next(ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Hide].Count)];
                        break;
                    case ARMOR_RULES_TYPE_LEATHER:
                        set = ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Leather][Generation.rand.Next(ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Leather].Count)];
                        break;
                    case ARMOR_RULES_TYPE_PADDED:
                        set = ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Padded][Generation.rand.Next(ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Padded].Count)];
                        break;
                    case ARMOR_RULES_TYPE_SCALE:
                        set = ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Scale][Generation.rand.Next(ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.Scale].Count)];
                        break;
                    case ARMOR_RULES_TYPE_STUDDED_LEATHER:
                        set = ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.StuddedLeather][Generation.rand.Next(ACR_Items.ArmorSetLibrary[ACR_Items.ArmorSetTypes.StuddedLeather].Count)];
                        break;
                }
                if (set != null)
                {
                    ItemModels.TakeArmorStyle(ALFA.Shared.Modules.InfoStore.ModifiedGff[ACR_Items.ModelChangeVarName], set);
                }
                ColorPair color = GeneratedColors.ColorPairs[armorTheme][Generation.rand.Next(GeneratedColors.ColorPairs[armorTheme].Count)];
                ItemColors.SetColorThemes(ALFA.Shared.Modules.InfoStore.ModifiedGff[ACR_Items.ModelChangeVarName], color.Primary, color.Accent);
                script.DestroyObject(armor, 0.0f, TRUE);
                armor = script.RetrieveCampaignObject(ACR_Items.ItemChangeDBName, ACR_Items.ModelChangeVarName, script.GetLocation(script.OBJECT_SELF), script.OBJECT_SELF, script.OBJECT_SELF);
            }
            #endregion

            #region See if We Want This to be Masterwork
            if (maxValue >= 150)
            {
                switch (selectedArmorType)
                {
                    case ARMOR_RULES_TYPE_BANDED:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_BANDED_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                    case ARMOR_RULES_TYPE_BREASTPLATE:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_BREASTPLATE_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                    case ARMOR_RULES_TYPE_CHAIN_SHIRT:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_CHAIN_SHIRT_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                    case ARMOR_RULES_TYPE_CHAINMAIL:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_CHAINMAIL_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                    case ARMOR_RULES_TYPE_FULL_PLATE:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_FULL_PLATE_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                    case ARMOR_RULES_TYPE_HALF_PLATE:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_HALF_PLATE_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                    case ARMOR_RULES_TYPE_HIDE:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_HIDE_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                    case ARMOR_RULES_TYPE_LEATHER:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_LEATHER_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                    case ARMOR_RULES_TYPE_PADDED:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_PADDED_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                    case ARMOR_RULES_TYPE_SCALE:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_SCALE_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                    case ARMOR_RULES_TYPE_SHIELD_HEAVY:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_SHIELD_HEAVY_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                    case ARMOR_RULES_TYPE_SHIELD_LIGHT:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_SHIELD_LIGHT_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                    case ARMOR_RULES_TYPE_SHIELD_TOWER:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_SHIELD_TOWER_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                    case ARMOR_RULES_TYPE_SPLINT:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_SPLINT_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                    case ARMOR_RULES_TYPE_STUDDED_LEATHER:
                        script.SetArmorRulesType(armor, ARMOR_RULES_TYPE_STUDDED_LEATHER_MASTERWORK);
                        armorValue += 150;
                        maxValue -= 150;
                        break;
                }
            }
            else
            {
                // We can't even afford masterwork. Carry on.
                return armorValue;
            }
            #endregion

            #region Calculate Effective Plus
            double effectivePlusRemaining = Math.Sqrt((double)(maxValue / 1000)); // we cast after the division because we're going to turn this into an int later.
            double currentEffectivePlus = 0.0;
            #endregion

            #region Set Base Properties
            int enhancementBonus = 0;
            if (effectivePlusRemaining >= 1.0)
            {
                enhancementBonus = 1;
                effectivePlusRemaining -= 1;
                currentEffectivePlus = 1;
                bool quirkAdded = false;
                while (effectivePlusRemaining >= 1)
                {
                    if (Generation.rand.Next(100) > 95)
                    {
                        // The remainder of the enchantment will
                        // be personality heavy.
                        break;
                    }
                    if (!quirkAdded && Generation.rand.Next(100) < 75)
                    {
                        enhancementBonus += 1;
                        effectivePlusRemaining -= 1;
                        currentEffectivePlus += 1;
                    }
                    else
                    {
                        List<EnhancementTypes> quirks = BuildBaseEnchantmentPossibilities(script.GetBaseItemType(armor), effectivePlusRemaining);
                        if (quirks.Count > 0)
                        {
                            EnhancementTypes quirk = quirks[Generation.rand.Next(quirks.Count)];
                            if (selectedArmorType == ARMOR_RULES_TYPE_CLOTH &&
                                quirk == EnhancementTypes.Twilight)
                            {
                                quirk = EnhancementTypes.SpellFocus;
                            }
                            switch (quirk)
                            {
                                case EnhancementTypes.CombatCasting:
                                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusFeat(IP_CONST_FEAT_COMBAT_CASTING), armor, 0.0f);
                                    script.SetFirstName(armor, String.Format("Battlemage's {0}", script.GetName(armor)));
                                    effectivePlusRemaining -= 1;
                                    currentEffectivePlus += 1;
                                    break;
                                case EnhancementTypes.DeflectArrows:
                                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusFeat(IP_CONST_FEAT_DEFLECT_ARROWS), armor, 0.0f);
                                    script.SetFirstName(armor, String.Format("Arrowcatching {0}", script.GetName(armor)));
                                    effectivePlusRemaining -= 2;
                                    currentEffectivePlus += 2;
                                    break;
                                case EnhancementTypes.Dodge:
                                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusFeat(IP_CONST_FEAT_DODGE), armor, 0.0f);
                                    script.SetFirstName(armor, String.Format("Nimble {0}", script.GetName(armor)));
                                    effectivePlusRemaining -= 1;
                                    currentEffectivePlus += 1;
                                    break;
                                case EnhancementTypes.ExtraTurning:
                                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusFeat(IP_CONST_FEAT_EXTRA_TURNING), armor, 0.0f);
                                    script.SetFirstName(armor, String.Format("Turning {0}", script.GetName(armor)));
                                    effectivePlusRemaining -= 1;
                                    currentEffectivePlus += 1;
                                    break;
                                case EnhancementTypes.SpellFocus:
                                    int primarySchool = Generation.SpellSchoolFocus[Generation.rand.Next(Generation.SpellSchoolFocus.Count)];
                                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusFeat(primarySchool), armor, 0.0f);
                                    script.SetFirstName(armor, String.Format("Mage's {0}", script.GetName(armor)));
                                    effectivePlusRemaining -= 1;
                                    currentEffectivePlus += 1;
                                    if (effectivePlusRemaining >= 0.5)
                                    {
                                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusFeat(Generation.SpellFocusLeft[primarySchool]), armor, 0.0f);
                                        effectivePlusRemaining -= 0.5;
                                        currentEffectivePlus += 0.5;
                                    }
                                    if (effectivePlusRemaining >= 0.5)
                                    {
                                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusFeat(Generation.SpellFocusRight[primarySchool]), armor, 0.0f);
                                        effectivePlusRemaining -= 0.5;
                                        currentEffectivePlus += 0.5;
                                    }
                                    break;
                                case EnhancementTypes.SpellPenetration:
                                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusFeat(IP_CONST_FEAT_SPELLPENETRATION), armor, 0.0f);
                                    script.SetFirstName(armor, String.Format("Mage's {0}", script.GetName(armor)));
                                    effectivePlusRemaining -= 1.5;
                                    currentEffectivePlus += 1.5;
                                    break;
                                case EnhancementTypes.SR12:
                                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_12), armor, 0.0f);
                                    script.SetFirstName(armor, String.Format("Spellsoaking {0}", script.GetName(armor)));
                                    effectivePlusRemaining -= 2;
                                    currentEffectivePlus += 2;
                                    break;
                                case EnhancementTypes.SR14:
                                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_14), armor, 0.0f);
                                    script.SetFirstName(armor, String.Format("Spellsoaking {0}", script.GetName(armor)));
                                    effectivePlusRemaining -= 3;
                                    currentEffectivePlus += 3;
                                    break;
                                case EnhancementTypes.SR16:
                                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_16), armor, 0.0f);
                                    script.SetFirstName(armor, String.Format("Spellsoaking {0}", script.GetName(armor)));
                                    effectivePlusRemaining -= 4;
                                    currentEffectivePlus += 4;
                                    break;
                                case EnhancementTypes.SR18:
                                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_18), armor, 0.0f);
                                    script.SetFirstName(armor, String.Format("Spellsoaking {0}", script.GetName(armor)));
                                    effectivePlusRemaining -= 5;
                                    currentEffectivePlus += 5;
                                    break;
                                case EnhancementTypes.Twilight:
                                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyArcaneSpellFailure(IP_CONST_ARCANE_SPELL_FAILURE_MINUS_10_PERCENT), armor, 0.0f);
                                    script.SetFirstName(armor, String.Format("Twilight {0}", script.GetName(armor)));
                                    effectivePlusRemaining -= 1;
                                    currentEffectivePlus += 1;
                                    break;
                            }
                        }
                        quirkAdded = true;
                    }
                }
                script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(enhancementBonus), armor, 0.0f);
                script.SetFirstName(armor, String.Format("{0} +{1}", script.GetName(armor), enhancementBonus));
            }
            #endregion

            #region Armor Personality
            SetPersonalityProperties(script, armor, armorTheme, enhancementBonus, ref effectivePlusRemaining, ref currentEffectivePlus);
            armorValue += (int)(currentEffectivePlus * currentEffectivePlus * 1000);
            Pricing.CalculatePrice(script, armor);
            return armorValue;
            #endregion
        }
 public static int NewHelmet(CLRScriptBase script, int maxValue)
 {
     List<int> potentialAbilities = new List<int>();
     foreach (KeyValuePair<int, int> ability in AvailableAbilities)
     {
         if (ability.Value <= maxValue)
         {
             potentialAbilities.Add(ability.Key);
         }
     }
     if (potentialAbilities.Count == 0)
     {
         return 0;
     }
     int selectedAbility = potentialAbilities[Generation.rand.Next(potentialAbilities.Count)];
     uint helmet = script.CreateItemOnObject("zitem_helm2", script.OBJECT_SELF, 1, "", FALSE);
     switch (selectedAbility)
     {
         #region Helmets of Ability Scores
         case ITEM_PROPERTY_ABILITY_BONUS:
             {
                 int abilityScore = AvailableAbilityScores[Generation.rand.Next(AvailableAbilityScores.Count)];
                 string name = AbilityScoreNames[abilityScore];
                 if (maxValue >= 36000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 6), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " +6");
                     Pricing.CalculatePrice(script, helmet);
                     return 36000;
                 }
                 else if (maxValue >= 25000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 5), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " +5");
                     Pricing.CalculatePrice(script, helmet);
                     return 25000;
                 }
                 else if (maxValue >= 16000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 4), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " +4");
                     Pricing.CalculatePrice(script, helmet);
                     return 16000;
                 }
                 else if (maxValue >= 9000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 3), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " +3");
                     Pricing.CalculatePrice(script, helmet);
                     return 9000;
                 }
                 else if (maxValue >= 4000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 2), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " +2");
                     Pricing.CalculatePrice(script, helmet);
                     return 4000;
                 }
                 else if (maxValue >= 1000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 1), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " +1");
                     Pricing.CalculatePrice(script, helmet);
                     return 1000;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
         #region Helmets with Bonus Feats
         case ITEM_PROPERTY_BONUS_FEAT:
             {
                 List<int> possibleFeats = new List<int>();
                 foreach (KeyValuePair<int, int> feat in AvailableFeats)
                 {
                     if (feat.Value <= maxValue)
                     {
                         possibleFeats.Add(feat.Key);
                     }
                 }
                 if (possibleFeats.Count == 0)
                 {
                     return 0;
                 }
                 int selectedFeat = possibleFeats[Generation.rand.Next(possibleFeats.Count)];
                 script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusFeat(selectedFeat), helmet, 0.0f);
                 script.SetFirstName(helmet, FeatNames[selectedFeat]);
                 Pricing.CalculatePrice(script, helmet);
                 return AvailableFeats[selectedFeat];
             }
         #endregion
         #region Bonus Spell Slots
         case ITEM_PROPERTY_BONUS_SPELL_SLOT_OF_LEVEL_N:
             {
                 int bonusType = AvailableBonusSpells[Generation.rand.Next(AvailableBonusSpells.Count)];
                 string name = BonusSpellNames[bonusType];
                 if (maxValue >= 81000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_9), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " IX");
                     Pricing.CalculatePrice(script, helmet);
                     return 81000;
                 }
                 else if (maxValue >= 64000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_8), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " VIII");
                     Pricing.CalculatePrice(script, helmet);
                     return 64000;
                 }
                 else if (maxValue >= 49000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_7), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " VII");
                     Pricing.CalculatePrice(script, helmet);
                     return 49000;
                 }
                 else if (maxValue >= 36000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_6), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " VI");
                     Pricing.CalculatePrice(script, helmet);
                     return 36000;
                 }
                 else if (maxValue >= 25000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_5), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " V");
                     Pricing.CalculatePrice(script, helmet);
                     return 25000;
                 }
                 else if (maxValue >= 16000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_4), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " IV");
                     Pricing.CalculatePrice(script, helmet);
                     return 16000;
                 }
                 else if (maxValue >= 9000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_3), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " III");
                     Pricing.CalculatePrice(script, helmet);
                     return 9000;
                 }
                 else if (maxValue >= 4000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_2), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " II");
                     Pricing.CalculatePrice(script, helmet);
                     return 4000;
                 }
                 else if (maxValue >= 1000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_1), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " I");
                     Pricing.CalculatePrice(script, helmet);
                     return 1000;
                 }
                 else if (maxValue >= 500)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusLevelSpell(bonusType, IP_CONST_SPELLLEVEL_0), helmet, 0.0f);
                     script.SetFirstName(helmet, name + " 0");
                     Pricing.CalculatePrice(script, helmet);
                     return 500;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
         #region Immunities
         case ITEM_PROPERTY_IMMUNITY_MISCELLANEOUS:
             {
                 List<int> possibleImmunities = new List<int>();
                 foreach (KeyValuePair<int, int> immunity in AvailableImmunities)
                 {
                     if (immunity.Value <= maxValue)
                     {
                         possibleImmunities.Add(immunity.Key);
                     }
                 }
                 if (possibleImmunities.Count == 0)
                 {
                     return 0;
                 }
                 int selectedImmunity = possibleImmunities[Generation.rand.Next(possibleImmunities.Count)];
                 script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyImmunityMisc(selectedImmunity), helmet, 0.0f);
                 script.SetFirstName(helmet, ImmunityNames[selectedImmunity]);
                 Pricing.CalculatePrice(script, helmet);
                 return AvailableImmunities[selectedImmunity];
             }
         #endregion
         #region Saving Throws vs. Specific
         case ITEM_PROPERTY_SAVING_THROW_BONUS_SPECIFIC:
             {
                 int saveType = AvailableSaveTypes[Generation.rand.Next(AvailableSaveTypes.Count)];
                 script.SetFirstName(helmet, SaveTypeNames[saveType]);
                 if (maxValue >= 6250)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 5), helmet, 0.0f);
                     script.SetFirstName(helmet, String.Format("{0} +5", script.GetName(helmet)));
                     Pricing.CalculatePrice(script, helmet);
                     return 6250;
                 }
                 else if (maxValue >= 4000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 4), helmet, 0.0f);
                     script.SetFirstName(helmet, String.Format("{0} +4", script.GetName(helmet)));
                     Pricing.CalculatePrice(script, helmet);
                     return 4000;
                 }
                 else if (maxValue >= 2250)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 3), helmet, 0.0f);
                     script.SetFirstName(helmet, String.Format("{0} +3", script.GetName(helmet)));
                     Pricing.CalculatePrice(script, helmet);
                     return 2250;
                 }
                 else if (maxValue >= 1000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 2), helmet, 0.0f);
                     script.SetFirstName(helmet, String.Format("{0} +2", script.GetName(helmet)));
                     Pricing.CalculatePrice(script, helmet);
                     return 1000;
                 }
                 else if (maxValue >= 250)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 1), helmet, 0.0f);
                     script.SetFirstName(helmet, String.Format("{0} +1", script.GetName(helmet)));
                     Pricing.CalculatePrice(script, helmet);
                     return 250;
                 }
                 break;
             }
         #endregion
         #region Skill Bonus
         case ITEM_PROPERTY_SKILL_BONUS:
             {
                 int skillBonus = AvailableSkills[Generation.rand.Next(AvailableSkills.Count)];
                 script.SetFirstName(helmet, SkillNames[skillBonus]);
                 if (maxValue >= 10000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 10), helmet, 0.0f);
                     script.SetFirstName(helmet, script.GetName(helmet) + " +10");
                     Pricing.CalculatePrice(script, helmet);
                     return 10000;
                 }
                 else if (maxValue >= 8100)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 9), helmet, 0.0f);
                     script.SetFirstName(helmet, script.GetName(helmet) + " +9");
                     Pricing.CalculatePrice(script, helmet);
                     return 8100;
                 }
                 else if (maxValue >= 6400)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 8), helmet, 0.0f);
                     script.SetFirstName(helmet, script.GetName(helmet) + " +8");
                     Pricing.CalculatePrice(script, helmet);
                     return 6400;
                 }
                 else if (maxValue >= 4900)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 7), helmet, 0.0f);
                     script.SetFirstName(helmet, script.GetName(helmet) + " +7");
                     Pricing.CalculatePrice(script, helmet);
                     return 4900;
                 }
                 else if (maxValue >= 3600)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 6), helmet, 0.0f);
                     script.SetFirstName(helmet, script.GetName(helmet) + " +6");
                     Pricing.CalculatePrice(script, helmet);
                     return 3600;
                 }
                 else if (maxValue >= 2500)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 5), helmet, 0.0f);
                     script.SetFirstName(helmet, script.GetName(helmet) + " +5");
                     Pricing.CalculatePrice(script, helmet);
                     return 2500;
                 }
                 else if (maxValue >= 1600)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 4), helmet, 0.0f);
                     script.SetFirstName(helmet, script.GetName(helmet) + " +4");
                     Pricing.CalculatePrice(script, helmet);
                     return 1600;
                 }
                 else if (maxValue >= 900)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 3), helmet, 0.0f);
                     script.SetFirstName(helmet, script.GetName(helmet) + " +3");
                     Pricing.CalculatePrice(script, helmet);
                     return 900;
                 }
                 else if (maxValue >= 400)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 2), helmet, 0.0f);
                     script.SetFirstName(helmet, script.GetName(helmet) + " +2");
                     Pricing.CalculatePrice(script, helmet);
                     return 400;
                 }
                 else if (maxValue >= 100)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 1), helmet, 0.0f);
                     script.SetFirstName(helmet, script.GetName(helmet) + " +1");
                     Pricing.CalculatePrice(script, helmet);
                     return 100;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
     }
     script.DestroyObject(helmet, 0.0f, FALSE);
     return 0;
 }
 public static int NewAmulet(CLRScriptBase script, int maxValue)
 {
     List<int> potentialAbilities = new List<int>();
     foreach (KeyValuePair<int, int> ability in PrimaryAmuletAbility)
     {
         if (ability.Value <= maxValue)
         {
             potentialAbilities.Add(ability.Key);
         }
     }
     if (potentialAbilities.Count == 0)
     {
         return 0;
     }
     int selectedAbility = potentialAbilities[Generation.rand.Next(potentialAbilities.Count)];
     uint amulet = script.CreateItemOnObject("nw_it_mneck020", script.OBJECT_SELF, 1, "", FALSE);
     switch (selectedAbility)
     {
         #region Amulets of Natural Armor
         case ITEM_PROPERTY_AC_BONUS:
             {
                 if (maxValue >= 50000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(5), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Natural Armor +5");
                     Pricing.CalculatePrice(script, amulet);
                     return 50000;
                 }
                 else if (maxValue >= 32000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(4), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Natural Armor +4");
                     Pricing.CalculatePrice(script, amulet);
                     return 32000;
                 }
                 else if (maxValue >= 18000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(3), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Natural Armor +3");
                     Pricing.CalculatePrice(script, amulet);
                     return 18000;
                 }
                 else if (maxValue >= 8000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(2), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Natural Armor +2");
                     Pricing.CalculatePrice(script, amulet);
                     return 8000;
                 }
                 else if (maxValue >= 2000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(1), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Natural Armor +1");
                     Pricing.CalculatePrice(script, amulet);
                     return 2000;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
         #region Amulets of Health and Wisdom
         case ITEM_PROPERTY_ABILITY_BONUS:
             {
                 int abilityScore = IP_CONST_ABILITY_CON;
                 string name = "Amulet of Health";
                 if (script.d2(1) == 1)
                 {
                     abilityScore = IP_CONST_ABILITY_WIS;
                     name = "Amulet of Wisdom";
                 }
                 if (maxValue >= 36000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 6), amulet, 0.0f);
                     script.SetFirstName(amulet, name + " +6");
                     Pricing.CalculatePrice(script, amulet);
                     return 36000;
                 }
                 else if (maxValue >= 25000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 5), amulet, 0.0f);
                     script.SetFirstName(amulet, name + " +5");
                     Pricing.CalculatePrice(script, amulet);
                     return 25000;
                 }
                 else if (maxValue >= 16000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 4), amulet, 0.0f);
                     script.SetFirstName(amulet, name + " +4");
                     Pricing.CalculatePrice(script, amulet);
                     return 16000;
                 }
                 else if (maxValue >= 9000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 3), amulet, 0.0f);
                     script.SetFirstName(amulet, name + " +3");
                     Pricing.CalculatePrice(script, amulet);
                     return 9000;
                 }
                 else if (maxValue >= 4000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 2), amulet, 0.0f);
                     script.SetFirstName(amulet, name + " +2");
                     Pricing.CalculatePrice(script, amulet);
                     return 4000;
                 }
                 else if (maxValue >= 1000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 1), amulet, 0.0f);
                     script.SetFirstName(amulet, name + " +1");
                     Pricing.CalculatePrice(script, amulet);
                     return 1000;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
         #region Amulets with Bonus Feats
         case ITEM_PROPERTY_BONUS_FEAT:
             {
                 List<int> possibleFeats = new List<int>();
                 foreach (KeyValuePair<int, int> feat in AvailableFeats)
                 {
                     if (feat.Value <= maxValue)
                     {
                         possibleFeats.Add(feat.Key);
                     }
                 }
                 if (possibleFeats.Count == 0)
                 {
                     return 0;
                 }
                 int selectedFeat = possibleFeats[Generation.rand.Next(possibleFeats.Count)];
                 script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusFeat(selectedFeat), amulet, 0.0f);
                 switch (selectedFeat)
                 {
                     case IP_CONST_FEAT_COMBAT_CASTING:
                         script.SetFirstName(amulet, "Amulet of the Battlemage");
                         break;
                     case IP_CONST_FEAT_EXTRA_TURNING:
                         script.SetFirstName(amulet, "Amulet of Turning");
                         break;
                     case IP_CONST_FEAT_DARKVISION:
                         script.SetFirstName(amulet, "Amulet of Darkvision");
                         break;
                 }
                 Pricing.CalculatePrice(script, amulet);
                 return AvailableFeats[selectedFeat];
             }
         #endregion
         #region Damage Resistance
         case ITEM_PROPERTY_DAMAGE_RESISTANCE:
             {
                 int damageResistType = DamageResistances[Generation.rand.Next(DamageResistances.Count)];
                 if (damageResistType == IP_CONST_DAMAGETYPE_NEGATIVE &&
                     maxValue < 6000)
                 {
                     int attempts = 0;
                     while (damageResistType == IP_CONST_DAMAGETYPE_NEGATIVE)
                     {
                         damageResistType = DamageResistances[Generation.rand.Next(DamageResistances.Count)];
                         attempts++;
                         if (attempts == 10)
                         {
                             // something is wrong. Break out and just go with fire or something.
                             damageResistType = IP_CONST_DAMAGETYPE_FIRE;
                             break;
                         }
                     }
                 }
                 if (damageResistType == IP_CONST_DAMAGETYPE_NEGATIVE)
                 {
                     if (maxValue >= 66000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_30), amulet, 0.0f);
                         script.SetFirstName(amulet, DamageResistanceNames[damageResistType] + ", 30");
                         Pricing.CalculatePrice(script, amulet);
                         return 66000;
                     }
                     else if (maxValue >= 54000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_25), amulet, 0.0f);
                         script.SetFirstName(amulet, DamageResistanceNames[damageResistType] + ", 25");
                         Pricing.CalculatePrice(script, amulet);
                         return 54000;
                     }
                     else if (maxValue >= 42000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_20), amulet, 0.0f);
                         script.SetFirstName(amulet, DamageResistanceNames[damageResistType] + ", 20");
                         Pricing.CalculatePrice(script, amulet);
                         return 42000;
                     }
                     else if (maxValue >= 30000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_15), amulet, 0.0f);
                         script.SetFirstName(amulet, DamageResistanceNames[damageResistType] + ", 15");
                         Pricing.CalculatePrice(script, amulet);
                         return 30000;
                     }
                     else if (maxValue >= 18000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_10), amulet, 0.0f);
                         script.SetFirstName(amulet, DamageResistanceNames[damageResistType] + ", 10");
                         Pricing.CalculatePrice(script, amulet);
                         return 18000;
                     }
                     else if (maxValue >= 6000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_5), amulet, 0.0f);
                         script.SetFirstName(amulet, DamageResistanceNames[damageResistType] + ", 5");
                         Pricing.CalculatePrice(script, amulet);
                         return 6000;
                     }
                 }
                 else
                 {
                     if (maxValue >= 44000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_30), amulet, 0.0f);
                         script.SetFirstName(amulet, DamageResistanceNames[damageResistType] + ", 30");
                         Pricing.CalculatePrice(script, amulet);
                         return 44000;
                     }
                     else if (maxValue >= 36000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_25), amulet, 0.0f);
                         script.SetFirstName(amulet, DamageResistanceNames[damageResistType] + ", 25");
                         Pricing.CalculatePrice(script, amulet);
                         return 36000;
                     }
                     else if (maxValue >= 28000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_20), amulet, 0.0f);
                         script.SetFirstName(amulet, DamageResistanceNames[damageResistType] + ", 20");
                         Pricing.CalculatePrice(script, amulet);
                         return 28000;
                     }
                     else if (maxValue >= 20000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_15), amulet, 0.0f);
                         script.SetFirstName(amulet, DamageResistanceNames[damageResistType] + ", 15");
                         Pricing.CalculatePrice(script, amulet);
                         return 20000;
                     }
                     else if (maxValue >= 12000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_10), amulet, 0.0f);
                         script.SetFirstName(amulet, DamageResistanceNames[damageResistType] + ", 10");
                         Pricing.CalculatePrice(script, amulet);
                         return 12000;
                     }
                     else if (maxValue >= 4000)
                     {
                         script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_5), amulet, 0.0f);
                         script.SetFirstName(amulet, DamageResistanceNames[damageResistType] + ", 5");
                         Pricing.CalculatePrice(script, amulet);
                         return 4000;
                     }
                 }
                 break;
             }
         #endregion
         #region Freedom of Movement
         case ITEM_PROPERTY_FREEDOM_OF_MOVEMENT:
             {
                 script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyFreeAction(), amulet, 0.0f);
                 script.SetFirstName(amulet, "Amulet of Freedom");
                 Pricing.CalculatePrice(script, amulet);
                 return 40000;
             }
         #endregion
         #region Immunities
         case ITEM_PROPERTY_IMMUNITY_MISCELLANEOUS:
             {
                 List<int> possibleImmunities = new List<int>();
                 foreach (KeyValuePair<int, int> immunity in AvailableImmunities)
                 {
                     if (immunity.Value <= maxValue)
                     {
                         possibleImmunities.Add(immunity.Key);
                     }
                 }
                 if (possibleImmunities.Count == 0)
                 {
                     return 0;
                 }
                 int selectedImmunity = possibleImmunities[Generation.rand.Next(possibleImmunities.Count)];
                 script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyImmunityMisc(selectedImmunity), amulet, 0.0f);
                 switch (selectedImmunity)
                 {
                     case IP_CONST_IMMUNITYMISC_DEATH_MAGIC:
                         script.SetFirstName(amulet, "Amulet of Lifeshielding");
                         break;
                     case IP_CONST_IMMUNITYMISC_DISEASE:
                         script.SetFirstName(amulet, "Amulet of Good Health");
                         break;
                     case IP_CONST_IMMUNITYMISC_FEAR:
                         script.SetFirstName(amulet, "Amulet of Fearlessness");
                         break;
                     case IP_CONST_IMMUNITYMISC_KNOCKDOWN:
                         script.SetFirstName(amulet, "Amulet of Stability");
                         break;
                     case IP_CONST_IMMUNITYMISC_LEVEL_ABIL_DRAIN:
                         script.SetFirstName(amulet, "Amulet of Undeath's Deflection");
                         break;
                     case IP_CONST_IMMUNITYMISC_PARALYSIS:
                         script.SetFirstName(amulet, "Amulet of Mobility");
                         break;
                     case IP_CONST_IMMUNITYMISC_POISON:
                         script.SetFirstName(amulet, "Amulet of Antivenom");
                         break;
                 }
                 Pricing.CalculatePrice(script, amulet);
                 return AvailableImmunities[selectedImmunity];
             }
         #endregion
         #region Saving Throws
         case ITEM_PROPERTY_SAVING_THROW_BONUS:
             {
                 if (maxValue >= 25000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL, 5), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Resistance +5");
                     Pricing.CalculatePrice(script, amulet);
                     return 25000;
                 }
                 else if (maxValue >= 16000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL, 4), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Resistance +4");
                     Pricing.CalculatePrice(script, amulet);
                     return 16000;
                 }
                 else if (maxValue >= 9000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL, 3), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Resistance +3");
                     Pricing.CalculatePrice(script, amulet);
                     return 9000;
                 }
                 else if (maxValue >= 4000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL, 2), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Resistance +2");
                     Pricing.CalculatePrice(script, amulet);
                     return 4000;
                 }
                 else if (maxValue >= 1000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL, 1), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Resistance +1");
                     Pricing.CalculatePrice(script, amulet);
                     return 1000;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
         #region Saving Throws vs. Specific
         case ITEM_PROPERTY_SAVING_THROW_BONUS_SPECIFIC:
             {
                 int saveType = AvailableSaveTypes[Generation.rand.Next(AvailableSaveTypes.Count)];
                 script.SetFirstName(amulet, SaveTypeNames[saveType]);
                 if (maxValue >= 6250)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 5), amulet, 0.0f);
                     script.SetFirstName(amulet, String.Format("{0} +5", script.GetName(amulet)));
                     Pricing.CalculatePrice(script, amulet);
                     return 6250;
                 }
                 else if (maxValue >= 4000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 4), amulet, 0.0f);
                     script.SetFirstName(amulet, String.Format("{0} +4", script.GetName(amulet)));
                     Pricing.CalculatePrice(script, amulet);
                     return 4000;
                 }
                 else if (maxValue >= 2250)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 3), amulet, 0.0f);
                     script.SetFirstName(amulet, String.Format("{0} +3", script.GetName(amulet)));
                     Pricing.CalculatePrice(script, amulet);
                     return 2250;
                 }
                 else if (maxValue >= 1000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 2), amulet, 0.0f);
                     script.SetFirstName(amulet, String.Format("{0} +2", script.GetName(amulet)));
                     Pricing.CalculatePrice(script, amulet);
                     return 1000;
                 }
                 else if (maxValue >= 250)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 1), amulet, 0.0f);
                     script.SetFirstName(amulet, String.Format("{0} +1", script.GetName(amulet)));
                     Pricing.CalculatePrice(script, amulet);
                     return 250;
                 }
                 break;
             }
         #endregion
         #region Skill Bonus
         case ITEM_PROPERTY_SKILL_BONUS:
             {
                 int skillBonus = AvailableSkills[Generation.rand.Next(AvailableSkills.Count)];
                 script.SetFirstName(amulet, SkillNames[skillBonus]);
                 if (maxValue >= 10000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 10), amulet, 0.0f);
                     script.SetFirstName(amulet, script.GetName(amulet) + " +10");
                     Pricing.CalculatePrice(script, amulet);
                     return 10000;
                 }
                 else if (maxValue >= 8100)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 9), amulet, 0.0f);
                     script.SetFirstName(amulet, script.GetName(amulet) + " +9");
                     Pricing.CalculatePrice(script, amulet);
                     return 8100;
                 }
                 else if (maxValue >= 6400)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 8), amulet, 0.0f);
                     script.SetFirstName(amulet, script.GetName(amulet) + " +8");
                     Pricing.CalculatePrice(script, amulet);
                     return 6400;
                 }
                 else if (maxValue >= 4900)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 7), amulet, 0.0f);
                     script.SetFirstName(amulet, script.GetName(amulet) + " +7");
                     Pricing.CalculatePrice(script, amulet);
                     return 4900;
                 }
                 else if (maxValue >= 3600)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 6), amulet, 0.0f);
                     script.SetFirstName(amulet, script.GetName(amulet) + " +6");
                     Pricing.CalculatePrice(script, amulet);
                     return 3600;
                 }
                 else if (maxValue >= 2500)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 5), amulet, 0.0f);
                     script.SetFirstName(amulet, script.GetName(amulet) + " +5");
                     Pricing.CalculatePrice(script, amulet);
                     return 2500;
                 }
                 else if (maxValue >= 1600)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 4), amulet, 0.0f);
                     script.SetFirstName(amulet, script.GetName(amulet) + " +4");
                     Pricing.CalculatePrice(script, amulet);
                     return 1600;
                 }
                 else if (maxValue >= 900)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 3), amulet, 0.0f);
                     script.SetFirstName(amulet, script.GetName(amulet) + " +3");
                     Pricing.CalculatePrice(script, amulet);
                     return 900;
                 }
                 else if (maxValue >= 400)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 2), amulet, 0.0f);
                     script.SetFirstName(amulet, script.GetName(amulet) + " +2");
                     Pricing.CalculatePrice(script, amulet);
                     return 400;
                 }
                 else if (maxValue >= 100)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 1), amulet, 0.0f);
                     script.SetFirstName(amulet, script.GetName(amulet) + " +1");
                     Pricing.CalculatePrice(script, amulet);
                     return 100;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
         #region Spell Resistance
         case ITEM_PROPERTY_SPELL_RESISTANCE:
             {
                 if (maxValue >= 140000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_26), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Spell Resistance, 26");
                     Pricing.CalculatePrice(script, amulet);
                     return 140000;
                 }
                 else if (maxValue >= 120000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_24), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Spell Resistance, 24");
                     Pricing.CalculatePrice(script, amulet);
                     return 120000;
                 }
                 else if (maxValue >= 100000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_22), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Spell Resistance, 22");
                     Pricing.CalculatePrice(script, amulet);
                     return 100000;
                 }
                 else if (maxValue >= 80000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_20), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Spell Resistance, 20");
                     Pricing.CalculatePrice(script, amulet);
                     return 80000;
                 }
                 else if (maxValue >= 60000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_18), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Spell Resistance, 18");
                     Pricing.CalculatePrice(script, amulet);
                     return 60000;
                 }
                 else if (maxValue >= 40000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_16), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Spell Resistance, 16");
                     Pricing.CalculatePrice(script, amulet);
                     return 40000;
                 }
                 else if (maxValue >= 20000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_14), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Spell Resistance, 14");
                     Pricing.CalculatePrice(script, amulet);
                     return 20000;
                 }
                 else if (maxValue >= 10000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_12), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Spell Resistance, 12");
                     Pricing.CalculatePrice(script, amulet);
                     return 10000;
                 }
                 else if (maxValue >= 6000)
                 {
                     script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_10), amulet, 0.0f);
                     script.SetFirstName(amulet, "Amulet of Spell Resistance, 10");
                     Pricing.CalculatePrice(script, amulet);
                     return 6000;
                 }
                 else
                 {
                     return 0;
                 }
             }
         #endregion
     }
     // Something has gone wrong. Nuke that amulet before it spreads the plague.
     script.DestroyObject(amulet, 0.0f, FALSE);
     return 0;
 }