boss_apothecary_hummel.cpp

Go to the documentation of this file.

/*
 * 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 "ScriptMgr.h"
#include "Containers.h"
#include "GridNotifiersImpl.h"
#include "Group.h"
#include "InstanceScript.h"
#include "LFGMgr.h"
#include "Map.h"
#include "MotionMaster.h"
#include "Player.h"
#include "ScriptedCreature.h"
#include "ScriptedGossip.h"
#include "shadowfang_keep.h"
#include "SpellScript.h"
 
enum ApothecarySpells
{
    SPELL_ALLURING_PERFUME       = 68589,
    SPELL_PERFUME_SPRAY          = 68607,
    SPELL_CHAIN_REACTION         = 68821,
    SPELL_SUMMON_TABLE           = 69218,
    SPELL_PERMANENT_FEIGN_DEATH  = 29266,
    SPELL_QUIET_SUICIDE          = 3617,
    SPELL_COLOGNE_SPRAY          = 68948,
    SPELL_VALIDATE_AREA          = 68644,
    SPELL_THROW_COLOGNE          = 68841,
    SPELL_BUNNY_LOCKDOWN         = 69039,
    SPELL_THROW_PERFUME          = 68799,
    SPELL_PERFUME_SPILL          = 68798,
    SPELL_COLOGNE_SPILL          = 68614,
    SPELL_PERFUME_SPILL_DAMAGE   = 68927,
    SPELL_COLOGNE_SPILL_DAMAGE   = 68934
};
 
enum ApothecarySays
{
    SAY_INTRO_0      = 0,
    SAY_INTRO_1      = 1,
    SAY_INTRO_2      = 2,
    SAY_CALL_BAXTER  = 3,
    SAY_CALL_FRYE    = 4,
    SAY_HUMMEL_DEATH = 5,
    SAY_SUMMON_ADDS  = 6,
    SAY_BAXTER_DEATH = 0,
    SAY_FRYE_DEATH   = 0
};
 
enum ApothecaryEvents
{
    EVENT_HUMMEL_SAY_0 = 1,
    EVENT_HUMMEL_SAY_1,
    EVENT_HUMMEL_SAY_2,
    EVENT_START_FIGHT,
    EVENT_CHAIN_REACTION,
    EVENT_PERFUME_SPRAY,
    EVENT_COLOGNE_SPRAY,
    EVENT_CALL_BAXTER,
    EVENT_CALL_FRYE
};
 
enum ApothecaryMisc
{
    ACTION_START_EVENT          = 1,
    ACTION_START_FIGHT          = 2,
    GOSSIP_OPTION_START         = 0,
    GOSSIP_MENU_HUMMEL          = 10847,
    QUEST_YOUVE_BEEN_SERVED     = 14488,
    NPC_APOTHECARY_FRYE         = 36272,
    NPC_APOTHECARY_BAXTER       = 36565,
    NPC_VIAL_BUNNY              = 36530,
    NPC_CROWN_APOTHECARY        = 36885,
    PHASE_ALL                   = 0,
    PHASE_INTRO                 = 1
};
 
Position const BaxterMovePos = { -221.4115f, 2206.825f, 79.93151f, 0.0f };
Position const FryeMovePos = { -196.2483f, 2197.224f, 79.9315f, 0.0f };
 
struct boss_apothecary_hummel : public BossAI
{
    boss_apothecary_hummel(Creature* creature) : BossAI(creature, BOSS_APOTHECARY_HUMMEL), _deadCount(0), _isDead(false) { }
 
    bool OnGossipSelect(Player* player, uint32 menuId, uint32 gossipListId) override
    {
        if (menuId == GOSSIP_MENU_HUMMEL && gossipListId == GOSSIP_OPTION_START)
        {
            me->RemoveNpcFlag(UNIT_NPC_FLAG_GOSSIP);
            CloseGossipMenuFor(player);
            DoAction(ACTION_START_EVENT);
        }
        return false;
    }
 
    void Reset() override
    {
        _Reset();
        _deadCount = 0;
        _isDead = false;
        events.SetPhase(PHASE_ALL);
        me->SetFaction(FACTION_FRIENDLY);
        me->SummonCreatureGroup(1);
    }
 
    void EnterEvadeMode(EvadeReason /*why*/) override
    {
        summons.DespawnAll();
        _EnterEvadeMode();
        _DespawnAtEvade(Seconds(10));
    }
 
    void DoAction(int32 action) override
    {
        if (action == ACTION_START_EVENT && events.IsInPhase(PHASE_ALL))
        {
            events.SetPhase(PHASE_INTRO);
            events.ScheduleEvent(EVENT_HUMMEL_SAY_0, Milliseconds(1));
 
            me->SetImmuneToPC(true);
            me->SetFaction(FACTION_MONSTER);
            DummyEntryCheckPredicate pred;
            summons.DoAction(ACTION_START_EVENT, pred);
        }
    }
 
    void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
    {
        if (damage >= me->GetHealth())
            if (_deadCount < 2)
            {
                damage = me->GetHealth() - 1;
                if (!_isDead)
                {
                    _isDead = true;
                    me->RemoveAurasDueToSpell(SPELL_ALLURING_PERFUME);
                    DoCastSelf(SPELL_PERMANENT_FEIGN_DEATH, true);
                    me->SetUninteractible(true);
                    Talk(SAY_HUMMEL_DEATH);
                }
            }
    }
 
    void SummonedCreatureDies(Creature* summon, Unit* /*killer*/) override
    {
        if (summon->GetEntry() == NPC_APOTHECARY_FRYE || summon->GetEntry() == NPC_APOTHECARY_BAXTER)
            _deadCount++;
 
        if (me->HasAura(SPELL_PERMANENT_FEIGN_DEATH) && _deadCount == 2)
            DoCastSelf(SPELL_QUIET_SUICIDE, true);
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        if (!_isDead)
            Talk(SAY_HUMMEL_DEATH);
 
        events.Reset();
        me->SetUninteractible(false);
        instance->SetBossState(BOSS_APOTHECARY_HUMMEL, DONE);
 
        Map::PlayerList const& players = me->GetMap()->GetPlayers();
        if (!players.empty())
        {
            if (Group* group = players.begin()->GetSource()->GetGroup())
                if (group->isLFGGroup())
                    sLFGMgr->FinishDungeon(group->GetGUID(), 288, me->GetMap());
        }
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim() && !events.IsInPhase(PHASE_INTRO))
            return;
 
        events.Update(diff);
 
        if (me->HasUnitState(UNIT_STATE_CASTING))
            return;
 
        while (uint32 eventId = events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_HUMMEL_SAY_0:
                    Talk(SAY_INTRO_0);
                    events.ScheduleEvent(EVENT_HUMMEL_SAY_1, Seconds(4));
                    break;
                case EVENT_HUMMEL_SAY_1:
                    Talk(SAY_INTRO_1);
                    events.ScheduleEvent(EVENT_HUMMEL_SAY_2, Seconds(4));
                    break;
                case EVENT_HUMMEL_SAY_2:
                    Talk(SAY_INTRO_2);
                    events.ScheduleEvent(EVENT_START_FIGHT, 4s);
                    break;
                case EVENT_START_FIGHT:
                {
                    me->SetImmuneToAll(false);
                    DoZoneInCombat();
                    events.ScheduleEvent(EVENT_CALL_BAXTER, 6s);
                    events.ScheduleEvent(EVENT_CALL_FRYE, 14s);
                    events.ScheduleEvent(EVENT_PERFUME_SPRAY, Milliseconds(3640));
                    events.ScheduleEvent(EVENT_CHAIN_REACTION, 15s);
 
                    Talk(SAY_SUMMON_ADDS);
                    std::vector<Creature*> trashs;
                    me->GetCreatureListWithEntryInGrid(trashs, NPC_CROWN_APOTHECARY);
                    for (Creature* crea : trashs)
                        crea->DespawnOrUnsummon();
 
                    break;
                }
                case EVENT_CALL_BAXTER:
                {
                    Talk(SAY_CALL_BAXTER);
                    EntryCheckPredicate pred(NPC_APOTHECARY_BAXTER);
                    summons.DoAction(ACTION_START_FIGHT, pred);
                    summons.DoZoneInCombat(NPC_APOTHECARY_BAXTER);
                    break;
                }
                case EVENT_CALL_FRYE:
                {
                    Talk(SAY_CALL_FRYE);
                    EntryCheckPredicate pred(NPC_APOTHECARY_FRYE);
                    summons.DoAction(ACTION_START_FIGHT, pred);
                    break;
                }
                case EVENT_PERFUME_SPRAY:
                    DoCastVictim(SPELL_PERFUME_SPRAY);
                    events.Repeat(Milliseconds(3640));
                    break;
                case EVENT_CHAIN_REACTION:
                    DoCastVictim(SPELL_SUMMON_TABLE, true);
                    DoCastAOE(SPELL_CHAIN_REACTION);
                    events.Repeat(Seconds(25));
                    break;
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
 
    void OnQuestReward(Player* /*player*/, Quest const* quest, LootItemType /*type*/, uint32 /*opt*/) override
    {
        if (quest->GetQuestId() == QUEST_YOUVE_BEEN_SERVED)
            DoAction(ACTION_START_EVENT);
    }
 
    private:
        uint8 _deadCount;
        bool _isDead;
};
 
