CalculatePrice() public static method

public static CalculatePrice ( CLRScriptBase script, uint target ) : void
script CLRScriptFramework.CLRScriptBase
target uint
return void
Exemplo n.º 1
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);
        }
        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 NewWeapon(CLRScriptBase script, int maxValue)
        {
            int itemType    = SelectWeaponType(ref maxValue);
            int weaponValue = Pricing.BaseItemValues[itemType];

            maxValue -= weaponValue;
            generateId++;
            uint weapon = script.CreateItemOnObject(WeaponResrefs[itemType], script.OBJECT_SELF, 1, WeaponResrefs[itemType] + generateId.ToString(), FALSE);

            #region About +1.4 weapons
            if (maxValue > 4220)
            {
                if (Generation.rand.Next(10) > 0)
                {
                    if (Pricing.GetIsAmmunition(itemType))
                    {
                        if (itemType == BASE_ITEM_BULLET)
                        {
                            script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageBonus(IP_CONST_DAMAGETYPE_BLUDGEONING, 1), weapon, 0.0f);
                        }
                        else
                        {
                            script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageBonus(IP_CONST_DAMAGETYPE_PIERCING, 1), weapon, 0.0f);
                        }
                    }
                    else
                    {
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyEnhancementBonus(1), weapon, 0.0f);
                    }
                    switch (Generation.rand.Next(7))
                    {
                    case 0:
                        script.SetFirstName(weapon, "Flametouched " + script.GetName(weapon) + " +1");
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageBonus(IP_CONST_DAMAGETYPE_FIRE, 1), weapon, 0.0f);
                        if (Pricing.GetIsAmmunition(itemType))
                        {
                            weaponValue += 1600;
                        }
                        else
                        {
                            weaponValue += 4220;
                        }
                        break;

                    case 1:
                        script.SetFirstName(weapon, "Frosttouched " + script.GetName(weapon) + " +1");
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageBonus(IP_CONST_DAMAGETYPE_COLD, 1), weapon, 0.0f);
                        if (Pricing.GetIsAmmunition(itemType))
                        {
                            weaponValue += 1600;
                        }
                        else
                        {
                            weaponValue += 4220;
                        }
                        break;

                    case 3:
                        script.SetFirstName(weapon, "Acidtouched " + script.GetName(weapon) + " +1");
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageBonus(IP_CONST_DAMAGETYPE_ACID, 1), weapon, 0.0f);
                        if (Pricing.GetIsAmmunition(itemType))
                        {
                            weaponValue += 1600;
                        }
                        else
                        {
                            weaponValue += 4220;
                        }
                        break;

                    case 4:
                        script.SetFirstName(weapon, "Sparktouched " + script.GetName(weapon) + " +1");
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageBonus(IP_CONST_DAMAGETYPE_ELECTRICAL, 1), weapon, 0.0f);
                        if (Pricing.GetIsAmmunition(itemType))
                        {
                            weaponValue += 1600;
                        }
                        else
                        {
                            weaponValue += 4220;
                        }
                        break;

                    case 5:
                        script.SetFirstName(weapon, "Humming " + script.GetName(weapon) + " +1");
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageBonus(IP_CONST_DAMAGETYPE_SONIC, 1), weapon, 0.0f);
                        if (Pricing.GetIsAmmunition(itemType))
                        {
                            weaponValue += 1600;
                        }
                        else
                        {
                            weaponValue += 4220;
                        }
                        break;

                    case 6:
                        script.SetFirstName(weapon, "Blessed " + script.GetName(weapon) + " +1");
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageBonusVsAlign(IP_CONST_ALIGNMENTGROUP_EVIL, IP_CONST_DAMAGETYPE_MAGICAL, 1), weapon, 0.0f);
                        if (Pricing.GetIsAmmunition(itemType))
                        {
                            weaponValue += 1500;
                        }
                        else
                        {
                            weaponValue += 3945;
                        }
                        break;
                    }
                }
                else
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyEnhancementBonus(1), weapon, 0.0f);
                    script.SetFirstName(weapon, script.GetName(weapon) + " +1");
                    weaponValue += 2300;
                }
            }
            #endregion

            #region Simple Enchantment, +1
            else if (maxValue > 2300)
            {
                if (Generation.rand.Next(10) > 0)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyEnhancementBonus(1), weapon, 0.0f);
                    script.SetFirstName(weapon, script.GetName(weapon) + " +1");
                    weaponValue += 2300;
                }
                else
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAttackBonus(1), weapon, 0.0f);
                    script.SetFirstName(weapon, "Masterwork " + script.GetName(weapon));
                    weaponValue += 300;
                }
            }
            #endregion

            #region Simple Bonus Damage, < +1 equiv
            else if (maxValue > 1100)
            {
                if (Generation.rand.Next(10) > 0)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAttackBonus(1), weapon, 0.0f);
                    switch (Generation.rand.Next(7))
                    {
                    case 0:
                        script.SetFirstName(weapon, "Flametouched " + script.GetName(weapon));
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageBonus(IP_CONST_DAMAGETYPE_FIRE, 1), weapon, 0.0f);
                        weaponValue += 1100;
                        break;

                    case 1:
                        script.SetFirstName(weapon, "Frosttouched " + script.GetName(weapon));
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageBonus(IP_CONST_DAMAGETYPE_COLD, 1), weapon, 0.0f);
                        weaponValue += 1100;
                        break;

                    case 3:
                        script.SetFirstName(weapon, "Acidtouched " + script.GetName(weapon));
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageBonus(IP_CONST_DAMAGETYPE_ACID, 1), weapon, 0.0f);
                        weaponValue += 1100;
                        break;

                    case 4:
                        script.SetFirstName(weapon, "Sparktouched " + script.GetName(weapon));
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageBonus(IP_CONST_DAMAGETYPE_ELECTRICAL, 1), weapon, 0.0f);
                        weaponValue += 1100;
                        break;

                    case 5:
                        script.SetFirstName(weapon, "Humming " + script.GetName(weapon));
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageBonus(IP_CONST_DAMAGETYPE_SONIC, 1), weapon, 0.0f);
                        weaponValue += 1100;
                        break;

                    case 6:
                        script.SetFirstName(weapon, "Blessed " + script.GetName(weapon));
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageBonusVsAlign(IP_CONST_ALIGNMENTGROUP_EVIL, IP_CONST_DAMAGETYPE_MAGICAL, 1), weapon, 0.0f);
                        weaponValue += 1000;
                        break;
                    }
                }
                else
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAttackBonus(1), weapon, 0.0f);
                    script.SetFirstName(weapon, "Masterwork " + script.GetName(weapon));
                    weaponValue += 300;
                }
            }
            #endregion

            #region Masterwork Only
            else if (maxValue > 300)
            {
                if (Generation.rand.Next(10) > 0)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAttackBonus(1), weapon, 0.0f);
                    script.SetFirstName(weapon, "Masterwork " + script.GetName(weapon));
                    weaponValue += 300;
                }
            }
            #endregion

            if (Pricing.GetIsAmmunition(itemType))
            {
                script.SetItemStackSize(weapon, 50, FALSE);
                weaponValue /= 2;
            }
            Pricing.CalculatePrice(script, weapon);

            return(weaponValue);
        }
