Esempio n. 1
0
           void HandleImprovedFreeze()
           {
               if (!_didHit)
                   return;

               Unit* owner = GetCaster()->GetOwner();
               if (!owner)
                   return;

               if (AuraEffect* aurEff = owner->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_MAGE, ICON_MAGE_IMPROVED_FREEZE, EFFECT_0))
               {
                   if (roll_chance_i(aurEff->GetAmount()))
                       owner->CastCustomSpell(SPELL_MAGE_FINGERS_OF_FROST, SPELLVALUE_AURA_STACK, 2, owner, true);
               }
           }
Esempio n. 2
0
        void JustDied(Unit* killer) override
        {
            Player* player = killer->ToPlayer();

            if (!player)
                return;

            if (roll_chance_i(20))
            {
                player->CastSpell(me, SPELL_SUMMON_FREED_MIST_WHISPER_SCOUT, true);
                player->KilledMonsterCredit(NPC_MIST_WHISPER_SCOUT);
            }
            else
                player->CastSpell(me, rivenWidowCocoonVictims[urand(0, 10)], true);
        }
Esempio n. 3
0
            void HandleImprovedFlamestrike()
            {
                if (_targetCount >= 2)
                    if (AuraEffect* aurEff = GetCaster()->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_MAGE, ICON_MAGE_IMPROVED_FLAMESTRIKE, EFFECT_0))
                        if (roll_chance_i(aurEff->GetAmount()))
                        {
                            float x, y, z;
                            WorldLocation const* loc = GetExplTargetDest();
                            if (!loc)
                                return;

                            loc->GetPosition(x, y, z);
                            GetCaster()->CastSpell(x, y, z, SPELL_MAGE_FLAMESTRIKE, true);
                        }
            }
Esempio n. 4
0
        void Absorb(AuraEffect* aurEff, DamageInfo & dmgInfo, uint32 & absorbAmount)
        {
            Unit* target = GetTarget();
            if (AuraEffect* talentAurEff = target->GetAuraEffectOfRankedSpell(SPELL_MAGE_FROST_WARDING_R1, EFFECT_0))
            {
                int32 chance = talentAurEff->GetSpellInfo()->Effects[EFFECT_1].CalcValue();

                if (roll_chance_i(chance))
                {
                    absorbAmount = dmgInfo.GetDamage();
                    int32 bp = absorbAmount;
                    target->CastCustomSpell(target, SPELL_MAGE_FROST_WARDING_TRIGGERED, &bp, NULL, NULL, true, NULL, aurEff);
                }
            }
        }
 void HandleOnHit()
 {
     // Fix Sword and Board
     if (Player* _player = GetCaster()->ToPlayer())
     {
         if (Unit* target = GetHitUnit())
         {
             if (roll_chance_i(30))
             {
                 _player->CastSpell(_player, WARRIOR_SPELL_SWORD_AND_BOARD, true);
                 _player->RemoveSpellCooldown(WARRIOR_SPELL_SHIELD_SLAM, true);
             }
         }
     }
 }
