bool BattlegroundSA::ResetObjs()
{
uint32 atF = BG_SA_Factions[attackers];
uint32 defF = BG_SA_Factions[attackers ? TEAM_ALLIANCE : TEAM_HORDE];
for (uint8 i = 0; i <BG_SA_MAXOBJ; i++)
DelObject(i);
for (uint8 i = 0; i < BG_SA_MAXNPC; i++)
DelCreature(i);
for (uint8 i = BG_SA_MAXNPC; i < BG_SA_MAXNPC + BG_SA_MAX_GY; i++)
DelCreature(i);
for (uint8 i = 0; i < 6; i++)
GateStatus[i] = BG_SA_GATE_OK;
for (uint8 i = 0; i < BG_SA_CENTRAL_FLAG; i++)
{
if (!AddObject(i,BG_SA_ObjEntries[i],
BG_SA_ObjSpawnlocs[i][0],BG_SA_ObjSpawnlocs[i][1],
BG_SA_ObjSpawnlocs[i][2],BG_SA_ObjSpawnlocs[i][3],
0,0,0,0,RESPAWN_ONE_DAY))
return false;
}
//Cannons and demolishers - NPCs are spawned
//By capturing GYs.
for (uint8 i = 0; i < BG_SA_NPC_SPARKLIGHT; i++)
{
if (!AddCreature(BG_SA_NpcEntries[i], i, (attackers == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE),
BG_SA_NpcSpawnlocs[i][0],BG_SA_NpcSpawnlocs[i][1],
BG_SA_NpcSpawnlocs[i][2],BG_SA_NpcSpawnlocs[i][3],600))
return false;
}
OverrideGunFaction();
DemolisherStartState(true);
for (uint8 i = 0; i <= BG_SA_TITAN_RELIC; i++)
{
SpawnBGObject(i, RESPAWN_IMMEDIATELY);
GetBGObject(i)->SetUInt32Value(GAMEOBJECT_FACTION, defF);
}
GetBGObject(BG_SA_TITAN_RELIC)->SetUInt32Value(GAMEOBJECT_FACTION, atF);
GetBGObject(BG_SA_TITAN_RELIC)->Refresh();
for (uint8 i = 0; i <= 5; i++)
GateStatus[i] = BG_SA_GATE_OK;
// MAD props for Kiper for discovering those values - 4 hours of his work.
GetBGObject(BG_SA_BOAT_ONE)->UpdateRotationFields(1.0f, 0.0002f);
GetBGObject(BG_SA_BOAT_TWO)->UpdateRotationFields(1.0f, 0.00001f);
SpawnBGObject(BG_SA_BOAT_ONE, RESPAWN_IMMEDIATELY);
SpawnBGObject(BG_SA_BOAT_TWO, RESPAWN_IMMEDIATELY);
TotalTime = 0;
ShipsStarted = false;
//Graveyards!
for (uint8 i = 0;i < BG_SA_MAX_GY; i++)
{
WorldSafeLocsEntry const *sg = NULL;
sg = sWorldSafeLocsStore.LookupEntry(BG_SA_GYEntries[i]);
if (!sg)
{
sLog.outError("SOTA: Can't find GY entry %u",BG_SA_GYEntries[i]);
return false;
}
if (i == BG_SA_BEACH_GY)
{
GraveyardStatus[i] = attackers;
AddSpiritGuide(i + BG_SA_MAXNPC, sg->x, sg->y, sg->z, BG_SA_GYOrientation[i], ((attackers == TEAM_HORDE)? HORDE : ALLIANCE));
}
else
{
GraveyardStatus[i] = ((attackers == TEAM_HORDE)? TEAM_ALLIANCE : TEAM_HORDE);
if (!AddSpiritGuide(i + BG_SA_MAXNPC, sg->x, sg->y, sg->z, BG_SA_GYOrientation[i], ((attackers == TEAM_HORDE)? ALLIANCE : HORDE)))
sLog.outError("SOTA: couldn't spawn GY: %u",i);
}
}
//GY capture points
for (uint8 i = BG_SA_CENTRAL_FLAG; i < BG_SA_PORTAL_DEFFENDER_BLUE; i++)
{
AddObject(i, (BG_SA_ObjEntries[i] - (attackers == TEAM_ALLIANCE ? 1:0)),
BG_SA_ObjSpawnlocs[i][0], BG_SA_ObjSpawnlocs[i][1],
BG_SA_ObjSpawnlocs[i][2], BG_SA_ObjSpawnlocs[i][3],
0,0,0,0,RESPAWN_ONE_DAY);
GetBGObject(i)->SetUInt32Value(GAMEOBJECT_FACTION, atF);
}
for (uint8 i = BG_SA_PORTAL_DEFFENDER_BLUE; i < BG_SA_BOMB; i++)
{
AddObject(i, BG_SA_ObjEntries[i],
BG_SA_ObjSpawnlocs[i][0], BG_SA_ObjSpawnlocs[i][1],
BG_SA_ObjSpawnlocs[i][2], BG_SA_ObjSpawnlocs[i][3],
0,0,0,0,RESPAWN_ONE_DAY);
GetBGObject(i)->SetUInt32Value(GAMEOBJECT_FACTION, defF);
}
for (uint8 i = BG_SA_BOMB; i < BG_SA_MAXOBJ; i++)
{
AddObject(i, BG_SA_ObjEntries[BG_SA_BOMB],
BG_SA_ObjSpawnlocs[i][0], BG_SA_ObjSpawnlocs[i][1],
BG_SA_ObjSpawnlocs[i][2], BG_SA_ObjSpawnlocs[i][3],
0,0,0,0,RESPAWN_ONE_DAY);
GetBGObject(i)->SetUInt32Value(GAMEOBJECT_FACTION, atF);
}
//Player may enter BEFORE we set up bG - lets update his worldstates anyway...
UpdateWorldState(BG_SA_RIGHT_GY_HORDE , GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_HORDE?1:0);
UpdateWorldState(BG_SA_LEFT_GY_HORDE , GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_HORDE?1:0);
UpdateWorldState(BG_SA_CENTER_GY_HORDE , GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_HORDE?1:0);
UpdateWorldState(BG_SA_RIGHT_GY_ALLIANCE , GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_ALLIANCE?1:0);
UpdateWorldState(BG_SA_LEFT_GY_ALLIANCE , GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_ALLIANCE?1:0);
UpdateWorldState(BG_SA_CENTER_GY_ALLIANCE , GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_ALLIANCE?1:0);
if (attackers == TEAM_ALLIANCE)
{
UpdateWorldState(BG_SA_ALLY_ATTACKS, 1);
UpdateWorldState(BG_SA_HORDE_ATTACKS, 0);
UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_ALL, 1);
UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_ALL, 1);
UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_HRD, 0);
UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_HRD, 0);
UpdateWorldState(BG_SA_HORDE_DEFENCE_TOKEN,1);
UpdateWorldState(BG_SA_ALLIANCE_DEFENCE_TOKEN,0);
}
else
{
UpdateWorldState(BG_SA_HORDE_ATTACKS, 1);
UpdateWorldState(BG_SA_ALLY_ATTACKS, 0);
UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_ALL, 0);
UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_ALL, 0);
UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_HRD, 1);
UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_HRD, 1);
UpdateWorldState(BG_SA_HORDE_DEFENCE_TOKEN,0);
UpdateWorldState(BG_SA_ALLIANCE_DEFENCE_TOKEN,1);
}
UpdateWorldState(BG_SA_PURPLE_GATEWS, 1);
UpdateWorldState(BG_SA_RED_GATEWS, 1);
UpdateWorldState(BG_SA_BLUE_GATEWS, 1);
UpdateWorldState(BG_SA_GREEN_GATEWS, 1);
UpdateWorldState(BG_SA_YELLOW_GATEWS, 1);
UpdateWorldState(BG_SA_ANCIENT_GATEWS, 1);
TeleportPlayers();
return true;
}
void UpdateAI(const uint32 diff)
{
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
return;
if (m_creature->GetHealthPercent() < 10.0f && !Enraged)
{
Enraged = true;
DoCastSpellIfCan(m_creature, SPELL_ENRAGE, CAST_TRIGGERED);
DoScriptText(SAY_ENRAGE, m_creature);
}
//Randomly cast one beam.
if (BeamTimer < diff)
{
Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (!target || !target->isAlive())
return;
BeamTimer = 9000;
switch(CurrentBeam)
{
case 0:
DoCastSpellIfCan(target, SPELL_BEAM_SINISTER);
break;
case 1:
DoCastSpellIfCan(target, SPELL_BEAM_VILE);
break;
case 2:
DoCastSpellIfCan(target, SPELL_BEAM_WICKED);
break;
case 3:
DoCastSpellIfCan(target, SPELL_BEAM_SINFUL);
break;
}
++BeamCount;
uint32 Beam = CurrentBeam;
if (BeamCount > 3)
while(CurrentBeam == Beam)
CurrentBeam = urand(0, 2);
}else BeamTimer -= diff;
// Random Prismatic Shield every 15 seconds.
if (PrismaticShieldTimer < diff)
{
uint32 random = urand(0, 5);
if (PrismaticAuras[random])
DoCastSpellIfCan(m_creature, PrismaticAuras[random]);
PrismaticShieldTimer = 15000;
}else PrismaticShieldTimer -= diff;
// Select 3 random targets (can select same target more than once), teleport to a random location then make them cast explosions until they get away from each other.
if (FatalAttractionTimer < diff)
{
ExplosionCount = 0;
TeleportPlayers();
DoScriptText(urand(0, 1) ? SAY_SPELL2 : SAY_SPELL3, m_creature);
FatalAttractionExplodeTimer = 2000;
FatalAttractionTimer = urand(40000, 70000);
}else FatalAttractionTimer -= diff;
if (FatalAttractionExplodeTimer < diff)
{
// Just make them explode three times... they're supposed to keep exploding while they are in range, but it'll take too much code. I'll try to think of an efficient way for it later.
if (ExplosionCount < 3)
{
for(uint8 i = 0; i < 3; ++i)
{
Unit* pUnit = NULL;
if (TargetGUID[i])
{
pUnit = Unit::GetUnit((*m_creature), TargetGUID[i]);
if (pUnit)
pUnit->CastSpell(pUnit, SPELL_ATTRACTION, true);
TargetGUID[i] = 0;
}
}
++ExplosionCount;
FatalAttractionExplodeTimer = 1000;
}
else
{
FatalAttractionExplodeTimer = FatalAttractionTimer + 2000;
ExplosionCount = 0;
}
}else FatalAttractionExplodeTimer -= diff;
if (ShriekTimer < diff)
{
DoCastSpellIfCan(m_creature->getVictim(), SPELL_SILENCING_SHRIEK);
ShriekTimer = 30000;
}else ShriekTimer -= diff;
//Enrage
if (!m_creature->HasAura(SPELL_BERSERK, EFFECT_INDEX_0))
{
if (EnrageTimer < diff)
{
DoCastSpellIfCan(m_creature, SPELL_BERSERK);
DoScriptText(SAY_ENRAGE, m_creature);
}else EnrageTimer -= diff;
}
//Random taunts
if (RandomYellTimer < diff)
{
switch(urand(0, 2))
{
case 0: DoScriptText(SAY_TAUNT1, m_creature); break;
case 1: DoScriptText(SAY_TAUNT2, m_creature); break;
case 2: DoScriptText(SAY_TAUNT3, m_creature); break;
}
RandomYellTimer = urand(60000, 150000);
}else RandomYellTimer -= diff;
DoMeleeAttackIfReady();
}
bool BattlegroundSA::ResetObjs()
{
/*for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
if (Player* player = ObjectAccessor::FindPlayer(itr->first))
SendTransportsRemove(player);*/
uint32 atF = BG_SA_Factions[Attackers];
uint32 defF = BG_SA_Factions[Attackers ? TEAM_ALLIANCE : TEAM_HORDE];
for (uint8 i = 0; i < BG_SA_MAXOBJ; i++)
DelObject(i);
for (uint8 i = 0; i < BG_SA_MAXNPC; i++)
DelCreature(i);
for (uint8 i = BG_SA_MAXNPC; i < BG_SA_MAXNPC + BG_SA_MAX_GY; i++)
DelCreature(i);
for (uint8 i = 0; i < 6; i++)
GateStatus[i] = BG_SA_GATE_OK;
for (uint8 i = 0; i <= BG_SA_PORTAL_DEFFENDER_RED; i++)
{
if (!AddObject(i, BG_SA_ObjEntries[i], BG_SA_ObjSpawnlocs[i][0], BG_SA_ObjSpawnlocs[i][1], BG_SA_ObjSpawnlocs[i][2], BG_SA_ObjSpawnlocs[i][3], 0, 0, 0, 0, RESPAWN_ONE_DAY))
return false;
}
/*for (uint8 i = BG_SA_BOAT_ONE; i <= BG_SA_BOAT_TWO; i++)
{
uint32 boatid = 0;
switch (i)
{
case BG_SA_BOAT_ONE:
boatid = Attackers ? BG_SA_BOAT_ONE_H : BG_SA_BOAT_ONE_A;
break;
case BG_SA_BOAT_TWO:
boatid = Attackers ? BG_SA_BOAT_TWO_H : BG_SA_BOAT_TWO_A;
break;
default:
break;
}
if (!AddObject(i, boatid, BG_SA_ObjSpawnlocs[i][0],
BG_SA_ObjSpawnlocs[i][1],
BG_SA_ObjSpawnlocs[i][2]+(Attackers ? -3.750f: 0),
BG_SA_ObjSpawnlocs[i][3], 0, 0, 0, 0, RESPAWN_ONE_DAY))
return false;
}*/
for (uint8 i = BG_SA_SIGIL_1; i <= BG_SA_LEFT_FLAGPOLE; i++)
{
if (!AddObject(i, BG_SA_ObjEntries[i],
BG_SA_ObjSpawnlocs[i][0], BG_SA_ObjSpawnlocs[i][1],
BG_SA_ObjSpawnlocs[i][2], BG_SA_ObjSpawnlocs[i][3],
0, 0, 0, 0, RESPAWN_ONE_DAY))
return false;
}
// MAD props for Kiper for discovering those values - 4 hours of his work.
//GetBGObject(BG_SA_BOAT_ONE)->UpdateRotationFields(1.0f, 0.0002f);
//GetBGObject(BG_SA_BOAT_TWO)->UpdateRotationFields(1.0f, 0.00001f);
//SpawnBGObject(BG_SA_BOAT_ONE, RESPAWN_IMMEDIATELY);
//SpawnBGObject(BG_SA_BOAT_TWO, RESPAWN_IMMEDIATELY);
//Cannons and demolishers - NPCs are spawned
//By capturing GYs.
for (uint8 i = 0; i < BG_SA_DEMOLISHER_5; i++)
{
if (!AddCreature(BG_SA_NpcEntries[i], i, (Attackers == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE),
BG_SA_NpcSpawnlocs[i][0], BG_SA_NpcSpawnlocs[i][1],
BG_SA_NpcSpawnlocs[i][2], BG_SA_NpcSpawnlocs[i][3], 600))
return false;
}
OverrideGunFaction();
DemolisherStartState(true);
for (uint8 i = 0; i <= BG_SA_PORTAL_DEFFENDER_RED; i++)
{
SpawnBGObject(i, RESPAWN_IMMEDIATELY);
GetBGObject(i)->SetUInt32Value(GAMEOBJECT_FIELD_FACTION_TEMPLATE, defF);
}
GetBGObject(BG_SA_TITAN_RELIC)->SetUInt32Value(GAMEOBJECT_FIELD_FACTION_TEMPLATE, atF);
GetBGObject(BG_SA_TITAN_RELIC)->Refresh();
for (uint8 i = 0; i <= 5; i++)
GateStatus[i] = BG_SA_GATE_OK;
TotalTime = 0;
ShipsStarted = false;
gateDestroyed = false;
//Graveyards
for (uint8 i = 0; i < BG_SA_MAX_GY; i++)
{
WorldSafeLocsEntry const* sg = NULL;
sg = sWorldSafeLocsStore.LookupEntry(BG_SA_GYEntries[i]);
if (!sg)
return false;
if (i == BG_SA_BEACH_GY)
{
GraveyardStatus[i] = Attackers;
AddSpiritGuide(i + BG_SA_MAXNPC, sg->x, sg->y, sg->z, BG_SA_GYOrientation[i], ((Attackers == TEAM_HORDE)? HORDE : ALLIANCE));
}
else
{
GraveyardStatus[i] = ((Attackers == TEAM_HORDE)? TEAM_ALLIANCE : TEAM_HORDE);
AddSpiritGuide(i + BG_SA_MAXNPC, sg->x, sg->y, sg->z, BG_SA_GYOrientation[i], ((Attackers == TEAM_HORDE)? ALLIANCE : HORDE));
}
}
//GY capture points
for (uint8 i = BG_SA_CENTRAL_FLAG; i <= BG_SA_LEFT_FLAG; i++)
{
AddObject(i, (BG_SA_ObjEntries[i] - (Attackers == TEAM_ALLIANCE ? 1 : 0)),
BG_SA_ObjSpawnlocs[i][0], BG_SA_ObjSpawnlocs[i][1],
BG_SA_ObjSpawnlocs[i][2], BG_SA_ObjSpawnlocs[i][3],
0, 0, 0, 0, RESPAWN_ONE_DAY);
GetBGObject(i)->SetUInt32Value(GAMEOBJECT_FIELD_FACTION_TEMPLATE, atF);
}
for (uint8 i = BG_SA_BOMB; i < BG_SA_MAXOBJ; i++)
{
AddObject(i, BG_SA_ObjEntries[BG_SA_BOMB],
BG_SA_ObjSpawnlocs[i][0], BG_SA_ObjSpawnlocs[i][1],
BG_SA_ObjSpawnlocs[i][2], BG_SA_ObjSpawnlocs[i][3],
0, 0, 0, 0, RESPAWN_ONE_DAY);
GetBGObject(i)->SetUInt32Value(GAMEOBJECT_FIELD_FACTION_TEMPLATE, atF);
if (i > 46)
GetBGObject(i)->SetFlag(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_NOT_SELECTABLE);
}
//Player may enter BEFORE we set up BG - lets update his worldstates anyway...
UpdateWorldState(BG_SA_RIGHT_GY_HORDE, GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
UpdateWorldState(BG_SA_LEFT_GY_HORDE, GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
UpdateWorldState(BG_SA_CENTER_GY_HORDE, GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
UpdateWorldState(BG_SA_RIGHT_GY_ALLIANCE, GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
UpdateWorldState(BG_SA_LEFT_GY_ALLIANCE, GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
UpdateWorldState(BG_SA_CENTER_GY_ALLIANCE, GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
if (Attackers == TEAM_ALLIANCE)
{
UpdateWorldState(BG_SA_ALLY_ATTACKS, 1);
UpdateWorldState(BG_SA_HORDE_ATTACKS, 0);
UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_ALL, 1);
UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_ALL, 1);
UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_HRD, 0);
UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_HRD, 0);
UpdateWorldState(BG_SA_HORDE_DEFENCE_TOKEN, 1);
UpdateWorldState(BG_SA_ALLIANCE_DEFENCE_TOKEN, 0);
}
else
{
UpdateWorldState(BG_SA_HORDE_ATTACKS, 1);
UpdateWorldState(BG_SA_ALLY_ATTACKS, 0);
UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_ALL, 0);
UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_ALL, 0);
UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_HRD, 1);
UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_HRD, 1);
UpdateWorldState(BG_SA_HORDE_DEFENCE_TOKEN, 0);
UpdateWorldState(BG_SA_ALLIANCE_DEFENCE_TOKEN, 1);
}
UpdateWorldState(BG_SA_PURPLE_GATEWS, 1);
UpdateWorldState(BG_SA_RED_GATEWS, 1);
UpdateWorldState(BG_SA_BLUE_GATEWS, 1);
UpdateWorldState(BG_SA_GREEN_GATEWS, 1);
UpdateWorldState(BG_SA_YELLOW_GATEWS, 1);
UpdateWorldState(BG_SA_ANCIENT_GATEWS, 1);
/*for (int i = BG_SA_BOAT_ONE; i <= BG_SA_BOAT_TWO; i++)
for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
if (Player* player = ObjectAccessor::FindPlayer(itr->first))
SendTransportInit(player);*/
// set status manually so preparation is cast correctly in 2nd round too
SetStatus(STATUS_WAIT_JOIN);
TeleportPlayers();
return true;
}
void ExecuteEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_RANDOM_BEAM:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
switch (CurrentBeam)
{
case SINISTER_BEAM:
DoCast(target, SPELL_BEAM_SINISTER);
break;
case VILE_BEAM:
DoCast(target, SPELL_BEAM_VILE);
break;
case WICKED_BEAM:
DoCast(target, SPELL_BEAM_WICKED);
break;
case SINFUL_BEAM:
DoCast(target, SPELL_BEAM_SINFUL);
break;
default:
break;
}
++BeamCount;
uint32 Beam = CurrentBeam;
if (BeamCount > 3)
while (CurrentBeam == Beam)
CurrentBeam = urand(0, 3);
}
events.ScheduleEvent(EVENT_RANDOM_BEAM, 9000);
break;
case EVENT_PRISMATIC_SHIELD:
// Random Prismatic Shield every 15 seconds.
DoCast(me, PrismaticAuras[urand(0, 6)]);
events.ScheduleEvent(EVENT_PRISMATIC_SHIELD, 15000);
break;
case EVENT_FATAL_ATTRACTION:
// Select 3 random targets (can select same target more than once), teleport to a random location then make them cast explosions until they get away from each other.
ExplosionCount = 0;
TeleportPlayers();
Talk(SAY_SPELL);
events.ScheduleEvent(EVENT_FATAL_ATTRACTION_EXPLOSION, 2000);
events.ScheduleEvent(EVENT_FATAL_ATTRACTION, 40000, 71000);
break;
case EVENT_FATAL_ATTRACTION_EXPLOSION:
// Just make them explode three times... they're supposed to keep exploding while they are in range, but it'll take too much code. I'll try to think of an efficient way for it later.
if (ExplosionCount < 3)
{
for (uint8 i = 0; i < 3; ++i)
{
if (TargetGUID[i])
{
if (Unit* unit = ObjectAccessor::GetUnit(*me, TargetGUID[i]))
unit->CastSpell(unit, SPELL_ATTRACTION, true);
TargetGUID[i].Clear();
}
}
++ExplosionCount;
}
else
ExplosionCount = 0;
events.ScheduleEvent(EVENT_FATAL_ATTRACTION_EXPLOSION, ExplosionCount < 3 ? 1000 : events.GetTimeUntilEvent(EVENT_FATAL_ATTRACTION) + 2000);
break;
case EVENT_SILENCING_SHRIEK:
DoCastVictim(SPELL_SILENCING_SHRIEK);
events.ScheduleEvent(EVENT_SILENCING_SHRIEK, urand(25000, 35000));
break;
case EVENT_SABER_SLASH:
DoCastVictim(SPELL_SABER_LASH);
events.ScheduleEvent(EVENT_SABER_SLASH, urand(25000, 35000));
break;
case EVENT_RANDOM_TAUNT:
Talk(SAY_TAUNT);
events.ScheduleEvent(EVENT_RANDOM_TAUNT, urand(60000, 151000));
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK);
Talk(SAY_ENRAGE);
break;
default:
break;
}
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
if (HealthBelowPct(10) && !Enraged)
{
Enraged = true;
DoCast(me, SPELL_ENRAGE, true);
Talk(SAY_ENRAGE);
}
//Randomly cast one beam.
if (BeamTimer <= diff)
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (!target || !target->IsAlive())
return;
BeamTimer = 9000;
switch (CurrentBeam)
{
case 0:
DoCast(target, SPELL_BEAM_SINISTER);
break;
case 1:
DoCast(target, SPELL_BEAM_VILE);
break;
case 2:
DoCast(target, SPELL_BEAM_WICKED);
break;
case 3:
DoCast(target, SPELL_BEAM_SINFUL);
break;
}
++BeamCount;
uint32 Beam = CurrentBeam;
if (BeamCount > 3)
while (CurrentBeam == Beam)
CurrentBeam = rand()%3;
} else BeamTimer -= diff;
// Random Prismatic Shield every 15 seconds.
if (PrismaticShieldTimer <= diff)
{
uint32 random = rand()%6;
if (PrismaticAuras[random])
DoCast(me, PrismaticAuras[random]);
PrismaticShieldTimer = 15000;
} else PrismaticShieldTimer -= diff;
// Select 3 random targets (can select same target more than once), teleport to a random location then make them cast explosions until they get away from each other.
if (FatalAttractionTimer <= diff)
{
ExplosionCount = 0;
TeleportPlayers();
Talk(SAY_SPELL);
FatalAttractionExplodeTimer = 2000;
FatalAttractionTimer = urand(40, 71) * 1000;
} else FatalAttractionTimer -= diff;
if (FatalAttractionExplodeTimer <= diff)
{
// Just make them explode three times... they're supposed to keep exploding while they are in range, but it'll take too much code. I'll try to think of an efficient way for it later.
if (ExplosionCount < 3)
{
for (uint8 i = 0; i < 3; ++i)
{
if (TargetGUID[i])
{
if (Unit* unit = ObjectAccessor::GetUnit(*me, TargetGUID[i]))
unit->CastSpell(unit, SPELL_ATTRACTION, true);
TargetGUID[i] = 0;
}
}
++ExplosionCount;
FatalAttractionExplodeTimer = 1000;
}
else
{
FatalAttractionExplodeTimer = FatalAttractionTimer + 2000;
ExplosionCount = 0;
}
} else FatalAttractionExplodeTimer -= diff;
if (ShriekTimer <= diff)
{
DoCastVictim(SPELL_SILENCING_SHRIEK);
ShriekTimer = 25000+rand()%10 * 1000;
} else ShriekTimer -= diff;
if (SaberTimer <= diff)
{
DoCastVictim(SPELL_SABER_LASH);
SaberTimer = 25000+rand()%10 * 1000;
} else SaberTimer -= diff;
//Enrage
if (!me->HasAura(SPELL_BERSERK))
{
if (EnrageTimer <= diff)
{
DoCast(me, SPELL_BERSERK);
Talk(SAY_ENRAGE);
} else EnrageTimer -= diff;
}
//Random taunts
if (RandomYellTimer <= diff)
{
Talk(SAY_TAUNT);
RandomYellTimer = urand(60, 151) * 1000;
} else RandomYellTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (((me->GetHealth() * 100 / me->GetMaxHealth()) < 10) && !Enraged)
{
Enraged = true;
DoCast(me, SPELL_ENRAGE, true);
DoScriptText(SAY_ENRAGE, me);
}
if (BeamTimer <= diff)
{
if (!me->IsNonMeleeSpellCast(false))
{
switch (CurrentBeam)
{
case 0:
DoCast(me, SPELL_BEAM_SINISTER_TRIGGER);
break;
case 1:
DoCast(me, SPELL_BEAM_VILE_TRIGGER);
break;
case 2:
DoCast(me, SPELL_BEAM_WICKED_TRIGGER);
break;
case 3:
DoCast(me, SPELL_BEAM_SINFUL_TRIGGER);
break;
}
uint32 Beam = CurrentBeam;
while (CurrentBeam == Beam)
CurrentBeam = rand() % 4;
BeamTimer = 30000;
}
}
else BeamTimer -= diff;
// Select 3 random targets (can select same target more than once), teleport to a random location then make them cast explosions until they get away from each other.
if (FatalAttractionTimer <= diff)
{
TeleportPlayers();
DoScriptText(RAND(SAY_SPELL2, SAY_SPELL3), me);
FatalAttractionExplodeTimer = 2000;
FatalAttractionTimer = 30000;
}
else FatalAttractionTimer -= diff;
if (FatalAttractionExplodeTimer <= diff)
{
Player* targets[3];
for (uint8 i = 0; i < 3; ++i)
{
if (TargetGUID[i])
targets[i] = Player::GetPlayer(*me, TargetGUID[i]);
else
targets[i] = NULL;
}
if (targets[0] && targets[0]->IsAlive())
{
bool isNear = false;
if (targets[1] && targets[1]->IsAlive() && targets[0]->GetDistance2d(targets[1]) < 25)
isNear = true;
if (!isNear)
if (targets[2] && targets[2]->IsAlive() && targets[0]->GetDistance2d(targets[2]) < 25)
isNear = true;
if (isNear)
targets[0]->CastSpell(targets[0], SPELL_ATTRACTION, true);
else
{
targets[0]->RemoveAurasDueToSpell(SPELL_ATTRACTION_VIS);
TargetGUID[0] = 0;
targets[0] = NULL;
}
}
if (targets[1] && targets[1]->IsAlive())
{
bool isNear = false;
if (targets[0] && targets[0]->IsAlive() && targets[1]->GetDistance2d(targets[0]) < 25)
isNear = true;
if (!isNear)
if (targets[2] && targets[2]->IsAlive() && targets[1]->GetDistance2d(targets[2]) < 25)
isNear = true;
if (isNear)
targets[1]->CastSpell(targets[1], SPELL_ATTRACTION, true);
else
{
targets[1]->RemoveAurasDueToSpell(SPELL_ATTRACTION_VIS);
TargetGUID[1] = 0;
targets[1] = NULL;
}
}
if (targets[2] && targets[2]->IsAlive())
{
bool isNear = false;
if (targets[0] && targets[0]->IsAlive() && targets[2]->GetDistance2d(targets[0]) < 25)
isNear = true;
if (!isNear)
if (targets[1] && targets[1]->IsAlive() && targets[2]->GetDistance2d(targets[1]) < 25)
isNear = true;
if (isNear)
targets[2]->CastSpell(targets[1], SPELL_ATTRACTION, true);
else
{
targets[2]->RemoveAurasDueToSpell(SPELL_ATTRACTION_VIS);
TargetGUID[2] = 0;
targets[2] = NULL;
}
}
bool allClear = true;
for (uint8 i = 0; i < 3; i++)
{
if (TargetGUID[i] != 0)
allClear = false;
}
if (allClear)
FatalAttractionExplodeTimer = 60000;
else
FatalAttractionExplodeTimer = 1000;
}
else FatalAttractionExplodeTimer -= diff;
if (ShriekTimer <= diff)
{
if (TryDoCast(me->getVictim(), SPELL_SILENCING_SHRIEK))
ShriekTimer = 20000;
}
else ShriekTimer -= diff;
//Enrage
if (!me->HasAura(SPELL_BERSERK, 0))
{
if (EnrageTimer <= diff)
{
DoCast(me, SPELL_BERSERK);
DoScriptText(SAY_ENRAGE, me);
}
else EnrageTimer -= diff;
}
//Random taunts
if (RandomYellTimer <= diff)
{
DoScriptText(RAND(SAY_TAUNT1, SAY_TAUNT2, SAY_TAUNT3), me);
RandomYellTimer = 60000 + rand() % 91 * 1000;
}
else RandomYellTimer -= diff;
DoMeleeAttackIfReady();
}
bool BattlegroundSA::ResetObjs()
{
for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
if (Player* player = ObjectAccessor::FindPlayer(itr->first))
SendTransportsRemove(player);
uint32 atF = BG_SA_Factions[Attackers];
uint32 defF = BG_SA_Factions[Attackers ? TEAM_ALLIANCE : TEAM_HORDE];
for (uint8 i = 0; i < BG_SA_MAXOBJ; i++)
DelObject(i);
for (uint8 i = 0; i < BG_SA_MAXNPC; i++)
DelCreature(i);
for (uint8 i = BG_SA_MAXNPC; i < BG_SA_MAXNPC + BG_SA_MAX_GY; i++)
DelCreature(i);
for (uint8 i = 0; i < 6; i++)
GateStatus[i] = BG_SA_GATE_OK;
if (!AddCreature(BG_SA_NpcEntries[BG_SA_NPC_KANRETHAD], BG_SA_NPC_KANRETHAD, BG_SA_NpcSpawnlocs[BG_SA_NPC_KANRETHAD]))
{
TC_LOG_ERROR("bg.battleground", "SOTA: couldn't spawn Kanrethad, aborted. Entry: %u", BG_SA_NpcEntries[BG_SA_NPC_KANRETHAD]);
return false;
}
for (uint8 i = 0; i <= BG_SA_PORTAL_DEFFENDER_RED; i++)
{
if (!AddObject(i, BG_SA_ObjEntries[i], BG_SA_ObjSpawnlocs[i], 0, 0, 0, 0, RESPAWN_ONE_DAY))
{
TC_LOG_ERROR("bg.battleground", "SOTA: couldn't spawn BG_SA_PORTAL_DEFFENDER_RED, Entry: %u", BG_SA_ObjEntries[i]);
continue;
}
}
for (uint8 i = BG_SA_BOAT_ONE; i <= BG_SA_BOAT_TWO; i++)
{
uint32 boatid = 0;
switch (i)
{
case BG_SA_BOAT_ONE:
boatid = Attackers ? BG_SA_BOAT_ONE_H : BG_SA_BOAT_ONE_A;
break;
case BG_SA_BOAT_TWO:
boatid = Attackers ? BG_SA_BOAT_TWO_H : BG_SA_BOAT_TWO_A;
break;
default:
break;
}
if (!AddObject(i, boatid, BG_SA_ObjSpawnlocs[i].GetPositionX(),
BG_SA_ObjSpawnlocs[i].GetPositionY(),
BG_SA_ObjSpawnlocs[i].GetPositionZ() + (Attackers ? -3.750f: 0),
BG_SA_ObjSpawnlocs[i].GetOrientation(), 0, 0, 0, 0, RESPAWN_ONE_DAY))
{
TC_LOG_ERROR("bg.battleground", "SOTA: couldn't spawn one of the BG_SA_BOAT, Entry: %u", boatid);
continue;
}
}
for (uint8 i = BG_SA_SIGIL_1; i <= BG_SA_LEFT_FLAGPOLE; i++)
{
if (!AddObject(i, BG_SA_ObjEntries[i], BG_SA_ObjSpawnlocs[i], 0, 0, 0, 0, RESPAWN_ONE_DAY))
{
TC_LOG_ERROR("bg.battleground", "SOTA: couldn't spawn Sigil, Entry: %u", BG_SA_ObjEntries[i]);
continue;
}
}
// MAD props for Kiper for discovering those values - 4 hours of his work.
GetBGObject(BG_SA_BOAT_ONE)->UpdateRotationFields(1.0f, 0.0002f);
GetBGObject(BG_SA_BOAT_TWO)->UpdateRotationFields(1.0f, 0.00001f);
SpawnBGObject(BG_SA_BOAT_ONE, RESPAWN_IMMEDIATELY);
SpawnBGObject(BG_SA_BOAT_TWO, RESPAWN_IMMEDIATELY);
//Cannons and demolishers - NPCs are spawned
//By capturing GYs.
for (uint8 i = 0; i < BG_SA_DEMOLISHER_5; i++)
{
if (!AddCreature(BG_SA_NpcEntries[i], i, BG_SA_NpcSpawnlocs[i], Attackers == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE, 600))
{
TC_LOG_ERROR("bg.battleground", "SOTA: couldn't spawn Cannon or demolisher, Entry: %u, Attackers: %s", BG_SA_NpcEntries[i], Attackers == TEAM_ALLIANCE ? "Horde(1)" : "Alliance(0)");
continue;
}
}
OverrideGunFaction();
DemolisherStartState(true);
for (uint8 i = 0; i <= BG_SA_PORTAL_DEFFENDER_RED; i++)
{
SpawnBGObject(i, RESPAWN_IMMEDIATELY);
GetBGObject(i)->SetFaction(defF);
}
GetBGObject(BG_SA_TITAN_RELIC)->SetFaction(atF);
GetBGObject(BG_SA_TITAN_RELIC)->Refresh();
for (uint8 i = 0; i <= 5; i++)
GateStatus[i] = BG_SA_GATE_OK;
TotalTime = 0;
ShipsStarted = false;
//Graveyards
for (uint8 i = 0; i < BG_SA_MAX_GY; i++)
{
WorldSafeLocsEntry const* sg = NULL;
sg = sWorldSafeLocsStore.LookupEntry(BG_SA_GYEntries[i]);
if (!sg)
{
TC_LOG_ERROR("bg.battleground", "SOTA: Can't find GY entry %u", BG_SA_GYEntries[i]);
return false;
}
if (i == BG_SA_BEACH_GY)
{
GraveyardStatus[i] = Attackers;
AddSpiritGuide(i + BG_SA_MAXNPC, sg->x, sg->y, sg->z, BG_SA_GYOrientation[i], Attackers);
}
else
{
GraveyardStatus[i] = ((Attackers == TEAM_HORDE)? TEAM_ALLIANCE : TEAM_HORDE);
if (!AddSpiritGuide(i + BG_SA_MAXNPC, sg->x, sg->y, sg->z, BG_SA_GYOrientation[i], Attackers == TEAM_HORDE ? TEAM_ALLIANCE : TEAM_HORDE))
TC_LOG_ERROR("bg.battleground", "SOTA: couldn't spawn GY: %u", i);
}
}
//GY capture points
for (uint8 i = BG_SA_CENTRAL_FLAG; i <= BG_SA_LEFT_FLAG; i++)
{
if (!AddObject(i, (BG_SA_ObjEntries[i] - (Attackers == TEAM_ALLIANCE ? 1 : 0)), BG_SA_ObjSpawnlocs[i], 0, 0, 0, 0, RESPAWN_ONE_DAY))
{
TC_LOG_ERROR("bg.battleground", "SOTA: couldn't spawn Central Flag Entry: %u", BG_SA_ObjEntries[i] - (Attackers == TEAM_ALLIANCE ? 1 : 0));
continue;
}
GetBGObject(i)->SetFaction(atF);
}
for (uint8 i = BG_SA_BOMB; i < BG_SA_MAXOBJ; i++)
{
if (!AddObject(i, BG_SA_ObjEntries[BG_SA_BOMB], BG_SA_ObjSpawnlocs[i], 0, 0, 0, 0, RESPAWN_ONE_DAY))
{
TC_LOG_ERROR("bg.battleground", "SOTA: couldn't spawn SA Bomb Entry: %u", BG_SA_ObjEntries[BG_SA_BOMB] + i);
continue;
}
GetBGObject(i)->SetFaction(atF);
}
//Player may enter BEFORE we set up BG - lets update his worldstates anyway...
UpdateWorldState(BG_SA_RIGHT_GY_HORDE, GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
UpdateWorldState(BG_SA_LEFT_GY_HORDE, GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
UpdateWorldState(BG_SA_CENTER_GY_HORDE, GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
UpdateWorldState(BG_SA_RIGHT_GY_ALLIANCE, GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
UpdateWorldState(BG_SA_LEFT_GY_ALLIANCE, GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
UpdateWorldState(BG_SA_CENTER_GY_ALLIANCE, GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
if (Attackers == TEAM_ALLIANCE)
{
UpdateWorldState(BG_SA_ALLY_ATTACKS, 1);
UpdateWorldState(BG_SA_HORDE_ATTACKS, 0);
UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_ALL, 1);
UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_ALL, 1);
UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_HRD, 0);
UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_HRD, 0);
UpdateWorldState(BG_SA_HORDE_DEFENCE_TOKEN, 1);
UpdateWorldState(BG_SA_ALLIANCE_DEFENCE_TOKEN, 0);
}
else
{
UpdateWorldState(BG_SA_HORDE_ATTACKS, 1);
UpdateWorldState(BG_SA_ALLY_ATTACKS, 0);
UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_ALL, 0);
UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_ALL, 0);
UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_HRD, 1);
UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_HRD, 1);
UpdateWorldState(BG_SA_HORDE_DEFENCE_TOKEN, 0);
UpdateWorldState(BG_SA_ALLIANCE_DEFENCE_TOKEN, 1);
}
UpdateWorldState(BG_SA_PURPLE_GATEWS, 1);
UpdateWorldState(BG_SA_RED_GATEWS, 1);
UpdateWorldState(BG_SA_BLUE_GATEWS, 1);
UpdateWorldState(BG_SA_GREEN_GATEWS, 1);
UpdateWorldState(BG_SA_YELLOW_GATEWS, 1);
UpdateWorldState(BG_SA_ANCIENT_GATEWS, 1);
for (int i = BG_SA_BOAT_ONE; i <= BG_SA_BOAT_TWO; i++)
for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
if (Player* player = ObjectAccessor::FindPlayer(itr->first))
SendTransportInit(player);
// set status manually so preparation is cast correctly in 2nd round too
SetStatus(STATUS_WAIT_JOIN);
TeleportPlayers();
return true;
}
bool MapMgr::Do()
{
#ifdef WIN32
threadid=GetCurrentThreadId();
#endif
thread_running = true;
ThreadState =THREADSTATE_BUSY;
SetThreadName("Map mgr - M%u|I%u",this->_mapId ,this->m_instanceID);
ObjectSet::iterator i;
uint32 last_exec=getMSTime();
/* create static objects */
for(GOSpawnList::iterator itr = _map->staticSpawns.GOSpawns.begin(); itr != _map->staticSpawns.GOSpawns.end(); ++itr)
{
GameObject * obj = CreateGameObject((*itr)->entry);
obj->Load((*itr));
_mapWideStaticObjects.insert(obj);
}
for(CreatureSpawnList::iterator itr = _map->staticSpawns.CreatureSpawns.begin(); itr != _map->staticSpawns.CreatureSpawns.end(); ++itr)
{
Creature * obj = CreateCreature((*itr)->entry);
obj->Load(*itr, 0, pMapInfo);
_mapWideStaticObjects.insert(obj);
}
/* add static objects */
for(set<Object*>::iterator itr = _mapWideStaticObjects.begin(); itr != _mapWideStaticObjects.end(); ++itr)
PushStaticObject(*itr);
/* load corpses */
objmgr.LoadCorpses(this);
// always declare local variables outside of the loop!
// otherwise theres a lot of sub esp; going on.
uint32 exec_time, exec_start;
#ifdef WIN32
HANDLE hThread = GetCurrentThread();
#endif
while((ThreadState != THREADSTATE_TERMINATE) && !_shutdown)
{
exec_start=getMSTime();
//first push to world new objects
m_objectinsertlock.Acquire();//<<<<<<<<<<<<<<<<
if(m_objectinsertpool.size())
{
for(i=m_objectinsertpool.begin();i!=m_objectinsertpool.end();i++)
{
//PushObject(*i);
(*i)->PushToWorld(this);
}
m_objectinsertpool.clear();
}
m_objectinsertlock.Release();//>>>>>>>>>>>>>>>>
//-------------------------------------------------------
//Now update sessions of this map + objects
_PerformObjectDuties();
last_exec=getMSTime();
exec_time=last_exec-exec_start;
if(exec_time<MAP_MGR_UPDATE_PERIOD)
{
/*
The common place I see this is waiting for a Win32 thread to exit. I used to come up with all sorts of goofy,
elaborate event-based systems to do this myself until I discovered that thread handles are waitable. Just use
WaitForSingleObject() on the thread handle and you're done. No risking race conditions with the thread exit code.
I think pthreads has pthread_join() for this too.
- http://www.virtualdub.org/blog/pivot/entry.php?id=62
*/
#ifdef WIN32
WaitForSingleObject(hThread, MAP_MGR_UPDATE_PERIOD-exec_time);
#else
Sleep(MAP_MGR_UPDATE_PERIOD-exec_time);
#endif
}
//////////////////////////////////////////////////////////////////////////
// Check if we have to die :P
//////////////////////////////////////////////////////////////////////////
if(InactiveMoveTime && UNIXTIME >= InactiveMoveTime)
break;
}
// Clear the instance's reference to us.
if(m_battleground)
{
BattlegroundManager.DeleteBattleground(m_battleground);
sInstanceMgr.DeleteBattlegroundInstance( GetMapId(), GetInstanceID() );
}
if(pInstance)
{
// check for a non-raid instance, these expire after 10 minutes.
if(GetMapInfo()->type == INSTANCE_NONRAID || pInstance->m_isBattleground)
{
pInstance->m_mapMgr = NULL;
sInstanceMgr._DeleteInstance(pInstance, true);
}
else
{
// just null out the pointer
pInstance->m_mapMgr=NULL;
}
}
else if(GetMapInfo()->type == INSTANCE_NULL)
sInstanceMgr.m_singleMaps[GetMapId()] = NULL;
// Teleport any left-over players out.
TeleportPlayers();
thread_running = false;
if(thread_kill_only)
return false;
// delete ourselves
delete this;
// already deleted, so the threadpool doesn't have to.
return false;
}
bool MapMgr::Do()
{
#ifdef WIN32
threadid = GetCurrentThreadId();
#endif
t_currentMapContext.set(this);
thread_running = true;
ThreadState.SetVal(THREADSTATE_BUSY);
SetThreadName("Map mgr - M%u|I%u", this->_mapId , this->m_instanceID);
ObjectSet::iterator i;
uint32 last_exec = getMSTime();
// Create Instance script
LoadInstanceScript();
/* create static objects */
for(GOSpawnList::iterator itr = _map->staticSpawns.GOSpawns.begin(); itr != _map->staticSpawns.GOSpawns.end(); ++itr)
{
GameObject* obj = CreateGameObject((*itr)->entry);
obj->Load((*itr));
PushStaticObject(obj);
}
// Call script OnLoad virtual procedure
CALL_INSTANCE_SCRIPT_EVENT(this, OnLoad)();
for(CreatureSpawnList::iterator itr = _map->staticSpawns.CreatureSpawns.begin(); itr != _map->staticSpawns.CreatureSpawns.end(); ++itr)
{
Creature* obj = CreateCreature((*itr)->entry);
obj->Load(*itr, 0, pMapInfo);
PushStaticObject(obj);
}
/* load corpses */
objmgr.LoadCorpses(this);
worldstateshandler.InitWorldStates( objmgr.GetWorldStatesForMap( _mapId ) );
worldstateshandler.setObserver( this );
// always declare local variables outside of the loop!
// otherwise there's a lot of sub esp; going on.
uint32 exec_time, exec_start;
while((GetThreadState() != THREADSTATE_TERMINATE) && !_shutdown)
{
exec_start = getMSTime();
///////////////////////////////////////////// first push to world new objects ////////////////////////////////////////////
m_objectinsertlock.Acquire();
if(m_objectinsertpool.size())
{
for(i = m_objectinsertpool.begin(); i != m_objectinsertpool.end(); ++i)
{
Object* o = *i;
o->PushToWorld(this);
}
m_objectinsertpool.clear();
}
m_objectinsertlock.Release();
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Now update sessions of this map + objects
_PerformObjectDuties();
last_exec = getMSTime();
exec_time = last_exec - exec_start;
if(exec_time < MAP_MGR_UPDATE_PERIOD)
{
Arcemu::Sleep(MAP_MGR_UPDATE_PERIOD - exec_time);
}
//////////////////////////////////////////////////////////////////////////
// Check if we have to die :P
//////////////////////////////////////////////////////////////////////////
if(InactiveMoveTime && UNIXTIME >= InactiveMoveTime)
break;
}
// Teleport any left-over players out.
TeleportPlayers();
// Clear the instance's reference to us.
if(m_battleground)
{
BattlegroundManager.DeleteBattleground(m_battleground);
sInstanceMgr.DeleteBattlegroundInstance(GetMapId(), GetInstanceID());
}
if(pInstance)
{
// check for a non-raid instance, these expire after 10 minutes.
if(GetMapInfo()->type == INSTANCE_NONRAID || pInstance->m_isBattleground)
{
pInstance->m_mapMgr = NULL;
sInstanceMgr._DeleteInstance(pInstance, true);
pInstance = NULL;
}
else
{
// just null out the pointer
pInstance->m_mapMgr = NULL;
}
}
else if(GetMapInfo()->type == INSTANCE_NULL)
sInstanceMgr.m_singleMaps[GetMapId()] = NULL;
thread_running = false;
if(thread_kill_only)
return false;
// delete ourselves
delete this;
// already deleted, so the threadpool doesn't have to.
return false;
}
