示例#1
0
    void UpdateAI(const uint32 diff)
    {
        if (IsIntro)
        {
            if (IntroPhaseTimer <= diff)
                DoIntro();
            else IntroPhaseTimer -= diff;

            if (IntroPhase == 3 + 1)
            {
                if (IntroFrostBoltTimer <= diff)
                {
                    if (Madrigosa)
                    {
                        Madrigosa->CastSpell(m_creature, SPELL_INTRO_FROSTBOLT, true);
                        IntroFrostBoltTimer = 2000;
                    }
                } else IntroFrostBoltTimer -= diff;
            }
            DoMeleeAttackIfReady();
        }

        if (!UpdateVictim() || IsIntro)
            return;

        if (SlashTimer <= diff)
        {
            DoCast(m_creature->getVictim(), SPELL_METEOR_SLASH);
            SlashTimer = 11000;
        } else SlashTimer -= diff;

        if (StompTimer <= diff)
        {
            DoScriptText(RAND(YELL_LOVE1,YELL_LOVE2,YELL_LOVE3), m_creature);
            DoCast(m_creature->getVictim(), SPELL_STOMP);
            StompTimer = 30000;
        } else StompTimer -= diff;

        if (BurnTimer <= diff)
        {
            std::list<Unit*> pTargets;
            SelectTargetList(pTargets, 10, SELECT_TARGET_RANDOM, 100, true);
            for (std::list<Unit*>::iterator i = pTargets.begin(); i != pTargets.end(); ++i)
                if(!(*i)->HasAura(SPELL_BURN))
                {
                    (*i)->CastSpell((*i), SPELL_BURN, true);
                    break;
                }
            BurnTimer = urand(60000,180000);
        } else BurnTimer -= diff;

        if (BerserkTimer < diff && !Enraged)
        {
            DoScriptText(YELL_BERSERK, m_creature);
            DoCast(m_creature, SPELL_BERSERK);
            Enraged = true;
        } else BerserkTimer -= diff;

        DoMeleeAttackIfReady();
    }
示例#2
0
        void UpdateAI(const uint32 diff)
        {
            //if(Intro && !IsIntro)
            //    StartIntro();

            if(IsIntro)
            {
                if(IntroPhaseTimer <= diff)
                {
                    DoIntro();
                }else IntroPhaseTimer -= diff;

                if(IntroPhase == 3 + 1){
                    if(IntroFrostBoltTimer <= diff)
                    {
                        if(Madrigosa){
                            Madrigosa->CastSpell(me, SPELL_INTRO_FROSTBOLT, false);
                            IntroFrostBoltTimer = 2000;
                        }
                    }else IntroFrostBoltTimer -= diff;
                }
            }

            if(!UpdateVictim() || IsIntro)
                return;

            if(SlashTimer <= diff)
            {
                DoCast(me->getVictim(), SPELL_METEOR_SLASH);
                SlashTimer = 11000;
            }else SlashTimer -= diff;

            if(StompTimer < diff)
            {
                switch(rand()%3)
                {
                    case 0: DoScriptText(YELL_LOVE1, me); break;
                    case 1: DoScriptText(YELL_LOVE2, me); break;
                    case 2: DoScriptText(YELL_LOVE3, me); break;
                }
                DoCast(me->getVictim(), SPELL_STOMP);
                StompTimer = 30000;
            }else StompTimer -= diff;

            if(BurnTimer <= diff)
            {
                if(Unit *target = SelectTarget(SELECT_TARGET_RANDOM, 0, 200, true))
                    me->CastSpell(target, SPELL_BURN, true);
                BurnTimer = 20000;
            }else BurnTimer -= diff;

            if(BerserkTimer <= diff && !Enraged)
            {
                DoScriptText(YELL_BERSERK, me);
                DoCast(me, SPELL_BERSERK);
                Enraged = true;
            }else BerserkTimer -= diff;

            DoMeleeAttackIfReady();
        }
        void UpdateAI(const uint32 diff)
        {
            if (!Intro && !HasEscortState(STATE_ESCORT_ESCORTING))
            {
                if (EventCheck_Timer <= diff)
                {
                    if (m_pInstance)
                    {
                        if (m_pInstance->GetData(TYPE_OVERSEER) == DONE)
                        {
                            DoIntro();
                            return;
                        }
                    }
                    EventCheck_Timer = 5000;
                    return;
                }
                else
                {
                    EventCheck_Timer -= diff;
                    return;
                }
            }

            npc_escortAI::UpdateAI(diff);

            if (!UpdateVictim())
                return;

            if (me->HasAura(SPELL_BANISH, 0))
            {
                EnterEvadeMode();
                return;
            }

            if (CorrosiveAcid_Timer <= diff)
            {
                DoCast(me->getVictim(), SPELL_CORROSIVE_ACID);
                CorrosiveAcid_Timer = urand(15000, 25000);
            } else CorrosiveAcid_Timer -= diff;

            if (Fear_Timer <= diff)
            {
                DoCast(me, SPELL_FEAR);
                Fear_Timer = urand(20000, 35000);
            } else Fear_Timer -= diff;

            if (IsHeroic())
            {
                if (!Enraged && Enrage_Timer <= diff)
                {
                    DoCast(me, SPELL_ENRAGE);
                    Enraged = true;
                } else Enrage_Timer -= diff;
            }
        }
