zone_storm_peaks.cpp

Go to the documentation of this file.

/*
* This file is part of Project SkyFire https://www.projectskyfire.org. 
* See LICENSE.md file for Copyright information
*/
 
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "ScriptedGossip.h"
#include "ScriptedEscortAI.h"
#include "SpellScript.h"
#include "SpellAuraEffects.h"
#include "Vehicle.h"
#include "CombatAI.h"
#include "Player.h"
#include "WorldSession.h"

 
enum InjuredGoblinMiner
{
    QUEST_BITTER_DEPARTURE     = 12832,
    SAY_QUEST_ACCEPT           = 0,
    SAY_END_WP_REACHED         = 1,
    GOSSIP_ID                  = 9859,
    GOSSIP_OPTION_ID           = 0
};
 
class npc_injured_goblin : public CreatureScript
{
public:
    npc_injured_goblin() : CreatureScript("npc_injured_goblin") { }
 
    struct npc_injured_goblinAI : public npc_escortAI
    {
        npc_injured_goblinAI(Creature* creature) : npc_escortAI(creature) { }
 
        void WaypointReached(uint32 waypointId) OVERRIDE
        {
            Player* player = GetPlayerForEscort();
            if (!player)
                return;
 
            switch (waypointId)
            {
                case 26:
                    Talk(SAY_END_WP_REACHED, player);
                    break;
                case 27:
                    player->GroupEventHappens(QUEST_BITTER_DEPARTURE, me);
                    break;
            }
        }
 
        void EnterCombat(Unit* /*who*/) OVERRIDE { }
 
        void Reset() OVERRIDE { }
 
        void JustDied(Unit* /*killer*/) OVERRIDE
        {
            Player* player = GetPlayerForEscort();
            if (HasEscortState(STATE_ESCORT_ESCORTING) && player)
                player->FailQuest(QUEST_BITTER_DEPARTURE);
        }
 
       void UpdateAI(uint32 uiDiff) OVERRIDE
        {
            npc_escortAI::UpdateAI(uiDiff);
            if (!UpdateVictim())
                return;
            DoMeleeAttackIfReady();
        }
 
        void sGossipSelect(Player* player, uint32 sender, uint32 action) OVERRIDE
        {
            if (sender == GOSSIP_ID && action == GOSSIP_OPTION_ID)
            {
                player->CLOSE_GOSSIP_MENU();
                me->setFaction(113);
                npc_escortAI::Start(true, true, player->GetGUID());
            }
        }
    };
 
    CreatureAI* GetAI(Creature* creature) const OVERRIDE
    {
        return new npc_injured_goblinAI(creature);
    }
 
    bool OnQuestAccept(Player* /*player*/, Creature* creature, Quest const* quest) OVERRIDE
    {
        if (quest->GetQuestId() == QUEST_BITTER_DEPARTURE)
            creature->AI()->Talk(SAY_QUEST_ACCEPT);
 
        return false;
    }
};
 
/*######
## npc_roxi_ramrocket
######*/
 
enum RoxiRamrocket
{
    SPELL_MECHANO_HOG               = 60866,
    SPELL_MEKGINEERS_CHOPPER        = 60867
};
 
class npc_roxi_ramrocket : public CreatureScript
{
public:
    npc_roxi_ramrocket() : CreatureScript("npc_roxi_ramrocket") { }
 
    bool OnGossipHello(Player* player, Creature* creature) OVERRIDE
    {
        //Quest Menu
        if (creature->IsQuestGiver())
            player->PrepareQuestMenu(creature->GetGUID());
 
        //Trainer Menu
        if ( creature->IsTrainer() )
            player->ADD_GOSSIP_ITEM(GOSSIP_ICON_TRAINER, GOSSIP_TEXT_TRAIN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRAIN);
 
        //Vendor Menu
        if ( creature->IsVendor() )
            if (player->HasSpell(SPELL_MECHANO_HOG) || player->HasSpell(SPELL_MEKGINEERS_CHOPPER))
                player->ADD_GOSSIP_ITEM(GOSSIP_ICON_VENDOR, GOSSIP_TEXT_BROWSE_GOODS, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRADE);
 
        player->SEND_GOSSIP_MENU(player->GetGossipTextId(creature), creature->GetGUID());
        return true;
    }
 
    bool OnGossipSelect(Player* player, Creature* creature, uint32 /*sender*/, uint32 action) OVERRIDE
    {
        player->PlayerTalkClass->ClearMenus();
        switch (action)
        {
        case GOSSIP_ACTION_TRAIN:
            player->GetSession()->SendTrainerList(creature->GetGUID());
            break;
        case GOSSIP_ACTION_TRADE:
            player->GetSession()->SendListInventory(creature->GetGUID());
            break;
        }
        return true;
    }
};
 
