Class for manage Strand of Ancient battleground. More...

#include <BattlegroundSA.h>

Public Member Functions
	BattlegroundSA ()

	~BattlegroundSA ()

void	PostUpdateImpl (uint32 diff) override
	Called every time for update battle data -Update timer -Round switch. More...

void	AddPlayer (Player *player) override
	Called when a player join battle. More...

void	StartingEventCloseDoors () override
	Called when battle start. More...

void	StartingEventOpenDoors () override

bool	SetupBattleground () override
	Called for ini battleground, after that the first player be entered. More...

void	Reset () override

void	FillInitialWorldStates (WorldPackets::WorldState::InitWorldStates &packet) override
	Called for generate packet contain worldstate data. More...

void	HandleKillUnit (Creature creature, Player killer) override
	Called when a player kill a unit in bg. More...

WorldSafeLocsEntry const *	GetClosestGraveYard (Player *player) override
	Return the nearest graveyard where player can respawn. More...

void	ProcessEvent (WorldObject , uint32, WorldObject =NULL) override
	Called when someone activates an event. More...

void	EventPlayerClickedOnFlag (Player source, GameObject go) override
	Called when a player click on flag (graveyard flag) More...

void	TitanRelicActivated (Player *clicker)
	Called when a player clicked on relic. More...

GateInfo const *	GetGate (uint32 entry)
	Return GateInfo, relative to bg data, according to gameobject entry. More...

void	EndBattleground (uint32 winner) override
	Called on battleground ending. More...

void	RemovePlayer (Player *player, ObjectGuid guid, uint32 team) override
	Called when a player leave battleground. More...

void	HandleAreaTrigger (Player *source, uint32 trigger, bool entered) override

bool	CheckAchievementCriteriaMeet (uint32 criteriaId, Player const source, Unit const target=NULL, uint32 miscValue=0) override

bool	IsSpellAllowed (uint32 spellId, Player const *player) const override

Public Member Functions inherited from Battleground
	Battleground ()

virtual	~Battleground ()

void	Update (uint32 diff)

virtual void	ResetBGSubclass ()

virtual bool	IsAllNodesControlledByTeam (uint32) const

void	StartTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry)

std::string const &	GetName () const

uint64	GetQueueId () const

BattlegroundTypeId	GetTypeID (bool GetRandom=false) const

BattlegroundBracketId	GetBracketId () const

uint32	GetInstanceID () const

BattlegroundStatus	GetStatus () const

uint32	GetClientInstanceID () const

uint32	GetElapsedTime () const

uint32	GetRemainingTime () const

uint32	GetLastResurrectTime () const

uint32	GetMaxPlayers () const

uint32	GetMinPlayers () const

uint32	GetMinLevel () const

uint32	GetMaxLevel () const

uint32	GetMaxPlayersPerTeam () const

uint32	GetMinPlayersPerTeam () const

int32	GetStartDelayTime () const

uint8	GetArenaType () const

BattlegroundTeamId	GetWinner () const

uint32	GetScriptId () const

uint32	GetBonusHonorFromKill (uint32 kills) const

bool	IsRandom () const

void	SetQueueId (uint64 queueId)

void	SetName (std::string const &name)

void	SetTypeID (BattlegroundTypeId TypeID)

void	SetRandomTypeID (BattlegroundTypeId TypeID)

void	SetBracket (PvPDifficultyEntry const *bracketEntry)

void	SetInstanceID (uint32 InstanceID)

void	SetStatus (BattlegroundStatus Status)

void	SetClientInstanceID (uint32 InstanceID)

void	SetElapsedTime (uint32 Time)

void	SetRemainingTime (uint32 Time)

void	SetLastResurrectTime (uint32 Time)

void	SetMaxPlayers (uint32 MaxPlayers)

void	SetMinPlayers (uint32 MinPlayers)

void	SetLevelRange (uint32 min, uint32 max)

void	SetRated (bool state)

void	SetArenaType (uint8 type)

void	SetArenaorBGType (bool _isArena)

void	SetWinner (BattlegroundTeamId winnerTeamId)

void	SetScriptId (uint32 scriptId)

void	ModifyStartDelayTime (int diff)

void	SetStartDelayTime (int Time)

void	SetMaxPlayersPerTeam (uint32 MaxPlayers)

void	SetMinPlayersPerTeam (uint32 MinPlayers)

void	AddToBGFreeSlotQueue ()

void	RemoveFromBGFreeSlotQueue ()

void	DecreaseInvitedCount (uint32 team)

void	IncreaseInvitedCount (uint32 team)

void	SetRandom (bool isRandom)

uint32	GetInvitedCount (uint32 team) const

bool	HasFreeSlots () const

uint32	GetFreeSlotsForTeam (uint32 Team) const

bool	isArena () const

bool	isBattleground () const

bool	isRated () const

BattlegroundPlayerMap const &	GetPlayers () const

uint32	GetPlayersSize () const

uint32	GetPlayerScoresSize () const

uint32	GetReviveQueueSize () const

void	AddPlayerToResurrectQueue (ObjectGuid npc_guid, ObjectGuid player_guid)

void	RemovePlayerFromResurrectQueue (ObjectGuid player_guid)

void	RelocateDeadPlayers (ObjectGuid guideGuid)
	Relocate all players in ReviveQueue to the closest graveyard. More...

void	StartBattleground ()

GameObject *	GetBGObject (uint32 type, bool logError=true)

Creature *	GetBGCreature (uint32 type, bool logError=true)

void	SetMapId (uint32 MapID)

uint32	GetMapId () const

void	SetBgMap (BattlegroundMap *map)

BattlegroundMap *	GetBgMap () const

BattlegroundMap *	FindBgMap () const

void	SetTeamStartPosition (TeamId teamId, Position const &pos)

Position const *	GetTeamStartPosition (TeamId teamId) const

void	SetStartMaxDist (float startMaxDist)

float	GetStartMaxDist () const

void	SendPacketToTeam (uint32 TeamID, WorldPacket const packet, Player sender=NULL, bool self=true) const

void	SendPacketToAll (WorldPacket const *packet) const

void	SendChatMessage (Creature source, uint8 textId, WorldObject target=NULL)

template<class Do >
void	BroadcastWorker (Do &_do)

void	PlaySoundToTeam (uint32 SoundID, uint32 TeamID)

void	PlaySoundToAll (uint32 SoundID)

void	CastSpellOnTeam (uint32 SpellID, uint32 TeamID)

void	RemoveAuraOnTeam (uint32 SpellID, uint32 TeamID)

void	RewardHonorToTeam (uint32 Honor, uint32 TeamID)

void	RewardReputationToTeam (uint32 faction_id, uint32 Reputation, uint32 TeamID)

void	UpdateWorldState (uint32 variable, uint32 value, bool hidden=false)

void	BlockMovement (Player *player)

void	SendMessageToAll (uint32 entry, ChatMsg type, Player const *source=NULL)

void	PSendMessageToAll (uint32 entry, ChatMsg type, Player const *source,...)

void	SendMessage2ToAll (uint32 entry, ChatMsg type, Player const *source, uint32 strId1=0, uint32 strId2=0)

Group *	GetBgRaid (uint32 TeamID) const

