سلام ، آیا این بازدید اول شماست ؟ یا
logo_forum_header

تبلیغات
×
+
سفارش تبلیغات

صفحه 2 از 2 نخستنخست 12
نمایش نتایج: از 11 به 17 از 17

موضوع: sacred shiled پالادین

  1. #11

    شماره عضویت
    266
    تاریخ عضویت
    Apr 2015
    نوشته ها
    75
    نسل
    نسل مورد علاقه
    نژاد
    نژاد  مورد علاقه
    کلاس
     کلاس  مورد علاقه
    سورس
     سورس مورد علاقه
    پچ
    پچ مورد علاقه
    پسندیده : 91
    مورد پسند : 24 بار در 14 پست
    سیستم عامل و مرورگر:
    نقل قول نوشته اصلی توسط DrEhsan نمایش پست ها
    برنامه نویس بزرگوار بهتر بود منبع این اسکریپت رو هم می نوشتین ، که از کجا کپی و پیست شده.

    تازه کد کامل کپی نکردید و کلا این کد ارور خواهد داد.

    خواهشا یا حذف کنید این کد رو یا اگر حذف نمی کنید منبع رو هم ذکر کنید.

    جناب NightPrince این جور موارد حداقل از شما انتظار نمی ره.

    با تشکر
    تنها كاربران عضو مي توانند لينك ها را مشاهده كنند.
    داداش گلم و دوست عزیزم ! درود بر شما !
    عزیز من این اسکریپت و Sql رو تو سیستم ذخیره کرده داشتم و اگه جسارت نباشه من نمیتونم هر اسکریپت یا پچی رو میخوام تو سیستم ذخیره کنم رو منبع هم ذکر کنم آخر اونا :|
    من اینو از سیستم گذاشتم اینجا و یادم نبود منبعش رو !!! اما چشم از این به بعد سعی میکنم منبع رو هم ذکر کنم حق دوستای عزیزمون هم پایمال نشه !! با تشکر

  2. # ADS
    سیستم تبلیغات
    تاریخ عضویت
    01/01/2014
    نوشته ها
    پستی ندارد.
     

  3. #12

    شماره عضویت
    311
    تاریخ عضویت
    Apr 2015
    نوشته ها
    18
    نژاد
    نژاد  مورد علاقه
    کلاس
     کلاس  مورد علاقه
    سورس
     سورس مورد علاقه
    پسندیده : 0
    مورد پسند : 1 بار در 1 پست
    سیستم عامل و مرورگر:
    نقل قول نوشته اصلی توسط Hamed_Ezio نمایش پست ها
    اررور هارو اینجا قرار بدید
    Error 1 error C2065: 'SPELL_PALADIN_SPELL_SACRED_SHIELD' : undeclared identifier D:\Server New\TrinityCore\src\server\scripts\Spells\spell_pa ladin.cpp 1240 1 scripts
    Warning 2 warning C4305: 'argument' : truncation from 'double' to 'float' D:\Server New\TrinityCore\src\server\scripts\Custom\per.cpp 36 1 scripts
    Warning 3 warning C4305: 'argument' : truncation from 'double' to 'float' D:\Server New\TrinityCore\src\server\scripts\Custom\per.cpp 38 1 scripts
    Error 4 error LNK1181: cannot open input file '..\scripts\Release\scripts.lib' D:\Server New\Build\src\server\worldserver\LINK worldserver

  4. #13

    شماره عضویت
    266
    تاریخ عضویت
    Apr 2015
    نوشته ها
    75
    نسل
    نسل مورد علاقه
    نژاد
    نژاد  مورد علاقه
    کلاس
     کلاس  مورد علاقه
    سورس
     سورس مورد علاقه
    پچ
    پچ مورد علاقه
    پسندیده : 91
    مورد پسند : 24 بار در 14 پست
    سیستم عامل و مرورگر:
    نقل قول نوشته اصلی توسط alpha2015 نمایش پست ها
    Error 1 error C2065: 'SPELL_PALADIN_SPELL_SACRED_SHIELD' : undeclared identifier D:\Server New\TrinityCore\src\server\scripts\Spells\spell_pa ladin.cpp 1240 1 scripts
    Warning 2 warning C4305: 'argument' : truncation from 'double' to 'float' D:\Server New\TrinityCore\src\server\scripts\Custom\per.cpp 36 1 scripts
    Warning 3 warning C4305: 'argument' : truncation from 'double' to 'float' D:\Server New\TrinityCore\src\server\scripts\Custom\per.cpp 38 1 scripts
    Error 4 error LNK1181: cannot open input file '..\scripts\Release\scripts.lib' D:\Server New\Build\src\server\worldserver\LINK worldserver
    سلام و درود !!!
    دوست عزیز اگه دقت کنید دو ارور
    کد PHP:
    Warning    2    warning C4305'argument' truncation  from 'double' to 'float'    D:\Server  New\TrinityCore\src\server\scripts\Custom\per.cpp    36    1    scripts
    Warning    3    warning C4305
    'argument' truncation from 'double' to  'float'    D:\Server New\TrinityCore\src\server\scripts\Custom\per.cpp     38    1    scripts 
    از کاستوم اسکریپت های شماست و ربطی به اون نداره!!!
    واما ارور
    کد PHP:
    Error    1    error C2065:  'SPELL_PALADIN_SPELL_SACRED_SHIELD' undeclared identifier    D:\Server  New\TrinityCore\src\server\scripts\Spells\spell_pa  ladin.cpp    1240     1    scripts 
    تو spell_paladin.cpp اون اسپل رو داشتی و جایگذین کردی یا آخر اسکریپت اضافه کردی؟

    افزوده شده بعد از 8 دقیقه :
    راستی از چه tdb یا کر استفاده میکنید؟
    ویرایش توسط iceboy : 05-19-2015 در ساعت 11:59 AM دلیل: ادغام پست

  5. #14

    شماره عضویت
    311
    تاریخ عضویت
    Apr 2015
    نوشته ها
    18
    نژاد
    نژاد  مورد علاقه
    کلاس
     کلاس  مورد علاقه
    سورس
     سورس مورد علاقه
    پسندیده : 0
    مورد پسند : 1 بار در 1 پست
    سیستم عامل و مرورگر:
    قسمت
    // Sacred shield - 148039 بود من جایگزین کردم.

    ولی قسمت
    // Sacred shield absorb - 65148 نبود. پاین اون sacred shield قرار دادم.

    از TDB 58


    کد اصلی ای هست.

    کد HTML:
    #include "Player.h"
    #include "ScriptMgr.h"
    #include "SpellScript.h"
    #include "SpellAuraEffects.h"
    #include "Group.h"
    
    enum PaladinSpells
    {
        SPELL_PALADIN_DIVINE_PLEA                    = 54428,
        SPELL_PALADIN_BLESSING_OF_SANCTUARY_BUFF     = 67480,
        SPELL_PALADIN_BLESSING_OF_SANCTUARY_ENERGIZE = 57319,
    
        SPELL_PALADIN_HOLY_SHOCK_R1                  = 20473,
        SPELL_PALADIN_HOLY_SHOCK_R1_DAMAGE           = 25912,
        SPELL_PALADIN_HOLY_SHOCK_R1_HEALING          = 25914,
    
        SPELL_PALADIN_BLESSING_OF_LOWER_CITY_DRUID   = 37878,
        SPELL_PALADIN_BLESSING_OF_LOWER_CITY_PALADIN = 37879,
        SPELL_PALADIN_BLESSING_OF_LOWER_CITY_PRIEST  = 37880,
        SPELL_PALADIN_BLESSING_OF_LOWER_CITY_SHAMAN  = 37881,
    
        SPELL_PALADIN_DIVINE_STORM                   = 53385,
        SPELL_PALADIN_DIVINE_STORM_DUMMY             = 54171,
        SPELL_PALADIN_DIVINE_STORM_HEAL              = 54172,
    
        SPELL_PALADIN_EYE_FOR_AN_EYE_DAMAGE          = 25997,
    
        SPELL_PALADIN_FORBEARANCE                    = 25771,
        SPELL_PALADIN_AVENGING_WRATH_MARKER          = 61987,
        SPELL_PALADIN_IMMUNE_SHIELD_MARKER           = 61988,
    
        SPELL_PALADIN_HAND_OF_SACRIFICE              = 6940,
        SPELL_PALADIN_DIVINE_SACRIFICE               = 64205,
    
        SPELL_PALADIN_ITEM_HEALING_TRANCE            = 37706,
    
        SPELL_PALADIN_JUDGEMENT_DAMAGE               = 54158,
        SPELL_PALADIN_JUDGEMENT_OF_JUSTICE           = 20184,
        SPELL_PALADIN_JUDGEMENT_OF_LIGHT             = 20185,
        SPELL_PALADIN_JUDGEMENT_OF_WISDOM            = 20186,
    
        SPELL_PALADIN_GLYPH_OF_SALVATION             = 63225,
    
        SPELL_PALADIN_RIGHTEOUS_DEFENSE_TAUNT        = 31790,
    
        SPELL_PALADIN_SANCTIFIED_WRATH               = 57318,
        SPELL_PALADIN_SANCTIFIED_WRATH_TALENT_R1     = 53375,
    
        SPELL_PALADIN_SEAL_OF_RIGHTEOUSNESS          = 25742,
    
        SPELL_PALADIN_CONCENTRACTION_AURA            = 19746,
        SPELL_PALADIN_SANCTIFIED_RETRIBUTION_R1      = 31869,
        SPELL_PALADIN_SWIFT_RETRIBUTION_R1           = 53379,
    
        SPELL_PALADIN_IMPROVED_CONCENTRACTION_AURA   = 63510,
        SPELL_PALADIN_IMPROVED_DEVOTION_AURA         = 63514,
        SPELL_PALADIN_SANCTIFIED_RETRIBUTION_AURA    = 63531,
        SPELL_PALADIN_AURA_MASTERY_IMMUNE            = 64364,
    
        SPELL_GENERIC_ARENA_DAMPENING                = 74410,
        SPELL_GENERIC_BATTLEGROUND_DAMPENING         = 74411
    };
    
    enum PaladinSpellIcons
    {
        PALADIN_ICON_ID_RETRIBUTION_AURA             = 555
    };
    
    // 31850 - Ardent Defender
    class spell_pal_ardent_defender : public SpellScriptLoader
    {
        public:
            spell_pal_ardent_defender() : SpellScriptLoader("spell_pal_ardent_defender") { }
    
            class spell_pal_ardent_defender_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_ardent_defender_AuraScript);
    
            public:
                spell_pal_ardent_defender_AuraScript()
                {
                    absorbPct = 0;
                    healPct = 0;
                }
    
            private:
                uint32 absorbPct, healPct;
    
                enum Spell
                {
                    PAL_SPELL_ARDENT_DEFENDER_HEAL = 66235,
                };
    
                bool Load() override
                {
                    healPct = GetSpellInfo()->Effects[EFFECT_1].CalcValue();
                    absorbPct = GetSpellInfo()->Effects[EFFECT_0].CalcValue();
                    return GetUnitOwner()->GetTypeId() == TYPEID_PLAYER;
                }
    
                void CalculateAmount(AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
                {
                    // Set absorbtion amount to unlimited
                    amount = -1;
                }
    
                void Absorb(AuraEffect* aurEff, DamageInfo & dmgInfo, uint32 & absorbAmount)
                {
                    Unit* victim = GetTarget();
                    int32 remainingHealth = victim->GetHealth() - dmgInfo.GetDamage();
                    uint32 allowedHealth = victim->CountPctFromMaxHealth(35);
                    // If damage kills us
                    if (remainingHealth <= 0 && !victim->ToPlayer()->HasSpellCooldown(PAL_SPELL_ARDENT_DEFENDER_HEAL))
                    {
                        // Cast healing spell, completely avoid damage
                        absorbAmount = dmgInfo.GetDamage();
    
                        uint32 defenseSkillValue = victim->GetDefenseSkillValue();
                        // Max heal when defense skill denies critical hits from raid bosses
                        // Formula: max defense at level + 140 (raiting from gear)
                        uint32 reqDefForMaxHeal  = victim->getLevel() * 5 + 140;
                        float pctFromDefense = (defenseSkillValue >= reqDefForMaxHeal)
                            ? 1.0f
                            : float(defenseSkillValue) / float(reqDefForMaxHeal);
    
                        int32 healAmount = int32(victim->CountPctFromMaxHealth(uint32(healPct * pctFromDefense)));
                        victim->CastCustomSpell(victim, PAL_SPELL_ARDENT_DEFENDER_HEAL, &healAmount, NULL, NULL, true, NULL, aurEff);
                        victim->ToPlayer()->AddSpellCooldown(PAL_SPELL_ARDENT_DEFENDER_HEAL, 0, time(NULL) + 120);
                    }
                    else if (remainingHealth < int32(allowedHealth))
                    {
                        // Reduce damage that brings us under 35% (or full damage if we are already under 35%) by x%
                        uint32 damageToReduce = (victim->GetHealth() < allowedHealth)
                            ? dmgInfo.GetDamage()
                            : allowedHealth - remainingHealth;
                        absorbAmount = CalculatePct(damageToReduce, absorbPct);
                    }
                }
    
                void Register() override
                {
                     DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pal_ardent_defender_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
                     OnEffectAbsorb += AuraEffectAbsorbFn(spell_pal_ardent_defender_AuraScript::Absorb, EFFECT_0);
                }
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_ardent_defender_AuraScript();
            }
    };
    
    // 31821 - Aura Mastery
    class spell_pal_aura_mastery : public SpellScriptLoader
    {
        public:
            spell_pal_aura_mastery() : SpellScriptLoader("spell_pal_aura_mastery") { }
    
            class spell_pal_aura_mastery_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_aura_mastery_AuraScript);
    
                bool Validate(SpellInfo const* /*spellInfo*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_AURA_MASTERY_IMMUNE))
                        return false;
                    return true;
                }
    
                void HandleEffectApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
                {
                    GetTarget()->CastSpell(GetTarget(), SPELL_PALADIN_AURA_MASTERY_IMMUNE, true);
                }
    
                void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
                {
                    GetTarget()->RemoveOwnedAura(SPELL_PALADIN_AURA_MASTERY_IMMUNE, GetCasterGUID());
                }
    
                void Register() override
                {
                    AfterEffectApply += AuraEffectApplyFn(spell_pal_aura_mastery_AuraScript::HandleEffectApply, EFFECT_0, SPELL_AURA_ADD_PCT_MODIFIER, AURA_EFFECT_HANDLE_REAL);
                    AfterEffectRemove += AuraEffectRemoveFn(spell_pal_aura_mastery_AuraScript::HandleEffectRemove, EFFECT_0, SPELL_AURA_ADD_PCT_MODIFIER, AURA_EFFECT_HANDLE_REAL);
                }
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_aura_mastery_AuraScript();
            }
    };
    
    // 64364 - Aura Mastery Immune
    class spell_pal_aura_mastery_immune : public SpellScriptLoader
    {
        public:
            spell_pal_aura_mastery_immune() : SpellScriptLoader("spell_pal_aura_mastery_immune") { }
    
            class spell_pal_aura_mastery_immune_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_aura_mastery_immune_AuraScript);
    
                bool Validate(SpellInfo const* /*spellInfo*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_CONCENTRACTION_AURA))
                        return false;
                    return true;
                }
    
                bool CheckAreaTarget(Unit* target)
                {
                    return target->HasAura(SPELL_PALADIN_CONCENTRACTION_AURA, GetCasterGUID());
                }
    
                void Register() override
                {
                    DoCheckAreaTarget += AuraCheckAreaTargetFn(spell_pal_aura_mastery_immune_AuraScript::CheckAreaTarget);
                }
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_aura_mastery_immune_AuraScript();
            }
    };
    
    // 31884 - Avenging Wrath
    class spell_pal_avenging_wrath : public SpellScriptLoader
    {
        public:
            spell_pal_avenging_wrath() : SpellScriptLoader("spell_pal_avenging_wrath") { }
    
            class spell_pal_avenging_wrath_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_avenging_wrath_AuraScript);
    
                bool Validate(SpellInfo const* /*spellInfo*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_SANCTIFIED_WRATH)
                        || !sSpellMgr->GetSpellInfo(SPELL_PALADIN_SANCTIFIED_WRATH_TALENT_R1))
                        return false;
                    return true;
                }
    
                void HandleApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
                {
                    Unit* target = GetTarget();
                    if (AuraEffect const* aurEff = target->GetAuraEffectOfRankedSpell(SPELL_PALADIN_SANCTIFIED_WRATH_TALENT_R1, EFFECT_2))
                    {
                        int32 basepoints = aurEff->GetAmount();
                        target->CastCustomSpell(target, SPELL_PALADIN_SANCTIFIED_WRATH, &basepoints, &basepoints, NULL, true, NULL, aurEff);
                    }
                }
    
                void HandleRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
                {
                    GetTarget()->RemoveAurasDueToSpell(SPELL_PALADIN_SANCTIFIED_WRATH);
                }
    
                void Register() override
                {
                    OnEffectApply += AuraEffectApplyFn(spell_pal_avenging_wrath_AuraScript::HandleApply, EFFECT_0, SPELL_AURA_MOD_DAMAGE_PERCENT_DONE, AURA_EFFECT_HANDLE_REAL);
                    AfterEffectRemove += AuraEffectRemoveFn(spell_pal_avenging_wrath_AuraScript::HandleRemove, EFFECT_0, SPELL_AURA_MOD_DAMAGE_PERCENT_DONE, AURA_EFFECT_HANDLE_REAL);
                }
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_avenging_wrath_AuraScript();
            }
    };
    
    // 37877 - Blessing of Faith
    class spell_pal_blessing_of_faith : public SpellScriptLoader
    {
        public:
            spell_pal_blessing_of_faith() : SpellScriptLoader("spell_pal_blessing_of_faith") { }
    
            class spell_pal_blessing_of_faith_SpellScript : public SpellScript
            {
                PrepareSpellScript(spell_pal_blessing_of_faith_SpellScript);
    
                bool Validate(SpellInfo const* /*spellInfo*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_BLESSING_OF_LOWER_CITY_DRUID) || !sSpellMgr->GetSpellInfo(SPELL_PALADIN_BLESSING_OF_LOWER_CITY_PALADIN) || !sSpellMgr->GetSpellInfo(SPELL_PALADIN_BLESSING_OF_LOWER_CITY_PRIEST) || !sSpellMgr->GetSpellInfo(SPELL_PALADIN_BLESSING_OF_LOWER_CITY_SHAMAN))
                        return false;
                    return true;
                }
    
                void HandleDummy(SpellEffIndex /*effIndex*/)
                {
                    if (Unit* unitTarget = GetHitUnit())
                    {
                        uint32 spell_id = 0;
                        switch (unitTarget->getClass())
                        {
                            case CLASS_DRUID:
                                spell_id = SPELL_PALADIN_BLESSING_OF_LOWER_CITY_DRUID;
                                break;
                            case CLASS_PALADIN:
                                spell_id = SPELL_PALADIN_BLESSING_OF_LOWER_CITY_PALADIN;
                                break;
                            case CLASS_PRIEST:
                                spell_id = SPELL_PALADIN_BLESSING_OF_LOWER_CITY_PRIEST;
                                break;
                            case CLASS_SHAMAN:
                                spell_id = SPELL_PALADIN_BLESSING_OF_LOWER_CITY_SHAMAN;
                                break;
                            default:
                                return; // ignore for non-healing classes
                        }
                        Unit* caster = GetCaster();
                        caster->CastSpell(caster, spell_id, true);
                    }
                }
    
                void Register() override
                {
                    OnEffectHitTarget += SpellEffectFn(spell_pal_blessing_of_faith_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
                }
            };
    
            SpellScript* GetSpellScript() const override
            {
                return new spell_pal_blessing_of_faith_SpellScript();
            }
    };
    
    // 20911 - Blessing of Sanctuary
    // 25899 - Greater Blessing of Sanctuary
    class spell_pal_blessing_of_sanctuary : public SpellScriptLoader
    {
        public:
            spell_pal_blessing_of_sanctuary() : SpellScriptLoader("spell_pal_blessing_of_sanctuary") { }
    
            class spell_pal_blessing_of_sanctuary_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_blessing_of_sanctuary_AuraScript);
    
                bool Validate(SpellInfo const* /*spellInfo*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_BLESSING_OF_SANCTUARY_BUFF))
                        return false;
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_BLESSING_OF_SANCTUARY_ENERGIZE))
                        return false;
                    return true;
                }
    
                void HandleEffectApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
                {
                    Unit* target = GetTarget();
                    if (Unit* caster = GetCaster())
                        caster->CastSpell(target, SPELL_PALADIN_BLESSING_OF_SANCTUARY_BUFF, true);
                }
    
                void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
                {
                    Unit* target = GetTarget();
                    target->RemoveAura(SPELL_PALADIN_BLESSING_OF_SANCTUARY_BUFF, GetCasterGUID());
                }
    
                bool CheckProc(ProcEventInfo& /*eventInfo*/)
                {
                    return GetTarget()->getPowerType() == POWER_MANA;
                }
    
                void HandleProc(AuraEffect const* aurEff, ProcEventInfo& /*eventInfo*/)
                {
                    PreventDefaultAction();
                    GetTarget()->CastSpell(GetTarget(), SPELL_PALADIN_BLESSING_OF_SANCTUARY_ENERGIZE, true, NULL, aurEff);
                }
    
                void Register() override
                {
                    AfterEffectApply += AuraEffectApplyFn(spell_pal_blessing_of_sanctuary_AuraScript::HandleEffectApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
                    AfterEffectRemove += AuraEffectRemoveFn(spell_pal_blessing_of_sanctuary_AuraScript::HandleEffectRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
                    DoCheckProc += AuraCheckProcFn(spell_pal_blessing_of_sanctuary_AuraScript::CheckProc);
                    OnEffectProc += AuraEffectProcFn(spell_pal_blessing_of_sanctuary_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
                }
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_blessing_of_sanctuary_AuraScript();
            }
    };
    
    // 64205 - Divine Sacrifice
    class spell_pal_divine_sacrifice : public SpellScriptLoader
    {
        public:
            spell_pal_divine_sacrifice() : SpellScriptLoader("spell_pal_divine_sacrifice") { }
    
            class spell_pal_divine_sacrifice_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_divine_sacrifice_AuraScript);
    
                uint32 groupSize, minHpPct;
                int32 remainingAmount;
    
                bool Load() override
                {
                    if (Unit* caster = GetCaster())
                    {
                        if (caster->GetTypeId() == TYPEID_PLAYER)
                        {
                            if (caster->ToPlayer()->GetGroup())
                                groupSize = caster->ToPlayer()->GetGroup()->GetMembersCount();
                            else
                                groupSize = 1;
                        }
                        else
                            return false;
    
                        remainingAmount = (caster->CountPctFromMaxHealth(GetSpellInfo()->Effects[EFFECT_2].CalcValue(caster)) * groupSize);
                        minHpPct = GetSpellInfo()->Effects[EFFECT_1].CalcValue(caster);
                        return true;
                    }
                    return false;
                }
    
                void Split(AuraEffect* /*aurEff*/, DamageInfo & /*dmgInfo*/, uint32 & splitAmount)
                {
                    remainingAmount -= splitAmount;
                    // break when absorbed everything it could, or if the casters hp drops below 20%
                    if (Unit* caster = GetCaster())
                        if (remainingAmount <= 0 || (caster->GetHealthPct() < minHpPct))
                            caster->RemoveAura(SPELL_PALADIN_DIVINE_SACRIFICE);
                }
    
                void Register() override
                {
                    OnEffectSplit += AuraEffectSplitFn(spell_pal_divine_sacrifice_AuraScript::Split, EFFECT_0);
                }
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_divine_sacrifice_AuraScript();
            }
    };
    
    // 53385 - Divine Storm
    class spell_pal_divine_storm : public SpellScriptLoader
    {
        public:
            spell_pal_divine_storm() : SpellScriptLoader("spell_pal_divine_storm") { }
    
            class spell_pal_divine_storm_SpellScript : public SpellScript
            {
                PrepareSpellScript(spell_pal_divine_storm_SpellScript);
    
            public:
                spell_pal_divine_storm_SpellScript()
                {
                    healPct = 0;
                }
    
            private:
                uint32 healPct;
    
                bool Validate(SpellInfo const* /*spellInfo*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_DIVINE_STORM_DUMMY))
                        return false;
                    return true;
                }
    
                bool Load() override
                {
                    healPct = GetSpellInfo()->Effects[EFFECT_1].CalcValue(GetCaster());
                    return true;
                }
    
                void TriggerHeal()
                {
                    Unit* caster = GetCaster();
                    caster->CastCustomSpell(SPELL_PALADIN_DIVINE_STORM_DUMMY, SPELLVALUE_BASE_POINT0, (GetHitDamage() * healPct) / 100, caster, true);
                }
    
                void Register() override
                {
                    AfterHit += SpellHitFn(spell_pal_divine_storm_SpellScript::TriggerHeal);
                }
            };
    
            SpellScript* GetSpellScript() const override
            {
                return new spell_pal_divine_storm_SpellScript();
            }
    };
    
    // 54171 - Divine Storm (Dummy)
    class spell_pal_divine_storm_dummy : public SpellScriptLoader
    {
        public:
            spell_pal_divine_storm_dummy() : SpellScriptLoader("spell_pal_divine_storm_dummy") { }
    
            class spell_pal_divine_storm_dummy_SpellScript : public SpellScript
            {
                PrepareSpellScript(spell_pal_divine_storm_dummy_SpellScript);
    
            public:
                spell_pal_divine_storm_dummy_SpellScript()
                {
                    _targetCount = 0;
                }
    
            private:
                bool Validate(SpellInfo const* /*spellInfo*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_DIVINE_STORM_HEAL))
                        return false;
                    return true;
                }
    
                void CountTargets(std::list<WorldObject*>& targetList)
                {
                    _targetCount = targetList.size();
                }
    
                void HandleDummy(SpellEffIndex /*effIndex*/)
                {
                    if (!_targetCount || ! GetHitUnit())
                        return;
    
                    int32 heal = GetEffectValue() / _targetCount;
                    GetCaster()->CastCustomSpell(GetHitUnit(), SPELL_PALADIN_DIVINE_STORM_HEAL, &heal, NULL, NULL, true);
                }
            private:
                uint32 _targetCount;
    
                void Register() override
                {
                    OnEffectHitTarget += SpellEffectFn(spell_pal_divine_storm_dummy_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
                    OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_pal_divine_storm_dummy_SpellScript::CountTargets, EFFECT_0, TARGET_UNIT_CASTER_AREA_RAID);
                }
            };
    
            SpellScript* GetSpellScript() const override
            {
                return new spell_pal_divine_storm_dummy_SpellScript();
            }
    };
    
    // 33695 - Exorcism and Holy Wrath Damage
    class spell_pal_exorcism_and_holy_wrath_damage : public SpellScriptLoader
    {
        public:
            spell_pal_exorcism_and_holy_wrath_damage() : SpellScriptLoader("spell_pal_exorcism_and_holy_wrath_damage") { }
    
            class spell_pal_exorcism_and_holy_wrath_damage_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_exorcism_and_holy_wrath_damage_AuraScript);
    
                void HandleEffectCalcSpellMod(AuraEffect const* aurEff, SpellModifier*& spellMod)
                {
                    if (!spellMod)
                    {
                        spellMod = new SpellModifier(aurEff->GetBase());
                        spellMod->op = SPELLMOD_DAMAGE;
                        spellMod->type = SPELLMOD_FLAT;
                        spellMod->spellId = GetId();
                        spellMod->mask[1] = 0x200002;
                    }
    
                    spellMod->value = aurEff->GetAmount();
                }
    
                void Register() override
                {
                    DoEffectCalcSpellMod += AuraEffectCalcSpellModFn(spell_pal_exorcism_and_holy_wrath_damage_AuraScript::HandleEffectCalcSpellMod, EFFECT_0, SPELL_AURA_DUMMY);
                }
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_exorcism_and_holy_wrath_damage_AuraScript();
            }
    };
    
    // -9799 - Eye for an Eye
    class spell_pal_eye_for_an_eye : public SpellScriptLoader
    {
        public:
            spell_pal_eye_for_an_eye() : SpellScriptLoader("spell_pal_eye_for_an_eye") { }
    
            class spell_pal_eye_for_an_eye_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_eye_for_an_eye_AuraScript);
    
                bool Validate(SpellInfo const* /*spellInfo*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_EYE_FOR_AN_EYE_DAMAGE))
                        return false;
                    return true;
                }
    
                void OnProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo)
                {
                    PreventDefaultAction();
                    // return damage % to attacker but < 50% own total health
                    int32 damage = int32(std::min(CalculatePct(eventInfo.GetDamageInfo()->GetDamage(), aurEff->GetAmount()), GetTarget()->GetMaxHealth() / 2));
                    GetTarget()->CastCustomSpell(SPELL_PALADIN_EYE_FOR_AN_EYE_DAMAGE, SPELLVALUE_BASE_POINT0, damage, eventInfo.GetProcTarget(), true, NULL, aurEff);
                }
    
                void Register() override
                {
                    OnEffectProc += AuraEffectProcFn(spell_pal_eye_for_an_eye_AuraScript::OnProc, EFFECT_0, SPELL_AURA_DUMMY);
                }
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_eye_for_an_eye_AuraScript();
            }
    };
    
    // 54968 - Glyph of Holy Light
    class spell_pal_glyph_of_holy_light : public SpellScriptLoader
    {
        public:
            spell_pal_glyph_of_holy_light() : SpellScriptLoader("spell_pal_glyph_of_holy_light") { }
    
            class spell_pal_glyph_of_holy_light_SpellScript : public SpellScript
            {
                PrepareSpellScript(spell_pal_glyph_of_holy_light_SpellScript);
    
                void FilterTargets(std::list<WorldObject*>& targets)
                {
                    uint32 const maxTargets = GetSpellInfo()->MaxAffectedTargets;
    
                    if (targets.size() > maxTargets)
                    {
                        targets.sort(Trinity::HealthPctOrderPred());
                        targets.resize(maxTargets);
                    }
                }
    
                void Register() override
                {
                    OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_pal_glyph_of_holy_light_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_DEST_AREA_ALLY);
                }
            };
    
            SpellScript* GetSpellScript() const override
            {
                return new spell_pal_glyph_of_holy_light_SpellScript();
            }
    };
    
    // 63521 - Guarded by The Light
    class spell_pal_guarded_by_the_light : public SpellScriptLoader
    {
        public:
            spell_pal_guarded_by_the_light() : SpellScriptLoader("spell_pal_guarded_by_the_light") { }
    
            class spell_pal_guarded_by_the_light_SpellScript : public SpellScript
            {
                PrepareSpellScript(spell_pal_guarded_by_the_light_SpellScript);
    
                bool Validate(SpellInfo const* /*spellInfo*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_DIVINE_PLEA))
                        return false;
                    return true;
                }
    
                void HandleScriptEffect(SpellEffIndex /*effIndex*/)
                {
                    // Divine Plea
                    if (Aura* aura = GetCaster()->GetAura(SPELL_PALADIN_DIVINE_PLEA))
                        aura->RefreshDuration();
                }
    
                void Register() override
                {
                    OnEffectHitTarget += SpellEffectFn(spell_pal_guarded_by_the_light_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
                }
            };
    
            SpellScript* GetSpellScript() const override
            {
                return new spell_pal_guarded_by_the_light_SpellScript();
            }
    };
    
    // 6940 - Hand of Sacrifice
    class spell_pal_hand_of_sacrifice : public SpellScriptLoader
    {
        public:
            spell_pal_hand_of_sacrifice() : SpellScriptLoader("spell_pal_hand_of_sacrifice") { }
    
            class spell_pal_hand_of_sacrifice_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_hand_of_sacrifice_AuraScript);
    
            public:
                spell_pal_hand_of_sacrifice_AuraScript()
                {
                    remainingAmount = 0;
                }
    
            private:
                int32 remainingAmount;
    
                bool Load() override
                {
                    if (Unit* caster = GetCaster())
                    {
                        remainingAmount = caster->GetMaxHealth();
                        return true;
                    }
                    return false;
                }
    
                void Split(AuraEffect* /*aurEff*/, DamageInfo & /*dmgInfo*/, uint32 & splitAmount)
                {
                    remainingAmount -= splitAmount;
    
                    if (remainingAmount <= 0)
                    {
                        GetTarget()->RemoveAura(SPELL_PALADIN_HAND_OF_SACRIFICE);
                    }
                }
    
                void Register() override
                {
                    OnEffectSplit += AuraEffectSplitFn(spell_pal_hand_of_sacrifice_AuraScript::Split, EFFECT_0);
                }
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_hand_of_sacrifice_AuraScript();
            }
    };
    
    // 1038 - Hand of Salvation
    class spell_pal_hand_of_salvation : public SpellScriptLoader
    {
        public:
            spell_pal_hand_of_salvation() : SpellScriptLoader("spell_pal_hand_of_salvation") { }
    
            class spell_pal_hand_of_salvation_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_hand_of_salvation_AuraScript);
    
                void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/)
                {
                    if (Unit* caster = GetCaster())
                    {
                        // Glyph of Salvation
                        if (caster->GetGUID() == GetUnitOwner()->GetGUID())
                            if (AuraEffect const* aurEff = caster->GetAuraEffect(SPELL_PALADIN_GLYPH_OF_SALVATION, EFFECT_0))
                                amount -= aurEff->GetAmount();
                    }
                }
    
                void Register() override
                {
                    DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pal_hand_of_salvation_AuraScript::CalculateAmount, EFFECT_1, SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN);
                }
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_hand_of_salvation_AuraScript();
            }
    };
    
    // -20473 - Holy Shock
    class spell_pal_holy_shock : public SpellScriptLoader
    {
        public:
            spell_pal_holy_shock() : SpellScriptLoader("spell_pal_holy_shock") { }
    
            class spell_pal_holy_shock_SpellScript : public SpellScript
            {
                PrepareSpellScript(spell_pal_holy_shock_SpellScript);
    
                bool Validate(SpellInfo const* spellInfo) override
                {
                    SpellInfo const* firstRankSpellInfo = sSpellMgr->GetSpellInfo(SPELL_PALADIN_HOLY_SHOCK_R1);
                    if (!firstRankSpellInfo)
                        return false;
    
                    // can't use other spell than holy shock due to spell_ranks dependency
                    if (!spellInfo->IsRankOf(firstRankSpellInfo))
                        return false;
    
                    uint8 rank = spellInfo->GetRank();
                    if (!sSpellMgr->GetSpellWithRank(SPELL_PALADIN_HOLY_SHOCK_R1_DAMAGE, rank, true) || !sSpellMgr->GetSpellWithRank(SPELL_PALADIN_HOLY_SHOCK_R1_HEALING, rank, true))
                        return false;
    
                    return true;
                }
    
                void HandleDummy(SpellEffIndex /*effIndex*/)
                {
                    Unit* caster = GetCaster();
                    if (Unit* unitTarget = GetHitUnit())
                    {
                        uint8 rank = GetSpellInfo()->GetRank();
                        if (caster->IsFriendlyTo(unitTarget))
                            caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(SPELL_PALADIN_HOLY_SHOCK_R1_HEALING, rank), true);
                        else
                            caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(SPELL_PALADIN_HOLY_SHOCK_R1_DAMAGE, rank), true);
                    }
                }
    
                SpellCastResult CheckCast()
                {
                    Unit* caster = GetCaster();
                    if (Unit* target = GetExplTargetUnit())
                    {
                        if (!caster->IsFriendlyTo(target))
                        {
                            if (!caster->IsValidAttackTarget(target))
                                return SPELL_FAILED_BAD_TARGETS;
    
                            if (!caster->isInFront(target))
                                return SPELL_FAILED_UNIT_NOT_INFRONT;
                        }
                    }
                    else
                        return SPELL_FAILED_BAD_TARGETS;
                    return SPELL_CAST_OK;
                }
    
                void Register() override
                {
                    OnCheckCast += SpellCheckCastFn(spell_pal_holy_shock_SpellScript::CheckCast);
                    OnEffectHitTarget += SpellEffectFn(spell_pal_holy_shock_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
                }
            };
    
            SpellScript* GetSpellScript() const override
            {
                return new spell_pal_holy_shock_SpellScript();
            }
    };
    
    // Maybe this is incorrect
    // These spells should always be cast on login, regardless of whether the player has the talent or not
    
    // -20254 - Improved Concentration Aura
    // -20138 - Improved Devotion Aura
    //  31869 - Sanctified Retribution
    // -53379 - Swift Retribution
    class spell_pal_improved_aura : public SpellScriptLoader
    {
        public:
            spell_pal_improved_aura(char const* name, uint32 spellId) : SpellScriptLoader(name), _spellId(spellId) { }
    
            class spell_pal_improved_aura_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_improved_aura_AuraScript);
    
            public:
                spell_pal_improved_aura_AuraScript(uint32 spellId) : AuraScript(), _spellId(spellId) { }
    
                bool Validate(SpellInfo const* /*spellInfo*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(_spellId)
                        || !sSpellMgr->GetSpellInfo(SPELL_PALADIN_SANCTIFIED_RETRIBUTION_R1)
                        || !sSpellMgr->GetSpellInfo(SPELL_PALADIN_SWIFT_RETRIBUTION_R1))
                        return false;
                    return true;
                }
    
                void HandleEffectApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
                {
                    Unit* target = GetTarget();
                    GetTarget()->RemoveOwnedAura(_spellId, GetCasterGUID()); // need to remove to reapply spellmods
                    target->CastSpell(target, _spellId, true);
                }
    
                void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
                {
                    uint32 spellId = GetSpellInfo()->GetFirstRankSpell()->Id;
    
                    if ((spellId == SPELL_PALADIN_SANCTIFIED_RETRIBUTION_R1 && GetTarget()->GetAuraOfRankedSpell(SPELL_PALADIN_SWIFT_RETRIBUTION_R1))
                        || (spellId == SPELL_PALADIN_SWIFT_RETRIBUTION_R1 && GetTarget()->GetAuraOfRankedSpell(SPELL_PALADIN_SANCTIFIED_RETRIBUTION_R1)))
                        return;
    
                    GetTarget()->RemoveOwnedAura(_spellId, GetCasterGUID());
                }
    
                void Register() override
                {
                    AfterEffectApply += AuraEffectApplyFn(spell_pal_improved_aura_AuraScript::HandleEffectApply, EFFECT_FIRST_FOUND, SPELL_AURA_ADD_FLAT_MODIFIER, AURA_EFFECT_HANDLE_REAL);
                    AfterEffectRemove += AuraEffectRemoveFn(spell_pal_improved_aura_AuraScript::HandleEffectRemove, EFFECT_FIRST_FOUND, SPELL_AURA_ADD_FLAT_MODIFIER, AURA_EFFECT_HANDLE_REAL);
                }
    
            private:
                uint32 _spellId;
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_improved_aura_AuraScript(_spellId);
            }
    
        private:
            uint32 _spellId;
    };
    
    // 63510 - Improved Concentraction Aura (Area Aura)
    // 63514 - Improved Devotion Aura (Area Aura)
    // 63531 - Sanctified Retribution (Area Aura)
    class spell_pal_improved_aura_effect : public SpellScriptLoader
    {
        public:
            spell_pal_improved_aura_effect(char const* name) : SpellScriptLoader(name) { }
    
            class spell_pal_improved_aura_effect_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_improved_aura_effect_AuraScript);
    
                bool CheckAreaTarget(Unit* target)
                {
                    Unit::AuraApplicationMap& appliedAuras = target->GetAppliedAuras();
                    for (Unit::AuraApplicationMap::iterator itr = appliedAuras.begin(); itr != appliedAuras.end(); ++itr)
                    {
                        Aura const* aura = itr->second->GetBase();
                        if (aura->GetSpellInfo()->GetSpellSpecific() == SPELL_SPECIFIC_AURA && aura->GetCasterGUID() == GetCasterGUID())
                        {
                            // Not allow for Retribution Aura (prevent stacking) - Retribution Aura Overflow and Retribution Aura has same spell effects
                            if (GetSpellInfo()->Id == SPELL_PALADIN_SANCTIFIED_RETRIBUTION_AURA && aura->GetSpellInfo()->SpellIconID == PALADIN_ICON_ID_RETRIBUTION_AURA)
                                return false;
                            return true;
                        }
                    }
    
                    return false;
                }
    
                void Register() override
                {
                    DoCheckAreaTarget += AuraCheckAreaTargetFn(spell_pal_improved_aura_effect_AuraScript::CheckAreaTarget);
                }
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_improved_aura_effect_AuraScript();
            }
    };
    
    // 37705 - Healing Discount
    class spell_pal_item_healing_discount : public SpellScriptLoader
    {
        public:
            spell_pal_item_healing_discount() : SpellScriptLoader("spell_pal_item_healing_discount") { }
    
            class spell_pal_item_healing_discount_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_item_healing_discount_AuraScript);
    
                bool Validate(SpellInfo const* /*spellInfo*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_ITEM_HEALING_TRANCE))
                        return false;
                    return true;
                }
    
                void HandleProc(AuraEffect const* aurEff, ProcEventInfo& /*eventInfo*/)
                {
                    PreventDefaultAction();
                    GetTarget()->CastSpell(GetTarget(), SPELL_PALADIN_ITEM_HEALING_TRANCE, true, NULL, aurEff);
                }
    
                void Register() override
                {
                    OnEffectProc += AuraEffectProcFn(spell_pal_item_healing_discount_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
                }
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_item_healing_discount_AuraScript();
            }
    };
    
    // 53407 - Judgement of Justice
    // 20271 - Judgement of Light
    // 53408 - Judgement of Wisdom
    class spell_pal_judgement : public SpellScriptLoader
    {
        public:
            spell_pal_judgement(char const* scriptName, uint32 spellId) : SpellScriptLoader(scriptName), _spellId(spellId) { }
    
            class spell_pal_judgement_SpellScript : public SpellScript
            {
                PrepareSpellScript(spell_pal_judgement_SpellScript);
    
            public:
                spell_pal_judgement_SpellScript(uint32 spellId) : SpellScript(), _spellId(spellId) { }
    
                bool Validate(SpellInfo const* /*spellInfo*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_JUDGEMENT_DAMAGE)
                        || !sSpellMgr->GetSpellInfo(_spellId))
                        return false;
                    return true;
                }
    
                void HandleScriptEffect(SpellEffIndex /*effIndex*/)
                {
                    uint32 spellId2 = SPELL_PALADIN_JUDGEMENT_DAMAGE;
    
                    // some seals have SPELL_AURA_DUMMY in EFFECT_2
                    Unit::AuraEffectList const& auras = GetCaster()->GetAuraEffectsByType(SPELL_AURA_DUMMY);
                    for (Unit::AuraEffectList::const_iterator i = auras.begin(); i != auras.end(); ++i)
                    {
                        if ((*i)->GetSpellInfo()->GetSpellSpecific() == SPELL_SPECIFIC_SEAL && (*i)->GetEffIndex() == EFFECT_2)
                            if (sSpellMgr->GetSpellInfo((*i)->GetAmount()))
                            {
                                spellId2 = (*i)->GetAmount();
                                break;
                            }
                    }
    
                    GetCaster()->CastSpell(GetHitUnit(), _spellId, true);
                    GetCaster()->CastSpell(GetHitUnit(), spellId2, true);
                }
    
                void Register() override
                {
                    OnEffectHitTarget += SpellEffectFn(spell_pal_judgement_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
                }
    
            private:
                uint32 const _spellId;
            };
    
            SpellScript* GetSpellScript() const override
            {
                return new spell_pal_judgement_SpellScript(_spellId);
            }
    
        private:
            uint32 const _spellId;
    };
    
    // 20425 - Judgement of Command
    class spell_pal_judgement_of_command : public SpellScriptLoader
    {
        public:
            spell_pal_judgement_of_command() : SpellScriptLoader("spell_pal_judgement_of_command") { }
    
            class spell_pal_judgement_of_command_SpellScript : public SpellScript
            {
                PrepareSpellScript(spell_pal_judgement_of_command_SpellScript);
    
                void HandleDummy(SpellEffIndex /*effIndex*/)
                {
                    if (Unit* unitTarget = GetHitUnit())
                        if (SpellInfo const* spell_proto = sSpellMgr->GetSpellInfo(GetEffectValue()))
                            GetCaster()->CastSpell(unitTarget, spell_proto, true, NULL);
                }
    
                void Register() override
                {
                    OnEffectHitTarget += SpellEffectFn(spell_pal_judgement_of_command_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
                }
            };
    
            SpellScript* GetSpellScript() const override
            {
                return new spell_pal_judgement_of_command_SpellScript();
            }
    };
    
    // -633 - Lay on Hands
    class spell_pal_lay_on_hands : public SpellScriptLoader
    {
        public:
            spell_pal_lay_on_hands() : SpellScriptLoader("spell_pal_lay_on_hands") { }
    
            class spell_pal_lay_on_hands_SpellScript : public SpellScript
            {
                PrepareSpellScript(spell_pal_lay_on_hands_SpellScript);
    
                bool Validate(SpellInfo const* /*spell*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_FORBEARANCE))
                        return false;
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_AVENGING_WRATH_MARKER))
                        return false;
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_IMMUNE_SHIELD_MARKER))
                        return false;
                    return true;
                }
    
                SpellCastResult CheckCast()
                {
                    Unit* caster = GetCaster();
                    if (Unit* target = GetExplTargetUnit())
                        if (caster == target)
                            if (target->HasAura(SPELL_PALADIN_FORBEARANCE) || target->HasAura(SPELL_PALADIN_AVENGING_WRATH_MARKER) || target->HasAura(SPELL_PALADIN_IMMUNE_SHIELD_MARKER))
                                return SPELL_FAILED_TARGET_AURASTATE;
    
                    return SPELL_CAST_OK;
                }
    
                void HandleScript()
                {
                    Unit* caster = GetCaster();
                    if (caster == GetHitUnit())
                    {
                        caster->CastSpell(caster, SPELL_PALADIN_FORBEARANCE, true);
                        caster->CastSpell(caster, SPELL_PALADIN_AVENGING_WRATH_MARKER, true);
                        caster->CastSpell(caster, SPELL_PALADIN_IMMUNE_SHIELD_MARKER, true);
                    }
                }
    
                void Register() override
                {
                    OnCheckCast += SpellCheckCastFn(spell_pal_lay_on_hands_SpellScript::CheckCast);
                    AfterHit += SpellHitFn(spell_pal_lay_on_hands_SpellScript::HandleScript);
                }
            };
    
            SpellScript* GetSpellScript() const override
            {
                return new spell_pal_lay_on_hands_SpellScript();
            }
    };
    
    // 31789 - Righteous Defense
    class spell_pal_righteous_defense : public SpellScriptLoader
    {
        public:
            spell_pal_righteous_defense() : SpellScriptLoader("spell_pal_righteous_defense") { }
    
            class spell_pal_righteous_defense_SpellScript : public SpellScript
            {
                PrepareSpellScript(spell_pal_righteous_defense_SpellScript);
    
                bool Validate(SpellInfo const* /*spellInfo*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_RIGHTEOUS_DEFENSE_TAUNT))
                        return false;
                    return true;
                }
    
                SpellCastResult CheckCast()
                {
                    Unit* caster = GetCaster();
                    if (caster->GetTypeId() != TYPEID_PLAYER)
                        return SPELL_FAILED_DONT_REPORT;
    
                    if (Unit* target = GetExplTargetUnit())
                    {
                        if (!target->IsFriendlyTo(caster) || target->getAttackers().empty())
                            return SPELL_FAILED_BAD_TARGETS;
                    }
                    else
                        return SPELL_FAILED_BAD_TARGETS;
    
                    return SPELL_CAST_OK;
                }
    
                void HandleTriggerSpellLaunch(SpellEffIndex effIndex)
                {
                    PreventHitDefaultEffect(effIndex);
                }
    
                void HandleTriggerSpellHit(SpellEffIndex effIndex)
                {
                    PreventHitDefaultEffect(effIndex);
                    if (Unit* target = GetHitUnit())
                        GetCaster()->CastSpell(target, SPELL_PALADIN_RIGHTEOUS_DEFENSE_TAUNT, true);
                }
    
                void Register() override
                {
                    OnCheckCast += SpellCheckCastFn(spell_pal_righteous_defense_SpellScript::CheckCast);
                    //! WORKAROUND
                    //! target select will be executed in hitphase of effect 0
                    //! so we must handle trigger spell also in hit phase (default execution in launch phase)
                    //! see issue #3718
                    OnEffectLaunchTarget += SpellEffectFn(spell_pal_righteous_defense_SpellScript::HandleTriggerSpellLaunch, EFFECT_1, SPELL_EFFECT_TRIGGER_SPELL);
                    OnEffectHitTarget += SpellEffectFn(spell_pal_righteous_defense_SpellScript::HandleTriggerSpellHit, EFFECT_1, SPELL_EFFECT_TRIGGER_SPELL);
                }
            };
    
            SpellScript* GetSpellScript() const override
            {
                return new spell_pal_righteous_defense_SpellScript();
            }
    };
    
    // 58597 - Sacred Shield
    class spell_pal_sacred_shield : public SpellScriptLoader
    {
        public:
            spell_pal_sacred_shield() : SpellScriptLoader("spell_pal_sacred_shield") { }
    
            class spell_pal_sacred_shield_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_sacred_shield_AuraScript);
    
                void CalculateAmount(AuraEffect const* aurEff, int32& amount, bool& /*canBeRecalculated*/)
                {
                    if (Unit* caster = GetCaster())
                    {
                        // +75.00% from sp bonus
                        float bonus = CalculatePct(caster->SpellBaseHealingBonusDone(GetSpellInfo()->GetSchoolMask()), 75.0f);
    
                        // Divine Guardian is only applied at the spell healing bonus because it was already applied to the base value in CalculateSpellDamage
                        bonus = caster->ApplyEffectModifiers(GetSpellInfo(), aurEff->GetEffIndex(), bonus);
                        bonus *= caster->CalculateLevelPenalty(GetSpellInfo());
    
                        amount += int32(bonus);
    
                        // Arena - Dampening
                        if (AuraEffect const* auraEffArenaDampening = caster->GetAuraEffect(SPELL_GENERIC_ARENA_DAMPENING, EFFECT_0))
                            AddPct(amount, auraEffArenaDampening->GetAmount());
                        // Battleground - Dampening
                        else if (AuraEffect const* auraEffBattlegroudDampening = caster->GetAuraEffect(SPELL_GENERIC_BATTLEGROUND_DAMPENING, EFFECT_0))
                            AddPct(amount, auraEffBattlegroudDampening->GetAmount());
                    }
                }
    
                void Register() override
                {
                    DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pal_sacred_shield_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
                }
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_sacred_shield_AuraScript();
            }
    };
    
    // 20154, 21084 - Seal of Righteousness - melee proc dummy (addition ${$MWS*(0.022*$AP+0.044*$SPH)} damage)
    class spell_pal_seal_of_righteousness : public SpellScriptLoader
    {
        public:
            spell_pal_seal_of_righteousness() : SpellScriptLoader("spell_pal_seal_of_righteousness") { }
    
            class spell_pal_seal_of_righteousness_AuraScript : public AuraScript
            {
                PrepareAuraScript(spell_pal_seal_of_righteousness_AuraScript);
    
                bool Validate(SpellInfo const* /*spellInfo*/) override
                {
                    if (!sSpellMgr->GetSpellInfo(SPELL_PALADIN_SEAL_OF_RIGHTEOUSNESS))
                        return false;
                    return true;
                }
    
                bool CheckProc(ProcEventInfo& eventInfo)
                {
                    return eventInfo.GetProcTarget() != nullptr;
                }
    
                void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo)
                {
                    PreventDefaultAction();
    
                    float ap = GetTarget()->GetTotalAttackPowerValue(BASE_ATTACK);
                    int32 holy = GetTarget()->SpellBaseDamageBonusDone(SPELL_SCHOOL_MASK_HOLY);
                    holy += eventInfo.GetProcTarget()->SpellBaseDamageBonusTaken(SPELL_SCHOOL_MASK_HOLY);
                    int32 bp = int32((ap * 0.022f + 0.044f * holy) * GetTarget()->GetAttackTime(BASE_ATTACK) / 1000);
                    GetTarget()->CastCustomSpell(SPELL_PALADIN_SEAL_OF_RIGHTEOUSNESS, SPELLVALUE_BASE_POINT0, bp, eventInfo.GetProcTarget(), true, NULL, aurEff);
                }
    
                void Register() override
                {
                    DoCheckProc += AuraCheckProcFn(spell_pal_seal_of_righteousness_AuraScript::CheckProc);
                    OnEffectProc += AuraEffectProcFn(spell_pal_seal_of_righteousness_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
                }
            };
    
            AuraScript* GetAuraScript() const override
            {
                return new spell_pal_seal_of_righteousness_AuraScript();
            }
    };
    
    void AddSC_paladin_spell_scripts()
    {
        new spell_pal_ardent_defender();
        new spell_pal_aura_mastery();
        new spell_pal_aura_mastery_immune();
        new spell_pal_avenging_wrath();
        new spell_pal_blessing_of_faith();
        new spell_pal_blessing_of_sanctuary();
        new spell_pal_divine_sacrifice();
        new spell_pal_divine_storm();
        new spell_pal_divine_storm_dummy();
        new spell_pal_exorcism_and_holy_wrath_damage();
        new spell_pal_eye_for_an_eye();
        new spell_pal_glyph_of_holy_light();
        new spell_pal_guarded_by_the_light();
        new spell_pal_hand_of_sacrifice();
        new spell_pal_hand_of_salvation();
        new spell_pal_holy_shock();
        new spell_pal_improved_aura("spell_pal_improved_concentraction_aura", SPELL_PALADIN_IMPROVED_CONCENTRACTION_AURA);
        new spell_pal_improved_aura("spell_pal_improved_devotion_aura", SPELL_PALADIN_IMPROVED_DEVOTION_AURA);
        new spell_pal_improved_aura("spell_pal_sanctified_retribution", SPELL_PALADIN_SANCTIFIED_RETRIBUTION_AURA);
        new spell_pal_improved_aura("spell_pal_swift_retribution", SPELL_PALADIN_SANCTIFIED_RETRIBUTION_AURA);
        new spell_pal_improved_aura_effect("spell_pal_improved_concentraction_aura_effect");
        new spell_pal_improved_aura_effect("spell_pal_improved_devotion_aura_effect");
        new spell_pal_improved_aura_effect("spell_pal_sanctified_retribution_effect");
        new spell_pal_item_healing_discount();
        new spell_pal_judgement("spell_pal_judgement_of_justice", SPELL_PALADIN_JUDGEMENT_OF_JUSTICE);
        new spell_pal_judgement("spell_pal_judgement_of_light", SPELL_PALADIN_JUDGEMENT_OF_LIGHT);
        new spell_pal_judgement("spell_pal_judgement_of_wisdom", SPELL_PALADIN_JUDGEMENT_OF_WISDOM);
        new spell_pal_judgement_of_command();
        new spell_pal_lay_on_hands();
        new spell_pal_righteous_defense();
        new spell_pal_sacred_shield();
        new spell_pal_seal_of_righteousness();
    }
    ویرایش توسط alpha2015 : 05-19-2015 در ساعت 12:07 PM

  6. #15

    شماره عضویت
    266
    تاریخ عضویت
    Apr 2015
    نوشته ها
    75
    نسل
    نسل مورد علاقه
    نژاد
    نژاد  مورد علاقه
    کلاس
     کلاس  مورد علاقه
    سورس
     سورس مورد علاقه
    پچ
    پچ مورد علاقه
    پسندیده : 91
    مورد پسند : 24 بار در 14 پست
    سیستم عامل و مرورگر:
    به جای SPELL_PALADIN_SPELL_SACRED_SHIELD این spell_pal_sacred_shield رو قرار بدین ببینید درست میشه؟

  7. #16

    شماره عضویت
    311
    تاریخ عضویت
    Apr 2015
    نوشته ها
    18
    نژاد
    نژاد  مورد علاقه
    کلاس
     کلاس  مورد علاقه
    سورس
     سورس مورد علاقه
    پسندیده : 0
    مورد پسند : 1 بار در 1 پست
    سیستم عامل و مرورگر:
    لطفا id yahoo بدید که دسترسی بدم.

  8. #17

    شماره عضویت
    266
    تاریخ عضویت
    Apr 2015
    نوشته ها
    75
    نسل
    نسل مورد علاقه
    نژاد
    نژاد  مورد علاقه
    کلاس
     کلاس  مورد علاقه
    سورس
     سورس مورد علاقه
    پچ
    پچ مورد علاقه
    پسندیده : 91
    مورد پسند : 24 بار در 14 پست
    سیستم عامل و مرورگر:
    نقل قول نوشته اصلی توسط alpha2015 نمایش پست ها
    لطفا id yahoo بدید که دسترسی بدم.
    تنها كاربران عضو مي توانند لينك ها را مشاهده كنند.

صفحه 2 از 2 نخستنخست 12

کلمات کلیدی این موضوع

مجوز های ارسال و ویرایش

  • شما نمیتوانید موضوع جدیدی ارسال کنید
  • شما امکان ارسال پاسخ را ندارید
  • شما نمیتوانید فایل پیوست کنید.
  • شما نمیتوانید پست های خود را ویرایش کنید
  •