ACR_Items.Pricing.CalculatePrice C# (CSharp) Метод

        public static void CalculatePrice(CLRScriptBase script, uint target)
        {
            #region Reject to Price Objects Which Can't or Shouldn't be Priced
            if (script.GetObjectType(target) != OBJECT_TYPE_ITEM)
            {
                return;
            }

            int itemType = script.GetBaseItemType(target);
            if (GetIsOOCItem(itemType))
            {
                return;
            }
            #endregion

            #region Find out What the Item Should be Worth
            int targetValue = 0;
            if (GetIsWeapon(itemType) || GetIsAmmunition(itemType))
            {
                targetValue = GetWeaponPrice(script, target);
            }
            else if (GetIsArmor(itemType))
            {
                targetValue = GetArmorPrice(script, target);
            }
            else
            {
                targetValue = GetWonderousPrice(script, target);
            }
            #endregion

            #region Early Return for Illegal and Custom-Scripted Items
            if (targetValue == -1)
            {
                // We can't price this item, because it's illegal.
                script.SetFirstName(target, "(Illegal) " + script.GetName(target));
                return;
            }
            else if (targetValue == -2)
            {
                return;
            }
            #endregion

            #region Determine if the Item Requires Adjustment, and Adjust if Necessary
            bool isPlot = false;
            bool isUnidentified = false;
            if (script.GetLocalInt(target, localVarName) == pricingVersion)
            {
                // We've already used this logic to price this item. We have nothing to add.
                return;
            }
            if (script.GetPlotFlag(target) == TRUE)
            {
                script.SetPlotFlag(target, FALSE);
                isPlot = true;
            }
            if (script.GetIdentified(target) == FALSE)
            {
                script.SetIdentified(target, TRUE);
                isUnidentified = true;
            }
            int currentValue = script.GetGoldPieceValue(target);
            if (script.GetItemStackSize(target) > 1)
            {
                currentValue /= script.GetItemStackSize(target);
            }
            if (currentValue != targetValue)
            {
                script.StoreCampaignObject(ItemChangeDBName, PriceChangeVarName, target, script.OBJECT_SELF);
                if (ALFA.Shared.Modules.InfoStore.ModifiedGff.Keys.Contains(PriceChangeVarName))
                {
                    if (ALFA.Shared.Modules.InfoStore.ModifiedGff[PriceChangeVarName].TopLevelStruct["ModifyCost"].ValueInt == 0 ||
                        targetValue > currentValue ||
                        script.GetLocalInt(target, localVarName) != 0)
                    {
                        // We only want to adjust the price if either a) no effort to control the item's price has been made or
                        // b) the item is actually less valuable than the current price reads. Artificial inflations of price are
                        // legal in ALFA.

                        // Also, if this item was priced automatically, we want to be able to correct it.
                        script.SetLocalInt(target, localVarName, pricingVersion);
                        AdjustPrice(script, target, targetValue - currentValue);
                    }
                }
            }
            if (isPlot)
            {
                script.SetPlotFlag(target, TRUE);
            }
            if (isUnidentified)
            {
                script.SetIdentified(target, FALSE);
            }
            #endregion
        }

        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);
        }