/*######
## npc_brunnhildar_prisoner
######*/
 
enum BrunnhildarPrisoner {
    SPELL_ICE_PRISON           = 54894,
    SPELL_ICE_LANCE            = 55046,
    SPELL_FREE_PRISONER        = 55048,
    SPELL_RIDE_DRAKE           = 55074,
    SPELL_SHARD_IMPACT         = 55047
};
 
class npc_brunnhildar_prisoner : public CreatureScript
{
public:
    npc_brunnhildar_prisoner() : CreatureScript("npc_brunnhildar_prisoner") { }
 
    struct npc_brunnhildar_prisonerAI : public ScriptedAI
    {
        npc_brunnhildar_prisonerAI(Creature* creature) : ScriptedAI(creature) { }
 
        bool freed;
 
        void Reset() OVERRIDE
        {
            freed = false;
            me->CastSpell(me, SPELL_ICE_PRISON, true);
        }
 
        void JustRespawned() OVERRIDE
        {
            Reset();
        }
 
        void UpdateAI(uint32 /*diff*/) OVERRIDE
        {
            if (!freed)
                return;
 
            if (!me->GetVehicle())
                me->DespawnOrUnsummon();
        }
 
        void SpellHit(Unit* caster, const SpellInfo* spell) OVERRIDE
        {
            if (spell->Id != SPELL_ICE_LANCE)
                return;
 
            if (caster->GetVehicleKit()->GetAvailableSeatCount() != 0)
            {
                me->CastSpell(me, SPELL_FREE_PRISONER, true);
                me->CastSpell(caster, SPELL_RIDE_DRAKE, true);
                me->CastSpell(me, SPELL_SHARD_IMPACT, true);
                freed = true;
            }
        }
    };
 
    CreatureAI* GetAI(Creature* creature) const OVERRIDE
    {
        return new npc_brunnhildar_prisonerAI(creature);
    }
};
 
/*######
## npc_freed_protodrake
######*/
 
enum FreedProtoDrake
{
    NPC_DRAKE                           = 29709,
 
    AREA_VALLEY_OF_ANCIENT_WINTERS      = 4437,
 
    TEXT_EMOTE                          = 0,
 
    SPELL_KILL_CREDIT_PRISONER          = 55144,
    SPELL_SUMMON_LIBERATED              = 55073,
    SPELL_KILL_CREDIT_DRAKE             = 55143,
 
    EVENT_CHECK_AREA                    = 1,
    EVENT_REACHED_HOME                  = 2,
};
 
class npc_freed_protodrake : public CreatureScript
{
public:
    npc_freed_protodrake() : CreatureScript("npc_freed_protodrake") { }
 
    struct npc_freed_protodrakeAI : public VehicleAI
    {
        npc_freed_protodrakeAI(Creature* creature) : VehicleAI(creature) { }
 
        EventMap events;
 
        void Reset() OVERRIDE
        {
            events.ScheduleEvent(EVENT_CHECK_AREA, 5000);
        }
 
        void MovementInform(uint32 type, uint32 id) OVERRIDE
        {
            if (type != WAYPOINT_MOTION_TYPE)
                return;
 
            if (id == 15)
            // drake reached village
            events.ScheduleEvent(EVENT_REACHED_HOME, 2000);
        }
 
        void UpdateAI(uint32 diff) OVERRIDE
        {
            events.Update(diff);
 
            switch (events.ExecuteEvent())
            {
                case EVENT_CHECK_AREA:
                    if (me->GetAreaId() == AREA_VALLEY_OF_ANCIENT_WINTERS)
                    {
                        if (Vehicle* vehicle = me->GetVehicleKit())
                            if (Unit* passenger = vehicle->GetPassenger(0))
                            {
                                Talk(TEXT_EMOTE, passenger);
                                me->GetMotionMaster()->MovePath(NPC_DRAKE, false);
                            }
                    }
                    else
                        events.ScheduleEvent(EVENT_CHECK_AREA, 5000);
                    break;
                case EVENT_REACHED_HOME:
                    Unit* player = me->GetVehicleKit()->GetPassenger(0);
                    if (player && player->GetTypeId() == TypeID::TYPEID_PLAYER)
                    {
                        // for each prisoner on drake, give credit
                        for (uint8 i = 1; i < 4; ++i)
                            if (Unit* prisoner = me->GetVehicleKit()->GetPassenger(i))
                            {
                                if (prisoner->GetTypeId() != TypeID::TYPEID_UNIT)
                                    return;
                                prisoner->CastSpell(player, SPELL_KILL_CREDIT_PRISONER, true);
                                prisoner->CastSpell(prisoner, SPELL_SUMMON_LIBERATED, true);
                                prisoner->ExitVehicle();
                            }
                        me->CastSpell(me, SPELL_KILL_CREDIT_DRAKE, true);
                        player->ExitVehicle();
                    }
                    break;
            }
        }
    };
 
