diff options
Diffstat (limited to 'src')
4 files changed, 968 insertions, 0 deletions
diff --git a/src/server/scripts/BrokenIsles/TrialOfValor/boss_guarm.cpp b/src/server/scripts/BrokenIsles/TrialOfValor/boss_guarm.cpp new file mode 100644 index 00000000000..05707e01cb0 --- /dev/null +++ b/src/server/scripts/BrokenIsles/TrialOfValor/boss_guarm.cpp @@ -0,0 +1,823 @@ +/* + * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "AreaTrigger.h" +#include "AreaTriggerAI.h" +#include "Containers.h" +#include "Conversation.h" +#include "CreatureAI.h" +#include "CreatureAIImpl.h" +#include "InstanceScript.h" +#include "Map.h" +#include "MotionMaster.h" +#include "ObjectAccessor.h" +#include "Player.h" +#include "ScriptedCreature.h" +#include "ScriptMgr.h" +#include "SharedDefines.h" +#include "SpellAuras.h" +#include "SpellHistory.h" +#include "SpellScript.h" +#include "TemporarySummon.h" +#include "trial_of_valor.h" + +enum GuarmSpells +{ + SPELL_HELYATOSIS_AURA = 231561, + SPELL_HELYATOSIS_INITIAL_ENERGIZE = 235130, + SPELL_MULTI_HEADED_AURA = 227512, + SPELL_MULTI_HEADED_DAMAGE = 227642, + SPELL_FLASHING_FANGS = 227514, + SPELL_OFF_THE_LEASH = 228201, + + SPELL_FLAME_LICK_SELECTOR = 228226, // triggers 228227 missile + SPELL_SHADOW_LICK_SELECTOR = 228250, // triggers 228251 missile + SPELL_FROST_LICK_SELECTOR = 228246, // triggers 228247 missile + + SPELL_BERSERK = 26662, + SPELL_BERSERK_TRAMPLE_AOE = 232224, + SPELL_BERSERK_CHARGE_AT = 232173, // triggers 232197 + + SPELL_GUARDIANS_BREATH_COLOR_SELECTOR = 228187, + SPELL_GUARDIANS_BREATH_SUMMON_ATS_RGB = 232811, // Red Green Blue + SPELL_GUARDIANS_BREATH_SUMMON_ATS_RBG = 232810, // Red Blue Green + SPELL_GUARDIANS_BREATH_SUMMON_ATS_GRB = 232775, // Green Red Blue + SPELL_GUARDIANS_BREATH_SUMMON_ATS_GBR = 232808, // Green Blue Red + SPELL_GUARDIANS_BREATH_SUMMON_ATS_BRG = 232809, // Blue Red Green + SPELL_GUARDIANS_BREATH_SUMMON_ATS_BGR = 232807, // Blue Green Red + SPELL_GUARDIANS_BREATH_UNK = 227573, + SPELL_GUARDIANS_BREATH_CAST_RGB = 227673, // Red Green Blue + SPELL_GUARDIANS_BREATH_CAST_RBG = 227667, // Red Blue Green + SPELL_GUARDIANS_BREATH_CAST_GRB = 227669, // Green Red Blue + SPELL_GUARDIANS_BREATH_CAST_GBR = 227660, // Green Blue Red + SPELL_GUARDIANS_BREATH_CAST_BRG = 227666, // Blue Red Green + SPELL_GUARDIANS_BREATH_CAST_BGR = 227658, // Blue Green Red + SPELL_FIERY_PHLEGM = 232777, // Red + SPELL_FIERY_PHLEGM_AURA = 228758, + SPELL_SALTY_SPITTLE = 232798, // Green + SPELL_SALTY_SPITTLE_AURA = 228768, + SPELL_DARK_DISCHARGE = 232800, // Blue + SPELL_DARK_DISCHARGE_AURA = 228769, + SPELL_FROTHING_RAGE = 228174, // applied x times where x players not getting hit by breath + + SPELL_ROARING_LEAP_SELECTOR = 227894, // @TODO: requires TARGET_DEST_CASTER_CLUMP_CENTROID + SPELL_ROARING_LEAP_INITIAL_KNOCKBACK = 227883, + SPELL_ROARING_LEAP_JUMP = 229350, // triggers 227902 + SPELL_HEADLONG_CHARGE_INITIAL = 227816, + SPELL_HEADLONG_CHARGE_PERIODIC_DAMAGE = 229480, + SPELL_HEADLONG_CHARGE_DAMAGE = 228344, + SPELL_HEADLONG_CHARGE_AT = 227833, // triggers 227843 + + // Mythic + SPELL_VOLATILE_FOAM_INITIAL = 228824, + SPELL_VOLATILE_FOAM_SELECTOR_RED = 228684, + SPELL_VOLATILE_FOAM_SELECTOR_GREEN = 228809, + SPELL_VOLATILE_FOAM_SELECTOR_BLUE = 228817, +}; + +enum GuarmEvents +{ + EVENT_FLASHING_FANGS = 1, + EVENT_CHECK_ENERGY, + EVENT_LICK, + EVENT_ROARING_LEAP, + EVENT_HEADLONG_CHARGE, + EVENT_OFF_THE_LEASH, + EVENT_VOLATILE_FOAM, + EVENT_BERSERK, +}; + +enum GuarmTalks +{ + TALK_GUARDIANS_BREATH_ANNOUNCE = 0, // |TInterface\Icons\SPELL_FIRE_TWILIGHTFLAMEBREATH.BLP:20|t%s begins to cast |cFFFF0000|Hspell:227573|h[Guardian's Breath]|h|r! + TALK_BERSERK = 1, // %s goes into a berserker rage! +}; + +enum GuarmPoints +{ + POINT_BERSERK_JUMP = 0, + + POINT_HEADLONG_CHARGE = 50, + POINT_HEADLONG_CHARGE_MAX = 53, +}; + +enum GuarmPaths +{ + PATH_HEADLONG_CHARGE1 = (114323 * 100) + 0, + PATH_HEADLONG_CHARGE2 = (114323 * 100) + 1, + PATH_HEADLONG_CHARGE3 = (114323 * 100) + 2, + PATH_HEADLONG_CHARGE4 = (114323 * 100) + 3, + PATH_BERSERK = (114323 * 100) + 4, +}; + +enum GuarmSpellCategories +{ + SPELL_CATEGORY_GUARM = 1152, +}; + +enum GuarmConversations +{ + CONVERSATION_DEATH = 3917 +}; + +enum GuarmActions +{ + ACTION_BREATH_HIT_TARGET = 0, + ACTION_HANDLE_FROTHING_RAGE, +}; + +struct JumpMovePathPair +{ + Position JumpPos; + uint32 PathID; +}; + +JumpMovePathPair const HeadlongChargePairs[] = +{ + { { 478.535f, 446.623f, 4.88632f }, PATH_HEADLONG_CHARGE1 }, + { { 460.708f, 445.918f, 4.91909f }, PATH_HEADLONG_CHARGE2 }, + { { 454.967f, 543.651f, 2.99177f }, PATH_HEADLONG_CHARGE3 }, + { { 475.189f, 543.391f, 3.25487f }, PATH_HEADLONG_CHARGE4 }, +}; + +struct GuardiansBreathSpellPair +{ + uint32 SummonATSpellID; + uint32 CastSpellID; +}; + +GuardiansBreathSpellPair const GuardiansBreathSpellPairs[] = +{ + { SPELL_GUARDIANS_BREATH_SUMMON_ATS_RGB, SPELL_GUARDIANS_BREATH_CAST_RGB }, + { SPELL_GUARDIANS_BREATH_SUMMON_ATS_RBG, SPELL_GUARDIANS_BREATH_CAST_RBG }, + { SPELL_GUARDIANS_BREATH_SUMMON_ATS_GRB, SPELL_GUARDIANS_BREATH_CAST_GRB }, + { SPELL_GUARDIANS_BREATH_SUMMON_ATS_GBR, SPELL_GUARDIANS_BREATH_CAST_GBR }, + { SPELL_GUARDIANS_BREATH_SUMMON_ATS_BRG, SPELL_GUARDIANS_BREATH_CAST_BRG }, + { SPELL_GUARDIANS_BREATH_SUMMON_ATS_BGR, SPELL_GUARDIANS_BREATH_CAST_BGR } +}; + +JumpMovePathPair const BerserkerPair = { { 464.035f, 549.979f, 2.95187f }, PATH_BERSERK }; + +// 114323 - Guarm +struct boss_guarm : public BossAI +{ + boss_guarm(Creature* creature) : BossAI(creature, DATA_GUARM), _lickCount(0), _unitsHitByBreathCount(0) { } + + void JustAppeared() override + { + DoCastAOE(SPELL_MULTI_HEADED_AURA); + me->SetMaxPower(POWER_ENERGY, 100); // power is set to 0 in Creature::UpdateMaxPower + } + + void JustDied(Unit* /*killer*/) override + { + instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me); + + Conversation::CreateConversation(CONVERSATION_DEATH, me, me->GetPosition(), ObjectGuid::Empty); + + _JustDied(); + } + + void EnterEvadeMode(EvadeReason /*why*/) override + { + instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me); + + summons.DespawnAll(); + _EnterEvadeMode(); + _DespawnAtEvade(); + } + + void JustEngagedWith(Unit* who) override + { + BossAI::JustEngagedWith(who); + instance->SendEncounterUnit(ENCOUNTER_FRAME_ENGAGE, me, 1); + + DoCastAOE(SPELL_HELYATOSIS_AURA); + DoCastAOE(SPELL_HELYATOSIS_INITIAL_ENERGIZE); + + events.ScheduleEvent(EVENT_FLASHING_FANGS, 6s); + events.ScheduleEvent(EVENT_LICK, 12s); + events.ScheduleEvent(EVENT_CHECK_ENERGY, 500ms); + events.ScheduleEvent(EVENT_OFF_THE_LEASH, 45s); + + if (GetDifficulty() == DIFFICULTY_MYTHIC_RAID) + { + events.ScheduleEvent(EVENT_VOLATILE_FOAM, 11s); + events.ScheduleEvent(EVENT_BERSERK, 4min + 4s); + } + else if (GetDifficulty() == DIFFICULTY_HEROIC_RAID) + events.ScheduleEvent(EVENT_BERSERK, 5min); + else if (GetDifficulty() == DIFFICULTY_NORMAL_RAID) + events.ScheduleEvent(EVENT_BERSERK, 6min); + else // LFR + events.ScheduleEvent(EVENT_BERSERK, 7min); + } + + void UpdateAI(uint32 diff) override + { + if (!UpdateVictim()) + return; + + events.Update(diff); + + if (me->HasUnitState(UNIT_STATE_CASTING)) + return; + + switch (events.ExecuteEvent()) + { + case EVENT_FLASHING_FANGS: + DoCastVictim(SPELL_FLASHING_FANGS); + events.ScheduleEvent(EVENT_FLASHING_FANGS, 21s + 500ms); + break; + case EVENT_LICK: + _lickCount++; + DoCastAOE(RAND(SPELL_FLAME_LICK_SELECTOR, SPELL_SHADOW_LICK_SELECTOR, SPELL_FROST_LICK_SELECTOR)); + events.ScheduleEvent(EVENT_LICK, (_lickCount % 2) ? 4s : 10s); + break; + case EVENT_CHECK_ENERGY: + { + events.ScheduleEvent(EVENT_CHECK_ENERGY, 500ms); + if (me->GetPower(POWER_ENERGY) < 100) + break; + + _unitsHitByBreathCount = 0; + if (DoCastVictim(SPELL_GUARDIANS_BREATH_COLOR_SELECTOR) == SPELL_CAST_OK) + Talk(TALK_GUARDIANS_BREATH_ANNOUNCE); + + break; + } + case EVENT_ROARING_LEAP: + DoCastAOE(SPELL_ROARING_LEAP_SELECTOR); + break; + case EVENT_HEADLONG_CHARGE: + DoCastAOE(SPELL_HEADLONG_CHARGE_INITIAL); + break; + case EVENT_OFF_THE_LEASH: + DoCastAOE(SPELL_OFF_THE_LEASH); + events.ScheduleEvent(EVENT_OFF_THE_LEASH, 75s); + events.ScheduleEvent(EVENT_ROARING_LEAP, 3s); + events.ScheduleEvent(EVENT_HEADLONG_CHARGE, 13s); + events.CancelEvent(EVENT_FLASHING_FANGS); + events.CancelEvent(EVENT_LICK); + events.CancelEvent(EVENT_VOLATILE_FOAM); + break; + case EVENT_VOLATILE_FOAM: + DoCastAOE(SPELL_VOLATILE_FOAM_INITIAL); + events.ScheduleEvent(EVENT_VOLATILE_FOAM, 22s); + break; + case EVENT_BERSERK: + DoCastAOE(SPELL_BERSERK); + Talk(TALK_BERSERK, me); + events.CancelEvent(EVENT_FLASHING_FANGS); + events.CancelEvent(EVENT_LICK); + me->GetMotionMaster()->Clear(); // remove ChaseMovementGen + me->SetReactState(REACT_PASSIVE); + me->GetMotionMaster()->MoveJump(BerserkerPair.JumpPos, 42.0f, 21.5f, POINT_BERSERK_JUMP); + break; + default: + break; + } + + DoMeleeAttackIfReady(); + } + + void WaypointPathEnded(uint32 /*nodeId*/, uint32 pathId) override + { + me->SetReactState(REACT_AGGRESSIVE); + events.ScheduleEvent(EVENT_FLASHING_FANGS, 16s); + events.ScheduleEvent(EVENT_LICK, 18s); + if (GetDifficulty() == DIFFICULTY_MYTHIC_RAID) + events.ScheduleEvent(EVENT_VOLATILE_FOAM, 20s); + + // Headlong Charge + if (pathId != BerserkerPair.PathID) + { + me->RemoveAurasDueToSpell(SPELL_HEADLONG_CHARGE_PERIODIC_DAMAGE); + me->RemoveAurasDueToSpell(SPELL_HEADLONG_CHARGE_AT); + events.ScheduleEvent(EVENT_ROARING_LEAP, 5s); + } + else // Berserk + { + me->RemoveAurasDueToSpell(SPELL_BERSERK_CHARGE_AT); + } + } + + void MovementInform(uint32 type, uint32 pointId) override + { + if (type == EFFECT_MOTION_TYPE) + { + if (pointId >= POINT_HEADLONG_CHARGE && pointId <= POINT_HEADLONG_CHARGE_MAX) + { + uint32 headlongChargeId = pointId - POINT_HEADLONG_CHARGE; + DoCastAOE(SPELL_HEADLONG_CHARGE_DAMAGE, true); // manually trigger first damage tick + DoCastAOE(SPELL_HEADLONG_CHARGE_PERIODIC_DAMAGE, true); + DoCastAOE(SPELL_HEADLONG_CHARGE_AT, true); + + me->GetMotionMaster()->MovePath(HeadlongChargePairs[headlongChargeId].PathID, false, {}, 35.0f); + } + else if (pointId == POINT_BERSERK_JUMP) + { + DoCastAOE(SPELL_BERSERK_TRAMPLE_AOE); + DoCastAOE(SPELL_BERSERK_CHARGE_AT); + DoCastAOE(SPELL_ROARING_LEAP_INITIAL_KNOCKBACK, true); + + me->GetMotionMaster()->MovePath(BerserkerPair.PathID, false, {}, 35.0f); + } + } + } + + void DoAction(int32 param) override + { + switch (param) + { + case ACTION_BREATH_HIT_TARGET: + _unitsHitByBreathCount++; + break; + case ACTION_HANDLE_FROTHING_RAGE: + { + uint32 engagedPlayers = 0; + for (auto const& itr : me->GetThreatManager().GetUnsortedThreatList()) + { + if (itr->GetVictim()->IsPlayer()) + engagedPlayers++; + } + + uint32 frothingRageStacks = engagedPlayers - _unitsHitByBreathCount; + if (frothingRageStacks > 0) + { + if (Aura* aura = me->GetAura(SPELL_FROTHING_RAGE)) + frothingRageStacks += aura->GetStackAmount(); + me->SetAuraStack(SPELL_FROTHING_RAGE, me, frothingRageStacks); + } + break; + } + default: + break; + } + } + +private: + uint8 _lickCount; + uint8 _unitsHitByBreathCount; +}; + +// 227512 - Multi-Headed +class spell_multi_headed_proc_guarm : public AuraScript +{ + void HandleProc(ProcEventInfo& eventInfo) + { + GetTarget()->CastSpell(eventInfo.GetProcTarget(), SPELL_MULTI_HEADED_DAMAGE); + } + + void Register() override + { + OnProc += AuraProcFn(spell_multi_headed_proc_guarm::HandleProc); + } +}; + +// 227642 - Multi-Headed +class spell_multi_headed_damage_guarm : public SpellScript +{ + void FilterTargets(std::list<WorldObject*>& targets) + { + if (targets.size() < 2) + return; + + targets.sort(Trinity::ObjectDistanceOrderPred(GetExplTargetUnit())); + targets.pop_front(); // skip expl target if multiple players are in range + targets.resize(1); + } + + void Register() override + { + OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_multi_headed_damage_guarm::FilterTargets, EFFECT_1, TARGET_UNIT_DEST_AREA_ENEMY); + } +}; + +// 228226 - Flame Lick +// 228250 - Shadow Lick +// 228246 - Frost Lick +class spell_lick_selector_guarm : public SpellScript +{ + bool Validate(SpellInfo const* spellInfo) override + { + return ValidateSpellInfo({ (uint32)spellInfo->GetEffect(EFFECT_0).BasePoints }) && ValidateSpellEffect({ { spellInfo->Id, EFFECT_0 } }); + } + + void HandleHitTarget(SpellEffIndex /*effIndex*/) + { + GetCaster()->CastSpell(GetHitUnit(), GetEffectValue(), true); + } + + void Register() override + { + OnEffectHitTarget += SpellEffectFn(spell_lick_selector_guarm::HandleHitTarget, EFFECT_0, SPELL_EFFECT_DUMMY); + } +}; + +// 228187 - Guardian's Breath +class spell_guardians_breath_color_selector : public SpellScript +{ + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo( + { + SPELL_GUARDIANS_BREATH_SUMMON_ATS_RGB, + SPELL_GUARDIANS_BREATH_SUMMON_ATS_RBG, + SPELL_GUARDIANS_BREATH_SUMMON_ATS_GRB, + SPELL_GUARDIANS_BREATH_SUMMON_ATS_GBR, + SPELL_GUARDIANS_BREATH_SUMMON_ATS_BRG, + SPELL_GUARDIANS_BREATH_SUMMON_ATS_BGR, + SPELL_GUARDIANS_BREATH_UNK, + SPELL_GUARDIANS_BREATH_CAST_RGB, + SPELL_GUARDIANS_BREATH_CAST_RBG, + SPELL_GUARDIANS_BREATH_CAST_GRB, + SPELL_GUARDIANS_BREATH_CAST_GBR, + SPELL_GUARDIANS_BREATH_CAST_BRG, + SPELL_GUARDIANS_BREATH_CAST_BGR + }); + } + + void HandleHit(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + GuardiansBreathSpellPair const& pair = GuardiansBreathSpellPairs[urand(0, 6)]; + caster->CastSpell(nullptr, pair.CastSpellID); + caster->CastSpell(nullptr, pair.SummonATSpellID); + caster->CastSpell(nullptr, SPELL_GUARDIANS_BREATH_UNK); + } + + void Register() override + { + OnEffectHit += SpellEffectFn(spell_guardians_breath_color_selector::HandleHit, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); + } +}; + +// 227673 - Guardian's Breath +// 227667 - Guardian's Breath +// 227669 - Guardian's Breath +// 227660 - Guardian's Breath +// 227666 - Guardian's Breath +// 227658 - Guardian's Breath +class spell_guardians_breath : public SpellScript +{ + void HandleHit(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + if (!caster->IsAIEnabled()) + return; + + caster->GetAI()->DoAction(ACTION_HANDLE_FROTHING_RAGE); + } + + void Register() override + { + OnEffectHit += SpellEffectFn(spell_guardians_breath::HandleHit, EFFECT_0, SPELL_EFFECT_DUMMY); + } +}; + +/* + Guarm + v + Color: R-- Spell: 232803 AreaTrigger: 13352 + Color: -R- Spell: 232773 AreaTrigger: 13352 + Color: --R Spell: 232804 AreaTrigger: 13352 + Color: G-- Spell: 232774 AreaTrigger: 13353 + Color: -G- Spell: 232805 AreaTrigger: 13353 + Color: --G Spell: 232806 AreaTrigger: 13353 + Color: B-- Spell: 232801 AreaTrigger: 13354 + Color: -B- Spell: 232802 AreaTrigger: 13354 + Color: --B Spell: 232776 AreaTrigger: 13354 +*/ + +// 232803 - Guardian's Breath +// 232773 - Guardian's Breath +// 232804 - Guardian's Breath +// 232774 - Guardian's Breath +// 232805 - Guardian's Breath +// 232806 - Guardian's Breath +// 232801 - Guardian's Breath +// 232802 - Guardian's Breath +// 232776 - Guardian's Breath +template<uint32 ColorSpellId> +class at_guardians_breath : public AreaTriggerEntityScript +{ +public: + at_guardians_breath(char const* script) : AreaTriggerEntityScript(script) { } + + template<uint32 ColorSpell> + struct at_guardians_breathAI : AreaTriggerAI + { + at_guardians_breathAI(AreaTrigger* at) : AreaTriggerAI(at) { } + + uint32 GetBreathDebuffByDamageSpell(uint32 breathDamageSpell) const + { + switch (breathDamageSpell) + { + case SPELL_FIERY_PHLEGM: + return SPELL_FIERY_PHLEGM_AURA; + case SPELL_SALTY_SPITTLE: + return SPELL_SALTY_SPITTLE_AURA; + case SPELL_DARK_DISCHARGE: + return SPELL_DARK_DISCHARGE_AURA; + } + return 0; + } + + void OnRemove() override + { + InstanceScript* instance = at->GetInstanceScript(); + if (!instance) + return; + + Creature* guarm = instance->GetCreature(DATA_GUARM); + if (!guarm) + return; + + if (!guarm->IsAIEnabled()) + return; + + for (ObjectGuid const& guid : at->GetInsideUnits()) + { + Player* player = ObjectAccessor::GetPlayer(*at, guid); + if (!player) + continue; + + if (player->isDead()) + continue; + + guarm->GetAI()->DoAction(ACTION_BREATH_HIT_TARGET); + guarm->CastSpell(player, ColorSpell, true); + player->CastSpell(nullptr, GetBreathDebuffByDamageSpell(ColorSpell)); + } + } + }; + + AreaTriggerAI* GetAI(AreaTrigger* at) const override + { + return new at_guardians_breathAI<ColorSpellId>(at); + } +}; + +// 227720 - Mixed Elements +// 227721 - Mixed Elements +// 227735 - Mixed Elements +template<uint32 SpellId1, uint32 SpellId2> +class spell_mixed_elements : public SpellScript +{ + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo( + { + SpellId1, + SpellId2 + }); + } + + void FilterTargets(std::list<WorldObject*>& targets) + { + targets.remove_if([](WorldObject* target) + { + Player* unit = target->ToPlayer(); + if (!unit) + return true; + + if (!unit->HasAura(SpellId1) || !unit->HasAura(SpellId2)) + return true; + + return false; + }); + } + + void Register() override + { + OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_mixed_elements::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY); + } +}; + +// 227894 - Roaring Leap +class spell_roaring_leap_selector : public SpellScript +{ + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo({ SPELL_ROARING_LEAP_INITIAL_KNOCKBACK, SPELL_ROARING_LEAP_JUMP }); + } + + void HandleHitTarget(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + // @TODO: cast 232036 + implement (achievement) + // @TODO: related to achievement aswell: 232393 + caster->CastSpell(nullptr, SPELL_ROARING_LEAP_INITIAL_KNOCKBACK, true); + caster->CastSpell(*GetHitDest(), SPELL_ROARING_LEAP_JUMP); + } + + void Register() override + { + OnEffectHitTarget += SpellEffectFn(spell_roaring_leap_selector::HandleHitTarget, EFFECT_0, SPELL_EFFECT_DUMMY); + } +}; + +// 227816 - Headlong Charge +class spell_headlong_charge_trigger : public SpellScript +{ + void HandleHit(SpellEffIndex /*effIndex*/) + { + Creature* caster = GetCaster()->ToCreature(); + if (!caster) + return; + + uint8 pairId = urand(0, 3); + caster->GetMotionMaster()->Clear(); // remove ChaseMovementGen + caster->SetReactState(REACT_PASSIVE); + caster->GetMotionMaster()->MoveJump(HeadlongChargePairs[pairId].JumpPos, 42.0f, 21.5f, POINT_HEADLONG_CHARGE + pairId); + } + + void Register() override + { + OnEffectHit += SpellEffectFn(spell_headlong_charge_trigger::HandleHit, EFFECT_0, SPELL_EFFECT_DUMMY); + } +}; + +// 228201 - Off the Leash +class spell_off_the_leash : public AuraScript +{ + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo({ SPELL_HELYATOSIS_AURA }); + } + + void HandleApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/ ) + { + GetTarget()->RemoveAurasDueToSpell(SPELL_HELYATOSIS_AURA); + } + + void HandleRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + { + GetTarget()->CastSpell(nullptr, SPELL_HELYATOSIS_AURA); + } + + void Register() override + { + AfterEffectApply += AuraEffectApplyFn(spell_off_the_leash::HandleApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL); + AfterEffectRemove += AuraEffectApplyFn(spell_off_the_leash::HandleRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL); + } +}; + +// 228824 - Volatile Foam +class spell_volatile_foam_initial : public SpellScript +{ + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo( + { + SPELL_VOLATILE_FOAM_SELECTOR_RED, + SPELL_VOLATILE_FOAM_SELECTOR_GREEN, + SPELL_VOLATILE_FOAM_SELECTOR_BLUE + }); + } + + void HandleHit(SpellEffIndex /*effIndex*/) + { + GetCaster()->CastSpell(nullptr, RAND(SPELL_VOLATILE_FOAM_SELECTOR_RED, SPELL_VOLATILE_FOAM_SELECTOR_GREEN, SPELL_VOLATILE_FOAM_SELECTOR_BLUE)); + } + + void Register() override + { + OnEffectHit += SpellEffectFn(spell_volatile_foam_initial::HandleHit, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); + } +}; + +// 228684 - Volatile Foam // Red +// 228809 - Volatile Foam // Green +// 228817 - Volatile Foam // Blue +template<uint32 ExcludeSpellId> +class spell_volatile_foam_selector : public SpellScript +{ + bool Validate(SpellInfo const* spellInfo) override + { + return ValidateSpellInfo({ (uint32)spellInfo->GetEffect(EFFECT_0).BasePoints }); + } + + void FilterTargets(std::list<WorldObject*>& targets) + { + targets.remove_if([](WorldObject* target) + { + Unit* unit = target->ToUnit(); + if (!unit) + return true; + + if (unit->HasAura(ExcludeSpellId)) + return true; + + return false; + }); + } + + void HandleHitTarget(SpellEffIndex /*effIndex*/) + { + GetCaster()->CastSpell(GetHitUnit(), GetEffectValue(), true); + } + + void Register() override + { + OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_volatile_foam_selector::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY); + OnEffectHitTarget += SpellEffectFn(spell_volatile_foam_selector::HandleHitTarget, EFFECT_0, SPELL_EFFECT_DUMMY); + } +}; + +// 228794 - Flaming Volatile Foam // after dispel +// 228811 - Briney Volatile Foam // after dispel +// 228819 - Shadowy Volatile Foam // after dispel +class spell_volatile_foam : public SpellScript +{ + void FilterTargets(std::list<WorldObject*>& targets) + { + targets.sort(Trinity::ObjectDistanceOrderPred(GetExplTargetUnit())); + } + + void Register() override + { + OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_volatile_foam::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ALLY); + OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_volatile_foam::FilterTargets, EFFECT_1, TARGET_UNIT_SRC_AREA_ALLY); + OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_volatile_foam::FilterTargets, EFFECT_2, TARGET_UNIT_SRC_AREA_ALLY); + } +}; + +// 228744 - Flaming Volatile Foam // initial +// 228794 - Flaming Volatile Foam // after dispel +// 228810 - Briney Volatile Foam // initial +// 228811 - Briney Volatile Foam // after dispel +// 228818 - Shadowy Volatile Foam // initial +// 228819 - Shadowy Volatile Foam // after dispel +template<uint32 SpellIdOnExpire> +class spell_volatile_foam_aura : public AuraScript +{ + bool Validate(SpellInfo const* spellInfo) override + { + return ValidateSpellEffect({ { spellInfo->Id, EFFECT_0 } }) && ValidateSpellInfo( + { + (uint32)spellInfo->GetEffect(EFFECT_0).CalcValue(), // SpellIdOnDispel + SpellIdOnExpire + }); + } + + void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + { + Unit* target = GetTarget(); + + AuraRemoveMode removeMode = GetTargetApplication()->GetRemoveMode(); + if (removeMode == AURA_REMOVE_BY_EXPIRE) + target->CastSpell(target, SpellIdOnExpire); + else if (removeMode == AURA_REMOVE_BY_ENEMY_SPELL) + target->CastSpell(nullptr, GetSpellInfo()->GetEffect(EFFECT_0).CalcValue()); + } + + void Register() override + { + AfterEffectRemove += AuraEffectRemoveFn(spell_volatile_foam_aura::OnRemove, EFFECT_1, SPELL_AURA_PERIODIC_DAMAGE, AURA_EFFECT_HANDLE_REAL); + } +}; + +void AddSC_boss_guarm() +{ + RegisterTrialOfValorCreatureAI(boss_guarm); + RegisterSpellScript(spell_multi_headed_proc_guarm); + RegisterSpellScript(spell_multi_headed_damage_guarm); + RegisterSpellScript(spell_lick_selector_guarm); + RegisterSpellScript(spell_guardians_breath_color_selector); + RegisterSpellScript(spell_guardians_breath); + new at_guardians_breath<SPELL_FIERY_PHLEGM>("at_guardians_breath_red"); + new at_guardians_breath<SPELL_SALTY_SPITTLE>("at_guardians_breath_green"); + new at_guardians_breath<SPELL_DARK_DISCHARGE>("at_guardians_breath_blue"); + RegisterSpellScriptWithArgs((spell_mixed_elements<SPELL_FIERY_PHLEGM_AURA, SPELL_SALTY_SPITTLE_AURA>), "spell_mixed_elements_red_green"); + RegisterSpellScriptWithArgs((spell_mixed_elements<SPELL_FIERY_PHLEGM_AURA, SPELL_DARK_DISCHARGE_AURA>), "spell_mixed_elements_red_blue"); + RegisterSpellScriptWithArgs((spell_mixed_elements<SPELL_SALTY_SPITTLE_AURA, SPELL_DARK_DISCHARGE_AURA>), "spell_mixed_elements_green_blue"); + RegisterSpellScript(spell_roaring_leap_selector); + RegisterSpellScript(spell_headlong_charge_trigger); + RegisterSpellScript(spell_off_the_leash); + RegisterSpellScript(spell_volatile_foam_initial); + RegisterSpellScriptWithArgs(spell_volatile_foam_selector<SPELL_FIERY_PHLEGM_AURA>, "spell_volatile_foam_selector_red"); + RegisterSpellScriptWithArgs(spell_volatile_foam_selector<SPELL_SALTY_SPITTLE_AURA>, "spell_volatile_foam_selector_green"); + RegisterSpellScriptWithArgs(spell_volatile_foam_selector<SPELL_DARK_DISCHARGE_AURA>, "spell_volatile_foam_selector_blue"); + RegisterSpellScriptWithArgs(spell_volatile_foam_aura<SPELL_FIERY_PHLEGM_AURA>, "spell_volatile_foam_aura_initial_red"); + RegisterSpellScriptWithArgs(spell_volatile_foam_aura<SPELL_SALTY_SPITTLE_AURA>, "spell_volatile_foam_aura_initial_green"); + RegisterSpellScriptWithArgs(spell_volatile_foam_aura<SPELL_DARK_DISCHARGE_AURA>, "spell_volatile_foam_aura_initial_blue"); + RegisterSpellAndAuraScriptPairWithArgs(spell_volatile_foam, spell_volatile_foam_aura<SPELL_FIERY_PHLEGM_AURA>, "spell_volatile_foam_aura_red"); + RegisterSpellAndAuraScriptPairWithArgs(spell_volatile_foam, spell_volatile_foam_aura<SPELL_SALTY_SPITTLE_AURA>, "spell_volatile_foam_aura_green"); + RegisterSpellAndAuraScriptPairWithArgs(spell_volatile_foam, spell_volatile_foam_aura<SPELL_DARK_DISCHARGE_AURA>, "spell_volatile_foam_aura_blue"); +} diff --git a/src/server/scripts/BrokenIsles/TrialOfValor/instance_trial_of_valor.cpp b/src/server/scripts/BrokenIsles/TrialOfValor/instance_trial_of_valor.cpp new file mode 100644 index 00000000000..5ff254f78cf --- /dev/null +++ b/src/server/scripts/BrokenIsles/TrialOfValor/instance_trial_of_valor.cpp @@ -0,0 +1,77 @@ +/* + * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "AreaBoundary.h" +#include "InstanceScript.h" +#include "ScriptMgr.h" +#include "trial_of_valor.h" + +BossBoundaryData const boundaries = +{ + { DATA_GUARM, new RectangleBoundary(443.320f, 492.354f, 430.713f, 561.020f) } +}; + +ObjectData const creatureData[] = +{ + { BOSS_ODYN, DATA_ODYN }, + { BOSS_GUARM, DATA_GUARM }, + { BOSS_HELYA, DATA_HELYA }, + { 0, 0 } // END +}; + +DoorData const doorData[] = +{ + { GO_GUARM_BOSS_DOOR_ENTRANCE, DATA_GUARM, DOOR_TYPE_ROOM }, + { GO_GUARM_BOSS_DOOR_EXIT, DATA_GUARM, DOOR_TYPE_PASSAGE }, + { 0, 0, DOOR_TYPE_ROOM } // END +}; + +DungeonEncounterData const encounters[] = +{ + { DATA_ODYN, {{ 1958 }} }, + { DATA_GUARM, {{ 1962 }} }, + { DATA_HELYA, {{ 2008 }} }, +}; + +class instance_trial_of_valor : public InstanceMapScript +{ + public: + instance_trial_of_valor() : InstanceMapScript(TOVScriptName, 1648) { } + + struct instance_trial_of_valor_InstanceMapScript: public InstanceScript + { + instance_trial_of_valor_InstanceMapScript(InstanceMap* map) : InstanceScript(map) + { + SetHeaders(DataHeader); + SetBossNumber(EncounterCount); + LoadObjectData(creatureData, nullptr); + LoadDoorData(doorData); + LoadBossBoundaries(boundaries); + LoadDungeonEncounterData(encounters); + } + }; + + InstanceScript* GetInstanceScript(InstanceMap* map) const override + { + return new instance_trial_of_valor_InstanceMapScript(map); + } +}; + +void AddSC_instance_trial_of_valor() +{ + new instance_trial_of_valor(); +} diff --git a/src/server/scripts/BrokenIsles/TrialOfValor/trial_of_valor.h b/src/server/scripts/BrokenIsles/TrialOfValor/trial_of_valor.h new file mode 100644 index 00000000000..13c16395ad7 --- /dev/null +++ b/src/server/scripts/BrokenIsles/TrialOfValor/trial_of_valor.h @@ -0,0 +1,58 @@ +/* + * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef DEF_AZURE_VAULT_H_ +#define DEF_AZURE_VAULT_H_ + +#include "CreatureAIImpl.h" + +#define DataHeader "TrialOfValor" +#define TOVScriptName "instance_trial_of_valor" + +uint32 const EncounterCount = 3; + +enum TOVDataTypes +{ + // Encounters + DATA_ODYN = 0, + DATA_GUARM, + DATA_HELYA, +}; + +enum TOVCreatureIds +{ + // Bosses + BOSS_ODYN = 114263, + BOSS_GUARM = 114323, + BOSS_HELYA = 114537, +}; + +enum TOVGameObjectIds +{ + GO_GUARM_BOSS_DOOR_ENTRANCE = 266532, + GO_GUARM_BOSS_DOOR_EXIT = 266533, +}; + +template <class AI, class T> +inline AI* GetTrialOfValorAI(T* obj) +{ + return GetInstanceAI<AI>(obj, TOVScriptName); +} + +#define RegisterTrialOfValorCreatureAI(ai_name) RegisterCreatureAIWithFactory(ai_name, GetTrialOfValorAI) + +#endif diff --git a/src/server/scripts/BrokenIsles/broken_isles_script_loader.cpp b/src/server/scripts/BrokenIsles/broken_isles_script_loader.cpp index 0c98885e33a..23c452eb8e5 100644 --- a/src/server/scripts/BrokenIsles/broken_isles_script_loader.cpp +++ b/src/server/scripts/BrokenIsles/broken_isles_script_loader.cpp @@ -16,6 +16,12 @@ */ // This is where scripts' loading functions should be declared: + +// Trial of Valor +void AddSC_boss_guarm(); +void AddSC_instance_trial_of_valor(); + +// Orderhalls void AddSC_orderhall_warrior(); void AddSC_zone_mardum(); @@ -23,6 +29,10 @@ void AddSC_zone_mardum(); // void Add${NameOfDirectory}Scripts() void AddBrokenIslesScripts() { + // Trial of Valor + AddSC_boss_guarm(); + AddSC_instance_trial_of_valor(); + AddSC_orderhall_warrior(); AddSC_zone_mardum(); } |