示例#4
0
    void UpdateAI(const uint32 diff)
    {
        if (!Intro && !IsBeingEscorted)
        {
            if (EventCheck_Timer < diff)
            {
                if (m_pInstance)
                {
                    if (m_pInstance->GetData(TYPE_OVERSEER) == DONE)
                    {
                        DoIntro();
                        return;
                    }
                }
                EventCheck_Timer = 5000;
                return;
            }
            else
            {
                EventCheck_Timer -= diff;
                return;
            }
        }

        npc_escortAI::UpdateAI(diff);

        if (!UpdateVictim())
            return;

        if (m_creature->HasAura(SPELL_BANISH, 0))
        {
            EnterEvadeMode();
            return;
        }

        if (CorrosiveAcid_Timer < diff)
        {
            DoCast(m_creature->getVictim(),SPELL_CORROSIVE_ACID);
            CorrosiveAcid_Timer = 15000 + rand()%10000;
        }else CorrosiveAcid_Timer -= diff;

        if (Fear_Timer < diff)
        {
            DoCast(m_creature,SPELL_FEAR);
            Fear_Timer = 20000 + rand()%15000;
        }else Fear_Timer -= diff;

        if (HeroicMode)
        {
            if (!Enraged && Enrage_Timer < diff)
            {
                DoCast(m_creature,SPELL_ENRAGE);
                Enraged = true;
            }else Enrage_Timer -= diff;
        }
    }
 void DoAction(int32 actionId) override
 {
     if (actionId == ACTION_AMBASSADOR_HELLMAW_INTRO)
         DoIntro();
     else if (actionId == ACTION_AMBASSADOR_HELLMAW_BANISH)
     {
         if (_instance->GetData(DATA_FEL_OVERSEER) && me->HasAura(SPELL_BANISH))
             DoCast(me, SPELL_BANISH, true); // this will not work, because he is immune to banish
     }
 }
    void UpdateAI(const uint32 diff)
    {
        if (!Intro)
        {
            if (EventCheck_Timer <= diff)
            {
                if (pInstance)
                {
                    if (pInstance->GetData(TYPE_OVERSEER) == DONE)
                        DoIntro();
                }
                EventCheck_Timer = 5000;
            } else EventCheck_Timer -= diff;
        }

        if (!me->isInCombat() && !IsBanished)
        {
            //this is where we add MovePoint()
            //DoWhine("I haz no mount!", LANG_UNIVERSAL, NULL);
        }

        if (!UpdateVictim())
            return;

        if (me->HasAura(SPELL_BANISH, 0))
        {
            EnterEvadeMode();
            return;
        }

        if (CorrosiveAcid_Timer <= diff)
        {
            DoCast(me,SPELL_CORROSIVE_ACID);
            CorrosiveAcid_Timer = 25000;
        } else CorrosiveAcid_Timer -= diff;

        if (Fear_Timer <= diff)
        {
            DoCast(me,SPELL_FEAR);
            Fear_Timer = 35000;
        } else Fear_Timer -= diff;

        /*if (HeroicMode)
        {
            if (Enrage_Timer <= diff)
            {
                DoCast(me,SPELL_ENRAGE);
            } else Enrage_Timer -= diff;
        }*/

        DoMeleeAttackIfReady();
    }
    void UpdateAI(const uint32 diff)
    {
        if (!Intro && !HasEscortState(STATE_ESCORT_ESCORTING))
        {
            if (EventCheck_Timer < diff)
            {
                if (m_pInstance)
                {
                    if (m_pInstance->GetData(TYPE_OVERSEER) == DONE)
                    {
                        DoIntro();
                        return;
                    }
                }
                EventCheck_Timer = 5000;
                return;
            }
            else
            {
                EventCheck_Timer -= diff;
                return;
            }
        }

        npc_escortAI::UpdateAI(diff);

        if (!m_creature->SelectHostilTarget() || !m_creature->getVictim())
            return;

        if (CorrosiveAcid_Timer < diff)
        {
            DoCast(m_creature->getVictim(),SPELL_CORROSIVE_ACID);
            CorrosiveAcid_Timer = 15000 + rand()%10000;
        }else CorrosiveAcid_Timer -= diff;

        if (Fear_Timer < diff)
        {
            DoCast(m_creature,SPELL_FEAR);
            Fear_Timer = 20000 + rand()%15000;
        }else Fear_Timer -= diff;

        if (m_bIsHeroicMode)
        {
            if (!Enraged && Enrage_Timer < diff)
            {
                DoCast(m_creature,SPELL_ENRAGE);
                Enraged = true;
            }else Enrage_Timer -= diff;
        }
    }
    void UpdateEscortAI(const uint32 diff)
    {
        if (!Intro && !HasEscortState(STATE_ESCORT_ESCORTING))
        {
            if (EventCheck_Timer < diff)
            {
                if (m_pInstance)
                {
                    if (m_pInstance->GetData(TYPE_OVERSEER) == DONE)
                    {
                        DoIntro();
                        return;
                    }
                }
                EventCheck_Timer = 5000;
                return;
            }
            else
            {
                EventCheck_Timer -= diff;
                return;
            }
        }

        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        if (CorrosiveAcid_Timer < diff)
        {
            DoCastSpellIfCan(m_creature->getVictim(),SPELL_CORROSIVE_ACID);
            CorrosiveAcid_Timer = urand(15000, 25000);
        }else CorrosiveAcid_Timer -= diff;

        if (Fear_Timer < diff)
        {
            DoCastSpellIfCan(m_creature,SPELL_FEAR);
            Fear_Timer = urand(20000, 35000);
        }else Fear_Timer -= diff;

        if (!m_bIsRegularMode)
        {
            if (!Enraged && Enrage_Timer < diff)
            {
                DoCastSpellIfCan(m_creature,SPELL_ENRAGE);
                Enraged = true;
            }else Enrage_Timer -= diff;
        }

        DoMeleeAttackIfReady();
    }