struct npc_apothecary_genericAI : public ScriptedAI
{
    npc_apothecary_genericAI(Creature* creature, Position pos) : ScriptedAI(creature), _movePos(pos) { }
 
    void DoAction(int32 action) override
    {
        if (action == ACTION_START_EVENT)
        {
            me->SetImmuneToPC(true);
            me->SetFaction(FACTION_MONSTER);
            me->GetMotionMaster()->MovePoint(1, _movePos);
        }
        else if (action == ACTION_START_FIGHT)
        {
            me->SetImmuneToAll(false);
            DoZoneInCombat();
        }
    }
 
    void MovementInform(uint32 type, uint32 pointId) override
    {
        if (type == POINT_MOTION_TYPE && pointId == 1)
            me->SetEmoteState(EMOTE_STATE_USE_STANDING);
    }
 
protected:
    Position _movePos;
};
 
struct npc_apothecary_frye : public npc_apothecary_genericAI
{
    npc_apothecary_frye(Creature* creature) : npc_apothecary_genericAI(creature, FryeMovePos) { }
 
    void JustDied(Unit* /*killer*/) override
    {
        Talk(SAY_FRYE_DEATH);
    }
};
 
struct npc_apothecary_baxter : public npc_apothecary_genericAI
{
    npc_apothecary_baxter(Creature* creature) : npc_apothecary_genericAI(creature, BaxterMovePos) { }
 