Esempio n. 6
0
bool GossipHello_go_ulduar_teleporter(Player* pPlayer, GameObject* pGo)
{
    instance_ulduar* pInstance = (instance_ulduar*)pGo->GetInstanceData();
    if (!pInstance)
        return true;

    if (roll_chance_i(10))
        DoOrSimulateScriptTextForMap(-1603430, 1000103, pGo->GetMap());

    // Base camp
    pPlayer->ADD_GOSSIP_ITEM_ID(GOSSIP_ICON_CHAT, GOSSIP_ITEM_TELE_BASE_CAMP, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF);

    // Formation grounds
    if (pInstance->GetData(TYPE_LEVIATHAN) != NOT_STARTED || pPlayer->isGameMaster())
        pPlayer->ADD_GOSSIP_ITEM_ID(GOSSIP_ICON_CHAT, GOSSIP_ITEM_TELE_FORMATION_GROUNDS, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);

    // Colossal Forge
    if (pInstance->GetData(TYPE_LEVIATHAN) == DONE || pPlayer->isGameMaster())
        pPlayer->ADD_GOSSIP_ITEM_ID(GOSSIP_ICON_CHAT, GOSSIP_ITEM_TELE_COLOSSAL_FORGE, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);

    // Scrapyard
    if ((pInstance->GetData(TYPE_IGNIS) == DONE && pInstance->GetData(TYPE_RAZORSCALE) == DONE && pInstance->GetData(TYPE_XT002) != NOT_STARTED) || pPlayer->isGameMaster())
        pPlayer->ADD_GOSSIP_ITEM_ID(GOSSIP_ICON_CHAT, GOSSIP_ITEM_TELE_SCRAPYARD, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 3);

    // Antechamber
    if (pInstance->GetData(TYPE_XT002) == DONE || pPlayer->isGameMaster())
        pPlayer->ADD_GOSSIP_ITEM_ID(GOSSIP_ICON_CHAT, GOSSIP_ITEM_TELE_ANTECHAMBER, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 4);

    // Shattered walkway
    if (pInstance->GetData(TYPE_KOLOGARN) == DONE || pPlayer->isGameMaster())
        pPlayer->ADD_GOSSIP_ITEM_ID(GOSSIP_ICON_CHAT, GOSSIP_ITEM_TELE_WALKWAY, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 5);

    // Conservatory of life
    if (pInstance->GetData(TYPE_AURIAYA) == DONE || pPlayer->isGameMaster())
        pPlayer->ADD_GOSSIP_ITEM_ID(GOSSIP_ICON_CHAT, GOSSIP_ITEM_TELE_CONSERVATORY, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 6);

    // Spark of imagination
    if (pInstance->GetData(TYPE_MIMIRON) != NOT_STARTED || pPlayer->isGameMaster())
        pPlayer->ADD_GOSSIP_ITEM_ID(GOSSIP_ICON_CHAT, GOSSIP_ITEM_TELE_SPARK_IMAGINATION, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 7);

    // Prison of Yogg-Saron
    if (pInstance->GetData(TYPE_VEZAX) == DONE || pPlayer->isGameMaster())
        pPlayer->ADD_GOSSIP_ITEM_ID(GOSSIP_ICON_CHAT, GOSSIP_ITEM_TELE_YOGG_SARON, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 8);

    pPlayer->SEND_GOSSIP_MENU(pPlayer->GetGossipTextId(pGo->GetGOInfo()->GetGossipMenuId()), pGo->GetGUID());

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

        // Cleave
        if (m_uiCleaveTimer <= uiDiff)
        {
            if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_SHADOW_CLEAVE) == CAST_OK)
                m_uiCleaveTimer = urand(4000, 8000);
        }
        else
            m_uiCleaveTimer -= uiDiff;

        // Necrotic Strike
        if (m_uiNecroticStrikeTimer <= uiDiff)
        {
            if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_NECROTIC_STRIKE) == CAST_OK)
                m_uiNecroticStrikeTimer = urand(5000, 10000);
        }
        else
            m_uiNecroticStrikeTimer -= uiDiff;

        // random transformation
        if (m_uiTransformationTimer <= uiDiff)
        {
            if (roll_chance_i(50))
            {
                if (DoCastSpellIfCan(m_creature, SPELL_DARK_TRANSFORMATION) == CAST_OK)
                {
                    m_creature->SetSpeedRate(MOVE_RUN, 0.5f);
                    m_uiTransformationTimer = HOUR * IN_MILLISECONDS;
                }
            }
            else
            {
                if (DoCastSpellIfCan(m_creature, SPELL_DARK_MARTYRDOM) == CAST_OK)
                {
                    DoCastSpellIfCan(m_creature, SPELL_FANATICS_DETERMINATION, CAST_TRIGGERED);
                    m_uiTransformationTimer = HOUR * IN_MILLISECONDS;
                }
            }
        }
        else
            m_uiTransformationTimer -= uiDiff;

        DoMeleeAttackIfReady();
    }
