C++ instance_trial_of_the_crusader::GetSingleCreatureFromStorage方法代码示例

    // Only for Dreadscale and Icehowl
    void DoSummonNextBeast(uint32 uiBeastEntry)
    {
        if (uiBeastEntry == NPC_DREADSCALE)
        {
            if (Creature* pTirion = m_pInstance->GetSingleCreatureFromStorage(NPC_TIRION_A))
                DoScriptText(SAY_TIRION_BEAST_2, pTirion);

            m_creature->SummonCreature(NPC_DREADSCALE, aSpawnPositions[2][0], aSpawnPositions[2][1], aSpawnPositions[2][2], aSpawnPositions[2][3], TEMPSUMMON_DEAD_DESPAWN, 0);
        }
        else
        {
            if (Creature* pTirion = m_pInstance->GetSingleCreatureFromStorage(NPC_TIRION_A))
                DoScriptText(SAY_TIRION_BEAST_3, pTirion);

            m_creature->SummonCreature(NPC_ICEHOWL, aSpawnPositions[4][0], aSpawnPositions[4][1], aSpawnPositions[4][2], aSpawnPositions[4][3], TEMPSUMMON_DEAD_DESPAWN, 0);
        }
    }

 void Aggro(Unit* /*pWho*/) override
 {
     // trigger the controller combat
     if (m_pInstance)
     {
         if (Creature* pStalker = m_pInstance->GetSingleCreatureFromStorage(NPC_BEASTS_COMBAT_STALKER))
             pStalker->SetInCombatWithZone();
     }
 }

    void KilledUnit(Unit* pVictim) override
    {
        if (!m_pInstance)
            return;

        Creature* pSpeaker = m_pInstance->GetSingleCreatureFromStorage(m_pInstance->GetPlayerTeam() == ALLIANCE ? NPC_GARROSH : NPC_VARIAN);
        if (!pSpeaker)
            return;

        switch (urand(0, 3))
        {
            case 0: DoScriptText(m_pInstance->GetPlayerTeam() == ALLIANCE ? SAY_GARROSH_PVP_A_SLAY_1 : SAY_VARIAN_PVP_H_SLAY_1, pSpeaker); break;
            case 1: DoScriptText(m_pInstance->GetPlayerTeam() == ALLIANCE ? SAY_GARROSH_PVP_A_SLAY_2 : SAY_VARIAN_PVP_H_SLAY_2, pSpeaker); break;
            case 2: DoScriptText(m_pInstance->GetPlayerTeam() == ALLIANCE ? SAY_GARROSH_PVP_A_SLAY_3 : SAY_VARIAN_PVP_H_SLAY_3, pSpeaker); break;
            case 3: DoScriptText(m_pInstance->GetPlayerTeam() == ALLIANCE ? SAY_GARROSH_PVP_A_SLAY_4 : SAY_VARIAN_PVP_H_SLAY_4, pSpeaker); break;
        }
    }

    void SummonedCreatureJustDied(Creature* pSummoned) override
    {
        if (!m_pInstance)
            return;

        switch (pSummoned->GetEntry())
        {
            case NPC_GORMOK:
                if (m_uiPhase == PHASE_GORMOK)
                    DoSummonNextBeast(NPC_DREADSCALE);
                break;

            case NPC_DREADSCALE:
            case NPC_ACIDMAW:
                if (m_bFirstWormDied && m_uiPhase == PHASE_WORMS)
                {
                    DoSummonNextBeast(NPC_ICEHOWL);

                    // cast achiev spell if timer is still running
                    if (m_uiWormAchievTimer)
                    {
                        m_creature->CastSpell(m_creature, SPELL_JORMUNGAR_ACHIEV_CREDIT, TRIGGERED_OLD_TRIGGERED);
                        m_uiWormAchievTimer = 0;
                    }
                }
                else
                {
                    m_bFirstWormDied = true;

                    // jormungar brother enrages
                    if (Creature* pWorm = m_pInstance->GetSingleCreatureFromStorage(pSummoned->GetEntry() == NPC_ACIDMAW ? NPC_DREADSCALE : NPC_ACIDMAW))
                    {
                        pWorm->CastSpell(pWorm, SPELL_JORMUNGAR_ENRAGE, TRIGGERED_OLD_TRIGGERED);
                        DoScriptText(EMOTE_JORMUNGAR_ENRAGE, pWorm);
                        m_uiWormAchievTimer = 10000;
                    }
                }
                break;

            case NPC_ICEHOWL:
                m_pInstance->SetData(TYPE_NORTHREND_BEASTS, DONE);
                m_creature->ForcedDespawn();
                break;
        }
    }

    // function that handles the special ability for both twins
    bool DoCastSpecialAbility()
    {
        if (!m_pInstance)
            return false;

        // choose the caster; it always alternates
        Unit* pCaster = NULL;
        uint32 uiSpell = 0;
        uint32 uiShieldSpell = 0;

        if (m_bIsLightTwin)
            pCaster = m_creature;
        else
        {
            Creature* pEydis = m_pInstance->GetSingleCreatureFromStorage(NPC_EYDIS);
            if (!pEydis)
                return false;

            pCaster = pEydis;
        }

        if (!pCaster)
            return false;

        // select and cast ability
        if (m_bIsVortex)
        {
            uiSpell = m_bIsLightTwin ? SPELL_LIGHT_VORTEX : SPELL_DARK_VORTEX;
            pCaster->CastSpell(pCaster, uiSpell, TRIGGERED_NONE);
            DoScriptText(m_bIsLightTwin ? SAY_TO_WHITE : SAY_TO_BLACK, pCaster);
        }
        else
        {
            uiSpell = m_bIsLightTwin ? SPELL_TWINS_PACT_LIGHT : SPELL_TWINS_PACT_DARK;
            uiShieldSpell = m_bIsLightTwin ? SPELL_SHIELD_OF_LIGHTS : SPELL_SHIELD_OF_DARKNESS;
            pCaster->CastSpell(pCaster, uiSpell, TRIGGERED_NONE);
            pCaster->CastSpell(pCaster, uiShieldSpell, TRIGGERED_OLD_TRIGGERED);
            DoScriptText(SAY_COLORSWITCH, pCaster);
        }

        m_bIsVortex = urand(0, 1) ? true : false;
        m_bIsLightTwin = !m_bIsLightTwin;
        return true;
    }

    void UpdateAI(const uint32 uiDiff) override
    {
        if (m_uiNextBeastTimer)
        {
            if (m_uiNextBeastTimer <= uiDiff)
            {
                if (m_uiPhase == PHASE_GORMOK)
                    DoSummonNextBeast(NPC_DREADSCALE);
                else if (m_uiPhase == PHASE_WORMS)
                    DoSummonNextBeast(NPC_ICEHOWL);

                m_uiNextBeastTimer = 0;
            }
            else
                m_uiNextBeastTimer -= uiDiff;
        }

        if (m_uiAttackDelayTimer)
        {
            if (m_uiAttackDelayTimer <= uiDiff)
            {
                // for worm phase, summon brother on aggro
                if (m_uiPhase == PHASE_WORMS)
                {
                    m_creature->SummonCreature(NPC_ACIDMAW, aSpawnPositions[3][0], aSpawnPositions[3][1], aSpawnPositions[3][2], aSpawnPositions[3][3], TEMPSUMMON_DEAD_DESPAWN, 0);
                    m_uiWormPhaseTimer = 45000;
                }

                // start combat
                if (Creature* pBeast = m_creature->GetMap()->GetCreature(m_aSummonedBossGuid[m_uiPhase]))
                {
                    pBeast->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);

                    // first boss doesn't automatically attack
                    if (pBeast->GetEntry() != NPC_GORMOK)
                        pBeast->SetInCombatWithZone();
                }

                m_uiAttackDelayTimer = 0;
            }
            else
                m_uiAttackDelayTimer -= uiDiff;
        }

        if (m_uiBerserkTimer)
        {
            if (m_uiBerserkTimer < uiDiff)
            {
                for (uint8 i = 0; i < 4; ++i)
                {
                    Creature* pBoss = m_creature->GetMap()->GetCreature(m_aSummonedBossGuid[i]);
                    if (pBoss && pBoss->isAlive())
                        pBoss->CastSpell(pBoss, SPELL_BERSERK, TRIGGERED_OLD_TRIGGERED);
                }
            }
            else
                m_uiBerserkTimer -= uiDiff;
        }

        // jormungars phase switch control
        if (m_uiWormPhaseTimer)
        {
            if (m_uiWormPhaseTimer <= uiDiff)
            {
                if (!m_pInstance)
                    return;

                ++m_uiWormPhaseStage;

                switch (m_uiWormPhaseStage)
                {
                    // submerge worms
                    case 1:
                        if (Creature* pWorm = m_pInstance->GetSingleCreatureFromStorage(NPC_ACIDMAW))
                        {
                            if (pWorm->isAlive())
                                SendAIEvent(AI_EVENT_CUSTOM_A, m_creature, pWorm);
                        }
                        if (Creature* pWorm = m_pInstance->GetSingleCreatureFromStorage(NPC_DREADSCALE))
                        {
                            if (pWorm->isAlive())
                                SendAIEvent(AI_EVENT_CUSTOM_A, m_creature, pWorm);
                        }

                        m_uiWormPhaseTimer = 4000;
                        break;

                    // change places
                    case 2:
                        float fX, fY, fZ;
                        if (Creature* pWorm = m_pInstance->GetSingleCreatureFromStorage(NPC_ACIDMAW))
                        {
                            if (pWorm->isAlive())
                            {
                                m_creature->GetRandomPoint(m_creature->GetPositionX(), m_creature->GetPositionY(), m_creature->GetPositionZ(), 45.0f, fX, fY, fZ);
                                pWorm->MonsterMoveWithSpeed(fX, fY, fZ, 7.7f);
                            }
                        }
                        if (Creature* pWorm = m_pInstance->GetSingleCreatureFromStorage(NPC_DREADSCALE))
                        {
//.........这里部分代码省略.........

    void UpdateAI(const uint32 uiDiff) override
    {
        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        // special ability spell
        if (m_uiSpecialAbilityTimer < uiDiff)
        {
            if (DoCastSpecialAbility())
                m_uiSpecialAbilityTimer = 45000;
        }
        else
            m_uiSpecialAbilityTimer -= uiDiff;

        if (m_uiSummonTimer < uiDiff)
        {
            DoCastSpellIfCan(m_creature, SPELL_LIGHT_BULLET_SUMMON_TRIGGER, CAST_TRIGGERED);
            DoCastSpellIfCan(m_creature, SPELL_DARK_BULLET_SUMMON_TRIGGER, CAST_TRIGGERED);
            m_uiSummonTimer = 30000;
        }
        else
            m_uiSummonTimer -= uiDiff;

        // berserk spell
        if (m_uiBerserkTimer)
        {
            if (m_uiBerserkTimer <= uiDiff)
            {
                // handle berserk for both twins
                if (DoCastSpellIfCan(m_creature, SPELL_BERSERK) == CAST_OK)
                {
                    if (m_pInstance)
                    {
                        if (Creature* pEydis = m_pInstance->GetSingleCreatureFromStorage(NPC_EYDIS))
                        {
                            pEydis->CastSpell(pEydis, SPELL_BERSERK, TRIGGERED_OLD_TRIGGERED);
                            DoScriptText(SAY_BERSERK, pEydis);
                        }
                    }

                    DoScriptText(SAY_BERSERK, m_creature);
                    m_uiBerserkTimer = 0;
                }
            }
            else
                m_uiBerserkTimer -= uiDiff;
        }

        if (m_uiTwinSpikeTimer < uiDiff)
        {
            if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_TWIN_SPIKE_LIGHT) == CAST_OK)
                m_uiTwinSpikeTimer = 10000;
        }
        else
            m_uiTwinSpikeTimer -= uiDiff;

        // heroic abilities
        if (m_pInstance && m_pInstance->IsHeroicDifficulty())
        {
            if (m_uiTouchTimer < uiDiff)
            {
                if (DoCastSpellIfCan(m_creature, SPELL_LIGHT_TOUCH) == CAST_OK)
                    m_uiTouchTimer = 20000;
            }
            else
                m_uiTouchTimer -= uiDiff;
        }

        DoMeleeAttackIfReady();
    }