void	SetBgRaid (uint32 TeamID, Group *bg_raid)

void	BuildPvPLogDataPacket (WorldPackets::Battleground::PVPLogData &pvpLogData)

virtual bool	UpdatePlayerScore (Player *player, uint32 type, uint32 value, bool doAddHonor=true)

uint32	GetPlayersCountByTeam (uint32 Team) const

uint32	GetAlivePlayersCountByTeam (uint32 Team) const

void	UpdatePlayersCountByTeam (uint32 Team, bool remove)

virtual void	CheckWinConditions ()

void	SetArenaTeamIdForTeam (uint32 Team, uint32 ArenaTeamId)

uint32	GetArenaTeamIdForTeam (uint32 Team) const

uint32	GetArenaTeamIdByIndex (uint32 index) const

void	SetArenaMatchmakerRating (uint32 Team, uint32 MMR)

uint32	GetArenaMatchmakerRating (uint32 Team) const

virtual void	HandleKillPlayer (Player player, Player killer)

virtual void	EventPlayerDroppedFlag (Player *)

void	EventPlayerLoggedIn (Player *player)

void	EventPlayerLoggedOut (Player *player)

virtual void	DoAction (uint32, ObjectGuid)

virtual void	HandlePlayerResurrect (Player *)

void	AddOrSetPlayerToCorrectBgGroup (Player *player, uint32 team)

virtual void	RemovePlayerAtLeave (ObjectGuid guid, bool Transport, bool SendPacket)

void	HandleTriggerBuff (ObjectGuid go_guid)

void	SetHoliday (bool is_holiday)

void	SpawnBGObject (uint32 type, uint32 respawntime)

virtual bool	AddObject (uint32 type, uint32 entry, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3, uint32 respawnTime=0, GOState goState=GO_STATE_READY)

bool	AddObject (uint32 type, uint32 entry, Position const &pos, float rotation0, float rotation1, float rotation2, float rotation3, uint32 respawnTime=0, GOState goState=GO_STATE_READY)

virtual Creature *	AddCreature (uint32 entry, uint32 type, float x, float y, float z, float o, TeamId teamId=TEAM_NEUTRAL, uint32 respawntime=0, Transport *transport=NULL)

Creature *	AddCreature (uint32 entry, uint32 type, Position const &pos, TeamId teamId=TEAM_NEUTRAL, uint32 respawntime=0, Transport *transport=NULL)

bool	DelCreature (uint32 type)

bool	DelObject (uint32 type)

virtual bool	AddSpiritGuide (uint32 type, float x, float y, float z, float o, TeamId teamId=TEAM_NEUTRAL)

bool	AddSpiritGuide (uint32 type, Position const &pos, TeamId teamId=TEAM_NEUTRAL)

int32	GetObjectType (ObjectGuid guid)

void	DoorOpen (uint32 type)

void	DoorClose (uint32 type)

virtual bool	HandlePlayerUnderMap (Player *)

uint32	GetPlayerTeam (ObjectGuid guid) const

uint32	GetOtherTeam (uint32 teamId) const

bool	IsPlayerInBattleground (ObjectGuid guid) const

bool	ToBeDeleted () const

void	SetDeleteThis ()

void	RewardXPAtKill (Player killer, Player victim)

bool	CanAwardArenaPoints () const

virtual ObjectGuid	GetFlagPickerGUID (int32=-1) const

virtual void	SetDroppedFlagGUID (ObjectGuid, int32=-1)

virtual void	HandleQuestComplete (uint32, Player *)

virtual bool	CanActivateGO (int32, uint32) const

uint32	GetTeamScore (uint32 TeamID) const

virtual uint32	GetPrematureWinner ()

uint8	GetUniqueBracketId () const

Private Member Functions
bool	ResetObjs ()
	Called on setup and between the two round -Delete all gameobject / creature -Respawn all gameobject / creature to have good faction. More...

void	StartShips ()
	Called for start ship movement. More...

void	TeleportPlayers ()
	Called between the two round -Teleport all players to good location. More...

void	TeleportToEntrancePosition (Player *player)

void	OverrideGunFaction ()
	Called on start and between the two round -Update faction of all vehicle. More...

void	DemolisherStartState (bool start)
	Set selectable or not demolisher, called on battle start, when boats arrive to dock. More...

bool	CanInteractWithObject (uint32 objectId)
	Checks if a player can interact with the given object. More...

void	UpdateObjectInteractionFlags (uint32 objectId)
	Updates interaction flags of specific objects. More...

void	UpdateObjectInteractionFlags ()

void	DestroyGate (Player player, GameObject go) override
	Called when a gate is destroy -Give honor to player witch destroy it -Update worldstate -Delete gameobject in front of door (lighting object, with different colours for each door) More...

void	SendTime ()
	Update timer worldstate. More...

void	CaptureGraveyard (BG_SA_Graveyards i, Player *Source)
	Called when a graveyard is capture -Update spiritguide -Update gameobject (flag) -Update Worldstate -Send warning for announce this. More...

void	ToggleTimer ()
	Switch on/off timer worldstate. More...

void	UpdateDemolisherSpawns ()
	Respawn dead demolisher. More...

void	SendTransportInit (Player *player)
	Send packet to player for create boats (client part) More...

void	SendTransportsRemove (Player *player)
	Send packet to player for destroy boats (client part) More...

Private Attributes
TeamId	Attackers
	Id of attacker team. More...

uint32	TotalTime
	Totale elapsed time of current round. More...

uint32	EndRoundTimer
	Max time of round. More...

bool	ShipsStarted
	For know if boats has start moving or not yet. More...

BG_SA_GateState	GateStatus [MAX_GATES]
	Status of each gate (Destroy/Damage/Intact) More...

BG_SA_Status	Status
	Statu of battle (Start or not, and what round) More...

TeamId	GraveyardStatus [BG_SA_MAX_GY]
	Team witch conntrol each graveyard. More...

BG_SA_RoundScore	RoundScores [2]
	Score of each round. More...

bool	TimerEnabled
	used for know we are in timer phase or not (used for worldstate update) More...

uint32	UpdateWaitTimer
	5secs before starting the 1min countdown for second round More...

bool	SignaledRoundTwo
	for know if warning about second round start has been sent More...

bool	SignaledRoundTwoHalfMin
	for know if warning about second round start has been sent More...

bool	InitSecondRound
	for know if second round has been init More...

std::map< uint32, uint32 >	DemoliserRespawnList

bool	_gateDestroyed

bool	_allVehiclesAlive [BG_TEAMS_COUNT]

Additional Inherited Members
Public Types inherited from Battleground
typedef std::map< ObjectGuid, BattlegroundPlayer >	BattlegroundPlayerMap

typedef std::map< ObjectGuid, BattlegroundScore * >	BattlegroundScoreMap

Static Public Member Functions inherited from Battleground
static TeamId	GetTeamIndexByTeamId (uint32 Team)

Public Attributes inherited from Battleground
GuidVector	BgObjects

GuidVector	BgCreatures

Protected Member Functions inherited from Battleground
void	EndNow ()

void	PlayerAddedToBGCheckIfBGIsRunning (Player *player)