示例#9
0
    void UpdateAI(const uint32 diff)
    {
        if (!Intro)
        {
            if (EventCheck_Timer < diff)
            {
                if (pInstance)
                {
                    if (pInstance->GetData(TYPE_OVERSEER) == DONE)
                        DoIntro();
                }
                EventCheck_Timer = 5000;
            }else EventCheck_Timer -= diff;
        }

        if (!InCombat && !IsBanished)
        {
            //this is where we add MovePoint()
            //DoWhine("I haz no mount!", LANG_UNIVERSAL, NULL);
        }

        if (!m_creature->SelectHostilTarget() || !m_creature->getVictim() )
            return;

        if (CorrosiveAcid_Timer < diff)
        {
            DoCast(m_creature->getVictim(),SPELL_CORROSIVE_ACID);
            CorrosiveAcid_Timer = 15000 + rand()%10000;
        }else CorrosiveAcid_Timer -= diff;

        if (Fear_Timer < diff)
        {
            DoCast(m_creature,SPELL_FEAR);
            Fear_Timer = 20000 + rand()%15000;
        }else Fear_Timer -= diff;

        /*if (HeroicMode)
        {
            if (Enrage_Timer < diff)
            {
                DoCast(m_creature,SPELL_ENRAGE);
            }else Enrage_Timer -= diff;
        }*/

        DoMeleeAttackIfReady();
    }
    void UpdateAI(const uint32 diff)
    {
        if (!pInstance)
            return;

        if (IsBanished)
        {
            if (Banish_Timer < diff)
            {
                DoCast(me, SPELL_BANISH, true);
                Banish_Timer = 40000;
            }
            else
                Banish_Timer -= diff;
        }

        if (!Intro)
        {
            if (EventCheck_Timer <= diff)
            {
                if (pInstance)
                {
                    if (pInstance->GetData(TYPE_RITUALIST) == DONE)
                    {
                        OnPath_Delay = 0;
                        DoIntro();
                    }
                }
                EventCheck_Timer = 5000;
            }
            else EventCheck_Timer -= diff;
        }

        if (!me->IsInCombat() && !IsBanished && !OnPath_Delay)
        {
            me->GetMotionMaster()->MovePath(PATH_PATROL, false);
            OnPath_Delay = 55000;
            patrol = false;
        }

        if (!me->IsInCombat() && !patrol && OnPath_Delay < diff)
        {
            me->GetMotionMaster()->MovePath(PATH_FINAL, true);
            patrol = true;
        }
        else
            OnPath_Delay -= diff;

        if (!UpdateVictim())
            return;

        if (CorrosiveAcid_Timer <= diff)
        {
            DoCast(me, SPELL_CORROSIVE_ACID);
            CorrosiveAcid_Timer = 25000;
        }
        else CorrosiveAcid_Timer -= diff;

        if (Fear_Timer <= diff)
        {
            DoCast(me, SPELL_FEAR);
            Fear_Timer = 35000;
        }
        else Fear_Timer -= diff;

        if (HeroicMode)
        {
            if (Enrage_Timer <= diff)
            {
                DoCast(me,SPELL_ENRAGE);
                Enrage_Timer = 5*MINUTE*1000;
            } else Enrage_Timer -= diff;
        }

        DoMeleeAttackIfReady();
    }
