void ElementalDamageTaken(Unit* Done_by, uint32 &Damage, SpellSchoolMask damageSchoolMask)
{
if (Done_by->GetTypeId() == TYPEID_PLAYER)
{
switch (state)
{
case NORMAL_STATE_1:
case NORMAL_STATE_2:
case NORMAL_STATE_3:
if (damageSchoolMask == SPELL_SCHOOL_MASK_FROST) //Only frost damage
{
if (++HitCounter >= 200)
{
NextState(state);
HitCounter = 0;
ChangePhase(state);
}
}
break;
case FROZEN_STATE_1:
case FROZEN_STATE_2:
case FROZEN_STATE_3:
if (damageSchoolMask == SPELL_SCHOOL_MASK_NORMAL) //Only Physical Damage
{
if (++HitCounter >= 200)
{
NextState(state);
HitCounter = 0;
ChangePhase(state);
}
}
break;
}
}
}
void EnterCombat(Unit* /*who*/) override
{
_EnterCombat();
ChangePhase();
events.ScheduleEvent(EVENT_BERSERK, 900000, GCD_CAST);
events.ScheduleEvent(EVENT_FLAME, 20000, GCD_CAST);
}
void EnterCombat(Unit* /*who*/) override
{
_EnterCombat();
ChangePhase();
events.ScheduleEvent(EVENT_BERSERK, Minutes(15));
events.ScheduleEvent(EVENT_FLAME, Seconds(20));
}
static void DoSimpleDataIn(const uint8 *data_in, uint32 len)
{
din.Write(data_in, len);
cd.data_transfer_done = true;
ChangePhase(PHASE_DATA_IN);
}
void EnterCombat(Unit * /*who*/)
{
if (pInstance)
pInstance->SetData(DATA_SUPREMUSEVENT, IN_PROGRESS);
ChangePhase();
events.ScheduleEvent(EVENT_BERSERK, 900000, GCD_CAST);
events.ScheduleEvent(EVENT_FLAME, 20000, GCD_CAST);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK, true);
break;
case EVENT_FLAME:
DoCast(me, SPELL_MOLTEN_PUNCH);
events.DelayEvents(1500, GCD_CAST);
events.ScheduleEvent(EVENT_FLAME, 20000, GCD_CAST);
break;
case EVENT_HATEFUL_STRIKE:
if (Unit *pTarget = CalculateHatefulStrikeTarget())
DoCast(pTarget, SPELL_HATEFUL_STRIKE);
events.DelayEvents(1000, GCD_CAST);
events.ScheduleEvent(EVENT_HATEFUL_STRIKE, 5000, GCD_CAST, PHASE_STRIKE);
break;
case EVENT_SWITCH_TARGET:
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 1, 100, true))
{
DoResetThreat();
me->AddThreat(pTarget, 5000000.0f);
DoScriptText(EMOTE_NEW_TARGET, me);
}
events.ScheduleEvent(EVENT_SWITCH_TARGET, 10000, 0, PHASE_CHASE);
break;
case EVENT_VOLCANO:
{
Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 999, true);
if (!pTarget) pTarget = me->getVictim();
if (pTarget)
{
//DoCast(pTarget, SPELL_VOLCANIC_SUMMON);//movement bugged
me->SummonCreature(CREATURE_VOLCANO,pTarget->GetPositionX(),pTarget->GetPositionY(),pTarget->GetPositionZ(),0,TEMPSUMMON_TIMED_DESPAWN,30000);
DoScriptText(EMOTE_GROUND_CRACK, me);
events.DelayEvents(1500, GCD_CAST);
}
events.ScheduleEvent(EVENT_VOLCANO, 10000, GCD_CAST, PHASE_CHASE);
return;
}
case EVENT_SWITCH_PHASE:
ChangePhase();
break;
}
}
DoMeleeAttackIfReady();
}
///////////////////////////////////////////////////////////////////////////////
/// @fn CBroker::RegisterModule
/// @description Places the module in to the list of schedulable phases. The
/// scheduler cycles through registered modules to do real-time round robin
/// scheduling.
/// @pre None
/// @post The module is registered with a phase duration specified by the
/// phase parameter.
/// @param m the identifier for the module.
/// @param phase the duration of the phase.
///////////////////////////////////////////////////////////////////////////////
void CBroker::RegisterModule(CBroker::ModuleIdent m, boost::posix_time::time_duration phase)
{
Logger.Trace << __PRETTY_FUNCTION__ << std::endl;
boost::mutex::scoped_lock schlock(m_schmutex);
boost::system::error_code err;
if(!IsModuleRegistered(m))
{
m_modules.push_back(PhaseTuple(m,phase));
if(m_modules.size() == 1)
{
schlock.unlock();
ChangePhase(err);
schlock.lock();
}
}
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (me->HealthBelowPct(51) && Phase == PHASE_NORMAL && PhaseCount == 0)
{
ChangePhase();
}
if (SpawnCount == 0 && Phase == PHASE_50_PER)
{
me->SetUInt32Value(UNIT_NPC_EMOTESTATE,0);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
SpawnCount = 8;
SetCombatMovement(true);
Phase = PHASE_NORMAL;
Phased = false;
me->SetReactState(REACT_AGGRESSIVE);
FlameBoltTimer = 7000;
RagingSmashTimer = 4000;
EarthSpikeTimer = 12000;
}
if (FlameBoltTimer <= diff && Phase == PHASE_NORMAL)
{
DoCastAOE(SPELL_FLAME_BOLT);
FlameBoltTimer = 12000;
} else FlameBoltTimer -= diff;
if (RagingSmashTimer <= diff && Phase == PHASE_NORMAL)
{
DoCastVictim(SPELL_RAGING_SMASH);
RagingSmashTimer = 8000;
} else RagingSmashTimer -= diff;
if (EarthSpikeTimer <= diff && Phase == PHASE_NORMAL)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_EARTH_SPIKE);
EarthSpikeTimer = 15000;
} else EarthSpikeTimer -= diff;
DoMeleeAttackIfReady();
}
void ExecuteEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK, true);
break;
case EVENT_FLAME:
DoCast(me, SPELL_MOLTEN_PUNCH);
events.DelayEvents(1500, GCD_CAST);
events.ScheduleEvent(EVENT_FLAME, 20000, GCD_CAST);
break;
case EVENT_HATEFUL_STRIKE:
if (Unit* target = CalculateHatefulStrikeTarget())
DoCast(target, SPELL_HATEFUL_STRIKE);
events.DelayEvents(1000, GCD_CAST);
events.ScheduleEvent(EVENT_HATEFUL_STRIKE, 5000, GCD_CAST, PHASE_STRIKE);
break;
case EVENT_SWITCH_TARGET:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 100, true))
{
DoResetThreat();
me->AddThreat(target, 5000000.0f);
Talk(EMOTE_NEW_TARGET);
}
events.ScheduleEvent(EVENT_SWITCH_TARGET, 10000, 0, PHASE_CHASE);
break;
case EVENT_VOLCANO:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 999, true))
{
//DoCast(target, SPELL_VOLCANIC_SUMMON);//movement bugged
me->SummonCreature(NPC_SUPREMUS_VOLCANO, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 30000);
Talk(EMOTE_GROUND_CRACK);
events.DelayEvents(1500, GCD_CAST);
}
events.ScheduleEvent(EVENT_VOLCANO, 10000, GCD_CAST, PHASE_CHASE);
return;
case EVENT_SWITCH_PHASE:
ChangePhase();
break;
default:
break;
}
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if ((me->HealthBelowPct(34) && Phase == PHASE_NORMAL && PhaseCount == 1) || (me->HealthBelowPct(67) && Phase == PHASE_NORMAL && PhaseCount == 0))
{
ChangePhase();
}
if (Phase == PHASE_SHIELD && FlameCount == 0)
{
me->RemoveAurasDueToSpell(SPELL_SHIELD_OF_LIGHT);
FlameCount = 2;
}
if (!me->HasUnitState(UNIT_STATE_CASTING) && Phase == PHASE_SHIELD)
{
Phase = PHASE_NORMAL;
RemoveSummons();
}
if (me->HasAura(SPELL_SHIELD_OF_LIGHT))
return;
if (DivineReckoningTimer <= diff && Phase == PHASE_NORMAL)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_DIVINE_RECKONING);
DivineReckoningTimer = urand(15000, 18000);
}
else DivineReckoningTimer -= diff;
if (SearingFlameTimer <= diff && Phase == PHASE_NORMAL)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
target->CastSpell(target, SPELL_SEARING_FLAME_SUMM, true);
SearingFlameTimer = 8000;
}
else SearingFlameTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() && !me->HasAura(SPELL_SHIELD_OF_LIGHT))
return;
if ((me->HealthBelowPct(34) && Phase == PHASE_NORMAL && PhaseCount == 1) ||
(me->HealthBelowPct(67) && Phase == PHASE_NORMAL && PhaseCount == 0))
{
ChangePhase();
}
if (Phase == PHASE_SHIELD && FlameCount == 0)
{
me->RemoveAurasDueToSpell(SPELL_SHIELD_OF_LIGHT);
FlameCount = 2;
}
if (!me->HasUnitState(UNIT_STAT_CASTING) && Phase == PHASE_SHIELD)
{
Phase = PHASE_NORMAL;
RemoveSummons();
}
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_REKOCKING:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_DIVINE_RECKONING);
events.ScheduleEvent(EVENT_REKOCKING, urand(15000, 18000));
break;
case EVENT_FLAMES:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
target->CastSpell(target, SPELL_SEARING_FLAME_SUMM, true);
events.ScheduleEvent(EVENT_FLAMES, 8000);
break;
}
}
DoMeleeAttackIfReady();
}
void ExecuteEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_BERSERK:
DoCastSelf(SPELL_BERSERK, true);
break;
case EVENT_FLAME:
DoCast(SPELL_MOLTEN_PUNCH);
events.Repeat(Seconds(15), Seconds(20));
break;
case EVENT_HATEFUL_STRIKE:
if (Unit* target = CalculateHatefulStrikeTarget())
DoCast(target, SPELL_HATEFUL_STRIKE);
events.Repeat(Seconds(5));
break;
case EVENT_SWITCH_TARGET:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 100.0f, true))
{
DoResetThreat();
me->AddThreat(target, 1000000.0f);
DoCast(target, SPELL_CHARGE);
Talk(EMOTE_NEW_TARGET);
}
events.Repeat(Seconds(10));
break;
case EVENT_VOLCANO:
DoCastAOE(SPELL_VOLCANIC_SUMMON, true);
Talk(EMOTE_GROUND_CRACK);
events.Repeat(Seconds(10));
break;
case EVENT_SWITCH_PHASE:
ChangePhase();
break;
default:
break;
}
}
static void SendStatusAndMessage(uint8 status, uint8 message)
{
// This should never ever happen, but that doesn't mean it won't. ;)
if(din.CanRead())
{
printf("BUG: %d bytes still in SCSI CD FIFO\n", din.CanRead());
din.Flush();
}
cd.message_pending = message;
cd.status_sent = FALSE;
cd.message_sent = FALSE;
if(status == STATUS_GOOD)
cd_bus.DB = 0x00;
else
cd_bus.DB = 0x01;
ChangePhase(PHASE_STATUS);
}
static void VirtualReset(void)
{
din.Flush();
cdda.CDDADivAcc = (int64)System_Clock * 65536 / 44100;
CDReadTimer = 0;
pce_lastsapsp_timestamp = monotonic_timestamp;
SectorAddr = SectorCount = 0;
read_sec_start = read_sec = 0;
read_sec_end = ~0;
cdda.PlayMode = PLAYMODE_SILENT;
cdda.CDDAReadPos = 0;
cdda.CDDAStatus = CDDASTATUS_STOPPED;
cdda.CDDADiv = 0;
cdda.ScanMode = 0;
cdda.scan_sec_end = 0;
ChangePhase(PHASE_BUS_FREE);
}