Player *	_GetPlayer (ObjectGuid guid, bool offlineRemove, const char *context) const

Player *	_GetPlayer (BattlegroundPlayerMap::iterator itr, const char *context)

Player *	_GetPlayer (BattlegroundPlayerMap::const_iterator itr, const char *context) const

Player *	_GetPlayerForTeam (uint32 teamId, BattlegroundPlayerMap::const_iterator itr, const char *context) const

virtual bool	PreUpdateImpl (uint32)
	Pre-update hook. More...

void	_ProcessOfflineQueue ()

void	_ProcessResurrect (uint32 diff)

void	_ProcessProgress (uint32 diff)

void	_ProcessLeave (uint32 diff)

void	_ProcessJoin (uint32 diff)

void	_CheckSafePositions (uint32 diff)

void	_ProcessPlayerPositionBroadcast (uint32 diff)

virtual void	GetPlayerPositionData (std::vector< WorldPackets::Battleground::BattlegroundPlayerPosition > *) const

Protected Attributes inherited from Battleground
BattlegroundScoreMap	PlayerScores

BattlegroundPlayerMap	m_Players

std::map< ObjectGuid, GuidVector >	m_ReviveQueue

uint8	m_Events

BattlegroundStartTimeIntervals	StartDelayTimes [BG_STARTING_EVENT_COUNT]

uint32	StartMessageIds [BG_STARTING_EVENT_COUNT]

bool	m_BuffChange

bool	m_IsRandom

BGHonorMode	m_HonorMode

int32	m_TeamScores [BG_TEAMS_COUNT]

ArenaTeamScore	_arenaTeamScores [BG_TEAMS_COUNT]

Detailed Description

Class for manage Strand of Ancient battleground.

Constructor & Destructor Documentation

BattlegroundSA::BattlegroundSA ( )

This is here to prevent an uninitialised variable warning The warning only occurs when SetUpBattleGround fails though. In the future this function should be called BEFORE sending initial worldstates.

 {
  StartMessageIds[BG_STARTING_EVENT_FIRST] = LANG_BG_SA_START_TWO_MINUTES;
  StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_BG_SA_START_ONE_MINUTE;
  StartMessageIds[BG_STARTING_EVENT_THIRD] = LANG_BG_SA_START_HALF_MINUTE;
  StartMessageIds[BG_STARTING_EVENT_FOURTH] = 0;
 
  BgObjects.resize(BG_SA_MAXOBJ);
  BgCreatures.resize(BG_SA_MAXNPC + BG_SA_MAX_GY);
  TimerEnabled = false;
  UpdateWaitTimer = 0;
  SignaledRoundTwo = false;
  SignaledRoundTwoHalfMin = false;
  InitSecondRound = false;
  _gateDestroyed = false;
  Attackers = TEAM_ALLIANCE;
  TotalTime = 0;
  EndRoundTimer = 0;
  ShipsStarted = false;
  Status = BG_SA_NOT_STARTED;
 
  for (uint8 i = 0; i < MAX_GATES; ++i)
  GateStatus[i] = BG_SA_GATE_OK;
 
  for (uint8 i = 0; i < 2; i++)
  {
  RoundScores[i].winner = TEAM_ALLIANCE;
  RoundScores[i].time = 0;
  _allVehiclesAlive[i] = true;
  }
 
  memset(&GraveyardStatus, 0, sizeof(GraveyardStatus));
 }

BattlegroundSA::~BattlegroundSA ( )

64 { }

Member Function Documentation

void BattlegroundSA::AddPlayer ( Player * player )

overridevirtual

Called when a player join battle.

Reimplemented from Battleground.

 {
  Battleground::AddPlayer(player);
  PlayerScores[player->GetGUID()] = new BattlegroundSAScore(player->GetGUID(), player->GetBGTeam());
 
  SendTransportInit(player);
 
  TeleportToEntrancePosition(player);
 }

Here is the call graph for this function:

bool BattlegroundSA::CanInteractWithObject ( uint32 objectId )

private

Checks if a player can interact with the given object.

 {
  switch (objectId)
  {
  case BG_SA_TITAN_RELIC:
  if (GateStatus[BG_SA_ANCIENT_GATE] != BG_SA_GATE_DESTROYED || GateStatus[BG_SA_YELLOW_GATE] != BG_SA_GATE_DESTROYED)
  return false;
  // no break
  case BG_SA_CENTRAL_FLAG:
  if (GateStatus[BG_SA_RED_GATE] != BG_SA_GATE_DESTROYED && GateStatus[BG_SA_PURPLE_GATE] != BG_SA_GATE_DESTROYED)
  return false;
  // no break
  case BG_SA_LEFT_FLAG:
  case BG_SA_RIGHT_FLAG:
  if (GateStatus[BG_SA_GREEN_GATE] != BG_SA_GATE_DESTROYED && GateStatus[BG_SA_BLUE_GATE] != BG_SA_GATE_DESTROYED)
  return false;
  break;
  default:
  ABORT();
  break;
  }
 
  return true;
 }

Here is the caller graph for this function:

void BattlegroundSA::CaptureGraveyard	(	BG_SA_Graveyards	i,
		Player *	Source
	)

private

Called when a graveyard is capture -Update spiritguide -Update gameobject (flag) -Update Worldstate -Send warning for announce this.

Parameters