示例#11
0
    void UpdateAI(const uint32 diff)
    {
        if (Intro)
        {
            if (IntroPhaseTimer > diff)
                IntroPhaseTimer = IntroPhaseTimer - diff;
            else
            {
                ++IntroPhase;
                if (Creature* Madrigosa = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_MADRIGOSA) : 0))
                    CAST_AI(npc_madrigosaAI, Madrigosa->AI())->IntroPhase = IntroPhase;

                DoIntro();
            }

            if (IntroPhase == 6 + 1)
            {
                if (IntroAttackTimer < diff)
                {
                    if (Creature* Madrigosa = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_MADRIGOSA) : 0))
                    {
                        Madrigosa->CastSpell(me, SPELL_INTRO_FREEZE, true);
                        DoCast(me, SPELL_INTRO_FROST_BLAST);
                        IntroAttackTimer = 12000;
                    }
                }
                else IntroAttackTimer -= diff;

                if (IntroFrostBoltTimer < diff)
                {
                    if (Creature* Madrigosa = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_MADRIGOSA) : 0))
                    {
                        Madrigosa->SetInCombatState(true, me);
                        Madrigosa->CastSpell(me, SPELL_INTRO_FROSTBOLT, true);
                        IntroFrostBoltTimer = 1100;
                    }
                }
                else IntroFrostBoltTimer -= diff;
            }

            if (IntroPhase == 11 + 1)
            {
                if (IntroAttackTimer < diff)
                {
                    if (Creature* Madrigosa = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_MADRIGOSA) : 0))
                    {
                        me->Attack(Madrigosa, true);
                        me->CastSpell(Madrigosa, 45185, true);
                        IntroAttackTimer = 1700;
                    }
                }
                else IntroAttackTimer -= diff;
            }

            if (!UpdateVictim())
                return;

            if (IntroPhase >= 5 && IntroPhase < 13)
                return;

            DoMeleeAttackIfReady();
            return;
        }

        if (!UpdateVictim())
            return;

        if (SlashTimer <= diff)
        {
            DoCastVictim( SPELL_METEOR_SLASH);
            SlashTimer = 11000;
        }
        else SlashTimer -= diff;

        if (StompTimer <= diff)
        {
            DoScriptText(RAND(YELL_LOVE1, YELL_LOVE2, YELL_LOVE3), me);
            DoCastVictim( SPELL_STOMP);
            StompTimer = 30000;
        }
        else StompTimer -= diff;

        if (BurnTimer <= diff)
        {
            std::list<Unit*> pTargets;
            SelectTargetList(pTargets, 10, SELECT_TARGET_RANDOM, 100, true);
            for (std::list<Unit*>::const_iterator i = pTargets.begin(); i != pTargets.end(); ++i)
                if (!(*i)->HasAura(SPELL_BURN, 0))
                {
                    (*i)->CastSpell((*i), SPELL_BURN, true);
                    break;
                }
            BurnTimer = urand(60000, 180000);
        }
        else BurnTimer -= diff;

        if (BerserkTimer <= diff && !Enraged)
        {
            DoScriptText(YELL_BERSERK, me);
            DoCast(me, SPELL_BERSERK);
            Enraged = true;
        }
        else BerserkTimer -= diff;

        DoMeleeAttackIfReady();
    }