Esempio n. 8
0
    void AttackedBy(Unit* pAttacker) override
    {
        if (!m_bIsFirstHit)
        {
            if (pAttacker->GetEntry() == NPC_MUTANUS)
                DoScriptText(SAY_MUTANUS, m_creature, pAttacker);
            // Check if already in ritual
            else if (m_uiPoint >= 30)
                DoScriptText(SAY_AGGRO_3, m_creature, pAttacker);
            else
                // Aggro 1 should be in 90% of the cases
                DoScriptText(roll_chance_i(90) ? SAY_AGGRO_1 : SAY_AGGRO_2, m_creature, pAttacker);

            m_bIsFirstHit = true;
        }
    }
            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_FROST_ATTACK:
                            DoCastVictim(SPELL_FROST_ATTACK, true);
                            events.ScheduleEvent(EVENT_FROST_ATTACK, urand(7000, 10000));
                            break;
                        case EVENT_ARCANE_BLAST:
                            DoCastVictim(SPELL_ARCANE_BLAST, true);
                            events.ScheduleEvent(EVENT_ARCANE_BLAST, 15000);
                            break;
                        case EVENT_DRAGONS_BREATH:
                            DoCastVictim(SPELL_DRAGONS_BREATH, true);
                            events.ScheduleEvent(EVENT_DRAGONS_BREATH, urand(12000, 22000));
                            if (roll_chance_i(50))
                                Talk(SAY_DRAGONS_BREATH);
                            break;
                        case EVENT_KNOCKBACK:
                            DoCastVictim(SPELL_KNOCKBACK, true);
                            events.ScheduleEvent(EVENT_KNOCKBACK, urand(15000, 25000));
                            break;
                        case EVENT_SOLARBURN:
                            DoCastVictim(SPELL_SOLARBURN, true);
                            events.ScheduleEvent(EVENT_SOLARBURN, 30000);
                            break;
                        default:
                            break;
                    }

                    if (me->HasUnitState(UNIT_STATE_CASTING))
                        return;
                }

                DoMeleeAttackIfReady();
            }
Esempio n. 10
0
    void DoSummonMushrooms(bool bIsFirstSummon)
    {
        // This implementation may not be 100% accurate;
        // On aggro boss summons about 20 mushrooms; On timer it summons about 5 mushrooms per turn
        // There is a 33% chance that the mushroom will be healthy
        // The summon position is based on the center of the area coords

        float fX, fY, fZ;
        uint32 uiMaxMushrooms = bIsFirstSummon ? 20 : 5;

        for (uint8 i = 0; i < uiMaxMushrooms; ++i)
        {
            uint32 uiMushroomEntry = roll_chance_i(33) ? NPC_HEALTHY_MUSHROOM : NPC_POISONOUS_MUSHROOM;
            m_creature->GetRandomPoint(aMushroomPos[0], aMushroomPos[1], aMushroomPos[2], 30.0f, fX, fY, fZ);
            m_creature->SummonCreature(uiMushroomEntry, fX, fY, fZ, 0.0f, TEMPSUMMON_DEAD_DESPAWN, 0);
        }
    }
            void UpdateAI(uint32 diff)
            {
                if (!me->IsInCombat())
                {
                    events2.Update(diff);
                    if (events2.ExecuteEvent() == EVENT_PHANTOM)
                    {
                        me->CastSpell(me, SPELL_SUMMON_PHANTOM, true);
                        events2.ScheduleEvent(EVENT_PHANTOM, urand(20000, 25000));
                    }
                }

                if (!UpdateVictim())
                return;

                events.Update(diff);
                if (me->HasUnitState(UNIT_STATE_CASTING))
                    return;

                switch (events.ExecuteEvent())
                {
                    case EVENT_GROUND_TREMOR:
                        if (roll_chance_i(50))
                            Talk(SAY_QUAKE);
                        me->CastSpell(me, me->GetDisplayId() != me->GetNativeDisplayId() ? SPELL_QUAKE : SPELL_GROUND_TREMOR, false);
                        events.ScheduleEvent(EVENT_GROUND_TREMOR, 10000);
                        break;
                    case EVENT_NUMBLING_SHOUT:
                        me->CastSpell(me, me->GetDisplayId() != me->GetNativeDisplayId() ? SPELL_NUMBING_ROAR : SPELL_NUMBING_SHOUT, false);
                        events.ScheduleEvent(EVENT_NUMBLING_SHOUT, 10000);
                        break;
                    case EVENT_DETERMINED_STAB:
                        me->CastSpell(me->GetVictim(), me->GetDisplayId() != me->GetNativeDisplayId() ? SPELL_DETERMINED_GORE : SPELL_DETERMINED_STAB, false);
                        events.ScheduleEvent(EVENT_DETERMINED_STAB, 8000);
                        break;
                    case EVENT_TRANSFORMATION:
                        Talk(EMOTE_TRANSFORM);
                        Talk(SAY_TRANSFORM);
                        me->CastSpell(me, SPELL_TRANSFORMATION, false);
                        me->CastSpell(me,SPELL_SUMMON_PHANTOM_TRANSFORM, true);
                        events.ScheduleEvent(EVENT_TRANSFORMATION, 10000);
                        break;
                }

                DoMeleeAttackIfReady();
            }