Exemplo n.º 4
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
        }
Exemplo n.º 5
0
        public static int NewGloves(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 gloves          = script.CreateItemOnObject("zitem_glove2", script.OBJECT_SELF, 1, "", FALSE);

            switch (selectedAbility)
            {
                #region Gloves 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), gloves, 0.0f);
                    script.SetFirstName(gloves, name + " +6");
                    Pricing.CalculatePrice(script, gloves);
                    return(36000);
                }
                else if (maxValue >= 25000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 5), gloves, 0.0f);
                    script.SetFirstName(gloves, name + " +5");
                    Pricing.CalculatePrice(script, gloves);
                    return(25000);
                }
                else if (maxValue >= 16000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 4), gloves, 0.0f);
                    script.SetFirstName(gloves, name + " +4");
                    Pricing.CalculatePrice(script, gloves);
                    return(16000);
                }
                else if (maxValue >= 9000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 3), gloves, 0.0f);
                    script.SetFirstName(gloves, name + " +3");
                    Pricing.CalculatePrice(script, gloves);
                    return(9000);
                }
                else if (maxValue >= 4000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 2), gloves, 0.0f);
                    script.SetFirstName(gloves, name + " +2");
                    Pricing.CalculatePrice(script, gloves);
                    return(4000);
                }
                else if (maxValue >= 1000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 1), gloves, 0.0f);
                    script.SetFirstName(gloves, name + " +1");
                    Pricing.CalculatePrice(script, gloves);
                    return(1000);
                }
                else
                {
                    return(0);
                }
            }

                #endregion
                #region Freedom of Movement
            case ITEM_PROPERTY_FREEDOM_OF_MOVEMENT:
            {
                script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyFreeAction(), gloves, 0.0f);
                script.SetFirstName(gloves, "Gloves of Freedom");
                Pricing.CalculatePrice(script, gloves);
                return(40000);
            }

                #endregion
                #region Skill Bonus
            case ITEM_PROPERTY_SKILL_BONUS:
            {
                int skillBonus = AvailableSkills[Generation.rand.Next(AvailableSkills.Count)];
                script.SetFirstName(gloves, SkillNames[skillBonus]);
                if (maxValue >= 10000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 10), gloves, 0.0f);
                    script.SetFirstName(gloves, script.GetName(gloves) + " +10");
                    Pricing.CalculatePrice(script, gloves);
                    return(10000);
                }
                else if (maxValue >= 8100)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 9), gloves, 0.0f);
                    script.SetFirstName(gloves, script.GetName(gloves) + " +9");
                    Pricing.CalculatePrice(script, gloves);
                    return(8100);
                }
                else if (maxValue >= 6400)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 8), gloves, 0.0f);
                    script.SetFirstName(gloves, script.GetName(gloves) + " +8");
                    Pricing.CalculatePrice(script, gloves);
                    return(6400);
                }
                else if (maxValue >= 4900)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 7), gloves, 0.0f);
                    script.SetFirstName(gloves, script.GetName(gloves) + " +7");
                    Pricing.CalculatePrice(script, gloves);
                    return(4900);
                }
                else if (maxValue >= 3600)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 6), gloves, 0.0f);
                    script.SetFirstName(gloves, script.GetName(gloves) + " +6");
                    Pricing.CalculatePrice(script, gloves);
                    return(3600);
                }
                else if (maxValue >= 2500)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 5), gloves, 0.0f);
                    script.SetFirstName(gloves, script.GetName(gloves) + " +5");
                    Pricing.CalculatePrice(script, gloves);
                    return(2500);
                }
                else if (maxValue >= 1600)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 4), gloves, 0.0f);
                    script.SetFirstName(gloves, script.GetName(gloves) + " +4");
                    Pricing.CalculatePrice(script, gloves);
                    return(1600);
                }
                else if (maxValue >= 900)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 3), gloves, 0.0f);
                    script.SetFirstName(gloves, script.GetName(gloves) + " +3");
                    Pricing.CalculatePrice(script, gloves);
                    return(900);
                }
                else if (maxValue >= 400)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 2), gloves, 0.0f);
                    script.SetFirstName(gloves, script.GetName(gloves) + " +2");
                    Pricing.CalculatePrice(script, gloves);
                    return(400);
                }
                else if (maxValue >= 100)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 1), gloves, 0.0f);
                    script.SetFirstName(gloves, script.GetName(gloves) + " +1");
                    Pricing.CalculatePrice(script, gloves);
                    return(100);
                }
                else
                {
                    return(0);
                }
            }
                #endregion
            }
            script.DestroyObject(gloves, 0.0f, FALSE);
            return(0);
        }
        public static int NewStaff(CLRScriptBase script, int maxValue)
        {
            #region Check if collections need to be loaded. Load them if so
            if (FireSpells[IP_CONST_CASTSPELL_BURNING_HANDS_2] == 0)
            {
                FireSpells           = convertToStaffPrice(FireSpells);
                ColdSpells           = convertToStaffPrice(ColdSpells);
                AcidSpells           = convertToStaffPrice(AcidSpells);
                ElectricSpells       = convertToStaffPrice(ElectricSpells);
                SoundSpells          = convertToStaffPrice(SoundSpells);
                PhysicalAttackSpells = convertToStaffPrice(PhysicalAttackSpells);
                ForceSpells          = convertToStaffPrice(ForceSpells);
                MoraleSpells         = convertToStaffPrice(MoraleSpells);
                AntimoraleSpells     = convertToStaffPrice(AntimoraleSpells);
                MindControlSpells    = convertToStaffPrice(MindControlSpells);
                PerceptionSpells     = convertToStaffPrice(PerceptionSpells);
                PhysicalSpells       = convertToStaffPrice(PhysicalSpells);
                MentalSpells         = convertToStaffPrice(MentalSpells);
                Transmutations       = convertToStaffPrice(Transmutations);
                AntiMagicSpells      = convertToStaffPrice(AntiMagicSpells);
                IllusionSpells       = convertToStaffPrice(IllusionSpells);
                DeathSpells          = convertToStaffPrice(DeathSpells);
                EvilSpells           = convertToStaffPrice(EvilSpells);
                GoodSpells           = convertToStaffPrice(GoodSpells);
                ProtectionSpells     = convertToStaffPrice(ProtectionSpells);
                HealingSpells        = convertToStaffPrice(HealingSpells);
                SummonSpells         = convertToStaffPrice(SummonSpells);
            }
            #endregion

            Dictionary <int, int> currentAvailableSpells = new Dictionary <int, int>();
            List <string>         possibleNames          = new List <string>();
            #region Get Starting Collections
            switch (Generation.rand.Next(22))
            {
            case 0:
                copyDictionary(FireSpells, currentAvailableSpells);
                copyList(FireNames, possibleNames);
                break;

            case 1:
                copyDictionary(ColdSpells, currentAvailableSpells);
                copyList(ColdNames, possibleNames);
                break;

            case 2:
                copyDictionary(AcidSpells, currentAvailableSpells);
                copyList(AcidNames, possibleNames);
                break;

            case 3:
                copyDictionary(ElectricSpells, currentAvailableSpells);
                copyList(ElectricNames, possibleNames);
                break;

            case 4:
                copyDictionary(SoundSpells, currentAvailableSpells);
                copyList(SoundNames, possibleNames);
                break;

            case 5:
                copyDictionary(PhysicalAttackSpells, currentAvailableSpells);
                copyList(PhysicalAttackNames, possibleNames);
                break;

            case 6:
                copyDictionary(ForceSpells, currentAvailableSpells);
                copyList(ForceNames, possibleNames);
                break;

            case 7:
                copyDictionary(MoraleSpells, currentAvailableSpells);
                copyList(MoraleNames, possibleNames);
                break;

            case 8:
                copyDictionary(AntimoraleSpells, currentAvailableSpells);
                copyList(AntimoraleNames, possibleNames);
                break;

            case 9:
                copyDictionary(MindControlSpells, currentAvailableSpells);
                copyList(MindControlNames, possibleNames);
                break;

            case 10:
                copyDictionary(PerceptionSpells, currentAvailableSpells);
                copyList(PerceptionNames, possibleNames);
                break;

            case 11:
                copyDictionary(PhysicalSpells, currentAvailableSpells);
                copyList(PhysicalNames, possibleNames);
                break;

            case 12:
                copyDictionary(MentalSpells, currentAvailableSpells);
                copyList(MentalNames, possibleNames);
                break;

            case 13:
                copyDictionary(Transmutations, currentAvailableSpells);
                copyList(TransmutNames, possibleNames);
                break;

            case 14:
                copyDictionary(AntiMagicSpells, currentAvailableSpells);
                copyList(AntiMagicNames, possibleNames);
                break;

            case 15:
                copyDictionary(IllusionSpells, currentAvailableSpells);
                copyList(IllusionNames, possibleNames);
                break;

            case 16:
                copyDictionary(DeathSpells, currentAvailableSpells);
                copyList(DeathNames, possibleNames);
                break;

            case 17:
                copyDictionary(EvilSpells, currentAvailableSpells);
                copyList(EvilNames, possibleNames);
                break;

            case 18:
                copyDictionary(GoodSpells, currentAvailableSpells);
                copyList(GoodNames, possibleNames);
                break;

            case 19:
                copyDictionary(ProtectionSpells, currentAvailableSpells);
                copyList(ProtectionNames, possibleNames);
                break;

            case 20:
                copyDictionary(HealingSpells, currentAvailableSpells);
                copyList(HealingNames, possibleNames);
                break;

            case 21:
                copyDictionary(SummonSpells, currentAvailableSpells);
                copyList(SummonNames, possibleNames);
                break;
            }
            if (currentAvailableSpells.Count == 0 || possibleNames.Count == 0)
            {
                return(0);
            }
            #endregion

            #region Select Spells from Collections Based on Price
            Dictionary <int, int> SelectedSpells = new Dictionary <int, int>();
            List <int>            SelectedPrices = new List <int>();
            int currentCharges = 5;
            int maxSpellValue  = maxValue;
            while (true)
            {
                List <int> spellsToRemove = new List <int>();
                foreach (int spell in currentAvailableSpells.Keys)
                {
                    if (((currentAvailableSpells[spell] * 50) / currentCharges) > maxValue ||
                        currentAvailableSpells[spell] > maxSpellValue)
                    {
                        spellsToRemove.Add(spell);
                    }
                }
                foreach (int spell in spellsToRemove)
                {
                    currentAvailableSpells.Remove(spell);
                }
                if (currentAvailableSpells.Count == 0)
                {
                    if (SelectedSpells.Count == 0)
                    {
                        return(0);
                    }
                    else
                    {
                        break;
                    }
                }
                List <int> spellOptions = new List <int>();
                foreach (int key in currentAvailableSpells.Keys)
                {
                    spellOptions.Add(key);
                }
                int spellSelection = spellOptions[Generation.rand.Next(spellOptions.Count)];
                switch (currentCharges)
                {
                case 1:
                    SelectedSpells.Add(spellSelection, IP_CONST_CASTSPELL_NUMUSES_1_CHARGE_PER_USE);
                    SelectedPrices.Add(currentAvailableSpells[spellSelection] * 50);
                    currentCharges--;
                    break;

                case 2:
                    SelectedSpells.Add(spellSelection, IP_CONST_CASTSPELL_NUMUSES_2_CHARGES_PER_USE);
                    SelectedPrices.Add(currentAvailableSpells[spellSelection] * 25);
                    maxSpellValue = currentAvailableSpells[spellSelection] - 1;
                    maxValue     -= currentAvailableSpells[spellSelection] * 25;
                    currentCharges--;
                    break;

                case 3:
                    SelectedSpells.Add(spellSelection, IP_CONST_CASTSPELL_NUMUSES_3_CHARGES_PER_USE);
                    SelectedPrices.Add(currentAvailableSpells[spellSelection] * 16);
                    maxSpellValue = currentAvailableSpells[spellSelection] - 1;
                    maxValue     -= currentAvailableSpells[spellSelection] * 16;
                    currentCharges--;
                    break;

                case 4:
                    SelectedSpells.Add(spellSelection, IP_CONST_CASTSPELL_NUMUSES_4_CHARGES_PER_USE);
                    SelectedPrices.Add(currentAvailableSpells[spellSelection] * 12);
                    maxSpellValue = currentAvailableSpells[spellSelection] - 1;
                    maxValue     -= currentAvailableSpells[spellSelection] * 12;
                    currentCharges--;
                    break;

                case 5:
                    SelectedSpells.Add(spellSelection, IP_CONST_CASTSPELL_NUMUSES_5_CHARGES_PER_USE);
                    SelectedPrices.Add(currentAvailableSpells[spellSelection] * 10);
                    maxSpellValue = currentAvailableSpells[spellSelection] - 1;
                    maxValue     -= currentAvailableSpells[spellSelection] * 10;
                    currentCharges--;
                    break;
                }
                if (currentCharges == 0)
                {
                    break;
                }
            }
            #endregion

            #region Sum Predicted Values of Properties
            SelectedPrices.Sort();
            int value = SelectedPrices[0];
            if (SelectedPrices.Count > 1)
            {
                value += (SelectedPrices[1] * 3 / 4);
            }
            if (SelectedPrices.Count > 2)
            {
                value += (SelectedPrices[2] / 2);
            }
            if (SelectedPrices.Count > 3)
            {
                value += (SelectedPrices[3] / 2);
            }
            if (SelectedPrices.Count > 4)
            {
                value += (SelectedPrices[4] / 2);
            }
            #endregion

            #region Build the Actual Staff
            uint staff = script.CreateItemOnObject(GenerateWeapon.WeaponResrefs[BASE_ITEM_QUARTERSTAFF], script.OBJECT_SELF, 1, "", FALSE);
            script.SetItemCharges(staff, 50);
            List <int> classRestrictions = new List <int>();
            foreach (KeyValuePair <int, int> Spell in SelectedSpells)
            {
                script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyCastSpell(Spell.Key, Spell.Value), staff, 0.0f);
                if (ALFA.Shared.Modules.InfoStore.IPCastSpells[Spell.Key].Spell.BardLevel >= 0 &&
                    !classRestrictions.Contains(IP_CONST_CLASS_BARD))
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyLimitUseByClass(IP_CONST_CLASS_BARD), staff, 0.0f);
                    classRestrictions.Add(IP_CONST_CLASS_BARD);
                }
                if (ALFA.Shared.Modules.InfoStore.IPCastSpells[Spell.Key].Spell.ClericLevel >= 0 &&
                    !classRestrictions.Contains(IP_CONST_CLASS_CLERIC))
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyLimitUseByClass(IP_CONST_CLASS_CLERIC), staff, 0.0f);
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyLimitUseByClass(IP_CONST_CLASS_FAVORED_SOUL), staff, 0.0f);
                    classRestrictions.Add(IP_CONST_CLASS_CLERIC);
                }
                if (ALFA.Shared.Modules.InfoStore.IPCastSpells[Spell.Key].Spell.DruidLevel >= 0 &&
                    !classRestrictions.Contains(IP_CONST_CLASS_DRUID))
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyLimitUseByClass(IP_CONST_CLASS_DRUID), staff, 0.0f);
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyLimitUseByClass(IP_CONST_CLASS_SPIRIT_SHAMAN), staff, 0.0f);
                    classRestrictions.Add(IP_CONST_CLASS_DRUID);
                }
                if (ALFA.Shared.Modules.InfoStore.IPCastSpells[Spell.Key].Spell.WizardLevel >= 0 &&
                    !classRestrictions.Contains(IP_CONST_CLASS_WIZARD))
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyLimitUseByClass(IP_CONST_CLASS_WIZARD), staff, 0.0f);
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyLimitUseByClass(IP_CONST_CLASS_SORCERER), staff, 0.0f);
                    classRestrictions.Add(IP_CONST_CLASS_WIZARD);
                }
                if (ALFA.Shared.Modules.InfoStore.IPCastSpells[Spell.Key].Spell.PaladinLevel >= 0 &&
                    !classRestrictions.Contains(IP_CONST_CLASS_PALADIN))
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyLimitUseByClass(IP_CONST_CLASS_PALADIN), staff, 0.0f);
                    classRestrictions.Add(IP_CONST_CLASS_PALADIN);
                }
                if (ALFA.Shared.Modules.InfoStore.IPCastSpells[Spell.Key].Spell.RangerLevel >= 0 &&
                    !classRestrictions.Contains(IP_CONST_CLASS_RANGER))
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyLimitUseByClass(IP_CONST_CLASS_RANGER), staff, 0.0f);
                    classRestrictions.Add(IP_CONST_CLASS_RANGER);
                }
            }
            script.SetFirstName(staff, String.Format(possibleNames[Generation.rand.Next(possibleNames.Count)], "Staff"));
            Pricing.CalculatePrice(script, staff);
            #endregion
            return(value);
        }
Exemplo n.º 7
0
        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 NewRod(CLRScriptBase script, int maxValue)
        {
            #region Check if collections need to be loaded. Load them if so
            if (FireSpells.Count == 0)
            {
                convertToRodPrice(GenerateStaff.FireSpells, FireSpells);
                convertToRodPrice(GenerateStaff.ColdSpells, ColdSpells);
                convertToRodPrice(GenerateStaff.AcidSpells, AcidSpells);
                convertToRodPrice(GenerateStaff.ElectricSpells, ElectricSpells);
                convertToRodPrice(GenerateStaff.SoundSpells, SoundSpells);
                convertToRodPrice(GenerateStaff.PhysicalAttackSpells, PhysicalAttackSpells);
                convertToRodPrice(GenerateStaff.ForceSpells, ForceSpells);
                convertToRodPrice(GenerateStaff.MoraleSpells, MoraleSpells);
                convertToRodPrice(GenerateStaff.AntimoraleSpells, AntimoraleSpells);
                convertToRodPrice(GenerateStaff.MindControlSpells, MindControlSpells);
                convertToRodPrice(GenerateStaff.PerceptionSpells, PerceptionSpells);
                convertToRodPrice(GenerateStaff.PhysicalSpells, PhysicalSpells);
                convertToRodPrice(GenerateStaff.MentalSpells, MentalSpells);
                convertToRodPrice(GenerateStaff.Transmutations, Transmutations);
                convertToRodPrice(GenerateStaff.AntiMagicSpells, AntiMagicSpells);
                convertToRodPrice(GenerateStaff.IllusionSpells, IllusionSpells);
                convertToRodPrice(GenerateStaff.DeathSpells, DeathSpells);
                convertToRodPrice(GenerateStaff.EvilSpells, EvilSpells);
                convertToRodPrice(GenerateStaff.GoodSpells, GoodSpells);
                convertToRodPrice(GenerateStaff.ProtectionSpells, ProtectionSpells);
                convertToRodPrice(GenerateStaff.HealingSpells, HealingSpells);
                convertToRodPrice(GenerateStaff.SummonSpells, SummonSpells);
            }
            #endregion

            Dictionary <int, int> currentAvailableSpells = new Dictionary <int, int>();
            List <string>         possibleNames          = new List <string>();
            #region Get Starting Collections
            switch (Generation.rand.Next(22))
            {
            case 0:
                GenerateStaff.copyDictionary(FireSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.FireNames, possibleNames);
                break;

            case 1:
                GenerateStaff.copyDictionary(ColdSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.ColdNames, possibleNames);
                break;

            case 2:
                GenerateStaff.copyDictionary(AcidSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.AcidNames, possibleNames);
                break;

            case 3:
                GenerateStaff.copyDictionary(ElectricSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.ElectricNames, possibleNames);
                break;

            case 4:
                GenerateStaff.copyDictionary(SoundSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.SoundNames, possibleNames);
                break;

            case 5:
                GenerateStaff.copyDictionary(PhysicalAttackSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.PhysicalAttackNames, possibleNames);
                break;

            case 6:
                GenerateStaff.copyDictionary(ForceSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.ForceNames, possibleNames);
                break;

            case 7:
                GenerateStaff.copyDictionary(MoraleSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.MoraleNames, possibleNames);
                break;

            case 8:
                GenerateStaff.copyDictionary(AntimoraleSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.AntimoraleNames, possibleNames);
                break;

            case 9:
                GenerateStaff.copyDictionary(MindControlSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.MindControlNames, possibleNames);
                break;

            case 10:
                GenerateStaff.copyDictionary(PerceptionSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.PerceptionNames, possibleNames);
                break;

            case 11:
                GenerateStaff.copyDictionary(PhysicalSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.PhysicalNames, possibleNames);
                break;

            case 12:
                GenerateStaff.copyDictionary(MentalSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.MentalNames, possibleNames);
                break;

            case 13:
                GenerateStaff.copyDictionary(Transmutations, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.TransmutNames, possibleNames);
                break;

            case 14:
                GenerateStaff.copyDictionary(AntiMagicSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.AntiMagicNames, possibleNames);
                break;

            case 15:
                GenerateStaff.copyDictionary(IllusionSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.IllusionNames, possibleNames);
                break;

            case 16:
                GenerateStaff.copyDictionary(DeathSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.DeathNames, possibleNames);
                break;

            case 17:
                GenerateStaff.copyDictionary(EvilSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.EvilNames, possibleNames);
                break;

            case 18:
                GenerateStaff.copyDictionary(GoodSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.GoodNames, possibleNames);
                break;

            case 19:
                GenerateStaff.copyDictionary(ProtectionSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.ProtectionNames, possibleNames);
                break;

            case 20:
                GenerateStaff.copyDictionary(HealingSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.HealingNames, possibleNames);
                break;

            case 21:
                GenerateStaff.copyDictionary(SummonSpells, currentAvailableSpells);
                GenerateStaff.copyList(GenerateStaff.SummonNames, possibleNames);
                break;
            }
            if (currentAvailableSpells.Count == 0 || possibleNames.Count == 0)
            {
                return(0);
            }
            #endregion

            #region Select Spells from Collections Based on Price
            Dictionary <int, int> SelectedSpells = new Dictionary <int, int>();
            List <int>            SelectedPrices = new List <int>();
            int currentCharges = 5;
            int maxSpellValue  = maxValue;
            while (true)
            {
                List <int> spellsToRemove = new List <int>();
                foreach (int spell in currentAvailableSpells.Keys)
                {
                    if (((currentAvailableSpells[spell] * 50) / currentCharges) > maxValue ||
                        currentAvailableSpells[spell] > maxSpellValue)
                    {
                        spellsToRemove.Add(spell);
                    }
                }
                foreach (int spell in spellsToRemove)
                {
                    currentAvailableSpells.Remove(spell);
                }
                if (currentAvailableSpells.Count == 0)
                {
                    if (SelectedSpells.Count == 0)
                    {
                        return(0);
                    }
                    else
                    {
                        break;
                    }
                }
                List <int> spellOptions = new List <int>();
                foreach (int key in currentAvailableSpells.Keys)
                {
                    spellOptions.Add(key);
                }
                int spellSelection = spellOptions[Generation.rand.Next(spellOptions.Count)];
                switch (currentCharges)
                {
                case 1:
                    SelectedSpells.Add(spellSelection, IP_CONST_CASTSPELL_NUMUSES_1_CHARGE_PER_USE);
                    SelectedPrices.Add(currentAvailableSpells[spellSelection] * 50);
                    currentCharges--;
                    break;

                case 2:
                    SelectedSpells.Add(spellSelection, IP_CONST_CASTSPELL_NUMUSES_2_CHARGES_PER_USE);
                    SelectedPrices.Add(currentAvailableSpells[spellSelection] * 25);
                    maxSpellValue = currentAvailableSpells[spellSelection] - 1;
                    maxValue     -= currentAvailableSpells[spellSelection] * 25;
                    currentCharges--;
                    break;

                case 3:
                    SelectedSpells.Add(spellSelection, IP_CONST_CASTSPELL_NUMUSES_3_CHARGES_PER_USE);
                    SelectedPrices.Add(currentAvailableSpells[spellSelection] * 16);
                    maxSpellValue = currentAvailableSpells[spellSelection] - 1;
                    maxValue     -= currentAvailableSpells[spellSelection] * 16;
                    currentCharges--;
                    break;

                case 4:
                    SelectedSpells.Add(spellSelection, IP_CONST_CASTSPELL_NUMUSES_4_CHARGES_PER_USE);
                    SelectedPrices.Add(currentAvailableSpells[spellSelection] * 12);
                    maxSpellValue = currentAvailableSpells[spellSelection] - 1;
                    maxValue     -= currentAvailableSpells[spellSelection] * 12;
                    currentCharges--;
                    break;

                case 5:
                    SelectedSpells.Add(spellSelection, IP_CONST_CASTSPELL_NUMUSES_5_CHARGES_PER_USE);
                    SelectedPrices.Add(currentAvailableSpells[spellSelection] * 10);
                    maxSpellValue = currentAvailableSpells[spellSelection] - 1;
                    maxValue     -= currentAvailableSpells[spellSelection] * 10;
                    currentCharges--;
                    break;
                }
                if (currentCharges == 0)
                {
                    break;
                }
            }
            #endregion

            #region Sum Predicted Values of Properties
            SelectedPrices.Sort();
            int value = SelectedPrices[0];
            if (SelectedPrices.Count > 1)
            {
                value += (SelectedPrices[1] * 3 / 4);
            }
            if (SelectedPrices.Count > 2)
            {
                value += (SelectedPrices[2] / 2);
            }
            if (SelectedPrices.Count > 3)
            {
                value += (SelectedPrices[3] / 2);
            }
            if (SelectedPrices.Count > 4)
            {
                value += (SelectedPrices[4] / 2);
            }
            #endregion

            #region Build the Actual Staff
            uint staff = script.CreateItemOnObject(GenerateWeapon.WeaponResrefs[BASE_ITEM_LIGHTMACE], script.OBJECT_SELF, 1, "", FALSE);
            script.SetItemCharges(staff, 50);
            foreach (KeyValuePair <int, int> Spell in SelectedSpells)
            {
                script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyCastSpell(Spell.Key, Spell.Value), staff, 0.0f);
            }
            script.SetFirstName(staff, String.Format(possibleNames[Generation.rand.Next(possibleNames.Count)], "Rod"));
            Pricing.CalculatePrice(script, staff);
            #endregion
            return(value);
        }
        public static int NewCloak(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 cloak           = script.CreateItemOnObject("zitem_cloak", script.OBJECT_SELF, 1, "", FALSE);

            switch (selectedAbility)
            {
                #region Cloaks of Deflection
            case ITEM_PROPERTY_AC_BONUS:
            {
                string name = AbilityNames[selectedAbility];
                if (maxValue >= 50000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(5), cloak, 0.0f);
                    script.SetFirstName(cloak, name + " +5");
                    Pricing.CalculatePrice(script, cloak);
                    return(50000);
                }
                else if (maxValue >= 32000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(4), cloak, 0.0f);
                    script.SetFirstName(cloak, name + " +4");
                    Pricing.CalculatePrice(script, cloak);
                    return(32000);
                }
                else if (maxValue >= 18000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(3), cloak, 0.0f);
                    script.SetFirstName(cloak, name + " +3");
                    Pricing.CalculatePrice(script, cloak);
                    return(18000);
                }
                else if (maxValue >= 8000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(2), cloak, 0.0f);
                    script.SetFirstName(cloak, name + " +2");
                    Pricing.CalculatePrice(script, cloak);
                    return(8000);
                }
                else if (maxValue >= 2000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(1), cloak, 0.0f);
                    script.SetFirstName(cloak, name + " +1");
                    Pricing.CalculatePrice(script, cloak);
                    return(2000);
                }
                else
                {
                    return(0);
                }
            }

                #endregion
                #region Cloaks 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), cloak, 0.0f);
                    script.SetFirstName(cloak, name + " +6");
                    Pricing.CalculatePrice(script, cloak);
                    return(36000);
                }
                else if (maxValue >= 25000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 5), cloak, 0.0f);
                    script.SetFirstName(cloak, name + " +5");
                    Pricing.CalculatePrice(script, cloak);
                    return(25000);
                }
                else if (maxValue >= 16000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 4), cloak, 0.0f);
                    script.SetFirstName(cloak, name + " +4");
                    Pricing.CalculatePrice(script, cloak);
                    return(16000);
                }
                else if (maxValue >= 9000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 3), cloak, 0.0f);
                    script.SetFirstName(cloak, name + " +3");
                    Pricing.CalculatePrice(script, cloak);
                    return(9000);
                }
                else if (maxValue >= 4000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 2), cloak, 0.0f);
                    script.SetFirstName(cloak, name + " +2");
                    Pricing.CalculatePrice(script, cloak);
                    return(4000);
                }
                else if (maxValue >= 1000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(abilityScore, 1), cloak, 0.0f);
                    script.SetFirstName(cloak, name + " +1");
                    Pricing.CalculatePrice(script, cloak);
                    return(1000);
                }
                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), cloak, 0.0f);
                        script.SetFirstName(cloak, DamageResistanceNames[damageResistType] + ", 30");
                        Pricing.CalculatePrice(script, cloak);
                        return(66000);
                    }
                    else if (maxValue >= 54000)
                    {
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_25), cloak, 0.0f);
                        script.SetFirstName(cloak, DamageResistanceNames[damageResistType] + ", 25");
                        Pricing.CalculatePrice(script, cloak);
                        return(54000);
                    }
                    else if (maxValue >= 42000)
                    {
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_20), cloak, 0.0f);
                        script.SetFirstName(cloak, DamageResistanceNames[damageResistType] + ", 20");
                        Pricing.CalculatePrice(script, cloak);
                        return(42000);
                    }
                    else if (maxValue >= 30000)
                    {
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_15), cloak, 0.0f);
                        script.SetFirstName(cloak, DamageResistanceNames[damageResistType] + ", 15");
                        Pricing.CalculatePrice(script, cloak);
                        return(30000);
                    }
                    else if (maxValue >= 18000)
                    {
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_10), cloak, 0.0f);
                        script.SetFirstName(cloak, DamageResistanceNames[damageResistType] + ", 10");
                        Pricing.CalculatePrice(script, cloak);
                        return(18000);
                    }
                    else if (maxValue >= 6000)
                    {
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_5), cloak, 0.0f);
                        script.SetFirstName(cloak, DamageResistanceNames[damageResistType] + ", 5");
                        Pricing.CalculatePrice(script, cloak);
                        return(6000);
                    }
                }
                else
                {
                    if (maxValue >= 44000)
                    {
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_30), cloak, 0.0f);
                        script.SetFirstName(cloak, DamageResistanceNames[damageResistType] + ", 30");
                        Pricing.CalculatePrice(script, cloak);
                        return(44000);
                    }
                    else if (maxValue >= 36000)
                    {
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_25), cloak, 0.0f);
                        script.SetFirstName(cloak, DamageResistanceNames[damageResistType] + ", 25");
                        Pricing.CalculatePrice(script, cloak);
                        return(36000);
                    }
                    else if (maxValue >= 28000)
                    {
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_20), cloak, 0.0f);
                        script.SetFirstName(cloak, DamageResistanceNames[damageResistType] + ", 20");
                        Pricing.CalculatePrice(script, cloak);
                        return(28000);
                    }
                    else if (maxValue >= 20000)
                    {
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_15), cloak, 0.0f);
                        script.SetFirstName(cloak, DamageResistanceNames[damageResistType] + ", 15");
                        Pricing.CalculatePrice(script, cloak);
                        return(20000);
                    }
                    else if (maxValue >= 12000)
                    {
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_10), cloak, 0.0f);
                        script.SetFirstName(cloak, DamageResistanceNames[damageResistType] + ", 10");
                        Pricing.CalculatePrice(script, cloak);
                        return(12000);
                    }
                    else if (maxValue >= 4000)
                    {
                        script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyDamageResistance(damageResistType, IP_CONST_DAMAGERESIST_5), cloak, 0.0f);
                        script.SetFirstName(cloak, DamageResistanceNames[damageResistType] + ", 5");
                        Pricing.CalculatePrice(script, cloak);
                        return(4000);
                    }
                }
                break;
            }

                #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), cloak, 0.0f);
                script.SetFirstName(cloak, ImmunityNames[selectedImmunity]);
                Pricing.CalculatePrice(script, cloak);
                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), cloak, 0.0f);
                    script.SetFirstName(cloak, "Cloak of Resistance +5");
                    Pricing.CalculatePrice(script, cloak);
                    return(25000);
                }
                else if (maxValue >= 16000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL, 4), cloak, 0.0f);
                    script.SetFirstName(cloak, "Cloak of Resistance +4");
                    Pricing.CalculatePrice(script, cloak);
                    return(16000);
                }
                else if (maxValue >= 9000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL, 3), cloak, 0.0f);
                    script.SetFirstName(cloak, "Cloak of Resistance +3");
                    Pricing.CalculatePrice(script, cloak);
                    return(9000);
                }
                else if (maxValue >= 4000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL, 2), cloak, 0.0f);
                    script.SetFirstName(cloak, "Cloak of Resistance +2");
                    Pricing.CalculatePrice(script, cloak);
                    return(4000);
                }
                else if (maxValue >= 1000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL, 1), cloak, 0.0f);
                    script.SetFirstName(cloak, "Cloak of Resistance +1");
                    Pricing.CalculatePrice(script, cloak);
                    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(cloak, SaveTypeNames[saveType]);
                if (maxValue >= 6250)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 5), cloak, 0.0f);
                    script.SetFirstName(cloak, String.Format("{0} +5", script.GetName(cloak)));
                    Pricing.CalculatePrice(script, cloak);
                    return(6250);
                }
                else if (maxValue >= 4000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 4), cloak, 0.0f);
                    script.SetFirstName(cloak, String.Format("{0} +4", script.GetName(cloak)));
                    Pricing.CalculatePrice(script, cloak);
                    return(4000);
                }
                else if (maxValue >= 2250)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 3), cloak, 0.0f);
                    script.SetFirstName(cloak, String.Format("{0} +3", script.GetName(cloak)));
                    Pricing.CalculatePrice(script, cloak);
                    return(2250);
                }
                else if (maxValue >= 1000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 2), cloak, 0.0f);
                    script.SetFirstName(cloak, String.Format("{0} +2", script.GetName(cloak)));
                    Pricing.CalculatePrice(script, cloak);
                    return(1000);
                }
                else if (maxValue >= 250)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSavingThrowVsX(saveType, 1), cloak, 0.0f);
                    script.SetFirstName(cloak, String.Format("{0} +1", script.GetName(cloak)));
                    Pricing.CalculatePrice(script, cloak);
                    return(250);
                }
                break;
            }

                #endregion
                #region Skill Bonus
            case ITEM_PROPERTY_SKILL_BONUS:
            {
                int skillBonus = AvailableSkills[Generation.rand.Next(AvailableSkills.Count)];
                script.SetFirstName(cloak, SkillNames[skillBonus]);
                if (maxValue >= 10000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 10), cloak, 0.0f);
                    script.SetFirstName(cloak, script.GetName(cloak) + " +10");
                    Pricing.CalculatePrice(script, cloak);
                    return(10000);
                }
                else if (maxValue >= 8100)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 9), cloak, 0.0f);
                    script.SetFirstName(cloak, script.GetName(cloak) + " +9");
                    Pricing.CalculatePrice(script, cloak);
                    return(8100);
                }
                else if (maxValue >= 6400)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 8), cloak, 0.0f);
                    script.SetFirstName(cloak, script.GetName(cloak) + " +8");
                    Pricing.CalculatePrice(script, cloak);
                    return(6400);
                }
                else if (maxValue >= 4900)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 7), cloak, 0.0f);
                    script.SetFirstName(cloak, script.GetName(cloak) + " +7");
                    Pricing.CalculatePrice(script, cloak);
                    return(4900);
                }
                else if (maxValue >= 3600)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 6), cloak, 0.0f);
                    script.SetFirstName(cloak, script.GetName(cloak) + " +6");
                    Pricing.CalculatePrice(script, cloak);
                    return(3600);
                }
                else if (maxValue >= 2500)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 5), cloak, 0.0f);
                    script.SetFirstName(cloak, script.GetName(cloak) + " +5");
                    Pricing.CalculatePrice(script, cloak);
                    return(2500);
                }
                else if (maxValue >= 1600)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 4), cloak, 0.0f);
                    script.SetFirstName(cloak, script.GetName(cloak) + " +4");
                    Pricing.CalculatePrice(script, cloak);
                    return(1600);
                }
                else if (maxValue >= 900)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 3), cloak, 0.0f);
                    script.SetFirstName(cloak, script.GetName(cloak) + " +3");
                    Pricing.CalculatePrice(script, cloak);
                    return(900);
                }
                else if (maxValue >= 400)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 2), cloak, 0.0f);
                    script.SetFirstName(cloak, script.GetName(cloak) + " +2");
                    Pricing.CalculatePrice(script, cloak);
                    return(400);
                }
                else if (maxValue >= 100)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 1), cloak, 0.0f);
                    script.SetFirstName(cloak, script.GetName(cloak) + " +1");
                    Pricing.CalculatePrice(script, cloak);
                    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), cloak, 0.0f);
                    script.SetFirstName(cloak, "Cloak of Spell Resistance, 26");
                    Pricing.CalculatePrice(script, cloak);
                    return(140000);
                }
                else if (maxValue >= 120000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_24), cloak, 0.0f);
                    script.SetFirstName(cloak, "Cloak of Spell Resistance, 24");
                    Pricing.CalculatePrice(script, cloak);
                    return(120000);
                }
                else if (maxValue >= 100000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_22), cloak, 0.0f);
                    script.SetFirstName(cloak, "Cloak of Spell Resistance, 22");
                    Pricing.CalculatePrice(script, cloak);
                    return(100000);
                }
                else if (maxValue >= 80000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_20), cloak, 0.0f);
                    script.SetFirstName(cloak, "Cloak of Spell Resistance, 20");
                    Pricing.CalculatePrice(script, cloak);
                    return(80000);
                }
                else if (maxValue >= 60000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_18), cloak, 0.0f);
                    script.SetFirstName(cloak, "Cloak of Spell Resistance, 18");
                    Pricing.CalculatePrice(script, cloak);
                    return(60000);
                }
                else if (maxValue >= 40000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_16), cloak, 0.0f);
                    script.SetFirstName(cloak, "Cloak of Spell Resistance, 16");
                    Pricing.CalculatePrice(script, cloak);
                    return(40000);
                }
                else if (maxValue >= 20000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_14), cloak, 0.0f);
                    script.SetFirstName(cloak, "Cloak of Spell Resistance, 14");
                    Pricing.CalculatePrice(script, cloak);
                    return(20000);
                }
                else if (maxValue >= 10000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_12), cloak, 0.0f);
                    script.SetFirstName(cloak, "Cloak of Spell Resistance, 12");
                    Pricing.CalculatePrice(script, cloak);
                    return(10000);
                }
                else if (maxValue >= 6000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyBonusSpellResistance(IP_CONST_SPELLRESISTANCEBONUS_10), cloak, 0.0f);
                    script.SetFirstName(cloak, "Cloak of Spell Resistance, 10");
                    Pricing.CalculatePrice(script, cloak);
                    return(6000);
                }
                else
                {
                    return(0);
                }
            }
                #endregion
            }
            script.DestroyObject(cloak, 0.0f, FALSE);
            return(0);
        }
        public static int NewBelt(CLRScriptBase script, int maxValue)
        {
            List <int> selectableAbilities = new List <int>();

            foreach (KeyValuePair <int, int> prop in PrimaryAmuletAbility)
            {
                if (prop.Value <= maxValue)
                {
                    selectableAbilities.Add(prop.Key);
                }
            }
            if (selectableAbilities.Count == 0)
            {
                return(0);
            }
            int  selectedAbility = selectableAbilities[Generation.rand.Next(selectableAbilities.Count)];
            uint belt            = script.CreateItemOnObject("zitem_belt", script.OBJECT_SELF, 1, "", FALSE);

            switch (selectedAbility)
            {
                #region Belt of Shielding
            case ITEM_PROPERTY_AC_BONUS:
            {
                if (maxValue >= 50000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(5), belt, 0.0f);
                    script.SetFirstName(belt, "Belt of Shielding +5");
                    Pricing.CalculatePrice(script, belt);
                    return(50000);
                }
                else if (maxValue >= 32000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(4), belt, 0.0f);
                    script.SetFirstName(belt, "Belt of Shielding +4");
                    Pricing.CalculatePrice(script, belt);
                    return(32000);
                }
                else if (maxValue >= 18000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(3), belt, 0.0f);
                    script.SetFirstName(belt, "Belt of Shielding +3");
                    Pricing.CalculatePrice(script, belt);
                    return(18000);
                }
                else if (maxValue >= 8000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(2), belt, 0.0f);
                    script.SetFirstName(belt, "Belt of Shielding +2");
                    Pricing.CalculatePrice(script, belt);
                    return(8000);
                }
                else if (maxValue >= 2000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyACBonus(1), belt, 0.0f);
                    script.SetFirstName(belt, "Belt of Shielding +1");
                    Pricing.CalculatePrice(script, belt);
                    return(2000);
                }
                else
                {
                    return(0);
                }
            }

                #endregion
                #region Ability Bonus
            case ITEM_PROPERTY_ABILITY_BONUS:
            {
                int ability = AbilityScores[Generation.rand.Next(AbilityScores.Count)];
                if (maxValue >= 36000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(ability, 6), belt, 0.0f);
                    script.SetFirstName(belt, AbilityScoreNames[ability] + " +6");
                    Pricing.CalculatePrice(script, belt);
                    return(36000);
                }
                else if (maxValue >= 25000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(ability, 5), belt, 0.0f);
                    script.SetFirstName(belt, AbilityScoreNames[ability] + " +5");
                    Pricing.CalculatePrice(script, belt);
                    return(25000);
                }
                else if (maxValue >= 16000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(ability, 4), belt, 0.0f);
                    script.SetFirstName(belt, AbilityScoreNames[ability] + " +4");
                    Pricing.CalculatePrice(script, belt);
                    return(16000);
                }
                else if (maxValue >= 9000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(ability, 3), belt, 0.0f);
                    script.SetFirstName(belt, AbilityScoreNames[ability] + " +3");
                    Pricing.CalculatePrice(script, belt);
                    return(9000);
                }
                else if (maxValue >= 4000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(ability, 2), belt, 0.0f);
                    script.SetFirstName(belt, AbilityScoreNames[ability] + " +2");
                    Pricing.CalculatePrice(script, belt);
                    return(4000);
                }
                else if (maxValue >= 1000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertyAbilityBonus(ability, 1), belt, 0.0f);
                    script.SetFirstName(belt, AbilityScoreNames[ability] + " +1");
                    Pricing.CalculatePrice(script, belt);
                    return(1000);
                }
                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), belt, 0.0f);
                script.SetFirstName(belt, ImmunityNames[selectedImmunity]);
                Pricing.CalculatePrice(script, belt);
                return(AvailableImmunities[selectedImmunity]);
            }

                #endregion
                #region Skill Bonuses
            case ITEM_PROPERTY_SKILL_BONUS:
            {
                int skillBonus = AvailableSkills[Generation.rand.Next(AvailableSkills.Count)];
                script.SetFirstName(belt, SkillNames[skillBonus]);
                if (maxValue >= 10000)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 10), belt, 0.0f);
                    script.SetFirstName(belt, script.GetName(belt) + " +10");
                    Pricing.CalculatePrice(script, belt);
                    return(10000);
                }
                else if (maxValue >= 8100)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 9), belt, 0.0f);
                    script.SetFirstName(belt, script.GetName(belt) + " +9");
                    Pricing.CalculatePrice(script, belt);
                    return(8100);
                }
                else if (maxValue >= 6400)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 8), belt, 0.0f);
                    script.SetFirstName(belt, script.GetName(belt) + " +8");
                    Pricing.CalculatePrice(script, belt);
                    return(6400);
                }
                else if (maxValue >= 4900)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 7), belt, 0.0f);
                    script.SetFirstName(belt, script.GetName(belt) + " +7");
                    Pricing.CalculatePrice(script, belt);
                    return(4900);
                }
                else if (maxValue >= 3600)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 6), belt, 0.0f);
                    script.SetFirstName(belt, script.GetName(belt) + " +6");
                    Pricing.CalculatePrice(script, belt);
                    return(3600);
                }
                else if (maxValue >= 2500)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 5), belt, 0.0f);
                    script.SetFirstName(belt, script.GetName(belt) + " +5");
                    Pricing.CalculatePrice(script, belt);
                    return(2500);
                }
                else if (maxValue >= 1600)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 4), belt, 0.0f);
                    script.SetFirstName(belt, script.GetName(belt) + " +4");
                    Pricing.CalculatePrice(script, belt);
                    return(1600);
                }
                else if (maxValue >= 900)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 3), belt, 0.0f);
                    script.SetFirstName(belt, script.GetName(belt) + " +3");
                    Pricing.CalculatePrice(script, belt);
                    return(900);
                }
                else if (maxValue >= 400)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 2), belt, 0.0f);
                    script.SetFirstName(belt, script.GetName(belt) + " +2");
                    Pricing.CalculatePrice(script, belt);
                    return(400);
                }
                else if (maxValue >= 100)
                {
                    script.AddItemProperty(DURATION_TYPE_PERMANENT, script.ItemPropertySkillBonus(skillBonus, 1), belt, 0.0f);
                    script.SetFirstName(belt, script.GetName(belt) + " +1");
                    Pricing.CalculatePrice(script, belt);
                    return(100);
                }
                break;
            }
                #endregion
            }
            script.DestroyObject(belt, 0.0f, FALSE);
            return(0);
        }