示例#12
0
        void UpdateAI(const uint32 diff)
        {
            if (IsIntro)
            {
                if (IntroPhaseTimer <= diff)
                    DoIntro();
                else IntroPhaseTimer -= diff;

                if (IntroPhase == 3 + 1)
                {
                    if (IntroFrostBoltTimer <= diff)
                    {
                        if (Creature* Madrigosa = Unit::GetCreature(*me, instance ? instance->GetData64(DATA_MADRIGOSA) : 0))
                        {
                            Madrigosa->CastSpell(me, SPELL_INTRO_FROSTBOLT, true);
                            IntroFrostBoltTimer = 2000;
                        }
                    } else IntroFrostBoltTimer -= diff;
                }
                if (!UpdateVictim())
                    return;
                DoMeleeAttackIfReady();
            }

            if (!UpdateVictim() || IsIntro)
                return;

            if (SlashTimer <= diff)
            {
                DoCastVictim(SPELL_METEOR_SLASH);
                SlashTimer = 11000;
            } else SlashTimer -= diff;

            if (StompTimer <= diff)
            {
                Talk(YELL_LOVE);
                DoCastVictim(SPELL_STOMP);
                StompTimer = 30000;
            } else StompTimer -= diff;

            if (BurnTimer <= diff)
            {
                std::list<Unit*> targets;
                SelectTargetList(targets, 10, SELECT_TARGET_RANDOM, 100, true);
                for (std::list<Unit*>::const_iterator i = targets.begin(); i != targets.end(); ++i)
                    if (!(*i)->HasAura(SPELL_BURN))
                    {
                        (*i)->CastSpell((*i), SPELL_BURN, true);
                        break;
                    }
                BurnTimer = urand(60000, 180000);
            } else BurnTimer -= diff;

            if (BerserkTimer < diff && !Enraged)
            {
                Talk(YELL_BERSERK);
                DoCast(me, SPELL_BERSERK);
                Enraged = true;
            } else BerserkTimer -= diff;

            DoMeleeAttackIfReady();
        }
    void UpdateAI(const uint32 diff)
    {
        if (pInstance->GetData(DATA_BRUTALLUS_INTRO_EVENT) == SPECIAL || pInstance->GetData(DATA_BRUTALLUS_INTRO_EVENT) == IN_PROGRESS || IntroPhase == 20)
        {
            if(IntroPhase < 12 && IntroPhase > 14)
            {
                if (CheckGroundTimer < diff)
                {
                    float x, y, z;
                    me->GetPosition(x, y, z);
                    float ground_z = me->GetTerrain()->GetHeight(x, y, MAX_HEIGHT, true);
                    if(z > ground_z)
                        me->GetMap()->CreatureRelocation(me, x, y, z, me->GetOrientation());
                    CheckGroundTimer = 500;
                }
                else
                    CheckGroundTimer -= diff;
            }

            if (IntroPhaseTimer < diff)
                DoIntro();
            else
                IntroPhaseTimer -= diff;

            if (IntroPhase >= 7 && IntroPhase <= 9)
            {
                if (IntroFrostBoltTimer < diff)
                {
                    if(Unit *pMadrigosa = me->GetUnit(pInstance->GetData64(DATA_MADRIGOSA)))
                    {
                        pMadrigosa->CastSpell(me, SPELL_INTRO_FROSTBOLT, false);
                        IntroFrostBoltTimer = 2000;
                    }
                }
                else
                    IntroFrostBoltTimer -= diff;
            }

            DoMeleeAttackIfReady();
            CastNextSpellIfAnyAndReady();
            return;
        }

        if (!UpdateVictim())
            return;

        if (CheckTimer < diff)
        {
            DoZoneInCombat();

            me->SetSpeed(MOVE_RUN, 2.0f);
            CheckTimer = 1000;
        }
        else
            CheckTimer -= diff;

        if (SlashTimer < diff)
        {
            AddSpellToCast(me, SPELL_METEOR_SLASH);
            SlashTimer = 11000;
        }
        else
            SlashTimer -= diff;

        if (StompTimer < diff)
        {
            AddSpellToCastWithScriptText(me->getVictim(), SPELL_STOMP, RAND(YELL_LOVE1, YELL_LOVE2, YELL_LOVE3));
            StompTimer = 30000;
        }
        else
            StompTimer -= diff;

        if (BurnTimer < diff)
        {
            if(Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 300.0f, true))
                AddSpellToCast(pTarget, SPELL_BURN);
            BurnTimer = 20000;
        }
        else
            BurnTimer -= diff;

        if (BerserkTimer < diff && !Enraged)
        {
            AddSpellToCastWithScriptText(me, SPELL_BERSERK, YELL_BERSERK);
            Enraged = true;
        }
        else
            BerserkTimer -= diff;

        CastNextSpellIfAnyAndReady();
        DoMeleeAttackIfReady();
    }