    void Reset() override
    {
        _events.Reset();
        _events.ScheduleEvent(EVENT_COLOGNE_SPRAY, 7s);
        _events.ScheduleEvent(EVENT_CHAIN_REACTION, 12s);
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        _events.Reset();
        Talk(SAY_BAXTER_DEATH);
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        _events.Update(diff);
 
        if (me->HasUnitState(UNIT_STATE_CASTING))
            return;
 
        while (uint32 eventId = _events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_COLOGNE_SPRAY:
                    DoCastVictim(SPELL_COLOGNE_SPRAY);
                    _events.Repeat(Seconds(4));
                    break;
                case EVENT_CHAIN_REACTION:
                    DoCastVictim(SPELL_SUMMON_TABLE);
                    DoCastVictim(SPELL_CHAIN_REACTION);
                    _events.Repeat(Seconds(25));
                    break;
                default:
                    break;
            }
        }
    }
 
private:
    EventMap _events;
};
 
// 68965 - [DND] Lingering Fumes Targetting (starter)
class spell_apothecary_lingering_fumes : public SpellScript
{
    void HandleAfterCast()
    {
        Unit* caster = GetCaster();
        if (!caster->IsInCombat() || roll_chance(50))
            return;
 
        std::list<Creature*> triggers;
        caster->GetCreatureListWithEntryInGrid(triggers, NPC_VIAL_BUNNY, 100.0f);
        if (triggers.empty())
            return;
 
        Creature* trigger = Trinity::Containers::SelectRandomContainerElement(triggers);
        caster->GetMotionMaster()->MovePoint(0, trigger->GetPosition());
 
    }
 