Esempio n. 12
0
            void HandleAfterHit()
            {
                Unit* target = GetHitUnit();
                Unit* caster = GetCaster();

                if (!caster || !target)
                    return;

                // Remove Mind Spike debuff
                target->RemoveAurasDueToSpell(87178, GetCaster()->GetGUID());

                // Improved Mind blast - Mind Trauma cast
                if (AuraEffect* improvedMindBlast = caster->GetDummyAuraEffect(SPELLFAMILY_PRIEST, 95, EFFECT_1))
                    if (caster->GetShapeshiftForm() == FORM_SHADOW)
                        if (roll_chance_i(improvedMindBlast->GetAmount()))
                            caster->CastSpell(target, 48301, true);
            }
Esempio n. 13
0
            void Absorb(AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount)
            {
                Unit* target = GetTarget();
                if (AuraEffect* talentAurEff = target->GetAuraEffectOfRankedSpell(SPELL_MAGE_FROST_WARDING_R1, EFFECT_0))
                {
                    int32 chance = talentAurEff->GetSpellInfo()->Effects[EFFECT_1].CalcValue(); // SPELL_EFFECT_DUMMY with NO_TARGET

                    if (roll_chance_i(chance))
                    {
                        int32 bp = dmgInfo.GetDamage();
                        dmgInfo.AbsorbDamage(bp);
                        target->CastCustomSpell(target, SPELL_MAGE_FROST_WARDING_TRIGGERED, &bp, NULL, NULL, true, NULL, aurEff);
                        absorbAmount = 0;
                        PreventDefaultAction();
                    }
                }
            }
Esempio n. 14
0
        bool HandleCheckProc(ProcEventInfo& eventInfo)
        {
            Unit const* const caster = GetCaster();
            SpellInfo const* const triggerSpell = eventInfo.GetSpellInfo();

            if (triggerSpell)
            {
                // Prevents proc by damage from the spell itself
                if (triggerSpell->Id != GetId())
                    return true;

                // Sanguinary Vein
                if (AuraEffect const* const aurEff = caster->GetAuraEffectOfRankedSpell(SPELL_SANGUINARY_VEIN, EFFECT_1))
                    if (triggerSpell->GetAuraState() == AURA_STATE_BLEEDING && roll_chance_i(aurEff->GetAmount()))
                        return false;
            }

            return true;
        }