示例#14
0
int main()
{
	// clear the video
	ClearVram(); 
	
	// init the music
	InitMusicPlayer(patches);

	// show the intro screen
	DoIntro();
	
	// joystick previous states
	int padPrev[2] = {0,0};
	
	// now the game loop
	while(1)
	{
		// wait for v sync
		WaitVsync(1);
		
		// load the next state if we need to
		if(nextState > 0)
		{
			// set the new game state and reset the next state
			gameState = nextState;
			nextState = 0;
			
			// fade out
			FadeOut(1, true);
			
			// init the state
			if(gameState == STATE_MAINMENU)
				InitState_MainMenu();
			else if(gameState == STATE_PLAYING)
				InitState_Playing();
			else if(gameState == STATE_HOWTOPLAY)
				InitState_HowToPlay();
			else if(gameState == STATE_CREDITS)
				InitState_Credits();
			else if(gameState == STATE_PLAYERSTART)
				InitState_PlayerStart();
			else if(gameState == STATE_GAMEOVER)
				InitState_GameOver();
		}
		
		// handle the input
		padHeld[0] = ReadJoypad(0);
		padPressed[0] = padHeld[0] & (padHeld[0] ^ padPrev[0]);
		padReleased[0] = padPrev[0] & (padHeld[0] ^ padPrev[0]);
		padPrev[0] = padHeld[0];
		padHeld[1] = ReadJoypad(0);//1);
		padPressed[1] = padHeld[1] & (padHeld[1] ^ padPrev[1]);
		padReleased[1] = padPrev[1] & (padHeld[1] ^ padPrev[1]);
		padPrev[1] = padHeld[1];
		
		// handle the states
		if(gameState == STATE_MAINMENU)
			DoState_MainMenu();
		else if(gameState == STATE_PLAYING)
			DoState_Playing();
		else if(gameState == STATE_HOWTOPLAY)
			DoState_HowToPlay();
		else if(gameState == STATE_CREDITS)
			DoState_Credits();
		else if(gameState == STATE_PLAYERSTART)
			DoState_PlayerStart();
		else if(gameState == STATE_GAMEOVER)
			DoState_GameOver();
	}
}