i	: id of graveyard
Source	: Player who capture gy

 {
  if (GraveyardStatus[i] == Attackers)
  return;
 
  DelCreature(BG_SA_MAXNPC + i);
  GraveyardStatus[i] = Source->GetTeamId();
  WorldSafeLocsEntry const* sg = sWorldSafeLocsStore.LookupEntry(BG_SA_GYEntries[i]);
  if (!sg)
  {
  TC_LOG_ERROR("bg.battleground", "BattlegroundSA::CaptureGraveyard: non-existant GY entry: %u", BG_SA_GYEntries[i]);
  return;
  }
 
  AddSpiritGuide(i + BG_SA_MAXNPC, sg->Loc.X, sg->Loc.Y, sg->Loc.Z, BG_SA_GYOrientation[i], GraveyardStatus[i]);
  uint32 npc = 0;
  uint32 flag = 0;
 
  switch (i)
  {
  case BG_SA_LEFT_CAPTURABLE_GY:
  flag = BG_SA_LEFT_FLAG;
  DelObject(flag);
  AddObject(flag, (BG_SA_ObjEntries[flag] - (Source->GetTeamId() == TEAM_ALLIANCE ? 0 : 1)),
  BG_SA_ObjSpawnlocs[flag], 0, 0, 0, 0, RESPAWN_ONE_DAY);
 
  npc = BG_SA_NPC_RIGSPARK;
  if (Creature* rigspark = AddCreature(BG_SA_NpcEntries[npc], npc, BG_SA_NpcSpawnlocs[npc], Attackers))
  rigspark->AI()->Talk(TEXT_SPARKLIGHT_RIGSPARK_SPAWN);
 
  for (uint8 j = BG_SA_DEMOLISHER_7; j <= BG_SA_DEMOLISHER_8; j++)
  {
  AddCreature(BG_SA_NpcEntries[j], j, BG_SA_NpcSpawnlocs[j], (Attackers == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE), 600);
 
  if (Creature* dem = GetBGCreature(j))
  dem->setFaction(BG_SA_Factions[Attackers]);
  }
 
  UpdateWorldState(BG_SA_LEFT_GY_ALLIANCE, GraveyardStatus[i] == TEAM_ALLIANCE);
  UpdateWorldState(BG_SA_LEFT_GY_HORDE, GraveyardStatus[i] == TEAM_HORDE);
 
  if (Creature* c = Source->FindNearestCreature(NPC_WORLD_TRIGGER, 500.0f))
  SendChatMessage(c, Source->GetTeamId() == TEAM_ALLIANCE ? TEXT_WEST_GRAVEYARD_CAPTURED_A : TEXT_WEST_GRAVEYARD_CAPTURED_H, Source);
 
  break;
  case BG_SA_RIGHT_CAPTURABLE_GY:
  flag = BG_SA_RIGHT_FLAG;
  DelObject(flag);
  AddObject(flag, (BG_SA_ObjEntries[flag] - (Source->GetTeamId() == TEAM_ALLIANCE ? 0 : 1)),
  BG_SA_ObjSpawnlocs[flag], 0, 0, 0, 0, RESPAWN_ONE_DAY);
 
  npc = BG_SA_NPC_SPARKLIGHT;
  if (Creature* sparklight = AddCreature(BG_SA_NpcEntries[npc], npc, BG_SA_NpcSpawnlocs[npc], Attackers))
  sparklight->AI()->Talk(TEXT_SPARKLIGHT_RIGSPARK_SPAWN);
 
  for (uint8 j = BG_SA_DEMOLISHER_5; j <= BG_SA_DEMOLISHER_6; j++)
  {
  AddCreature(BG_SA_NpcEntries[j], j, BG_SA_NpcSpawnlocs[j], Attackers == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE, 600);
 
  if (Creature* dem = GetBGCreature(j))
  dem->setFaction(BG_SA_Factions[Attackers]);
  }
 
  UpdateWorldState(BG_SA_RIGHT_GY_ALLIANCE, GraveyardStatus[i] == TEAM_ALLIANCE);
  UpdateWorldState(BG_SA_RIGHT_GY_HORDE, GraveyardStatus[i] == TEAM_HORDE);
 
  if (Creature* c = Source->FindNearestCreature(NPC_WORLD_TRIGGER, 500.0f))
  SendChatMessage(c, Source->GetTeamId() == TEAM_ALLIANCE ? TEXT_EAST_GRAVEYARD_CAPTURED_A : TEXT_EAST_GRAVEYARD_CAPTURED_H, Source);
 
  break;
  case BG_SA_CENTRAL_CAPTURABLE_GY:
  flag = BG_SA_CENTRAL_FLAG;
  DelObject(flag);
  AddObject(flag, (BG_SA_ObjEntries[flag] - (Source->GetTeamId() == TEAM_ALLIANCE ? 0 : 1)),
  BG_SA_ObjSpawnlocs[flag], 0, 0, 0, 0, RESPAWN_ONE_DAY);
 
  UpdateWorldState(BG_SA_CENTER_GY_ALLIANCE, GraveyardStatus[i] == TEAM_ALLIANCE);
  UpdateWorldState(BG_SA_CENTER_GY_HORDE, GraveyardStatus[i] == TEAM_HORDE);
 
  if (Creature* c = Source->FindNearestCreature(NPC_WORLD_TRIGGER, 500.0f))
  SendChatMessage(c, Source->GetTeamId() == TEAM_ALLIANCE ? TEXT_SOUTH_GRAVEYARD_CAPTURED_A : TEXT_SOUTH_GRAVEYARD_CAPTURED_H, Source);
 
  break;
  default:
  ABORT();
  break;
  };
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool BattlegroundSA::CheckAchievementCriteriaMeet	(	uint32	criteriaId,
		Player const *	source,
		Unit const *	target = `NULL`,
		uint32	miscValue = `0`
	)

overridevirtual

Reimplemented from Battleground.

 {
  switch (criteriaId)
  {
  case BG_CRITERIA_CHECK_NOT_EVEN_A_SCRATCH:
  return _allVehiclesAlive[GetTeamIndexByTeamId(source->GetTeam())];
  case BG_CRITERIA_CHECK_DEFENSE_OF_THE_ANCIENTS:
  return source->GetTeamId() != Attackers && !_gateDestroyed;
  }
 
  return Battleground::CheckAchievementCriteriaMeet(criteriaId, source, target, miscValue);
 }

Here is the call graph for this function:

void BattlegroundSA::DemolisherStartState ( bool start )

private

Set selectable or not demolisher, called on battle start, when boats arrive to dock.

 {
  if (!BgCreatures[0])
  return;
 
  // set flags only for the demolishers on the beach, factory ones dont need it
  for (uint8 i = BG_SA_DEMOLISHER_1; i <= BG_SA_DEMOLISHER_4; i++)
  {
  if (Creature* dem = GetBGCreature(i))
  {
  if (start)
  dem->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
  else
  dem->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
  }
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundSA::DestroyGate	(	Player *	player,
		GameObject *	go
	)

overrideprivatevirtual

Called when a gate is destroy -Give honor to player witch destroy it -Update worldstate -Delete gameobject in front of door (lighting object, with different colours for each door)

Reimplemented from Battleground.

685 {

686 }

void BattlegroundSA::EndBattleground ( uint32 winner )

overridevirtual

Called on battleground ending.

Reimplemented from Battleground.

 {
  // honor reward for winning
  if (winner == ALLIANCE)
  RewardHonorToTeam(GetBonusHonorFromKill(1), ALLIANCE);
  else if (winner == HORDE)
  RewardHonorToTeam(GetBonusHonorFromKill(1), HORDE);
 
  // complete map_end rewards (even if no team wins)
  RewardHonorToTeam(GetBonusHonorFromKill(2), ALLIANCE);
  RewardHonorToTeam(GetBonusHonorFromKill(2), HORDE);
 
  Battleground::EndBattleground(winner);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundSA::EventPlayerClickedOnFlag	(	Player *	source,
		GameObject *	go
	)

overridevirtual

Called when a player click on flag (graveyard flag)

Reimplemented from Battleground.

 {
  switch (go->GetEntry())
  {
  case 191307:
  case 191308:
  if (CanInteractWithObject(BG_SA_LEFT_FLAG))
  CaptureGraveyard(BG_SA_LEFT_CAPTURABLE_GY, source);
  break;
  case 191305:
  case 191306:
  if (CanInteractWithObject(BG_SA_RIGHT_FLAG))
  CaptureGraveyard(BG_SA_RIGHT_CAPTURABLE_GY, source);
  break;
  case 191310:
  case 191309:
  if (CanInteractWithObject(BG_SA_CENTRAL_FLAG))
  CaptureGraveyard(BG_SA_CENTRAL_CAPTURABLE_GY, source);
  break;
  default:
  return;
  };
 }

Here is the call graph for this function:

void BattlegroundSA::FillInitialWorldStates ( WorldPackets::WorldState::InitWorldStates & packet )

overridevirtual

Called for generate packet contain worldstate data.

Reimplemented from Battleground.

 {
  bool allyAttacks = Attackers == TEAM_ALLIANCE;
  bool hordeAttacks = Attackers == TEAM_HORDE;
 
  packet.Worldstates.emplace_back(uint32(BG_SA_ANCIENT_GATEWS), int32(GateStatus[BG_SA_ANCIENT_GATE]));
  packet.Worldstates.emplace_back(uint32(BG_SA_YELLOW_GATEWS), int32(GateStatus[BG_SA_YELLOW_GATE]));
  packet.Worldstates.emplace_back(uint32(BG_SA_GREEN_GATEWS), int32(GateStatus[BG_SA_GREEN_GATE]));
  packet.Worldstates.emplace_back(uint32(BG_SA_BLUE_GATEWS), int32(GateStatus[BG_SA_BLUE_GATE]));
  packet.Worldstates.emplace_back(uint32(BG_SA_RED_GATEWS), int32(GateStatus[BG_SA_RED_GATE]));
  packet.Worldstates.emplace_back(uint32(BG_SA_PURPLE_GATEWS), int32(GateStatus[BG_SA_PURPLE_GATE]));
 
  packet.Worldstates.emplace_back(uint32(BG_SA_BONUS_TIMER), 0);
 
  packet.Worldstates.emplace_back(uint32(BG_SA_HORDE_ATTACKS), int32(hordeAttacks));
  packet.Worldstates.emplace_back(uint32(BG_SA_ALLY_ATTACKS), int32(allyAttacks));
 
  // Time will be sent on first update...
  packet.Worldstates.emplace_back(uint32(BG_SA_ENABLE_TIMER), int32(TimerEnabled));
  packet.Worldstates.emplace_back(uint32(BG_SA_TIMER_MINS), 0);
  packet.Worldstates.emplace_back(uint32(BG_SA_TIMER_SEC_TENS), 0);
  packet.Worldstates.emplace_back(uint32(BG_SA_TIMER_SEC_DECS), 0);
 
  packet.Worldstates.emplace_back(uint32(BG_SA_RIGHT_GY_HORDE), int32(GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_HORDE));
  packet.Worldstates.emplace_back(uint32(BG_SA_LEFT_GY_HORDE), int32(GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_HORDE));
  packet.Worldstates.emplace_back(uint32(BG_SA_CENTER_GY_HORDE), int32(GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_HORDE));
 
  packet.Worldstates.emplace_back(uint32(BG_SA_RIGHT_GY_ALLIANCE), int32(GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_ALLIANCE));
  packet.Worldstates.emplace_back(uint32(BG_SA_LEFT_GY_ALLIANCE), int32(GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_ALLIANCE));
  packet.Worldstates.emplace_back(uint32(BG_SA_CENTER_GY_ALLIANCE), int32(GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_ALLIANCE));
 
  packet.Worldstates.emplace_back(uint32(BG_SA_HORDE_DEFENCE_TOKEN), int32(allyAttacks));
  packet.Worldstates.emplace_back(uint32(BG_SA_ALLIANCE_DEFENCE_TOKEN), int32(hordeAttacks));
 
  packet.Worldstates.emplace_back(uint32(BG_SA_LEFT_ATT_TOKEN_HRD), int32(hordeAttacks));
  packet.Worldstates.emplace_back(uint32(BG_SA_RIGHT_ATT_TOKEN_HRD), int32(hordeAttacks));
  packet.Worldstates.emplace_back(uint32(BG_SA_RIGHT_ATT_TOKEN_ALL), int32(allyAttacks));
  packet.Worldstates.emplace_back(uint32(BG_SA_LEFT_ATT_TOKEN_ALL), int32(allyAttacks));
 }

WorldSafeLocsEntry const * BattlegroundSA::GetClosestGraveYard ( Player * player )

overridevirtual

Return the nearest graveyard where player can respawn.

Reimplemented from Battleground.

 {
     uint32 safeloc = 0;
     WorldSafeLocsEntry const* ret;
     WorldSafeLocsEntry const* closest;
     float dist, nearest;
     float x, y, z;
 
     player->GetPosition(x, y, z);
 
     if (player->GetTeamId() == Attackers)
         safeloc = BG_SA_GYEntries[BG_SA_BEACH_GY];
     else
         safeloc = BG_SA_GYEntries[BG_SA_DEFENDER_LAST_GY];
 
     closest = sWorldSafeLocsStore.LookupEntry(safeloc);
     nearest = player->GetExactDistSq(closest->Loc.X, closest->Loc.Y, closest->Loc.Z);
 
     for (uint8 i = BG_SA_RIGHT_CAPTURABLE_GY; i < BG_SA_MAX_GY; i++)
     {
         if (GraveyardStatus[i] != player->GetTeamId())
             continue;
 
         ret = sWorldSafeLocsStore.LookupEntry(BG_SA_GYEntries[i]);
         dist = player->GetExactDistSq(ret->Loc.X, ret->Loc.Y, ret->Loc.Z);
         if (dist < nearest)
         {
             closest = ret;
             nearest = dist;
         }
     }
 
     return closest;
 }

GateInfo const* BattlegroundSA::GetGate ( uint32 entry )

inline

Return GateInfo, relative to bg data, according to gameobject entry.

         {
             for (uint8 i = 0; i < MAX_GATES; ++i)
                 if (Gates[i].GameObjectId == entry)
                     return &Gates[i];
             return NULL;
         }

Here is the caller graph for this function:

void BattlegroundSA::HandleAreaTrigger	(	Player *	source,
		uint32	trigger,
		bool	entered
	)

overridevirtual

Reimplemented from Battleground.

 {
     // this is wrong way to implement these things. On official it done by gameobject spell cast.
     if (GetStatus() != STATUS_IN_PROGRESS)
         return;
 }

Here is the call graph for this function:

void BattlegroundSA::HandleKillUnit	(	Creature *	creature,
		Player *	killer
	)

overridevirtual

Called when a player kill a unit in bg.

Reimplemented from Battleground.

 {
     if (creature->GetEntry() == NPC_DEMOLISHER_SA)
     {
         UpdatePlayerScore(killer, SCORE_DESTROYED_DEMOLISHER, 1);
         _allVehiclesAlive[Attackers] = false;
     }
 }

Here is the call graph for this function:

bool BattlegroundSA::IsSpellAllowed	(	uint32	spellId,
		Player const *	player
	)		const

overridevirtual

Reimplemented from Battleground.

 {
     switch (spellId)
     {
         case SPELL_ALLIANCE_CONTROL_PHASE_SHIFT:
             return Attackers == TEAM_HORDE;
         case SPELL_HORDE_CONTROL_PHASE_SHIFT:
             return Attackers == TEAM_ALLIANCE;
         case SPELL_PREPARATION:
             return Status == BG_SA_WARMUP || Status == BG_SA_SECOND_WARMUP;
         default:
            break;
     }
 
     return true;
 }

void BattlegroundSA::OverrideGunFaction ( )

private

Called on start and between the two round -Update faction of all vehicle.

 {
     if (!BgCreatures[0])
         return;
 
     for (uint8 i = BG_SA_GUN_1; i <= BG_SA_GUN_10; i++)
     {
         if (Creature* gun = GetBGCreature(i))
             gun->setFaction(BG_SA_Factions[Attackers ? TEAM_ALLIANCE : TEAM_HORDE]);
     }
 
     for (uint8 i = BG_SA_DEMOLISHER_1; i <= BG_SA_DEMOLISHER_4; i++)
     {
         if (Creature* dem = GetBGCreature(i))
             dem->setFaction(BG_SA_Factions[Attackers]);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundSA::PostUpdateImpl ( uint32 diff )

overridevirtual

Called every time for update battle data -Update timer -Round switch.

Reimplemented from Battleground.

 {
     if (InitSecondRound)
     {
         if (UpdateWaitTimer < diff)
         {
             if (!SignaledRoundTwo)
             {
                 SignaledRoundTwo = true;
                 InitSecondRound = false;
                 SendMessageToAll(LANG_BG_SA_ROUND_TWO_ONE_MINUTE, CHAT_MSG_BG_SYSTEM_NEUTRAL);
             }
         }
         else
         {
             UpdateWaitTimer -= diff;
             return;
         }
     }
     TotalTime += diff;
 
     if (Status == BG_SA_WARMUP)
     {
         EndRoundTimer = BG_SA_ROUNDLENGTH;
         if (TotalTime >= BG_SA_WARMUPLENGTH)
         {
             if (Creature* c = GetBGCreature(BG_SA_NPC_KANRETHAD))
                 SendChatMessage(c, TEXT_ROUND_STARTED);
 
             TotalTime = 0;
             ToggleTimer();
             DemolisherStartState(false);
             Status = BG_SA_ROUND_ONE;
             StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, (Attackers == TEAM_ALLIANCE) ? 23748 : 21702);
         }
         if (TotalTime >= BG_SA_BOAT_START)
             StartShips();
         return;
     }
     else if (Status == BG_SA_SECOND_WARMUP)
     {
         if (RoundScores[0].time<BG_SA_ROUNDLENGTH)
             EndRoundTimer = RoundScores[0].time;
         else
             EndRoundTimer = BG_SA_ROUNDLENGTH;
 
         if (TotalTime >= 60000)
         {
             if (Creature* c = GetBGCreature(BG_SA_NPC_KANRETHAD))
                 SendChatMessage(c, TEXT_ROUND_STARTED);
 
             TotalTime = 0;
             ToggleTimer();
             DemolisherStartState(false);
             Status = BG_SA_ROUND_TWO;
             StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, (Attackers == TEAM_ALLIANCE) ? 23748 : 21702);
             // status was set to STATUS_WAIT_JOIN manually for Preparation, set it back now
             SetStatus(STATUS_IN_PROGRESS);
             for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
                 if (Player* p = ObjectAccessor::FindPlayer(itr->first))
                     p->RemoveAurasDueToSpell(SPELL_PREPARATION);
         }
         if (TotalTime >= 30000)
         {
             if (!SignaledRoundTwoHalfMin)
             {
                 SignaledRoundTwoHalfMin = true;
                 SendMessageToAll(LANG_BG_SA_ROUND_TWO_START_HALF_MINUTE, CHAT_MSG_BG_SYSTEM_NEUTRAL);
             }
         }
         StartShips();
         return;
     }
     else if (GetStatus() == STATUS_IN_PROGRESS)
     {
         if (Status == BG_SA_ROUND_ONE)
         {
             if (TotalTime >= BG_SA_ROUNDLENGTH)
             {
                 CastSpellOnTeam(SPELL_END_OF_ROUND, ALLIANCE);
                 CastSpellOnTeam(SPELL_END_OF_ROUND, HORDE);
                 RoundScores[0].winner = Attackers;
                 RoundScores[0].time = BG_SA_ROUNDLENGTH;
                 TotalTime = 0;
                 Status = BG_SA_SECOND_WARMUP;
                 Attackers = (Attackers == TEAM_ALLIANCE) ? TEAM_HORDE : TEAM_ALLIANCE;
                 UpdateWaitTimer = 5000;
                 SignaledRoundTwo = false;
                 SignaledRoundTwoHalfMin = false;
                 InitSecondRound = true;
                 ToggleTimer();
                 ResetObjs();
                 GetBgMap()->UpdateAreaDependentAuras();
                 return;
             }
         }
         else if (Status == BG_SA_ROUND_TWO)
         {
             if (TotalTime >= EndRoundTimer)
             {
                 CastSpellOnTeam(SPELL_END_OF_ROUND, ALLIANCE);
                 CastSpellOnTeam(SPELL_END_OF_ROUND, HORDE);
                 RoundScores[1].time = BG_SA_ROUNDLENGTH;
                 RoundScores[1].winner = (Attackers == TEAM_ALLIANCE) ? TEAM_HORDE : TEAM_ALLIANCE;
                 if (RoundScores[0].time == RoundScores[1].time)
                     EndBattleground(0);
                 else if (RoundScores[0].time < RoundScores[1].time)
                     EndBattleground(RoundScores[0].winner == TEAM_ALLIANCE ? ALLIANCE : HORDE);
                 else
                     EndBattleground(RoundScores[1].winner == TEAM_ALLIANCE ? ALLIANCE : HORDE);
                 return;
             }
         }
         if (Status == BG_SA_ROUND_ONE || Status == BG_SA_ROUND_TWO)
         {
             SendTime();
             UpdateDemolisherSpawns();
         }
     }
 }

Here is the call graph for this function:

void BattlegroundSA::ProcessEvent	(	WorldObject *	obj,
		uint32	eventId,
		WorldObject *	invoker = `NULL`
	)

overridevirtual

Called when someone activates an event.

Reimplemented from Battleground.

 {
     if (GameObject* go = obj->ToGameObject())
     {
         switch (go->GetGoType())
         {
             case GAMEOBJECT_TYPE_GOOBER:
                 if (invoker)
                     if (eventId == BG_SA_EVENT_TITAN_RELIC_ACTIVATED)
                         TitanRelicActivated(invoker->ToPlayer());
                 break;
             case GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING:
             {
                 if (GateInfo const* gate = GetGate(obj->GetEntry()))
                 {
                     uint8 gateId = gate->GateId;
 
                     // damaged
                     if (eventId == go->GetGOInfo()->destructibleBuilding.DamagedEvent)
                     {
                         GateStatus[gateId] = BG_SA_GATE_DAMAGED;
 
                         if (Creature* c = obj->FindNearestCreature(NPC_WORLD_TRIGGER, 500.0f))
                             SendChatMessage(c, gate->DamagedText, invoker);
 
                         PlaySoundToAll(Attackers == TEAM_ALLIANCE ? SOUND_WALL_ATTACKED_ALLIANCE : SOUND_WALL_ATTACKED_HORDE);
                     }
                     // destroyed
                     else if (eventId == go->GetGOInfo()->destructibleBuilding.DestroyedEvent)
                     {
                         GateStatus[gate->GateId] = BG_SA_GATE_DESTROYED;
                         _gateDestroyed = true;
 
                         if (gateId < 5)
                             DelObject(gateId + 14);
 
                         if (Creature* c = obj->FindNearestCreature(NPC_WORLD_TRIGGER, 500.0f))
                             SendChatMessage(c, gate->DestroyedText, invoker);
 
                         PlaySoundToAll(Attackers == TEAM_ALLIANCE ? SOUND_WALL_DESTROYED_ALLIANCE : SOUND_WALL_DESTROYED_HORDE);
 
                         bool rewardHonor = true;
                         switch (gateId)
                         {
                             case BG_SA_GREEN_GATE:
                                 if (GateStatus[BG_SA_BLUE_GATE] == BG_SA_GATE_DESTROYED)
                                     rewardHonor = false;
                                 break;
                             case BG_SA_BLUE_GATE:
                                 if (GateStatus[BG_SA_GREEN_GATE] == BG_SA_GATE_DESTROYED)
                                     rewardHonor = false;
                                 break;
                             case BG_SA_RED_GATE:
                                 if (GateStatus[BG_SA_PURPLE_GATE] == BG_SA_GATE_DESTROYED)
                                     rewardHonor = false;
                                 break;
                             case BG_SA_PURPLE_GATE:
                                 if (GateStatus[BG_SA_RED_GATE] == BG_SA_GATE_DESTROYED)
                                     rewardHonor = false;
                                 break;
                             default:
                                 break;
                         }
 
                         if (invoker)
                         {
                             if (Unit* unit = invoker->ToUnit())
                             {
                                 if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
                                 {
                                     UpdatePlayerScore(player, SCORE_DESTROYED_WALL, 1);
                                     if (rewardHonor)
                                         UpdatePlayerScore(player, SCORE_BONUS_HONOR, GetBonusHonorFromKill(1));
                                 }
                             }
                         }
 
                         UpdateObjectInteractionFlags();
                     }
                     else
                         break;
 
                     UpdateWorldState(gate->WorldState, GateStatus[gateId]);
                 }
                 break;
             }
             default:
                 break;
         }
     }
 }

Here is the call graph for this function:

void BattlegroundSA::RemovePlayer	(	Player *	player,
		ObjectGuid	guid,
		uint32	team
	)

overridevirtual

Called when a player leave battleground.

Reimplemented from Battleground.

488 { }

void BattlegroundSA::Reset ( )

overridevirtual

Reimplemented from Battleground.

 {
     TotalTime = 0;
     Attackers = ((urand(0, 1)) ? TEAM_ALLIANCE : TEAM_HORDE);
     for (uint8 i = 0; i <= 5; i++)
         GateStatus[i] = BG_SA_GATE_OK;
     ShipsStarted = false;
     _gateDestroyed = false;
     _allVehiclesAlive[TEAM_ALLIANCE] = true;
     _allVehiclesAlive[TEAM_HORDE] = true;
     Status = BG_SA_WARMUP;
 }

Here is the call graph for this function:

bool BattlegroundSA::ResetObjs ( )

private

Called on setup and between the two round -Delete all gameobject / creature -Respawn all gameobject / creature to have good faction.

 {
     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 < MAX_GATES; ++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();
 
     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->Loc.X, sg->Loc.Y, sg->Loc.Z, BG_SA_GYOrientation[i], Attackers);
         }
         else
         {
             GraveyardStatus[i] = ((Attackers == TEAM_HORDE)? TEAM_ALLIANCE : TEAM_HORDE);
             if (!AddSpiritGuide(i + BG_SA_MAXNPC, sg->Loc.X, sg->Loc.Y, sg->Loc.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);
     }
 
     UpdateObjectInteractionFlags();
 
     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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundSA::SendTime ( )

private

Update timer worldstate.

 {
     uint32 end_of_round = (EndRoundTimer - TotalTime);
     UpdateWorldState(BG_SA_TIMER_MINS, end_of_round/60000);
     UpdateWorldState(BG_SA_TIMER_SEC_TENS, (end_of_round%60000)/10000);
     UpdateWorldState(BG_SA_TIMER_SEC_DECS, ((end_of_round%60000)%10000)/1000);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundSA::SendTransportInit ( Player * player )

private

Send packet to player for create boats (client part)

 {
     if (!BgObjects[BG_SA_BOAT_ONE].IsEmpty() || !BgObjects[BG_SA_BOAT_TWO].IsEmpty())
     {
         UpdateData transData(player->GetMapId());
         if (!BgObjects[BG_SA_BOAT_ONE].IsEmpty())
             GetBGObject(BG_SA_BOAT_ONE)->BuildCreateUpdateBlockForPlayer(&transData, player);
 
         if (!BgObjects[BG_SA_BOAT_TWO].IsEmpty())
             GetBGObject(BG_SA_BOAT_TWO)->BuildCreateUpdateBlockForPlayer(&transData, player);
 
         WorldPacket packet;
         transData.BuildPacket(&packet);
         player->SendDirectMessage(&packet);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundSA::SendTransportsRemove ( Player * player )

private

Send packet to player for destroy boats (client part)

 {
     if (!BgObjects[BG_SA_BOAT_ONE].IsEmpty() || !BgObjects[BG_SA_BOAT_TWO].IsEmpty())
     {
         UpdateData transData(player->GetMapId());
         if (!BgObjects[BG_SA_BOAT_ONE].IsEmpty())
             GetBGObject(BG_SA_BOAT_ONE)->BuildOutOfRangeUpdateBlock(&transData);
         if (!BgObjects[BG_SA_BOAT_TWO].IsEmpty())
             GetBGObject(BG_SA_BOAT_TWO)->BuildOutOfRangeUpdateBlock(&transData);
         WorldPacket packet;
         transData.BuildPacket(&packet);
         player->SendDirectMessage(&packet);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool BattlegroundSA::SetupBattleground ( )

overridevirtual

Called for ini battleground, after that the first player be entered.

Reimplemented from Battleground.

 {
     return ResetObjs();
 }

Here is the call graph for this function:

void BattlegroundSA::StartingEventCloseDoors ( )

overridevirtual

Called when battle start.

Reimplemented from Battleground.

434 { }

void BattlegroundSA::StartingEventOpenDoors ( )

overridevirtual

Reimplemented from Battleground.

436 { }

void BattlegroundSA::StartShips ( )

private

Called for start ship movement.

 {
     if (ShipsStarted)
         return;
 
     DoorOpen(BG_SA_BOAT_ONE);
     DoorOpen(BG_SA_BOAT_TWO);
 
     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* p = ObjectAccessor::FindPlayer(itr->first))
             {
                 UpdateData data(p->GetMapId());
                 WorldPacket pkt;
                 GetBGObject(i)->BuildValuesUpdateBlockForPlayer(&data, p);
                 data.BuildPacket(&pkt);
                 p->SendDirectMessage(&pkt);
             }
         }
     }
     ShipsStarted = true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundSA::TeleportPlayers ( )

private

Called between the two round -Teleport all players to good location.

 {
     for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
     {
         if (Player* player = ObjectAccessor::FindPlayer(itr->first))
         {
             // should remove spirit of redemption
             if (player->HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))
                 player->RemoveAurasByType(SPELL_AURA_MOD_SHAPESHIFT);
 
             if (!player->IsAlive())
             {
                 player->ResurrectPlayer(1.0f);
                 player->SpawnCorpseBones();
             }
 
             player->ResetAllPowers();
             player->CombatStopWithPets(true);
 
             player->CastSpell(player, SPELL_PREPARATION, true);
 
             TeleportToEntrancePosition(player);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundSA::TeleportToEntrancePosition ( Player * player )

private

 {
     if (player->GetTeamId() == Attackers)
     {
         if (!ShipsStarted)
         {
             // player->AddUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT);
 
             if (urand(0, 1))
                 player->TeleportTo(607, 2682.936f, -830.368f, 15.0f, 2.895f, 0);
             else
                 player->TeleportTo(607, 2577.003f, 980.261f, 15.0f, 0.807f, 0);
         }
         else
             player->TeleportTo(607, 1600.381f, -106.263f, 8.8745f, 3.78f, 0);
     }
     else
         player->TeleportTo(607, 1209.7f, -65.16f, 70.1f, 0.0f, 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundSA::TitanRelicActivated ( Player * clicker )

Called when a player clicked on relic.

 {
     if (!clicker)
         return;
 
     if (CanInteractWithObject(BG_SA_TITAN_RELIC))
     {
         if (clicker->GetTeamId() == Attackers)
         {
             if (clicker->GetTeamId() == TEAM_ALLIANCE)
                 SendMessageToAll(LANG_BG_SA_ALLIANCE_CAPTURED_RELIC, CHAT_MSG_BG_SYSTEM_NEUTRAL);
             else
                 SendMessageToAll(LANG_BG_SA_HORDE_CAPTURED_RELIC, CHAT_MSG_BG_SYSTEM_NEUTRAL);
 
             if (Status == BG_SA_ROUND_ONE)
             {
                 RoundScores[0].winner = Attackers;
                 RoundScores[0].time = TotalTime;
                 // Achievement Storm the Beach (1310)
                 for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
                 {
                     if (Player* player = ObjectAccessor::FindPlayer(itr->first))
                         if (player->GetTeamId() == Attackers)
                             player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, 65246);
                 }
 
                 Attackers = (Attackers == TEAM_ALLIANCE) ? TEAM_HORDE : TEAM_ALLIANCE;
                 Status = BG_SA_SECOND_WARMUP;
                 TotalTime = 0;
                 ToggleTimer();
 
                 if (Creature* c = GetBGCreature(BG_SA_NPC_KANRETHAD))
                     SendChatMessage(c, TEXT_ROUND_1_FINISHED);
 
                 UpdateWaitTimer = 5000;
                 SignaledRoundTwo = false;
                 SignaledRoundTwoHalfMin = false;
                 InitSecondRound = true;
                 ResetObjs();
                 GetBgMap()->UpdateAreaDependentAuras();
                 CastSpellOnTeam(SPELL_END_OF_ROUND, ALLIANCE);
                 CastSpellOnTeam(SPELL_END_OF_ROUND, HORDE);
             }
             else if (Status == BG_SA_ROUND_TWO)
             {
                 RoundScores[1].winner = Attackers;
                 RoundScores[1].time = TotalTime;
                 ToggleTimer();
                 // Achievement Storm the Beach (1310)
                 for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
                 {
                     if (Player* player = ObjectAccessor::FindPlayer(itr->first))
                         if (player->GetTeamId() == Attackers && RoundScores[1].winner == Attackers)
                             player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, 65246);
                 }
 
                 if (RoundScores[0].time == RoundScores[1].time)
                     EndBattleground(0);
                 else if (RoundScores[0].time < RoundScores[1].time)
                     EndBattleground(RoundScores[0].winner == TEAM_ALLIANCE ? ALLIANCE : HORDE);
                 else
                     EndBattleground(RoundScores[1].winner == TEAM_ALLIANCE ? ALLIANCE : HORDE);
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundSA::ToggleTimer ( )

private

Switch on/off timer worldstate.

 {
     TimerEnabled = !TimerEnabled;
     UpdateWorldState(BG_SA_ENABLE_TIMER, TimerEnabled);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundSA::UpdateDemolisherSpawns ( )

private

Respawn dead demolisher.

 {
     for (uint8 i = BG_SA_DEMOLISHER_1; i <= BG_SA_DEMOLISHER_8; i++)
     {
         if (!BgCreatures[i].IsEmpty())
         {
             if (Creature* Demolisher = GetBGCreature(i))
             {
                 if (Demolisher->isDead())
                 {
                     // Demolisher is not in list
                     if (DemoliserRespawnList.find(i) == DemoliserRespawnList.end())
                     {
                         DemoliserRespawnList[i] = getMSTime()+30000;
                     }
                     else
                     {
                         if (DemoliserRespawnList[i] < getMSTime())
                         {
                             Demolisher->Relocate(BG_SA_NpcSpawnlocs[i]);
                             Demolisher->Respawn();
                             DemoliserRespawnList.erase(i);
                         }
                     }
                 }
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundSA::UpdateObjectInteractionFlags ( uint32 objectId )

private

Updates interaction flags of specific objects.

 {
     if (GameObject* go = GetBGObject(objectId))
     {
         if (CanInteractWithObject(objectId))
             go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
         else
             go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
     }
 }

Here is the call graph for this function:

void BattlegroundSA::UpdateObjectInteractionFlags ( )

private

 {
     for (uint8 i = BG_SA_CENTRAL_FLAG; i <= BG_SA_LEFT_FLAG; ++i)
         UpdateObjectInteractionFlags(i);
     UpdateObjectInteractionFlags(BG_SA_TITAN_RELIC);
 }

Here is the caller graph for this function:

Member Data Documentation

bool BattlegroundSA::_allVehiclesAlive[BG_TEAMS_COUNT]

private

bool BattlegroundSA::_gateDestroyed

private

TeamId BattlegroundSA::Attackers

private

Id of attacker team.

std::map<uint32, uint32> BattlegroundSA::DemoliserRespawnList

private

uint32 BattlegroundSA::EndRoundTimer

private

Max time of round.

BG_SA_GateState BattlegroundSA::GateStatus[MAX_GATES]

private

Status of each gate (Destroy/Damage/Intact)

TeamId BattlegroundSA::GraveyardStatus[BG_SA_MAX_GY]

private

Team witch conntrol each graveyard.

bool BattlegroundSA::InitSecondRound

private

for know if second round has been init

BG_SA_RoundScore BattlegroundSA::RoundScores[2]

private

Score of each round.

bool BattlegroundSA::ShipsStarted

private

For know if boats has start moving or not yet.

bool BattlegroundSA::SignaledRoundTwo

private

for know if warning about second round start has been sent

bool BattlegroundSA::SignaledRoundTwoHalfMin

private

for know if warning about second round start has been sent

BG_SA_Status BattlegroundSA::Status

private

Statu of battle (Start or not, and what round)

bool BattlegroundSA::TimerEnabled

private

used for know we are in timer phase or not (used for worldstate update)

uint32 BattlegroundSA::TotalTime

private

Totale elapsed time of current round.

uint32 BattlegroundSA::UpdateWaitTimer

private

5secs before starting the 1min countdown for second round

The documentation for this class was generated from the following files:

src/server/game/Battlegrounds/Zones/BattlegroundSA.h
src/server/game/Battlegrounds/Zones/BattlegroundSA.cpp

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation