예제 #1
0
        private static void ProcessWaterEffects(CLRScriptBase script, uint Creature, uint Trigger)
        {
            if (script.GetIsImmune(Creature, CLRScriptBase.IMMUNITY_TYPE_MOVEMENT_SPEED_DECREASE, Trigger) != CLRScriptBase.FALSE)
            {
                return;
            }
            uint weapon = script.GetItemInSlot(CLRScriptBase.INVENTORY_SLOT_RIGHTHAND, Creature);

            if (script.GetIsObjectValid(weapon) == CLRScriptBase.TRUE)
            {
                int weaponType = script.GetBaseItemType(weapon);
                if (ALFA.Shared.Modules.InfoStore.BaseItems[weaponType].WeaponType != 1 &&
                    ALFA.Shared.Modules.InfoStore.BaseItems[weaponType].WeaponType != 0) // unfortunately, this is magic numbered in the 2da as well
                {
                    script.ApplyEffectToObject(CLRScriptBase.DURATION_TYPE_TEMPORARY, script.ExtraordinaryEffect(script.EffectAttackDecrease(2, CLRScriptBase.ATTACK_BONUS_ONHAND)), Creature, 6.0f);
                    int damagePenalty = ALFA.Shared.Modules.InfoStore.BaseItems[weaponType].DieToRoll / 4;
                    damagePenalty += script.GetAbilityModifier(CLRScriptBase.ABILITY_STRENGTH, Creature) / 2;
                    int damageType = CLRScriptBase.DAMAGE_TYPE_SLASHING;
                    switch (ALFA.Shared.Modules.InfoStore.BaseItems[weaponType].WeaponType)
                    {
                    case 2: damageType = CLRScriptBase.DAMAGE_TYPE_BLUDGEONING; break;

                    case 3: damageType = CLRScriptBase.DAMAGE_TYPE_SLASHING; break;

                    case 4: damageType = CLRScriptBase.DAMAGE_TYPE_SLASHING; break;

                    case 5: damageType = CLRScriptBase.DAMAGE_TYPE_BLUDGEONING; break;
                    }
                    script.EffectDamageDecrease(damagePenalty, damageType);
                }
                weapon = script.GetItemInSlot(CLRScriptBase.INVENTORY_SLOT_LEFTHAND, Creature);
                if (script.GetIsObjectValid(weapon) == CLRScriptBase.TRUE)
                {
                    weaponType = script.GetBaseItemType(weapon);
                    if (ALFA.Shared.Modules.InfoStore.BaseItems[weaponType].WeaponType != 1 &&
                        ALFA.Shared.Modules.InfoStore.BaseItems[weaponType].WeaponType != 0) // unfortunately, this is magic numbered in the 2da as well
                    {
                        script.ApplyEffectToObject(CLRScriptBase.DURATION_TYPE_TEMPORARY, script.ExtraordinaryEffect(script.EffectAttackDecrease(2, CLRScriptBase.ATTACK_BONUS_OFFHAND)), Creature, 6.0f);
                    }
                }
            }
            else
            {
                script.ApplyEffectToObject(CLRScriptBase.DURATION_TYPE_TEMPORARY, script.ExtraordinaryEffect(script.EffectAttackDecrease(2, CLRScriptBase.ATTACK_BONUS_ONHAND)), Creature, 6.0f);
                int damagePenalty = 1 + script.GetAbilityModifier(CLRScriptBase.ABILITY_STRENGTH, Creature) / 2;
                if (damagePenalty > 0)
                {
                    script.EffectDamageDecrease(damagePenalty, CLRScriptBase.DAMAGE_TYPE_BLUDGEONING);
                }
            }
        }
예제 #2
0
        public static int GetIsItemShield(uint oItem, CLRScriptBase s)
        {
            int nItemType = s.GetBaseItemType(oItem);

            if (nItemType == CLRScriptBase.BASE_ITEM_LARGESHIELD ||
                nItemType == CLRScriptBase.BASE_ITEM_SMALLSHIELD ||
                nItemType == CLRScriptBase.BASE_ITEM_TOWERSHIELD)
            {
                return(1);
            }

            return(0);
        }
예제 #3
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
        }
예제 #4
0
        public static void ActivateLongTermBuffs(uint oCaster, CLRScriptBase s)
        {
            // Cast protection from good/evil based on alignment.
            if (s.GetAlignmentGoodEvil(oCaster) == CLRScriptBase.ALIGNMENT_EVIL)
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_PROTECTION_FROM_GOOD, s);
            }
            else
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_PROTECTION_FROM_EVIL, s);
            }

            // Buff armor, if the creature has any.
            uint oItem = s.GetItemInSlot(CLRScriptBase.INVENTORY_SLOT_CHEST, s.OBJECT_SELF);

            if (oItem != CLRScriptBase.OBJECT_INVALID)
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_MAGIC_VESTMENT, s, oItem);
            }

            // Buff the shield, if the creature has one.
            uint oLeftHandItem  = s.GetItemInSlot(CLRScriptBase.INVENTORY_SLOT_LEFTHAND, oCaster);
            uint oRightHandItem = s.GetItemInSlot(CLRScriptBase.INVENTORY_SLOT_RIGHTHAND, oCaster);
            int  nLeftItemType  = s.GetBaseItemType(oLeftHandItem);
            int  nRightItemType = s.GetBaseItemType(oRightHandItem);

            if (GetIsItemShield(oLeftHandItem, s) != CLRScriptBase.FALSE)
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_MAGIC_VESTMENT, s, oLeftHandItem);
            }

            // FIX ME!! Weapon-buffing should be more intelligent. But we need to be
            // able to tell what a weapon is.
            _QuickBuff(oCaster, CLRScriptBase.SPELL_KEEN_EDGE, s);
            if (s.GetHasSpell(CLRScriptBase.SPELL_GREATER_MAGIC_WEAPON, oCaster) != CLRScriptBase.FALSE)
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_GREATER_MAGIC_WEAPON, s);
            }
            else
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_MAGIC_WEAPON, s);
            }
            _QuickBuff(oCaster, CLRScriptBase.SPELL_WEAPON_OF_IMPACT, s);

            _QuickBuff(oCaster, CLRScriptBase.SPELL_BARKSKIN, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_SPIDERSKIN, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_CONVICTION, s);

            if (s.GetHasSpell(CLRScriptBase.SPELL_PROTECTION_FROM_ENERGY, oCaster) != CLRScriptBase.FALSE)
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_PROTECTION_FROM_ENERGY, s);
            }
            else
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_ENDURE_ELEMENTS, s);
            }

            _QuickBuff(oCaster, CLRScriptBase.SPELL_FREEDOM_OF_MOVEMENT, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_HEROISM, s);

            if (s.GetHasSpell(CLRScriptBase.SPELL_IMPROVED_MAGE_ARMOR, oCaster) != CLRScriptBase.FALSE)
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_IMPROVED_MAGE_ARMOR, s);
            }
            else
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_MAGE_ARMOR, s);
            }

            if (s.GetHasSpell(CLRScriptBase.SPELL_GREATER_PLANAR_BINDING, oCaster) != CLRScriptBase.FALSE)
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_GREATER_PLANAR_BINDING, s);
            }
            else if (s.GetHasSpell(CLRScriptBase.SPELL_PLANAR_BINDING, oCaster) != CLRScriptBase.FALSE)
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_PLANAR_BINDING, s);
            }
            else if (s.GetHasSpell(CLRScriptBase.SPELL_PLANAR_ALLY, oCaster) != CLRScriptBase.FALSE)
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_PLANAR_ALLY, s);
            }
            else
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_LESSER_PLANAR_BINDING, s);
            }

            _QuickBuff(oCaster, CLRScriptBase.SPELL_GREATER_RESISTANCE, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_MIND_BLANK, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_ONE_WITH_THE_LAND, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_PREMONITION, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_PROTECTION_FROM_SPELLS, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_PROTECTION_FROM_ARROWS, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_GREATER_BULLS_STRENGTH, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_GREATER_CATS_GRACE, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_GREATER_EAGLE_SPLENDOR, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_GREATER_BEARS_ENDURANCE, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_GREATER_FOXS_CUNNING, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_GREATER_OWLS_WISDOM, s);
            _QuickBuff(oCaster, CLRScriptBase.SPELL_SEE_INVISIBILITY, s);

            if (s.GetHasSpell(CLRScriptBase.SPELL_PREMONITION, oCaster) != CLRScriptBase.FALSE)
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_PREMONITION, s);
            }
            else if (s.GetHasSpell(CLRScriptBase.SPELL_GREATER_STONESKIN, oCaster) != CLRScriptBase.FALSE)
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_GREATER_STONESKIN, s);
            }
            else
            {
                _QuickBuff(oCaster, CLRScriptBase.SPELL_STONESKIN, s);
            }

            // Delay party buffs a bit in case this guy has buddies spawning in next to him.
            s.DelayCommand(6.0f, delegate { _QuickBuff(oCaster, CLRScriptBase.SPELL_MASS_CAMOFLAGE, s); });
        }