Esempio n. 15
0
        void ReceiveEmote(Player* player, uint32 emote)
        {
            if (following)
                return;

            if (player->HasAura(SPELL_WARTS))
                return;

            if ((player->GetQuestStatus(QUEST_1) == QUEST_STATUS_INCOMPLETE) ||
                    (player->GetQuestStatus(QUEST_2) == QUEST_STATUS_INCOMPLETE) ||
                    (player->GetQuestStatus(QUEST_3) == QUEST_STATUS_INCOMPLETE) ||
                    (player->GetQuestStatus(QUEST_4) == QUEST_STATUS_INCOMPLETE) ||
                    (player->GetQuestStatus(QUEST_5) == QUEST_STATUS_INCOMPLETE) ||
                    (player->GetQuestStatus(QUEST_6) == QUEST_STATUS_INCOMPLETE) ||
                    (player->GetQuestStatus(QUEST_7) == QUEST_STATUS_INCOMPLETE) ||
                    (player->GetQuestStatus(QUEST_8) == QUEST_STATUS_INCOMPLETE) ||
                    (player->GetQuestStatus(QUEST_9) == QUEST_STATUS_INCOMPLETE) ||
                    (player->GetQuestStatus(QUEST_10) == QUEST_STATUS_INCOMPLETE) ||
                    (player->GetQuestStatus(QUEST_11) == QUEST_STATUS_INCOMPLETE) ||
                    (player->GetQuestStatus(QUEST_12) == QUEST_STATUS_INCOMPLETE))
            {
                if (emote == TEXT_EMOTE_KISS && me->IsWithinDistInMap(player, 30.0f))
                {
                    if (!player->HasAura(SPELL_WARTSBGONE_LIP_BALM))
                        player->AddAura(SPELL_WARTS, player);

                    else if (roll_chance_i(10))
                    {
                        if (Creature* maiden = player->SummonCreature(NPC_MAIDEN_OF_ASHWOOD_LAKE, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 30000))
                            maiden->MonsterSay(SAY_FREED, LANG_UNIVERSAL, 0);
                        me->DisappearAndDie();
                    }
                    else
                    {
                        player->RemoveAura(SPELL_WARTSBGONE_LIP_BALM);
                        me->AddAura(SPELL_FROG_LOVE, me);
                        me->GetMotionMaster()->MoveFollow(player, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
                        following = true;
                    }
                }
            }
        }
            void HandleOnHit()
            {
                rolled = false;

                if (Player* _player = GetCaster()->ToPlayer())
                {
                    if (Unit* target = GetHitUnit())
                    {
                        if (_player->HasAura(WARRIOR_SPELL_TASTE_FOR_BLOOD))
                        {
                            if (roll_chance_i(30))
                            {
                                rolled = true;
                                // Increase damage of next Heroic Strike or Slam
                                _player->CastSpell(_player, WARRIOR_SPELL_TASTE_FOR_BLOOD_DAMAGE_DONE, true);
                            }
                        }
                    }
                }
            }
    void DoSummonWave()
    {
        // summoning on all sides
        if (m_bIs25Man)
        {
            // summon 1 fanatic and 2 adherents on right side
            m_creature->SummonCreature(NPC_CULT_ADHERENT, SpawnLoc[1].x, SpawnLoc[1].y, SpawnLoc[1].z, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
            m_creature->SummonCreature(NPC_CULT_FANATIC, SpawnLoc[2].x, SpawnLoc[2].y, SpawnLoc[2].z, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
            m_creature->SummonCreature(NPC_CULT_ADHERENT, SpawnLoc[3].x, SpawnLoc[3].y, SpawnLoc[3].z, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);

            // summon 2 fanatics and 1 adherent on left side
            m_creature->SummonCreature(NPC_CULT_FANATIC, SpawnLoc[4].x, SpawnLoc[4].y, SpawnLoc[4].z, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
            m_creature->SummonCreature(NPC_CULT_ADHERENT, SpawnLoc[5].x, SpawnLoc[5].y, SpawnLoc[5].z, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
            m_creature->SummonCreature(NPC_CULT_FANATIC, SpawnLoc[6].x, SpawnLoc[6].y, SpawnLoc[6].z, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);

            // summon random on stairs
            m_creature->SummonCreature(roll_chance_i(50) ? NPC_CULT_FANATIC : NPC_CULT_ADHERENT, SpawnLoc[8].x, SpawnLoc[8].y, SpawnLoc[8].z, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
        }
        // summoning on 1 side alternatively
        else
        {
            // left side summoning
            if (m_bIsLeftSideSummon)
            {
                // summon 1 fanatic and 2 adherents
                m_creature->SummonCreature(NPC_CULT_ADHERENT, SpawnLoc[1].x, SpawnLoc[1].y, SpawnLoc[1].z, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
                m_creature->SummonCreature(NPC_CULT_FANATIC, SpawnLoc[2].x, SpawnLoc[2].y, SpawnLoc[2].z, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
                m_creature->SummonCreature(NPC_CULT_ADHERENT, SpawnLoc[3].x, SpawnLoc[3].y, SpawnLoc[3].z, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
            }
            else
            {
                // summon 2 fanatics and 1 adherent
                m_creature->SummonCreature(NPC_CULT_FANATIC, SpawnLoc[4].x, SpawnLoc[4].y, SpawnLoc[4].z, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
                m_creature->SummonCreature(NPC_CULT_ADHERENT, SpawnLoc[5].x, SpawnLoc[5].y, SpawnLoc[5].z, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
                m_creature->SummonCreature(NPC_CULT_FANATIC, SpawnLoc[6].x, SpawnLoc[6].y, SpawnLoc[6].z, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
            }

            // change sides for next summoning
            m_bIsLeftSideSummon = !m_bIsLeftSideSummon;
        }
    }
Esempio n. 18
0
    bool OnGossipSelect(Player* player, Creature* creature, uint32 /*sender*/, uint32 action)
    {
        player->PlayerTalkClass->ClearMenus();
        if (action == GOSSIP_ACTION_INFO_DEF+HALLOWEEN_EVENTID && IsEventActive(HALLOWEEN_EVENTID) && !player->HasAura(SPELL_TRICKED_OR_TREATED))
        {
            player->CastSpell(player, SPELL_TRICKED_OR_TREATED, true);
			creature->CastSpell(player, roll_chance_i(50) ? SPELL_TRICK : SPELL_TREAT, true);

            player->CLOSE_GOSSIP_MENU();
            return true;
        }

        player->CLOSE_GOSSIP_MENU();

        switch (action)
        {
            case GOSSIP_ACTION_TRADE: player->GetSession()->SendListInventory(creature->GetGUID()); break;
            case GOSSIP_ACTION_INN: player->SetBindPoint(creature->GetGUID()); break;
        }
        return true;
    }
Esempio n. 19
0
    void UpdateAI(const uint32 uiDiff) override
    {
        DialogueUpdate(uiDiff);

        if (m_uiCrowdSpeechTimer)
        {
            if (m_uiCrowdSpeechTimer <= uiDiff)
            {
                // only 15% chance to yell (guessed)
                if (roll_chance_i(15))
                {
                    if (Creature* pCitizen = m_creature->GetMap()->GetCreature(SelectRandomCrowdNpc()))
                        DoScriptText(aRandomTextEntries[urand(0, MAX_CROWD_TEXT_ENTRIES - 1)], pCitizen);
                }

                m_uiCrowdSpeechTimer = 1000;
            }
            else
                m_uiCrowdSpeechTimer -= uiDiff;
        }
    }
Esempio n. 20
0
            void HandleOnHit()
            {
                if (Unit* caster = GetCaster())
                {
                    if (Unit* target = GetHitUnit())
                    {
						if (caster->GetTypeId() == TYPEID_PLAYER && caster->HasAura(MASTERY_MONK_WINDWALKER))
                        {
							float Mastery = caster->GetFloatValue(PLAYER_MASTERY) * 1.4f;

                            if (roll_chance_f(Mastery))
                            {
                                if (roll_chance_i(50))
                                    caster->CastSpell(caster, MASTERY_SPELL_COMBO_BREAKER_1, true);
                                else
                                    caster->CastSpell(caster, MASTERY_SPELL_COMBO_BREAKER_2, true);
                            }
                        }
                    }
                }
            }
        void ExecuteEvent(uint32 eventId) override
        {
            switch (eventId)
            {
                case EVENT_HATEFUL_BOLT:
                    if (Unit* target = SelectTarget(SELECT_TARGET_MAXTHREAT, 1))
                        DoCast(target, SPELL_HATEFUL_BOLT);
                    events.Repeat(Seconds(7), Seconds(15));
                    break;
                case EVENT_ARCANE_INFUSION:
                    DoCastSelf(SPELL_ARCANE_INFUSION, true);
                    break;
                case EVENT_SUMMON_ASTRAL_FLARE:
                    if (roll_chance_i(50))
                        Talk(SAY_SUMMON);

                    DoCastSelf(RAND(SPELL_SUMMON_ASTRAL_FLARE_NE, SPELL_SUMMON_ASTRAL_FLARE_NW, SPELL_SUMMON_ASTRAL_FLARE_SE, SPELL_SUMMON_ASTRAL_FLARE_SW), true);

                    if (int32 mana = int32(me->GetMaxPower(POWER_MANA) / 10))
                    {
                        me->ModifyPower(POWER_MANA, -mana);

                        if (me->GetPower(POWER_MANA) * 100 / me->GetMaxPower(POWER_MANA) < 10)
                        {
                            Talk(SAY_EVOCATE);
                            me->InterruptNonMeleeSpells(false);
                            DoCastSelf(SPELL_EVOCATION);
                        }
                    }
                    events.Repeat(Seconds(10));
                    break;
                case EVENT_BERSERK:
                    Talk(SAY_ENRAGE);
                    DoCastSelf(SPELL_BERSERK, true);
                    break;
                default:
                    break;
            }
        }
Esempio n. 22
0
        void Absorb(AuraEffect* /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
        {
            Unit* target = GetTarget();
            if (dmgInfo.GetDamage() < target->GetHealth())
                return;
            if (target->ToPlayer()->HasSpellCooldown(ROG_SPELL_CHEAT_DEATH_COOLDOWN))
                return;
            if (!roll_chance_i(absorbChance))
                return;

            target->CastSpell(target, ROG_SPELL_CHEAT_DEATH_COOLDOWN, true);
            target->ToPlayer()->AddSpellCooldown(ROG_SPELL_CHEAT_DEATH_COOLDOWN, 0, time(NULL) + 60);

            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();
        }
Esempio n. 23
0
    void DoHandleBreathYell()
    {
        if (!m_pInstance || !roll_chance_i(25))
            return;

        // Yell on drake breath
        if (Creature* pSkadi = m_pInstance->GetSingleCreatureFromStorage(NPC_SKADI))
        {
            switch (urand(0, 2))
            {
            case 0:
                DoScriptText(SAY_DRAKEBREATH_1, pSkadi);
                break;
            case 1:
                DoScriptText(SAY_DRAKEBREATH_2, pSkadi);
                break;
            case 2:
                DoScriptText(SAY_DRAKEBREATH_3, pSkadi);
                break;
            }
        }
    }
Esempio n. 24
0
 void OnTargetHit(SpellEffIndex effect)
 {
     if (CheckAgain) // Dont re-cast the thing on each target if its already applied
     {
         // Check for Blood and Thunder
         if (Unit* caster = GetCaster())
         {
             if (caster->HasAura(84615) || (caster->HasAura(84614) && roll_chance_i(50))) // Blood and Thunder rank 1 & 2
             {
                 if (Unit* target = GetHitUnit())
                 {
                     if (target->HasAura(94009)) // If the target has Rend
                     {
                         CheckAgain = false;
                         for (std::list<Unit*>::iterator itr = targetList.begin(); itr != targetList.end(); ++itr)
                             if (Unit* curTrg = (*itr))
                                 caster->CastSpell(curTrg, 94009, true);
                     }
                 }
             }
         }
     }
 }
void instance_pit_of_saron::Update(uint32 uiDiff)
{
    DialogueUpdate(uiDiff);

    if (m_uiIciclesTimer)
    {
        if (m_uiIciclesTimer <= uiDiff)
        {
            for (GuidList::const_iterator itr = m_lTunnelStalkersGuidList.begin(); itr != m_lTunnelStalkersGuidList.end(); ++itr)
            {
                // Only 5% of the stalkers will actually spawn an icicle
                if (roll_chance_i(95))
                    continue;

                if (Creature* pStalker = instance->GetCreature(*itr))
                    pStalker->CastSpell(pStalker, SPELL_ICICLE_SUMMON, TRIGGERED_OLD_TRIGGERED);
            }
            m_uiIciclesTimer = urand(3000, 5000);
        }
        else
            m_uiIciclesTimer -= uiDiff;
    }
}
Esempio n. 26
0
        void Absorb(AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount)
        {
            Unit* caster = GetCaster();

            if (!caster)
                return;

            int32 remainingHealth = caster->GetHealth() - dmgInfo.GetDamage();
            int32 cauterizeHeal = caster->CountPctFromMaxHealth(40);

            if (caster->ToPlayer()->HasSpellCooldown(SPELL_MAGE_CAUTERIZE_DAMAGE))
                return;

            if (!roll_chance_i(absorbChance))
                return;

            if (remainingHealth <= 0)
            {
                absorbAmount = dmgInfo.GetDamage();
                caster->CastCustomSpell(caster, SPELL_MAGE_CAUTERIZE_DAMAGE, NULL,&cauterizeHeal, NULL, true, NULL, aurEff);
                caster->ToPlayer()->AddSpellCooldown(SPELL_MAGE_CAUTERIZE_DAMAGE, 0, time(NULL) + 60);
            }
        }
            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_STREAM_OF_MACHINE_FLUID:
                            DoCastVictim(SPELL_STREAM_OF_MACHINE_FLUID, true);
                            events.ScheduleEvent(EVENT_STREAM_OF_MACHINE_FLUID, urand(35000, 50000));
                            break;
                        case EVENT_JACKHAMMER:
                            Talk(EMOTE_HAMMER);
                            /// @todo expect cast this about 5 times in a row (?), announce it by emote only once
                            DoCastVictim(SPELL_JACKHAMMER, true);
                            if (roll_chance_i(50))
                                Talk(SAY_HAMMER);
                            events.ScheduleEvent(EVENT_JACKHAMMER, 30000);
                            break;
                        case EVENT_SHADOW_POWER:
                            DoCast(me, SPELL_SHADOW_POWER);
                            events.ScheduleEvent(EVENT_SHADOW_POWER, urand(20000, 28000));
                            break;
                        default:
                            break;
                    }
                }

                DoMeleeAttackIfReady();
            }
void RandomMovementGenerator<Creature>::_setRandomLocation(Creature& creature)
{
    float destX = i_x;
    float destY = i_y;
    float destZ = i_z;

    creature.addUnitState(UNIT_STAT_ROAMING_MOVE);

    // check if new random position is assigned, GetReachableRandomPosition may fail
    if (creature.GetMap()->GetReachableRandomPosition(&creature, destX, destY, destZ, i_radius))
    {
        Movement::MoveSplineInit init(creature);
        init.MoveTo(destX, destY, destZ, true);
        init.SetWalk(true);
        init.Launch();
        if (roll_chance_i(MOVEMENT_RANDOM_MMGEN_CHANCE_NO_BREAK))
            i_nextMoveTime.Reset(50);
        else
            i_nextMoveTime.Reset(urand(3000, 10000));       // Keep a short wait time
    }
    else
        i_nextMoveTime.Reset(50);                           // Retry later
    return;
}
Esempio n. 29
0
		void ReceiveEmote(Player* pPlayer, uint32 emote)
		{
			if(following) //Si la grenouille a dГ©ja recu un /bisou il ne se passe rien
				return;

			if(emote==TEXTEMOTE_KISS) // Si on fait /bisou
			{
				if(!pPlayer->HasAura(SPELL_WARTSBGONE_LIP_BALM))
					pPlayer->AddAura(SPELL_WARTS,pPlayer);
				else if(roll_chance_i(10)) // 10% de chance de trouver la grenouille
				{
					pPlayer->SummonCreature(NPC_MAIDEN_OF_ASHWOOD_LAKE,me->GetPositionX(),me->GetPositionY(),me->GetPositionZ(),0,TEMPSUMMON_TIMED_DESPAWN,30000);
					me->DisappearAndDie();		//dГ©pop
					me->Respawn(true); //Repop 15 secondes plus tard
				}
				else
				{
					pPlayer->RemoveAura(SPELL_WARTSBGONE_LIP_BALM);	//On enleve le buff mis par l'objet de quete
					me->AddAura(SPELL_FROG_LOVE,me); //On ajoute l'aura a la grenouille (les coeurs)
					StartFollow(pPlayer, 35, NULL); //La grenouille suis le joueur
					following=true;
				}
			}
		}
Esempio n. 30
0
        void SpellHit(Unit* caster, const SpellInfo* spell)
        {
            // Megaworkaround perché la spell 52781 Persuasive Strike non si riesce a castare "Can't do while confused"
            if (/*spell->Id == SPELL_PERSUASIVE_STRIKE &&*/roll_chance_i(60) && caster->GetTypeId() == TYPEID_PLAYER && me->isAlive() && !speechCounter && me->isInCombat() && me->HealthBelowPct(30))
            {
                if (Player* player = caster->ToPlayer())
                {
                    if (player->GetQuestStatus(QUEST_HOW_TO_WIN_FRIENDS) == QUEST_STATUS_INCOMPLETE)
                    {
                        playerGUID = player->GetGUID();
                        speechTimer = 1000;
                        speechCounter = 1;
                        me->setFaction(player->getFaction());
                        me->CombatStop(true);
                        me->GetMotionMaster()->MoveIdle();
                        me->SetReactState(REACT_PASSIVE);
                        DoCastAOE(SPELL_THREAT_PULSE, true);

                        sCreatureTextMgr->SendChat(me, SAY_PERSUADE_RAND, 0, CHAT_MSG_ADDON, LANG_ADDON, TEXT_RANGE_NORMAL, 0, TEAM_OTHER, false, player);
                        Talk(SAY_CRUSADER);
                    }
                }
            }
        }