    void HandleScript(SpellEffIndex /*effindex*/)
    {
        Unit* caster = GetCaster();
        caster->CastSpell(GetHitUnit(), SPELL_VALIDATE_AREA, true);
    }
 
    void Register() override
    {
        AfterCast += SpellCastFn(spell_apothecary_lingering_fumes::HandleAfterCast);
        OnEffectHitTarget += SpellEffectFn(spell_apothecary_lingering_fumes::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
// 68644 - [DND] Valentine Boss Validate Area
class spell_apothecary_validate_area : public SpellScript
{
    void FilterTargets(std::list<WorldObject*>& targets)
    {
        targets.remove_if(Trinity::UnitAuraCheck(true, SPELL_BUNNY_LOCKDOWN));
        if (targets.empty())
            return;
 
        WorldObject* target = Trinity::Containers::SelectRandomContainerElement(targets);
        targets.clear();
        targets.push_back(target);
    }
 
    void HandleScript(SpellEffIndex /*effindex*/)
    {
        GetHitUnit()->CastSpell(GetHitUnit(), SPELL_BUNNY_LOCKDOWN, true);
        GetCaster()->CastSpell(GetHitUnit(), RAND(SPELL_THROW_COLOGNE, SPELL_THROW_PERFUME), true);
    }
 
    void Register() override
    {
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_apothecary_validate_area::FilterTargets, EFFECT_0, TARGET_UNIT_DEST_AREA_ENTRY);
        OnEffectHitTarget += SpellEffectFn(spell_apothecary_validate_area::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
// 69038 - Throw Cologne
class spell_apothecary_throw_cologne : public SpellScript
{
    void HandleScript(SpellEffIndex /*effindex*/)
    {
        GetHitUnit()->CastSpell(GetHitUnit(), SPELL_COLOGNE_SPILL, true);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_apothecary_throw_cologne::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
// 68966 - Throw Perfume
class spell_apothecary_throw_perfume : public SpellScript
{
    void HandleScript(SpellEffIndex /*effindex*/)
    {
        GetHitUnit()->CastSpell(GetHitUnit(), SPELL_PERFUME_SPILL, true);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_apothecary_throw_perfume::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
// 68798 - Concentrated Alluring Perfume Spill
class spell_apothecary_perfume_spill : public AuraScript
{
    void OnPeriodic(AuraEffect const* /*aurEff*/)
    {
        GetTarget()->CastSpell(GetTarget(), SPELL_PERFUME_SPILL_DAMAGE, true);
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_apothecary_perfume_spill::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
    }
};
 
// 68614 - Concentrated Irresistible Cologne Spill
class spell_apothecary_cologne_spill : public AuraScript
{
    void OnPeriodic(AuraEffect const* /*aurEff*/)
    {
        GetTarget()->CastSpell(GetTarget(), SPELL_COLOGNE_SPILL_DAMAGE, true);
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_apothecary_cologne_spill::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
    }
};
 
void AddSC_boss_apothecary_hummel()
{
    RegisterShadowfangKeepCreatureAI(boss_apothecary_hummel);
    RegisterShadowfangKeepCreatureAI(npc_apothecary_baxter);
    RegisterShadowfangKeepCreatureAI(npc_apothecary_frye);
    RegisterSpellScript(spell_apothecary_lingering_fumes);
    RegisterSpellScript(spell_apothecary_validate_area);
    RegisterSpellScript(spell_apothecary_throw_cologne);
    RegisterSpellScript(spell_apothecary_throw_perfume);
    RegisterSpellScript(spell_apothecary_perfume_spill);
    RegisterSpellScript(spell_apothecary_cologne_spill);
}