    CreatureAI* GetAI(Creature* creature) const OVERRIDE
    {
        return new npc_freed_protodrakeAI(creature);
    }
};
 
class npc_icefang : public CreatureScript
{
public:
    npc_icefang() : CreatureScript("npc_icefang") { }
 
    struct npc_icefangAI : public npc_escortAI
    {
        npc_icefangAI(Creature* creature) : npc_escortAI(creature) { }
 
        void AttackStart(Unit* /*who*/) OVERRIDE { }
        void EnterCombat(Unit* /*who*/) OVERRIDE { }
        void EnterEvadeMode() OVERRIDE { }
 
        void PassengerBoarded(Unit* who, int8 /*seatId*/, bool apply) OVERRIDE
        {
            if (who->GetTypeId() == TypeID::TYPEID_PLAYER)
            {
                if (apply)
                    Start(false, true, who->GetGUID());
            }
        }
 
        void WaypointReached(uint32 /*waypointId*/) OVERRIDE
        {
        }
 
        void JustDied(Unit* /*killer*/) OVERRIDE
        {
        }
 
        void OnCharmed(bool /*apply*/) OVERRIDE
        {
        }
 
        void UpdateAI(uint32 diff) OVERRIDE
        {
            npc_escortAI::UpdateAI(diff);
 
            if (!UpdateVictim())
                return;
        }
    };
 
    CreatureAI* GetAI(Creature* creature) const OVERRIDE
    {
        return new npc_icefangAI(creature);
    }
};
 
class npc_hyldsmeet_protodrake : public CreatureScript
{
    enum NPCs
    {
        NPC_HYLDSMEET_DRAKERIDER = 29694
    };
 
    public:
        npc_hyldsmeet_protodrake() : CreatureScript("npc_hyldsmeet_protodrake") { }
 
        class npc_hyldsmeet_protodrakeAI : public CreatureAI
        {
            public:
                npc_hyldsmeet_protodrakeAI(Creature* creature) : CreatureAI(creature), _accessoryRespawnTimer(0), _vehicleKit(creature->GetVehicleKit()) { }
 
                void PassengerBoarded(Unit* who, int8 /*seat*/, bool apply) OVERRIDE
                {
                    if (apply)
                        return;
 
                    if (who->GetEntry() == NPC_HYLDSMEET_DRAKERIDER)
                        _accessoryRespawnTimer = 5 * MINUTE * IN_MILLISECONDS;
                }
 
                void UpdateAI(uint32 diff) OVERRIDE
                {
                    if (_accessoryRespawnTimer && _accessoryRespawnTimer <= diff && _vehicleKit)
                    {
                        _vehicleKit->InstallAllAccessories(true);
                        _accessoryRespawnTimer = 0;
                    }
                    else
                        _accessoryRespawnTimer -= diff;
                }
 
            private:
                uint32 _accessoryRespawnTimer;
                Vehicle* _vehicleKit;
        };
 
        CreatureAI* GetAI(Creature* creature) const OVERRIDE
        {
            return new npc_hyldsmeet_protodrakeAI(creature);
        }
};
 
enum CloseRift
{
    SPELL_DESPAWN_RIFT          = 61665
};
 
class spell_close_rift : public SpellScriptLoader
{
    public:
        spell_close_rift() : SpellScriptLoader("spell_close_rift") { }
 
        class spell_close_rift_AuraScript : public AuraScript
        {
            PrepareAuraScript(spell_close_rift_AuraScript);
 
            bool Load() OVERRIDE
            {
                _counter = 0;
                return true;
            }
 
            bool Validate(SpellInfo const* /*spell*/) OVERRIDE
            {
                return sSpellMgr->GetSpellInfo(SPELL_DESPAWN_RIFT);
            }
 
            void HandlePeriodic(AuraEffect const* /* aurEff */)
            {
                if (++_counter == 5)
                    GetTarget()->CastSpell((Unit*)NULL, SPELL_DESPAWN_RIFT, true);
            }
 
            void Register() OVERRIDE
            {
                OnEffectPeriodic += AuraEffectPeriodicFn(spell_close_rift_AuraScript::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
            }
 
        private:
            uint8 _counter;
        };
 
        AuraScript* GetAuraScript() const OVERRIDE
        {
            return new spell_close_rift_AuraScript();
        }
};
 
void AddSC_storm_peaks()
{
    new npc_injured_goblin();
    new npc_roxi_ramrocket();
    new npc_brunnhildar_prisoner();
    new npc_freed_protodrake();
    new npc_icefang();
    new npc_hyldsmeet_protodrake();
    new spell_close_rift();
}