diff --git a/src/server/scripts/Spells/spell_rogue.cpp b/src/server/scripts/Spells/spell_rogue.cpp index 063017b2e..bd864d718 100644 --- a/src/server/scripts/Spells/spell_rogue.cpp +++ b/src/server/scripts/Spells/spell_rogue.cpp @@ -43,294 +43,237 @@ enum RogueSpells SPELL_ROGUE_TRICKS_OF_THE_TRADE_PROC = 59628, }; -// Ours -class spell_rog_savage_combat : public SpellScriptLoader +class spell_rog_savage_combat : public AuraScript { -public: - spell_rog_savage_combat() : SpellScriptLoader("spell_rog_savage_combat") { } + PrepareAuraScript(spell_rog_savage_combat); - class spell_rog_savage_combat_AuraScript : public AuraScript + void CalcPeriodic(AuraEffect const* /*effect*/, bool& isPeriodic, int32& amplitude) { - PrepareAuraScript(spell_rog_savage_combat_AuraScript); + isPeriodic = true; + amplitude = 1000; + } - void CalcPeriodic(AuraEffect const* /*effect*/, bool& isPeriodic, int32& amplitude) - { - isPeriodic = true; - amplitude = 1000; - } - - void Update(AuraEffect* /*auraEffect*/) - { - Unit::AuraApplicationMap const& auras = GetUnitOwner()->GetAppliedAuras(); - for (Unit::AuraApplicationMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr) - if (itr->second->GetBase()->GetCasterGUID() == this->GetCasterGUID() && itr->second->GetBase()->GetSpellInfo()->Dispel == DISPEL_POISON) - return; - - SetDuration(0); - } - - void Register() override - { - DoEffectCalcPeriodic += AuraEffectCalcPeriodicFn(spell_rog_savage_combat_AuraScript::CalcPeriodic, EFFECT_0, SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN); - OnEffectUpdatePeriodic += AuraEffectUpdatePeriodicFn(spell_rog_savage_combat_AuraScript::Update, EFFECT_0, SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN); - } - }; - - AuraScript* GetAuraScript() const override + void Update(AuraEffect* /*auraEffect*/) { - return new spell_rog_savage_combat_AuraScript(); + Unit::AuraApplicationMap const& auras = GetUnitOwner()->GetAppliedAuras(); + for (Unit::AuraApplicationMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr) + if (itr->second->GetBase()->GetCasterGUID() == this->GetCasterGUID() && itr->second->GetBase()->GetSpellInfo()->Dispel == DISPEL_POISON) + return; + + SetDuration(0); + } + + void Register() override + { + DoEffectCalcPeriodic += AuraEffectCalcPeriodicFn(spell_rog_savage_combat::CalcPeriodic, EFFECT_0, SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN); + OnEffectUpdatePeriodic += AuraEffectUpdatePeriodicFn(spell_rog_savage_combat::Update, EFFECT_0, SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN); } }; -class spell_rog_combat_potency : public SpellScriptLoader +class spell_rog_combat_potency : public AuraScript { -public: - spell_rog_combat_potency() : SpellScriptLoader("spell_rog_combat_potency") { } + PrepareAuraScript(spell_rog_combat_potency); - class spell_rog_combat_potency_AuraScript : public AuraScript + bool CheckProc(ProcEventInfo& eventInfo) { - PrepareAuraScript(spell_rog_combat_potency_AuraScript); + return eventInfo.GetTypeMask() & PROC_FLAG_DONE_MELEE_AUTO_ATTACK; + } - bool CheckProc(ProcEventInfo& eventInfo) - { - return eventInfo.GetTypeMask() & PROC_FLAG_DONE_MELEE_AUTO_ATTACK; - } - - void Register() override - { - DoCheckProc += AuraCheckProcFn(spell_rog_combat_potency_AuraScript::CheckProc); - } - }; - - AuraScript* GetAuraScript() const override + void Register() override { - return new spell_rog_combat_potency_AuraScript(); + DoCheckProc += AuraCheckProcFn(spell_rog_combat_potency::CheckProc); } }; -// Theirs // 13877, 33735, (check 51211, 65956) - Blade Flurry -class spell_rog_blade_flurry : public SpellScriptLoader +class spell_rog_blade_flurry : public AuraScript { -public: - spell_rog_blade_flurry() : SpellScriptLoader("spell_rog_blade_flurry") { } + PrepareAuraScript(spell_rog_blade_flurry); - class spell_rog_blade_flurry_AuraScript : public AuraScript + bool Validate(SpellInfo const* /*spellInfo*/) override { - PrepareAuraScript(spell_rog_blade_flurry_AuraScript); - - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_ROGUE_BLADE_FLURRY_EXTRA_ATTACK }); - } - - bool Load() override - { - _procTargetGUID.Clear(); - return true; - } - - bool CheckProc(ProcEventInfo& eventInfo) - { - Unit* _procTarget = eventInfo.GetActor()->SelectNearbyNoTotemTarget(eventInfo.GetProcTarget()); - if (_procTarget) - _procTargetGUID = _procTarget->GetGUID(); - return _procTarget; - } - - void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) - { - PreventDefaultAction(); - // Xinef: no _procTarget but checkproc passed?? - // Unit::CalculateAOEDamageReduction (this=0x0, damage=4118, schoolMask=1, caster=0x7ffdad089000) - Unit* procTarget = ObjectAccessor::GetUnit(*GetTarget(), _procTargetGUID); - DamageInfo* damageInfo = eventInfo.GetDamageInfo(); - if (procTarget && damageInfo) - { - int32 damage = damageInfo->GetUnmitigatedDamage(); - - CustomSpellValues values; - values.AddSpellMod(SPELLVALUE_BASE_POINT0, damage); - values.AddSpellMod(SPELLVALUE_FORCED_CRIT_RESULT, int32(eventInfo.GetHitMask() & PROC_EX_CRITICAL_HIT)); - GetTarget()->CastCustomSpell(SPELL_ROGUE_BLADE_FLURRY_EXTRA_ATTACK, values, procTarget, TRIGGERED_FULL_MASK, nullptr, aurEff); - } - } - - void Register() override - { - DoCheckProc += AuraCheckProcFn(spell_rog_blade_flurry_AuraScript::CheckProc); - OnEffectProc += AuraEffectProcFn(spell_rog_blade_flurry_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_MOD_MELEE_HASTE); - } - - private: - ObjectGuid _procTargetGUID; - }; - - AuraScript* GetAuraScript() const override - { - return new spell_rog_blade_flurry_AuraScript(); + return ValidateSpellInfo({ SPELL_ROGUE_BLADE_FLURRY_EXTRA_ATTACK }); } + + bool Load() override + { + _procTargetGUID.Clear(); + return true; + } + + bool CheckProc(ProcEventInfo& eventInfo) + { + Unit* _procTarget = eventInfo.GetActor()->SelectNearbyNoTotemTarget(eventInfo.GetProcTarget()); + if (_procTarget) + _procTargetGUID = _procTarget->GetGUID(); + return _procTarget; + } + + void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) + { + PreventDefaultAction(); + // Xinef: no _procTarget but checkproc passed?? + // Unit::CalculateAOEDamageReduction (this=0x0, damage=4118, schoolMask=1, caster=0x7ffdad089000) + Unit* procTarget = ObjectAccessor::GetUnit(*GetTarget(), _procTargetGUID); + DamageInfo* damageInfo = eventInfo.GetDamageInfo(); + if (procTarget && damageInfo) + { + int32 damage = damageInfo->GetUnmitigatedDamage(); + + CustomSpellValues values; + values.AddSpellMod(SPELLVALUE_BASE_POINT0, damage); + values.AddSpellMod(SPELLVALUE_FORCED_CRIT_RESULT, int32(eventInfo.GetHitMask() & PROC_EX_CRITICAL_HIT)); + GetTarget()->CastCustomSpell(SPELL_ROGUE_BLADE_FLURRY_EXTRA_ATTACK, values, procTarget, TRIGGERED_FULL_MASK, nullptr, aurEff); + } + } + + void Register() override + { + DoCheckProc += AuraCheckProcFn(spell_rog_blade_flurry::CheckProc); + OnEffectProc += AuraEffectProcFn(spell_rog_blade_flurry::HandleProc, EFFECT_0, SPELL_AURA_MOD_MELEE_HASTE); + } + +private: + ObjectGuid _procTargetGUID; }; // -31228 - Cheat Death -class spell_rog_cheat_death : public SpellScriptLoader +class spell_rog_cheat_death : public AuraScript { -public: - spell_rog_cheat_death() : SpellScriptLoader("spell_rog_cheat_death") { } + PrepareAuraScript(spell_rog_cheat_death); - class spell_rog_cheat_death_AuraScript : public AuraScript + uint32 absorbChance; + + bool Validate(SpellInfo const* /*spellInfo*/) override { - PrepareAuraScript(spell_rog_cheat_death_AuraScript); + return ValidateSpellInfo({ SPELL_ROGUE_CHEAT_DEATH_COOLDOWN }); + } - uint32 absorbChance; - - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_ROGUE_CHEAT_DEATH_COOLDOWN }); - } - - bool Load() override - { - absorbChance = GetSpellInfo()->Effects[EFFECT_0].CalcValue(); - return GetUnitOwner()->ToPlayer(); - } - - void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) - { - // Set absorbtion amount to unlimited - amount = -1; - } - - void Absorb(AuraEffect* /*aurEff*/, DamageInfo& dmgInfo, uint32& absorbAmount) - { - Player* target = GetTarget()->ToPlayer(); - if (dmgInfo.GetDamage() < target->GetHealth() || target->HasSpellCooldown(SPELL_ROGUE_CHEAT_DEATH_COOLDOWN) || !roll_chance_i(absorbChance)) - return; - - target->CastSpell(target, SPELL_ROGUE_CHEAT_DEATH_COOLDOWN, true); - target->CastSpell(target, SPELL_ROGUE_CHEATING_DEATH, true); - target->AddSpellCooldown(SPELL_ROGUE_CHEAT_DEATH_COOLDOWN, 0, MINUTE * IN_MILLISECONDS); - - uint32 health10 = target->CountPctFromMaxHealth(10); - - // hp > 10% - absorb hp till 10% - if (target->GetHealth() > health10) - absorbAmount = dmgInfo.GetDamage() - target->GetHealth() + health10; - // hp lower than 10% - absorb everything - else - absorbAmount = dmgInfo.GetDamage(); - } - - void Register() override - { - DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_rog_cheat_death_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB); - OnEffectAbsorb += AuraEffectAbsorbFn(spell_rog_cheat_death_AuraScript::Absorb, EFFECT_0); - } - }; - - AuraScript* GetAuraScript() const override + bool Load() override { - return new spell_rog_cheat_death_AuraScript(); + absorbChance = GetSpellInfo()->Effects[EFFECT_0].CalcValue(); + return GetUnitOwner()->ToPlayer(); + } + + void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) + { + // Set absorbtion amount to unlimited + amount = -1; + } + + void Absorb(AuraEffect* /*aurEff*/, DamageInfo& dmgInfo, uint32& absorbAmount) + { + Player* target = GetTarget()->ToPlayer(); + if (dmgInfo.GetDamage() < target->GetHealth() || target->HasSpellCooldown(SPELL_ROGUE_CHEAT_DEATH_COOLDOWN) || !roll_chance_i(absorbChance)) + return; + + target->CastSpell(target, SPELL_ROGUE_CHEAT_DEATH_COOLDOWN, true); + target->CastSpell(target, SPELL_ROGUE_CHEATING_DEATH, true); + target->AddSpellCooldown(SPELL_ROGUE_CHEAT_DEATH_COOLDOWN, 0, MINUTE * IN_MILLISECONDS); + + uint32 health10 = target->CountPctFromMaxHealth(10); + + // hp > 10% - absorb hp till 10% + if (target->GetHealth() > health10) + absorbAmount = dmgInfo.GetDamage() - target->GetHealth() + health10; + // hp lower than 10% - absorb everything + else + absorbAmount = dmgInfo.GetDamage(); + } + + void Register() override + { + DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_rog_cheat_death::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB); + OnEffectAbsorb += AuraEffectAbsorbFn(spell_rog_cheat_death::Absorb, EFFECT_0); } }; // -2818 - Deadly Poison -class spell_rog_deadly_poison : public SpellScriptLoader +class spell_rog_deadly_poison : public SpellScript { -public: - spell_rog_deadly_poison() : SpellScriptLoader("spell_rog_deadly_poison") { } + PrepareSpellScript(spell_rog_deadly_poison); - class spell_rog_deadly_poison_SpellScript : public SpellScript + bool Load() override { - PrepareSpellScript(spell_rog_deadly_poison_SpellScript); + _stackAmount = 0; + // at this point CastItem must already be initialized + return GetCaster()->GetTypeId() == TYPEID_PLAYER && GetCastItem(); + } - bool Load() override + void HandleBeforeHit(SpellMissInfo missInfo) + { + if (missInfo != SPELL_MISS_NONE) { - _stackAmount = 0; - // at this point CastItem must already be initialized - return GetCaster()->GetTypeId() == TYPEID_PLAYER && GetCastItem(); + return; } - void HandleBeforeHit(SpellMissInfo missInfo) - { - if (missInfo != SPELL_MISS_NONE) - { - return; - } + if (Unit* target = GetHitUnit()) + // Deadly Poison + if (AuraEffect const* aurEff = target->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_ROGUE, 0x10000, 0x80000, 0, GetCaster()->GetGUID())) + _stackAmount = aurEff->GetBase()->GetStackAmount(); + } - if (Unit* target = GetHitUnit()) - // Deadly Poison - if (AuraEffect const* aurEff = target->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_ROGUE, 0x10000, 0x80000, 0, GetCaster()->GetGUID())) - _stackAmount = aurEff->GetBase()->GetStackAmount(); - } + void HandleAfterHit() + { + if (_stackAmount < 5) + return; - void HandleAfterHit() + Player* player = GetCaster()->ToPlayer(); + + if (Unit* target = GetHitUnit()) { - if (_stackAmount < 5) + Item* item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND); + + if (item == GetCastItem()) + item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND); + + if (!item) return; - Player* player = GetCaster()->ToPlayer(); - - if (Unit* target = GetHitUnit()) + // item combat enchantments + for (uint8 slot = 0; slot < MAX_ENCHANTMENT_SLOT; ++slot) { - Item* item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND); + SpellItemEnchantmentEntry const* enchant = sSpellItemEnchantmentStore.LookupEntry(item->GetEnchantmentId(EnchantmentSlot(slot))); + if (!enchant) + continue; - if (item == GetCastItem()) - item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND); - - if (!item) - return; - - // item combat enchantments - for (uint8 slot = 0; slot < MAX_ENCHANTMENT_SLOT; ++slot) + for (uint8 s = 0; s < 3; ++s) { - SpellItemEnchantmentEntry const* enchant = sSpellItemEnchantmentStore.LookupEntry(item->GetEnchantmentId(EnchantmentSlot(slot))); - if (!enchant) + if (enchant->type[s] != ITEM_ENCHANTMENT_TYPE_COMBAT_SPELL) continue; - for (uint8 s = 0; s < 3; ++s) + SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(enchant->spellid[s]); + if (!spellInfo) { - if (enchant->type[s] != ITEM_ENCHANTMENT_TYPE_COMBAT_SPELL) - continue; - - SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(enchant->spellid[s]); - if (!spellInfo) - { - LOG_ERROR("misc", "Player::CastItemCombatSpell Enchant %i, player (Name: %s, %s) cast unknown spell %i", - enchant->ID, player->GetName().c_str(), player->GetGUID().ToString().c_str(), enchant->spellid[s]); - continue; - } - - // Proc only rogue poisons - if (spellInfo->SpellFamilyName != SPELLFAMILY_ROGUE || spellInfo->Dispel != DISPEL_POISON) - continue; - - // Do not reproc deadly - if (spellInfo->SpellFamilyFlags.IsEqual(0x10000, 0x80000, 0)) - continue; - - if (spellInfo->IsPositive()) - player->CastSpell(player, enchant->spellid[s], true, item); - else - player->CastSpell(target, enchant->spellid[s], true, item); + LOG_ERROR("misc", "Player::CastItemCombatSpell Enchant %i, player (Name: %s, %s) cast unknown spell %i", + enchant->ID, player->GetName().c_str(), player->GetGUID().ToString().c_str(), enchant->spellid[s]); + continue; } + + // Proc only rogue poisons + if (spellInfo->SpellFamilyName != SPELLFAMILY_ROGUE || spellInfo->Dispel != DISPEL_POISON) + continue; + + // Do not reproc deadly + if (spellInfo->SpellFamilyFlags.IsEqual(0x10000, 0x80000, 0)) + continue; + + if (spellInfo->IsPositive()) + player->CastSpell(player, enchant->spellid[s], true, item); + else + player->CastSpell(target, enchant->spellid[s], true, item); } } } - - void Register() override - { - BeforeHit += BeforeSpellHitFn(spell_rog_deadly_poison_SpellScript::HandleBeforeHit); - AfterHit += SpellHitFn(spell_rog_deadly_poison_SpellScript::HandleAfterHit); - } - - uint8 _stackAmount; - }; - - SpellScript* GetSpellScript() const override - { - return new spell_rog_deadly_poison_SpellScript(); } + + void Register() override + { + BeforeHit += BeforeSpellHitFn(spell_rog_deadly_poison::HandleBeforeHit); + AfterHit += SpellHitFn(spell_rog_deadly_poison::HandleAfterHit); + } + + uint8 _stackAmount; }; // 51690 - Killing Spree @@ -462,83 +405,80 @@ public: }; // -31130 - Nerves of Steel -class spell_rog_nerves_of_steel : public SpellScriptLoader +class spell_rog_nerves_of_steel : public AuraScript { -public: - spell_rog_nerves_of_steel() : SpellScriptLoader("spell_rog_nerves_of_steel") { } + PrepareAuraScript(spell_rog_nerves_of_steel); - class spell_rog_nerves_of_steel_AuraScript : public AuraScript + uint32 absorbPct; + + bool Load() override { - PrepareAuraScript(spell_rog_nerves_of_steel_AuraScript); + absorbPct = GetSpellInfo()->Effects[EFFECT_0].CalcValue(GetCaster()); + return true; + } - uint32 absorbPct; - - bool Load() override - { - absorbPct = GetSpellInfo()->Effects[EFFECT_0].CalcValue(GetCaster()); - return true; - } - - void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) - { - // Set absorbtion amount to unlimited - amount = -1; - } - - void Absorb(AuraEffect* /*aurEff*/, DamageInfo& dmgInfo, uint32& absorbAmount) - { - // reduces all damage taken while stun or fear - if (GetTarget()->GetUInt32Value(UNIT_FIELD_FLAGS) & (UNIT_FLAG_FLEEING) || (GetTarget()->GetUInt32Value(UNIT_FIELD_FLAGS) & (UNIT_FLAG_STUNNED) && GetTarget()->HasAuraWithMechanic(1 << MECHANIC_STUN))) - absorbAmount = CalculatePct(dmgInfo.GetDamage(), absorbPct); - } - - void Register() override - { - DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_rog_nerves_of_steel_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB); - OnEffectAbsorb += AuraEffectAbsorbFn(spell_rog_nerves_of_steel_AuraScript::Absorb, EFFECT_0); - } - }; - - AuraScript* GetAuraScript() const override + void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) { - return new spell_rog_nerves_of_steel_AuraScript(); + // Set absorbtion amount to unlimited + amount = -1; + } + + void Absorb(AuraEffect* /*aurEff*/, DamageInfo& dmgInfo, uint32& absorbAmount) + { + // reduces all damage taken while stun or fear + if (GetTarget()->GetUInt32Value(UNIT_FIELD_FLAGS) & (UNIT_FLAG_FLEEING) || (GetTarget()->GetUInt32Value(UNIT_FIELD_FLAGS) & (UNIT_FLAG_STUNNED) && GetTarget()->HasAuraWithMechanic(1 << MECHANIC_STUN))) + absorbAmount = CalculatePct(dmgInfo.GetDamage(), absorbPct); + } + + void Register() override + { + DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_rog_nerves_of_steel::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB); + OnEffectAbsorb += AuraEffectAbsorbFn(spell_rog_nerves_of_steel::Absorb, EFFECT_0); } }; // 14185 - Preparation -class spell_rog_preparation : public SpellScriptLoader +class spell_rog_preparation : public SpellScript { -public: - spell_rog_preparation() : SpellScriptLoader("spell_rog_preparation") { } + PrepareSpellScript(spell_rog_preparation); - class spell_rog_preparation_SpellScript : public SpellScript + bool Load() override { - PrepareSpellScript(spell_rog_preparation_SpellScript); + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } - bool Load() override + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo({ SPELL_ROGUE_GLYPH_OF_PREPARATION }); + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Player* caster = GetCaster()->ToPlayer(); + //immediately finishes the cooldown on certain Rogue abilities + + bool hasGlyph = caster->HasAura(SPELL_ROGUE_GLYPH_OF_PREPARATION); + PlayerSpellMap const& spellMap = caster->GetSpellMap(); + for (PlayerSpellMap::const_iterator itr = spellMap.begin(); itr != spellMap.end(); ++itr) { - return GetCaster()->GetTypeId() == TYPEID_PLAYER; - } - - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_ROGUE_GLYPH_OF_PREPARATION }); - } - - void HandleDummy(SpellEffIndex /*effIndex*/) - { - Player* caster = GetCaster()->ToPlayer(); - //immediately finishes the cooldown on certain Rogue abilities - - bool hasGlyph = caster->HasAura(SPELL_ROGUE_GLYPH_OF_PREPARATION); - PlayerSpellMap const& spellMap = caster->GetSpellMap(); - for (PlayerSpellMap::const_iterator itr = spellMap.begin(); itr != spellMap.end(); ++itr) + SpellInfo const* spellInfo = sSpellMgr->AssertSpellInfo(itr->first); + if (spellInfo->SpellFamilyName == SPELLFAMILY_ROGUE) { - SpellInfo const* spellInfo = sSpellMgr->AssertSpellInfo(itr->first); - if (spellInfo->SpellFamilyName == SPELLFAMILY_ROGUE) + if (spellInfo->SpellFamilyFlags[1] & SPELLFAMILYFLAG1_ROGUE_COLDB_SHADOWSTEP || // Cold Blood, Shadowstep + spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_ROGUE_VAN_EVAS_SPRINT) // Vanish, Evasion, Sprint { - if (spellInfo->SpellFamilyFlags[1] & SPELLFAMILYFLAG1_ROGUE_COLDB_SHADOWSTEP || // Cold Blood, Shadowstep - spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_ROGUE_VAN_EVAS_SPRINT) // Vanish, Evasion, Sprint + SpellCooldowns::iterator citr = caster->GetSpellCooldownMap().find(spellInfo->Id); + if (citr != caster->GetSpellCooldownMap().end() && citr->second.needSendToClient) + caster->RemoveSpellCooldown(spellInfo->Id, true); + else + caster->RemoveSpellCooldown(spellInfo->Id, false); + } + else if (hasGlyph) + { + if (spellInfo->SpellFamilyFlags[1] & SPELLFAMILYFLAG1_ROGUE_DISMANTLE || // Dismantle + spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_ROGUE_KICK || // Kick + (spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_ROGUE_BLADE_FLURRY && // Blade Flurry + spellInfo->SpellFamilyFlags[1] & SPELLFAMILYFLAG1_ROGUE_BLADE_FLURRY)) { SpellCooldowns::iterator citr = caster->GetSpellCooldownMap().find(spellInfo->Id); if (citr != caster->GetSpellCooldownMap().end() && citr->second.needSendToClient) @@ -546,276 +486,199 @@ public: else caster->RemoveSpellCooldown(spellInfo->Id, false); } - else if (hasGlyph) - { - if (spellInfo->SpellFamilyFlags[1] & SPELLFAMILYFLAG1_ROGUE_DISMANTLE || // Dismantle - spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_ROGUE_KICK || // Kick - (spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_ROGUE_BLADE_FLURRY && // Blade Flurry - spellInfo->SpellFamilyFlags[1] & SPELLFAMILYFLAG1_ROGUE_BLADE_FLURRY)) - { - SpellCooldowns::iterator citr = caster->GetSpellCooldownMap().find(spellInfo->Id); - if (citr != caster->GetSpellCooldownMap().end() && citr->second.needSendToClient) - caster->RemoveSpellCooldown(spellInfo->Id, true); - else - caster->RemoveSpellCooldown(spellInfo->Id, false); - } - } } } } + } - void Register() override - { - OnEffectHitTarget += SpellEffectFn(spell_rog_preparation_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); - } - }; - - SpellScript* GetSpellScript() const override + void Register() override { - return new spell_rog_preparation_SpellScript(); + OnEffectHitTarget += SpellEffectFn(spell_rog_preparation::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); } }; // -51685 - Prey on the Weak -class spell_rog_prey_on_the_weak : public SpellScriptLoader +class spell_rog_prey_on_the_weak : public AuraScript { -public: - spell_rog_prey_on_the_weak() : SpellScriptLoader("spell_rog_prey_on_the_weak") { } + PrepareAuraScript(spell_rog_prey_on_the_weak); - class spell_rog_prey_on_the_weak_AuraScript : public AuraScript + bool Validate(SpellInfo const* /*spellInfo*/) override { - PrepareAuraScript(spell_rog_prey_on_the_weak_AuraScript); + return ValidateSpellInfo({ SPELL_ROGUE_PREY_ON_THE_WEAK }); + } - bool Validate(SpellInfo const* /*spellInfo*/) override + void HandleEffectPeriodic(AuraEffect const* /*aurEff*/) + { + Unit* target = GetTarget(); + Unit* victim = target->GetVictim(); + if (!victim && target->GetTypeId() == TYPEID_PLAYER) + victim = target->ToPlayer()->GetSelectedUnit(); + + if (victim && (target->GetHealthPct() > victim->GetHealthPct())) { - return ValidateSpellInfo({ SPELL_ROGUE_PREY_ON_THE_WEAK }); - } - - void HandleEffectPeriodic(AuraEffect const* /*aurEff*/) - { - Unit* target = GetTarget(); - Unit* victim = target->GetVictim(); - if (!victim && target->GetTypeId() == TYPEID_PLAYER) - victim = target->ToPlayer()->GetSelectedUnit(); - - if (victim && (target->GetHealthPct() > victim->GetHealthPct())) + if (!target->HasAura(SPELL_ROGUE_PREY_ON_THE_WEAK)) { - if (!target->HasAura(SPELL_ROGUE_PREY_ON_THE_WEAK)) - { - int32 bp = GetSpellInfo()->Effects[EFFECT_0].CalcValue(); - target->CastCustomSpell(target, SPELL_ROGUE_PREY_ON_THE_WEAK, &bp, 0, 0, true); - } + int32 bp = GetSpellInfo()->Effects[EFFECT_0].CalcValue(); + target->CastCustomSpell(target, SPELL_ROGUE_PREY_ON_THE_WEAK, &bp, 0, 0, true); } - else - target->RemoveAurasDueToSpell(SPELL_ROGUE_PREY_ON_THE_WEAK); } + else + target->RemoveAurasDueToSpell(SPELL_ROGUE_PREY_ON_THE_WEAK); + } - void Register() override - { - OnEffectPeriodic += AuraEffectPeriodicFn(spell_rog_prey_on_the_weak_AuraScript::HandleEffectPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY); - } - }; - - AuraScript* GetAuraScript() const override + void Register() override { - return new spell_rog_prey_on_the_weak_AuraScript(); + OnEffectPeriodic += AuraEffectPeriodicFn(spell_rog_prey_on_the_weak::HandleEffectPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY); } }; // -1943 - Rupture -class spell_rog_rupture : public SpellScriptLoader +class spell_rog_rupture : public AuraScript { -public: - spell_rog_rupture() : SpellScriptLoader("spell_rog_rupture") { } + PrepareAuraScript(spell_rog_rupture); - class spell_rog_rupture_AuraScript : public AuraScript + bool Load() override { - PrepareAuraScript(spell_rog_rupture_AuraScript); + Unit* caster = GetCaster(); + return caster && caster->GetTypeId() == TYPEID_PLAYER; + } - bool Load() override + void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& canBeRecalculated) + { + if (Unit* caster = GetCaster()) { - Unit* caster = GetCaster(); - return caster && caster->GetTypeId() == TYPEID_PLAYER; - } + canBeRecalculated = false; - void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& canBeRecalculated) - { - if (Unit* caster = GetCaster()) + float const attackpowerPerCombo[6] = { - canBeRecalculated = false; + 0.0f, + 0.015f, // 1 point: ${($m1 + $b1*1 + 0.015 * $AP) * 4} damage over 8 secs + 0.024f, // 2 points: ${($m1 + $b1*2 + 0.024 * $AP) * 5} damage over 10 secs + 0.03f, // 3 points: ${($m1 + $b1*3 + 0.03 * $AP) * 6} damage over 12 secs + 0.03428571f, // 4 points: ${($m1 + $b1*4 + 0.03428571 * $AP) * 7} damage over 14 secs + 0.0375f // 5 points: ${($m1 + $b1*5 + 0.0375 * $AP) * 8} damage over 16 secs + }; - float const attackpowerPerCombo[6] = - { - 0.0f, - 0.015f, // 1 point: ${($m1 + $b1*1 + 0.015 * $AP) * 4} damage over 8 secs - 0.024f, // 2 points: ${($m1 + $b1*2 + 0.024 * $AP) * 5} damage over 10 secs - 0.03f, // 3 points: ${($m1 + $b1*3 + 0.03 * $AP) * 6} damage over 12 secs - 0.03428571f, // 4 points: ${($m1 + $b1*4 + 0.03428571 * $AP) * 7} damage over 14 secs - 0.0375f // 5 points: ${($m1 + $b1*5 + 0.0375 * $AP) * 8} damage over 16 secs - }; + uint8 cp = caster->ToPlayer()->GetComboPoints(); + if (cp > 5) + cp = 5; - uint8 cp = caster->ToPlayer()->GetComboPoints(); - if (cp > 5) - cp = 5; - - amount += int32(caster->GetTotalAttackPowerValue(BASE_ATTACK) * attackpowerPerCombo[cp]); - } + amount += int32(caster->GetTotalAttackPowerValue(BASE_ATTACK) * attackpowerPerCombo[cp]); } + } - void Register() override - { - DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_rog_rupture_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE); - } - }; - - AuraScript* GetAuraScript() const override + void Register() override { - return new spell_rog_rupture_AuraScript(); + DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_rog_rupture::CalculateAmount, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE); } }; // 5938 - Shiv -class spell_rog_shiv : public SpellScriptLoader +class spell_rog_shiv : public SpellScript { -public: - spell_rog_shiv() : SpellScriptLoader("spell_rog_shiv") { } + PrepareSpellScript(spell_rog_shiv); - class spell_rog_shiv_SpellScript : public SpellScript + bool Load() override { - PrepareSpellScript(spell_rog_shiv_SpellScript); + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } - bool Load() override - { - return GetCaster()->GetTypeId() == TYPEID_PLAYER; - } - - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_ROGUE_SHIV_TRIGGERED }); - } - - void HandleDummy(SpellEffIndex /*effIndex*/) - { - Unit* caster = GetCaster(); - if (Unit* unitTarget = GetHitUnit()) - caster->CastSpell(unitTarget, SPELL_ROGUE_SHIV_TRIGGERED, true); - } - - void Register() override - { - OnEffectHitTarget += SpellEffectFn(spell_rog_shiv_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); - } - }; - - SpellScript* GetSpellScript() const override + bool Validate(SpellInfo const* /*spellInfo*/) override { - return new spell_rog_shiv_SpellScript(); + return ValidateSpellInfo({ SPELL_ROGUE_SHIV_TRIGGERED }); + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + if (Unit* unitTarget = GetHitUnit()) + caster->CastSpell(unitTarget, SPELL_ROGUE_SHIV_TRIGGERED, true); + } + + void Register() override + { + OnEffectHitTarget += SpellEffectFn(spell_rog_shiv::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); } }; // 57934 - Tricks of the Trade -class spell_rog_tricks_of_the_trade : public SpellScriptLoader +class spell_rog_tricks_of_the_trade : public AuraScript { -public: - spell_rog_tricks_of_the_trade() : SpellScriptLoader("spell_rog_tricks_of_the_trade") { } + PrepareAuraScript(spell_rog_tricks_of_the_trade); - class spell_rog_tricks_of_the_trade_AuraScript : public AuraScript + bool Validate(SpellInfo const* /*spellInfo*/) override { - PrepareAuraScript(spell_rog_tricks_of_the_trade_AuraScript); - - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_ROGUE_TRICKS_OF_THE_TRADE_DMG_BOOST, SPELL_ROGUE_TRICKS_OF_THE_TRADE_PROC }); - } - - bool Load() override - { - _redirectTarget = nullptr; - return true; - } - - void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) - { - if (GetTargetApplication()->GetRemoveMode() != AURA_REMOVE_BY_DEFAULT) - GetTarget()->ResetRedirectThreat(); - } - - bool CheckProc(ProcEventInfo& /*eventInfo*/) - { - _redirectTarget = GetTarget()->GetRedirectThreatTarget(); - return _redirectTarget; - } - - void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& /*eventInfo*/) - { - PreventDefaultAction(); - - Unit* target = GetTarget(); - target->CastSpell(_redirectTarget, SPELL_ROGUE_TRICKS_OF_THE_TRADE_DMG_BOOST, true); - target->CastSpell(target, SPELL_ROGUE_TRICKS_OF_THE_TRADE_PROC, true); - Remove(AURA_REMOVE_BY_DEFAULT); // maybe handle by proc charges - } - - void Register() override - { - AfterEffectRemove += AuraEffectRemoveFn(spell_rog_tricks_of_the_trade_AuraScript::OnRemove, EFFECT_1, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL); - DoCheckProc += AuraCheckProcFn(spell_rog_tricks_of_the_trade_AuraScript::CheckProc); - OnEffectProc += AuraEffectProcFn(spell_rog_tricks_of_the_trade_AuraScript::HandleProc, EFFECT_1, SPELL_AURA_DUMMY); - } - - private: - Unit* _redirectTarget; - }; - - AuraScript* GetAuraScript() const override - { - return new spell_rog_tricks_of_the_trade_AuraScript(); + return ValidateSpellInfo({ SPELL_ROGUE_TRICKS_OF_THE_TRADE_DMG_BOOST, SPELL_ROGUE_TRICKS_OF_THE_TRADE_PROC }); } + + bool Load() override + { + _redirectTarget = nullptr; + return true; + } + + void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + { + if (GetTargetApplication()->GetRemoveMode() != AURA_REMOVE_BY_DEFAULT) + GetTarget()->ResetRedirectThreat(); + } + + bool CheckProc(ProcEventInfo& /*eventInfo*/) + { + _redirectTarget = GetTarget()->GetRedirectThreatTarget(); + return _redirectTarget; + } + + void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& /*eventInfo*/) + { + PreventDefaultAction(); + + Unit* target = GetTarget(); + target->CastSpell(_redirectTarget, SPELL_ROGUE_TRICKS_OF_THE_TRADE_DMG_BOOST, true); + target->CastSpell(target, SPELL_ROGUE_TRICKS_OF_THE_TRADE_PROC, true); + Remove(AURA_REMOVE_BY_DEFAULT); // maybe handle by proc charges + } + + void Register() override + { + AfterEffectRemove += AuraEffectRemoveFn(spell_rog_tricks_of_the_trade::OnRemove, EFFECT_1, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL); + DoCheckProc += AuraCheckProcFn(spell_rog_tricks_of_the_trade::CheckProc); + OnEffectProc += AuraEffectProcFn(spell_rog_tricks_of_the_trade::HandleProc, EFFECT_1, SPELL_AURA_DUMMY); + } + +private: + Unit* _redirectTarget; }; // 59628 - Tricks of the Trade (Proc) -class spell_rog_tricks_of_the_trade_proc : public SpellScriptLoader +class spell_rog_tricks_of_the_trade_proc : public AuraScript { -public: - spell_rog_tricks_of_the_trade_proc() : SpellScriptLoader("spell_rog_tricks_of_the_trade_proc") { } + PrepareAuraScript(spell_rog_tricks_of_the_trade_proc); - class spell_rog_tricks_of_the_trade_proc_AuraScript : public AuraScript + void HandleRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) { - PrepareAuraScript(spell_rog_tricks_of_the_trade_proc_AuraScript); + GetTarget()->ResetRedirectThreat(); + } - void HandleRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) - { - GetTarget()->ResetRedirectThreat(); - } - - void Register() override - { - AfterEffectRemove += AuraEffectRemoveFn(spell_rog_tricks_of_the_trade_proc_AuraScript::HandleRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL); - } - }; - - AuraScript* GetAuraScript() const override + void Register() override { - return new spell_rog_tricks_of_the_trade_proc_AuraScript(); + AfterEffectRemove += AuraEffectRemoveFn(spell_rog_tricks_of_the_trade_proc::HandleRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL); } }; void AddSC_rogue_spell_scripts() { - // Ours - new spell_rog_savage_combat(); - new spell_rog_combat_potency(); - - // Theirs - new spell_rog_blade_flurry(); - new spell_rog_cheat_death(); - new spell_rog_deadly_poison(); + RegisterSpellScript(spell_rog_savage_combat); + RegisterSpellScript(spell_rog_combat_potency); + RegisterSpellScript(spell_rog_blade_flurry); + RegisterSpellScript(spell_rog_cheat_death); + RegisterSpellScript(spell_rog_deadly_poison); new spell_rog_killing_spree(); - new spell_rog_nerves_of_steel(); - new spell_rog_preparation(); - new spell_rog_prey_on_the_weak(); - new spell_rog_rupture(); - new spell_rog_shiv(); - new spell_rog_tricks_of_the_trade(); - new spell_rog_tricks_of_the_trade_proc(); + RegisterSpellScript(spell_rog_nerves_of_steel); + RegisterSpellScript(spell_rog_preparation); + RegisterSpellScript(spell_rog_prey_on_the_weak); + RegisterSpellScript(spell_rog_rupture); + RegisterSpellScript(spell_rog_shiv); + RegisterSpellScript(spell_rog_tricks_of_the_trade); + RegisterSpellScript(spell_rog_tricks_of_the_trade_proc); }