#include <BattlegroundAB.h>

Public Member Functions
	BattlegroundAB ()

	~BattlegroundAB ()

void	AddPlayer (Player *player) override

void	StartingEventCloseDoors () override

void	StartingEventOpenDoors () override

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

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

bool	SetupBattleground () override

void	Reset () override

void	EndBattleground (uint32 winner) override

WorldSafeLocsEntry const *	GetClosestGraveYard (Player *player) override

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

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

void	EventPlayerClickedOnFlag (Player source, GameObject target_obj) override

bool	IsAllNodesControlledByTeam (uint32 team) const override

bool	CheckAchievementCriteriaMeet (uint32, Player const , Unit const =nullptr, uint32=0) override

uint32	GetPrematureWinner () override

Public Member Functions inherited from Battleground
	Battleground ()

virtual	~Battleground ()

void	Update (uint32 diff)

virtual void	ResetBGSubclass ()

virtual void	DestroyGate (Player , GameObject )

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)

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	HandleKillUnit (Creature , Player )

virtual void	EventPlayerDroppedFlag (Player *)

void	EventPlayerLoggedIn (Player *player)

void	EventPlayerLoggedOut (Player *player)

virtual void	ProcessEvent (WorldObject , uint32, WorldObject =NULL)

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

virtual bool	IsSpellAllowed (uint32, Player const *) const

uint32	GetTeamScore (uint32 TeamID) const

uint8	GetUniqueBracketId () const

Private Member Functions
void	PostUpdateImpl (uint32 diff) override
	Post-update hook. More...

void	_CreateBanner (uint8 node, uint8 type, uint8 teamIndex, bool delay)

void	_DelBanner (uint8 node, uint8 type, uint8 teamIndex)

void	_SendNodeUpdate (uint8 node)

void	_NodeOccupied (uint8 node, Team team)

void	_NodeDeOccupied (uint8 node)

int32	_GetNodeNameId (uint8 node)

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]

Constructor & Destructor Documentation

BattlegroundAB::BattlegroundAB ( )

 {
  m_IsInformedNearVictory = false;
  m_BuffChange = true;
  BgObjects.resize(BG_AB_OBJECT_MAX);
  BgCreatures.resize(BG_AB_ALL_NODES_COUNT + 5);//+5 for aura triggers
 
  for (uint8 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
  {
  m_Nodes[i] = 0;
  m_prevNodes[i] = 0;
  m_NodeTimers[i] = 0;
  m_BannerTimers[i].timer = 0;
  m_BannerTimers[i].type = 0;
  m_BannerTimers[i].teamIndex = 0;
  }
 
  for (uint8 i = 0; i < BG_TEAMS_COUNT; ++i)
  {
  m_lastTick[i] = 0;
  m_HonorScoreTics[i] = 0;
  m_ReputationScoreTics[i] = 0;
  m_TeamScores500Disadvantage[i] = false;
  }
 
  m_HonorTics = 0;
  m_ReputationTics = 0;
 
  StartMessageIds[BG_STARTING_EVENT_FIRST] = LANG_BG_AB_START_TWO_MINUTES;
  StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_BG_AB_START_ONE_MINUTE;
  StartMessageIds[BG_STARTING_EVENT_THIRD] = LANG_BG_AB_START_HALF_MINUTE;
  StartMessageIds[BG_STARTING_EVENT_FOURTH] = LANG_BG_AB_HAS_BEGUN;
 }

BattlegroundAB::~BattlegroundAB ( )

62 { }

Member Function Documentation

void BattlegroundAB::_CreateBanner	(	uint8	node,
		uint8	type,
		uint8	teamIndex,
		bool	delay
	)

private

 {
  // Just put it into the queue
  if (delay)
  {
  m_BannerTimers[node].timer = 2000;
  m_BannerTimers[node].type = type;
  m_BannerTimers[node].teamIndex = teamIndex;
  return;
  }
 
  uint8 obj = node*8 + type + teamIndex;
 
  SpawnBGObject(obj, RESPAWN_IMMEDIATELY);
 
  // handle aura with banner
  if (!type)
  return;
  obj = node * 8 + ((type == BG_AB_NODE_TYPE_OCCUPIED) ? (5 + teamIndex) : 7);
  SpawnBGObject(obj, RESPAWN_IMMEDIATELY);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundAB::_DelBanner	(	uint8	node,
		uint8	type,
		uint8	teamIndex
	)

private

 {
  uint8 obj = node*8 + type + teamIndex;
  SpawnBGObject(obj, RESPAWN_ONE_DAY);
 
  // handle aura with banner
  if (!type)
  return;
  obj = node * 8 + ((type == BG_AB_NODE_TYPE_OCCUPIED) ? (5 + teamIndex) : 7);
  SpawnBGObject(obj, RESPAWN_ONE_DAY);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 BattlegroundAB::_GetNodeNameId ( uint8 node )

private

 {
  switch (node)
  {
  case BG_AB_NODE_STABLES: return LANG_BG_AB_NODE_STABLES;
  case BG_AB_NODE_BLACKSMITH: return LANG_BG_AB_NODE_BLACKSMITH;
  case BG_AB_NODE_FARM: return LANG_BG_AB_NODE_FARM;
  case BG_AB_NODE_LUMBER_MILL:return LANG_BG_AB_NODE_LUMBER_MILL;
  case BG_AB_NODE_GOLD_MINE: return LANG_BG_AB_NODE_GOLD_MINE;
  default:
  ABORT();
  }
  return 0;
 }

Here is the caller graph for this function:

void BattlegroundAB::_NodeDeOccupied ( uint8 node )

private

 {
  if (node >= BG_AB_DYNAMIC_NODES_COUNT)
  return;
 
  //remove bonus honor aura trigger creature when node is lost
  if (node < BG_AB_DYNAMIC_NODES_COUNT)//only dynamic nodes, no start points
  DelCreature(node+7);//NULL checks are in DelCreature! 0-6 spirit guides
 
  RelocateDeadPlayers(BgCreatures[node]);
 
  DelCreature(node);
 
  // buff object isn't despawned
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundAB::_NodeOccupied	(	uint8	node,
		Team	team
	)

private

Todo:: working, scripted peons spawning

 {
  if (!AddSpiritGuide(node, BG_AB_SpiritGuidePos[node], GetTeamIndexByTeamId(team)))
  TC_LOG_ERROR("bg.battleground", "Failed to spawn spirit guide! point: %u, team: %u, ", node, team);
 
  if (node >= BG_AB_DYNAMIC_NODES_COUNT)//only dynamic nodes, no start points
  return;
 
  uint8 capturedNodes = 0;
  for (uint8 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
  if (m_Nodes[i] == GetTeamIndexByTeamId(team) + BG_AB_NODE_TYPE_OCCUPIED && !m_NodeTimers[i])
  ++capturedNodes;
 
  if (capturedNodes >= 5)
  CastSpellOnTeam(SPELL_AB_QUEST_REWARD_5_BASES, team);
  if (capturedNodes >= 4)
  CastSpellOnTeam(SPELL_AB_QUEST_REWARD_4_BASES, team);
 
  Creature* trigger = !BgCreatures[node + 7] ? GetBGCreature(node + 7) : NULL; // 0-6 spirit guides
  if (!trigger)
  trigger = AddCreature(WORLD_TRIGGER, node+7, BG_AB_NodePositions[node], GetTeamIndexByTeamId(team));
 
  //add bonus honor aura trigger creature when node is accupied
  //cast bonus aura (+50% honor in 25yards)
  //aura should only apply to players who have accupied the node, set correct faction for trigger
  if (trigger)
  {
  trigger->setFaction(team == ALLIANCE ? 84 : 83);
  trigger->CastSpell(trigger, SPELL_HONORABLE_DEFENDER_25Y, false);
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundAB::_SendNodeUpdate ( uint8 node )

private

 {
  // Send node owner state update to refresh map icons on client
  const uint8 plusArray[] = {0, 2, 3, 0, 1};
 
  if (m_prevNodes[node])
  UpdateWorldState(BG_AB_OP_NODESTATES[node] + plusArray[m_prevNodes[node]], 0);
  else
  UpdateWorldState(BG_AB_OP_NODEICONS[node], 0);
 
  UpdateWorldState(BG_AB_OP_NODESTATES[node] + plusArray[m_Nodes[node]], 1);
 
  // How many bases each team owns
  uint8 ally = 0, horde = 0;
  for (uint8 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
  if (m_Nodes[i] == BG_AB_NODE_STATUS_ALLY_OCCUPIED)
  ++ally;
  else if (m_Nodes[i] == BG_AB_NODE_STATUS_HORDE_OCCUPIED)
  ++horde;
 
  UpdateWorldState(BG_AB_OP_OCCUPIED_BASES_ALLY, ally);
  UpdateWorldState(BG_AB_OP_OCCUPIED_BASES_HORDE, horde);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundAB::AddPlayer ( Player * player )

overridevirtual

Reimplemented from Battleground.

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

Here is the call graph for this function:

bool BattlegroundAB::CheckAchievementCriteriaMeet	(	uint32	criteriaId,
		Player const *	player,
		Unit const *	target = `nullptr`,
		uint32	miscvalue = `0`
	)

overridevirtual

Reimplemented from Battleground.

 {
  switch (criteriaId)
  {
  case BG_CRITERIA_CHECK_RESILIENT_VICTORY:
  return m_TeamScores500Disadvantage[GetTeamIndexByTeamId(player->GetTeam())];
  }
 
  return Battleground::CheckAchievementCriteriaMeet(criteriaId, player, target, miscvalue);
 }

Here is the call graph for this function:

void BattlegroundAB::EndBattleground ( uint32 winner )

overridevirtual

Reimplemented from Battleground.

 {
  // Win reward
  if (winner == ALLIANCE)
  RewardHonorToTeam(GetBonusHonorFromKill(1), ALLIANCE);
  if (winner == HORDE)
  RewardHonorToTeam(GetBonusHonorFromKill(1), HORDE);
  // Complete map_end rewards (even if no team wins)
  RewardHonorToTeam(GetBonusHonorFromKill(1), HORDE);
  RewardHonorToTeam(GetBonusHonorFromKill(1), ALLIANCE);
 
  Battleground::EndBattleground(winner);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundAB::EventPlayerClickedOnFlag	(	Player *	source,
		GameObject *	target_obj
	)

overridevirtual

Reimplemented from Battleground.

 {
  if (GetStatus() != STATUS_IN_PROGRESS)
  return;
 
  uint8 node = BG_AB_NODE_STABLES;
  GameObject* obj = GetBgMap()->GetGameObject(BgObjects[node*8+7]);
  while ((node < BG_AB_DYNAMIC_NODES_COUNT) && ((!obj) || (!source->IsWithinDistInMap(obj, 10))))
  {
  ++node;
  obj = GetBgMap()->GetGameObject(BgObjects[node*8+BG_AB_OBJECT_AURA_CONTESTED]);
  }
 
  if (node == BG_AB_DYNAMIC_NODES_COUNT)
  {
  // this means our player isn't close to any of banners - maybe cheater ??
  return;
  }
 
  TeamId teamIndex = GetTeamIndexByTeamId(source->GetTeam());
 
  // Check if player really could use this banner, not cheated
  if (!(m_Nodes[node] == 0 || teamIndex == m_Nodes[node]%2))
  return;
 
  source->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
  uint32 sound = 0;
  // If node is neutral, change to contested
  if (m_Nodes[node] == BG_AB_NODE_TYPE_NEUTRAL)
  {
  UpdatePlayerScore(source, SCORE_BASES_ASSAULTED, 1);
  m_prevNodes[node] = m_Nodes[node];
  m_Nodes[node] = teamIndex + 1;
  // burn current neutral banner
  _DelBanner(node, BG_AB_NODE_TYPE_NEUTRAL, 0);
  // create new contested banner
  _CreateBanner(node, BG_AB_NODE_TYPE_CONTESTED, teamIndex, true);
  _SendNodeUpdate(node);
  m_NodeTimers[node] = BG_AB_FLAG_CAPTURING_TIME;
 
  // FIXME: team and node names not localized
  if (teamIndex == 0)
  SendMessage2ToAll(LANG_BG_AB_NODE_CLAIMED, CHAT_MSG_BG_SYSTEM_ALLIANCE, source, _GetNodeNameId(node), LANG_BG_AB_ALLY);
  else
  SendMessage2ToAll(LANG_BG_AB_NODE_CLAIMED, CHAT_MSG_BG_SYSTEM_HORDE, source, _GetNodeNameId(node), LANG_BG_AB_HORDE);
 
  sound = BG_AB_SOUND_NODE_CLAIMED;
  }
  // If node is contested
  else if ((m_Nodes[node] == BG_AB_NODE_STATUS_ALLY_CONTESTED) || (m_Nodes[node] == BG_AB_NODE_STATUS_HORDE_CONTESTED))
  {
  // If last state is NOT occupied, change node to enemy-contested
  if (m_prevNodes[node] < BG_AB_NODE_TYPE_OCCUPIED)
  {
  UpdatePlayerScore(source, SCORE_BASES_ASSAULTED, 1);
  m_prevNodes[node] = m_Nodes[node];
  m_Nodes[node] = teamIndex + BG_AB_NODE_TYPE_CONTESTED;
  // burn current contested banner
  _DelBanner(node, BG_AB_NODE_TYPE_CONTESTED, !teamIndex);
  // create new contested banner
  _CreateBanner(node, BG_AB_NODE_TYPE_CONTESTED, teamIndex, true);
  _SendNodeUpdate(node);
  m_NodeTimers[node] = BG_AB_FLAG_CAPTURING_TIME;
 
  // FIXME: node names not localized
  if (teamIndex == TEAM_ALLIANCE)
  SendMessage2ToAll(LANG_BG_AB_NODE_ASSAULTED, CHAT_MSG_BG_SYSTEM_ALLIANCE, source, _GetNodeNameId(node));
  else
  SendMessage2ToAll(LANG_BG_AB_NODE_ASSAULTED, CHAT_MSG_BG_SYSTEM_HORDE, source, _GetNodeNameId(node));
  }
  // If contested, change back to occupied
  else
  {
  UpdatePlayerScore(source, SCORE_BASES_DEFENDED, 1);
  m_prevNodes[node] = m_Nodes[node];
  m_Nodes[node] = teamIndex + BG_AB_NODE_TYPE_OCCUPIED;
  // burn current contested banner
  _DelBanner(node, BG_AB_NODE_TYPE_CONTESTED, !teamIndex);
  // create new occupied banner
  _CreateBanner(node, BG_AB_NODE_TYPE_OCCUPIED, teamIndex, true);
  _SendNodeUpdate(node);
  m_NodeTimers[node] = 0;
  _NodeOccupied(node, (teamIndex == TEAM_ALLIANCE) ? ALLIANCE:HORDE);
 
  // FIXME: node names not localized
  if (teamIndex == TEAM_ALLIANCE)
  SendMessage2ToAll(LANG_BG_AB_NODE_DEFENDED, CHAT_MSG_BG_SYSTEM_ALLIANCE, source, _GetNodeNameId(node));
  else
  SendMessage2ToAll(LANG_BG_AB_NODE_DEFENDED, CHAT_MSG_BG_SYSTEM_HORDE, source, _GetNodeNameId(node));
  }
  sound = (teamIndex == TEAM_ALLIANCE) ? BG_AB_SOUND_NODE_ASSAULTED_ALLIANCE : BG_AB_SOUND_NODE_ASSAULTED_HORDE;
  }
  // If node is occupied, change to enemy-contested
  else
  {
  UpdatePlayerScore(source, SCORE_BASES_ASSAULTED, 1);
  m_prevNodes[node] = m_Nodes[node];
  m_Nodes[node] = teamIndex + BG_AB_NODE_TYPE_CONTESTED;
  // burn current occupied banner
  _DelBanner(node, BG_AB_NODE_TYPE_OCCUPIED, !teamIndex);
  // create new contested banner
  _CreateBanner(node, BG_AB_NODE_TYPE_CONTESTED, teamIndex, true);
  _SendNodeUpdate(node);
  _NodeDeOccupied(node);
  m_NodeTimers[node] = BG_AB_FLAG_CAPTURING_TIME;
 
  // FIXME: node names not localized
  if (teamIndex == TEAM_ALLIANCE)
  SendMessage2ToAll(LANG_BG_AB_NODE_ASSAULTED, CHAT_MSG_BG_SYSTEM_ALLIANCE, source, _GetNodeNameId(node));
  else
  SendMessage2ToAll(LANG_BG_AB_NODE_ASSAULTED, CHAT_MSG_BG_SYSTEM_HORDE, source, _GetNodeNameId(node));
 
  sound = (teamIndex == TEAM_ALLIANCE) ? BG_AB_SOUND_NODE_ASSAULTED_ALLIANCE : BG_AB_SOUND_NODE_ASSAULTED_HORDE;
  }
 
  // If node is occupied again, send "X has taken the Y" msg.
  if (m_Nodes[node] >= BG_AB_NODE_TYPE_OCCUPIED)
  {
  // FIXME: team and node names not localized
  if (teamIndex == TEAM_ALLIANCE)
  SendMessage2ToAll(LANG_BG_AB_NODE_TAKEN, CHAT_MSG_BG_SYSTEM_ALLIANCE, NULL, LANG_BG_AB_ALLY, _GetNodeNameId(node));
  else
  SendMessage2ToAll(LANG_BG_AB_NODE_TAKEN, CHAT_MSG_BG_SYSTEM_HORDE, NULL, LANG_BG_AB_HORDE, _GetNodeNameId(node));
  }
  PlaySoundToAll(sound);
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
  const uint8 plusArray[] = {0, 2, 3, 0, 1};
 
  // Node icons
  for (uint8 node = 0; node < BG_AB_DYNAMIC_NODES_COUNT; ++node)
  packet.Worldstates.emplace_back(uint32(BG_AB_OP_NODEICONS[node]), int32((m_Nodes[node] == 0) ? 1 : 0));
 
  // Node occupied states
  for (uint8 node = 0; node < BG_AB_DYNAMIC_NODES_COUNT; ++node)
  for (uint8 i = 1; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
  packet.Worldstates.emplace_back(uint32(BG_AB_OP_NODESTATES[node] + plusArray[i]), int32((m_Nodes[node] == i) ? 1 : 0));
 
  // How many bases each team owns
  uint8 ally = 0, horde = 0;
  for (uint8 node = 0; node < BG_AB_DYNAMIC_NODES_COUNT; ++node)
  if (m_Nodes[node] == BG_AB_NODE_STATUS_ALLY_OCCUPIED)
  ++ally;
  else if (m_Nodes[node] == BG_AB_NODE_STATUS_HORDE_OCCUPIED)
  ++horde;
 
  packet.Worldstates.emplace_back(uint32(BG_AB_OP_OCCUPIED_BASES_ALLY), int32(ally));
  packet.Worldstates.emplace_back(uint32(BG_AB_OP_OCCUPIED_BASES_HORDE), int32(horde));
 
  // Team scores
  packet.Worldstates.emplace_back(uint32(BG_AB_OP_RESOURCES_MAX), int32(BG_AB_MAX_TEAM_SCORE));
  packet.Worldstates.emplace_back(uint32(BG_AB_OP_RESOURCES_WARNING), int32(BG_AB_WARNING_NEAR_VICTORY_SCORE));
  packet.Worldstates.emplace_back(uint32(BG_AB_OP_RESOURCES_ALLY), int32(m_TeamScores[TEAM_ALLIANCE]));
     packet.Worldstates.emplace_back(uint32(BG_AB_OP_RESOURCES_HORDE), int32(m_TeamScores[TEAM_HORDE]));
 
     // other unknown
     packet.Worldstates.emplace_back(uint32(0x745), 0x2);
 }

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

overridevirtual

Reimplemented from Battleground.

 {
     TeamId teamIndex = GetTeamIndexByTeamId(player->GetTeam());
 
     // Is there any occupied node for this team?
     std::vector<uint8> nodes;
     for (uint8 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
         if (m_Nodes[i] == teamIndex + 3)
             nodes.push_back(i);
 
     WorldSafeLocsEntry const* good_entry = NULL;
     // If so, select the closest node to place ghost on
     if (!nodes.empty())
     {
         float plr_x = player->GetPositionX();
         float plr_y = player->GetPositionY();
 
         float mindist = 999999.0f;
         for (uint8 i = 0; i < nodes.size(); ++i)
         {
             WorldSafeLocsEntry const*entry = sWorldSafeLocsStore.LookupEntry(BG_AB_GraveyardIds[nodes[i]]);
             if (!entry)
                 continue;
             float dist = (entry->Loc.X - plr_x)*(entry->Loc.X - plr_x)+(entry->Loc.Y - plr_y)*(entry->Loc.Y - plr_y);
             if (mindist > dist)
             {
                 mindist = dist;
                 good_entry = entry;
             }
         }
         nodes.clear();
     }
     // If not, place ghost on starting location
     if (!good_entry)
         good_entry = sWorldSafeLocsStore.LookupEntry(BG_AB_GraveyardIds[teamIndex+5]);
 
     return good_entry;
 }

Here is the call graph for this function:

uint32 BattlegroundAB::GetPrematureWinner ( )

overridevirtual

Reimplemented from Battleground.

 {
     // How many bases each team owns
     uint8 ally = 0, horde = 0;
     for (uint8 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
         if (m_Nodes[i] == BG_AB_NODE_STATUS_ALLY_OCCUPIED)
             ++ally;
         else if (m_Nodes[i] == BG_AB_NODE_STATUS_HORDE_OCCUPIED)
             ++horde;
 
     if (ally > horde)
         return ALLIANCE;
     else if (horde > ally)
         return HORDE;
 
     // If the values are equal, fall back to the original result (based on number of players on each team)
     return Battleground::GetPrematureWinner();
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
     if (GetStatus() != STATUS_IN_PROGRESS)
         return;
 
     switch (trigger)
     {
         case 3948:                                          // Arathi Basin Alliance Exit.
             if (player->GetTeam() != ALLIANCE)
                 player->GetSession()->SendNotification("Only The Alliance can use that portal");
             else
                 player->LeaveBattleground();
             break;
         case 3949:                                          // Arathi Basin Horde Exit.
             if (player->GetTeam() != HORDE)
                 player->GetSession()->SendNotification("Only The Horde can use that portal");
             else
                 player->LeaveBattleground();
             break;
         case 3866:                                          // Stables
         case 3869:                                          // Gold Mine
         case 3867:                                          // Farm
         case 3868:                                          // Lumber Mill
         case 3870:                                          // Black Smith
         case 4020:                                          // Unk1
         case 4021:                                          // Unk2
         case 4674:                                          // Unk3
             //break;
         default:
             Battleground::HandleAreaTrigger(player, trigger, entered);
             break;
     }
 }

Here is the call graph for this function:

bool BattlegroundAB::IsAllNodesControlledByTeam ( uint32 team ) const

overridevirtual

Reimplemented from Battleground.

 {
     uint32 count = 0;
     for (int i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
         if ((team == ALLIANCE && m_Nodes[i] == BG_AB_NODE_STATUS_ALLY_OCCUPIED) ||
             (team == HORDE    && m_Nodes[i] == BG_AB_NODE_STATUS_HORDE_OCCUPIED))
             ++count;
 
     return count == BG_AB_DYNAMIC_NODES_COUNT;
 }

void BattlegroundAB::PostUpdateImpl ( uint32 )

overrideprivatevirtual

Post-update hook.

Will be called after battleground update has passed. May be used to implement custom update effects in subclasses.

Parameters

diff	a time difference between two worldserver update loops in milliseconds.

See also: Update(), PreUpdateImpl().

Reimplemented from Battleground.

 {
     if (GetStatus() == STATUS_IN_PROGRESS)
     {
         int team_points[BG_TEAMS_COUNT] = { 0, 0 };
 
         for (int node = 0; node < BG_AB_DYNAMIC_NODES_COUNT; ++node)
         {
             // 3 sec delay to spawn new banner instead previous despawned one
             if (m_BannerTimers[node].timer)
             {
                 if (m_BannerTimers[node].timer > diff)
                     m_BannerTimers[node].timer -= diff;
                 else
                 {
                     m_BannerTimers[node].timer = 0;
                     _CreateBanner(node, m_BannerTimers[node].type, m_BannerTimers[node].teamIndex, false);
                 }
             }
 
             // 1-minute to occupy a node from contested state
             if (m_NodeTimers[node])
             {
                 if (m_NodeTimers[node] > diff)
                     m_NodeTimers[node] -= diff;
                 else
                 {
                     m_NodeTimers[node] = 0;
                     // Change from contested to occupied !
                     uint8 teamIndex = m_Nodes[node]-1;
                     m_prevNodes[node] = m_Nodes[node];
                     m_Nodes[node] += 2;
                     // burn current contested banner
                     _DelBanner(node, BG_AB_NODE_TYPE_CONTESTED, teamIndex);
                     // create new occupied banner
                     _CreateBanner(node, BG_AB_NODE_TYPE_OCCUPIED, teamIndex, true);
                     _SendNodeUpdate(node);
                     _NodeOccupied(node, (teamIndex == 0) ? ALLIANCE:HORDE);
                     // Message to chatlog
 
                     if (teamIndex == 0)
                     {
                         // FIXME: team and node names not localized
                         SendMessage2ToAll(LANG_BG_AB_NODE_TAKEN, CHAT_MSG_BG_SYSTEM_ALLIANCE, NULL, LANG_BG_AB_ALLY, _GetNodeNameId(node));
                         PlaySoundToAll(BG_AB_SOUND_NODE_CAPTURED_ALLIANCE);
                     }
                     else
                     {
                         // FIXME: team and node names not localized
                         SendMessage2ToAll(LANG_BG_AB_NODE_TAKEN, CHAT_MSG_BG_SYSTEM_HORDE, NULL, LANG_BG_AB_HORDE, _GetNodeNameId(node));
                         PlaySoundToAll(BG_AB_SOUND_NODE_CAPTURED_HORDE);
                     }
                 }
             }
 
             for (int team = 0; team < BG_TEAMS_COUNT; ++team)
                 if (m_Nodes[node] == team + BG_AB_NODE_TYPE_OCCUPIED)
                     ++team_points[team];
         }
 
         // Accumulate points
         for (int team = 0; team < BG_TEAMS_COUNT; ++team)
         {
             int points = team_points[team];
             if (!points)
                 continue;
 
             m_lastTick[team] += diff;
 
             if (m_lastTick[team] > BG_AB_TickIntervals[points])
             {
                 m_lastTick[team] -= BG_AB_TickIntervals[points];
                 m_TeamScores[team] += BG_AB_TickPoints[points];
                 m_HonorScoreTics[team] += BG_AB_TickPoints[points];
                 m_ReputationScoreTics[team] += BG_AB_TickPoints[points];
 
                 if (m_ReputationScoreTics[team] >= m_ReputationTics)
                 {
                     (team == TEAM_ALLIANCE) ? RewardReputationToTeam(509, 10, ALLIANCE) : RewardReputationToTeam(510, 10, HORDE);
                     m_ReputationScoreTics[team] -= m_ReputationTics;
                 }
 
                 if (m_HonorScoreTics[team] >= m_HonorTics)
                 {
                     RewardHonorToTeam(GetBonusHonorFromKill(1), (team == TEAM_ALLIANCE) ? ALLIANCE : HORDE);
                     m_HonorScoreTics[team] -= m_HonorTics;
                 }
 
                 if (!m_IsInformedNearVictory && m_TeamScores[team] > BG_AB_WARNING_NEAR_VICTORY_SCORE)
                 {
                     if (team == TEAM_ALLIANCE)
                         SendMessageToAll(LANG_BG_AB_A_NEAR_VICTORY, CHAT_MSG_BG_SYSTEM_NEUTRAL);
                     else
                         SendMessageToAll(LANG_BG_AB_H_NEAR_VICTORY, CHAT_MSG_BG_SYSTEM_NEUTRAL);
                     PlaySoundToAll(BG_AB_SOUND_NEAR_VICTORY);
                     m_IsInformedNearVictory = true;
                 }
 
                 if (m_TeamScores[team] > BG_AB_MAX_TEAM_SCORE)
                     m_TeamScores[team] = BG_AB_MAX_TEAM_SCORE;
 
                 if (team == TEAM_ALLIANCE)
                     UpdateWorldState(BG_AB_OP_RESOURCES_ALLY, m_TeamScores[team]);
                 else if (team == TEAM_HORDE)
                     UpdateWorldState(BG_AB_OP_RESOURCES_HORDE, m_TeamScores[team]);
                 // update achievement flags
                 // we increased m_TeamScores[team] so we just need to check if it is 500 more than other teams resources
                 uint8 otherTeam = (team + 1) % BG_TEAMS_COUNT;
                 if (m_TeamScores[team] > m_TeamScores[otherTeam] + 500)
                     m_TeamScores500Disadvantage[otherTeam] = true;
             }
         }
 
         // Test win condition
         if (m_TeamScores[TEAM_ALLIANCE] >= BG_AB_MAX_TEAM_SCORE)
             EndBattleground(ALLIANCE);
         else if (m_TeamScores[TEAM_HORDE] >= BG_AB_MAX_TEAM_SCORE)
             EndBattleground(HORDE);
     }
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from Battleground.

229 {

230 }

void BattlegroundAB::Reset ( )

overridevirtual

Reimplemented from Battleground.

 {
     //call parent's class reset
     Battleground::Reset();
 
     m_TeamScores[TEAM_ALLIANCE]          = 0;
     m_TeamScores[TEAM_HORDE]             = 0;
     m_lastTick[TEAM_ALLIANCE]            = 0;
     m_lastTick[TEAM_HORDE]               = 0;
     m_HonorScoreTics[TEAM_ALLIANCE]      = 0;
     m_HonorScoreTics[TEAM_HORDE]         = 0;
     m_ReputationScoreTics[TEAM_ALLIANCE] = 0;
     m_ReputationScoreTics[TEAM_HORDE]    = 0;
     m_IsInformedNearVictory                 = false;
     bool isBGWeekend = sBattlegroundMgr->IsBGWeekend(GetTypeID());
     m_HonorTics = (isBGWeekend) ? BG_AB_ABBGWeekendHonorTicks : BG_AB_NotABBGWeekendHonorTicks;
     m_ReputationTics = (isBGWeekend) ? BG_AB_ABBGWeekendReputationTicks : BG_AB_NotABBGWeekendReputationTicks;
     m_TeamScores500Disadvantage[TEAM_ALLIANCE] = false;
     m_TeamScores500Disadvantage[TEAM_HORDE]    = false;
 
     for (uint8 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
     {
         m_Nodes[i] = 0;
         m_prevNodes[i] = 0;
         m_NodeTimers[i] = 0;
         m_BannerTimers[i].timer = 0;
     }
 
     for (uint8 i = 0; i < BG_AB_ALL_NODES_COUNT + 5; ++i)//+5 for aura triggers
         if (!BgCreatures[i].IsEmpty())
             DelCreature(i);
 }

Here is the call graph for this function:

bool BattlegroundAB::SetupBattleground ( )

overridevirtual

Reimplemented from Battleground.

 {
     for (int i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
     {
         if (!AddObject(BG_AB_OBJECT_BANNER_NEUTRAL + 8*i, BG_AB_OBJECTID_NODE_BANNER_0 + i, BG_AB_NodePositions[i], 0, 0, std::sin(BG_AB_NodePositions[i].GetOrientation()/2), std::cos(BG_AB_NodePositions[i].GetOrientation()/2), RESPAWN_ONE_DAY)
             || !AddObject(BG_AB_OBJECT_BANNER_CONT_A + 8*i, BG_AB_OBJECTID_BANNER_CONT_A, BG_AB_NodePositions[i], 0, 0, std::sin(BG_AB_NodePositions[i].GetOrientation()/2), std::cos(BG_AB_NodePositions[i].GetOrientation()/2), RESPAWN_ONE_DAY)
             || !AddObject(BG_AB_OBJECT_BANNER_CONT_H + 8*i, BG_AB_OBJECTID_BANNER_CONT_H, BG_AB_NodePositions[i], 0, 0, std::sin(BG_AB_NodePositions[i].GetOrientation()/2), std::cos(BG_AB_NodePositions[i].GetOrientation()/2), RESPAWN_ONE_DAY)
             || !AddObject(BG_AB_OBJECT_BANNER_ALLY + 8*i, BG_AB_OBJECTID_BANNER_A, BG_AB_NodePositions[i], 0, 0, std::sin(BG_AB_NodePositions[i].GetOrientation()/2), std::cos(BG_AB_NodePositions[i].GetOrientation()/2), RESPAWN_ONE_DAY)
             || !AddObject(BG_AB_OBJECT_BANNER_HORDE + 8*i, BG_AB_OBJECTID_BANNER_H, BG_AB_NodePositions[i], 0, 0, std::sin(BG_AB_NodePositions[i].GetOrientation()/2), std::cos(BG_AB_NodePositions[i].GetOrientation()/2), RESPAWN_ONE_DAY)
             || !AddObject(BG_AB_OBJECT_AURA_ALLY + 8*i, BG_AB_OBJECTID_AURA_A, BG_AB_NodePositions[i], 0, 0, std::sin(BG_AB_NodePositions[i].GetOrientation()/2), std::cos(BG_AB_NodePositions[i].GetOrientation()/2), RESPAWN_ONE_DAY)
             || !AddObject(BG_AB_OBJECT_AURA_HORDE + 8*i, BG_AB_OBJECTID_AURA_H, BG_AB_NodePositions[i], 0, 0, std::sin(BG_AB_NodePositions[i].GetOrientation()/2), std::cos(BG_AB_NodePositions[i].GetOrientation()/2), RESPAWN_ONE_DAY)
             || !AddObject(BG_AB_OBJECT_AURA_CONTESTED + 8*i, BG_AB_OBJECTID_AURA_C, BG_AB_NodePositions[i], 0, 0, std::sin(BG_AB_NodePositions[i].GetOrientation()/2), std::cos(BG_AB_NodePositions[i].GetOrientation()/2), RESPAWN_ONE_DAY))
         {
             TC_LOG_ERROR("sql.sql", "BatteGroundAB: Failed to spawn some object Battleground not created!");
             return false;
         }
     }
 
     if (!AddObject(BG_AB_OBJECT_GATE_A, BG_AB_OBJECTID_GATE_A, BG_AB_DoorPositions[0][0], BG_AB_DoorPositions[0][1], BG_AB_DoorPositions[0][2], BG_AB_DoorPositions[0][3], BG_AB_DoorPositions[0][4], BG_AB_DoorPositions[0][5], BG_AB_DoorPositions[0][6], BG_AB_DoorPositions[0][7], RESPAWN_IMMEDIATELY)
         || !AddObject(BG_AB_OBJECT_GATE_H, BG_AB_OBJECTID_GATE_H, BG_AB_DoorPositions[1][0], BG_AB_DoorPositions[1][1], BG_AB_DoorPositions[1][2], BG_AB_DoorPositions[1][3], BG_AB_DoorPositions[1][4], BG_AB_DoorPositions[1][5], BG_AB_DoorPositions[1][6], BG_AB_DoorPositions[1][7], RESPAWN_IMMEDIATELY))
     {
         TC_LOG_ERROR("sql.sql", "BatteGroundAB: Failed to spawn door object Battleground not created!");
         return false;
     }
 
     //buffs
     for (int i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
     {
         if (!AddObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + 3 * i, Buff_Entries[0], BG_AB_BuffPositions[i][0], BG_AB_BuffPositions[i][1], BG_AB_BuffPositions[i][2], BG_AB_BuffPositions[i][3], 0, 0, std::sin(BG_AB_BuffPositions[i][3]/2), std::cos(BG_AB_BuffPositions[i][3]/2), RESPAWN_ONE_DAY)
             || !AddObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + 3 * i + 1, Buff_Entries[1], BG_AB_BuffPositions[i][0], BG_AB_BuffPositions[i][1], BG_AB_BuffPositions[i][2], BG_AB_BuffPositions[i][3], 0, 0, std::sin(BG_AB_BuffPositions[i][3]/2), std::cos(BG_AB_BuffPositions[i][3]/2), RESPAWN_ONE_DAY)
             || !AddObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + 3 * i + 2, Buff_Entries[2], BG_AB_BuffPositions[i][0], BG_AB_BuffPositions[i][1], BG_AB_BuffPositions[i][2], BG_AB_BuffPositions[i][3], 0, 0, std::sin(BG_AB_BuffPositions[i][3]/2), std::cos(BG_AB_BuffPositions[i][3]/2), RESPAWN_ONE_DAY))
             TC_LOG_ERROR("sql.sql", "BatteGroundAB: Failed to spawn buff object!");
     }
 
     return true;
 }

Here is the call graph for this function:

void BattlegroundAB::StartingEventCloseDoors ( )

overridevirtual

Reimplemented from Battleground.

 {
     // despawn banners, auras and buffs
     for (int obj = BG_AB_OBJECT_BANNER_NEUTRAL; obj < BG_AB_DYNAMIC_NODES_COUNT * 8; ++obj)
         SpawnBGObject(obj, RESPAWN_ONE_DAY);
     for (int i = 0; i < BG_AB_DYNAMIC_NODES_COUNT * 3; ++i)
         SpawnBGObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + i, RESPAWN_ONE_DAY);
 
     // Starting doors
     DoorClose(BG_AB_OBJECT_GATE_A);
     DoorClose(BG_AB_OBJECT_GATE_H);
     SpawnBGObject(BG_AB_OBJECT_GATE_A, RESPAWN_IMMEDIATELY);
     SpawnBGObject(BG_AB_OBJECT_GATE_H, RESPAWN_IMMEDIATELY);
 
     // Starting base spirit guides
     _NodeOccupied(BG_AB_SPIRIT_ALIANCE, ALLIANCE);
     _NodeOccupied(BG_AB_SPIRIT_HORDE, HORDE);
 }

Here is the call graph for this function:

void BattlegroundAB::StartingEventOpenDoors ( )

overridevirtual

Reimplemented from Battleground.

 {
     // spawn neutral banners
     for (int banner = BG_AB_OBJECT_BANNER_NEUTRAL, i = 0; i < 5; banner += 8, ++i)
         SpawnBGObject(banner, RESPAWN_IMMEDIATELY);
     for (int i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
     {
         //randomly select buff to spawn
         uint8 buff = urand(0, 2);
         SpawnBGObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + buff + i * 3, RESPAWN_IMMEDIATELY);
     }
     DoorOpen(BG_AB_OBJECT_GATE_A);
     DoorOpen(BG_AB_OBJECT_GATE_H);
 
     // Achievement: Let's Get This Done
     StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, AB_EVENT_START_BATTLE);
 }

Here is the call graph for this function:

bool BattlegroundAB::UpdatePlayerScore	(	Player *	player,
		uint32	type,
		uint32	value,
		bool	doAddHonor = `true`
	)

overridevirtual

Reimplemented from Battleground.

 {
     if (!Battleground::UpdatePlayerScore(player, type, value, doAddHonor))
         return false;
 
     switch (type)
     {
         case SCORE_BASES_ASSAULTED:
             player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, AB_OBJECTIVE_ASSAULT_BASE);
             break;
         case SCORE_BASES_DEFENDED:
             player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, AB_OBJECTIVE_DEFEND_BASE);
             break;
         default:
             break;
     }
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

BG_AB_BannerTimer BattlegroundAB::m_BannerTimers[BG_AB_DYNAMIC_NODES_COUNT]

private

uint32 BattlegroundAB::m_HonorScoreTics[BG_TEAMS_COUNT]

private

uint32 BattlegroundAB::m_HonorTics

private

bool BattlegroundAB::m_IsInformedNearVictory

private

uint32 BattlegroundAB::m_lastTick[BG_TEAMS_COUNT]

private

uint8 BattlegroundAB::m_Nodes[BG_AB_DYNAMIC_NODES_COUNT]

private

uint32 BattlegroundAB::m_NodeTimers[BG_AB_DYNAMIC_NODES_COUNT]

private

uint8 BattlegroundAB::m_prevNodes[BG_AB_DYNAMIC_NODES_COUNT]

private

uint32 BattlegroundAB::m_ReputationScoreTics[BG_TEAMS_COUNT]

private

uint32 BattlegroundAB::m_ReputationTics

private

bool BattlegroundAB::m_TeamScores500Disadvantage[BG_TEAMS_COUNT]

private

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

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

Private Attributes
uint8	m_Nodes [BG_AB_DYNAMIC_NODES_COUNT]

uint8	m_prevNodes [BG_AB_DYNAMIC_NODES_COUNT]

BG_AB_BannerTimer	m_BannerTimers [BG_AB_DYNAMIC_NODES_COUNT]

uint32	m_NodeTimers [BG_AB_DYNAMIC_NODES_COUNT]

uint32	m_lastTick [BG_TEAMS_COUNT]

uint32	m_HonorScoreTics [BG_TEAMS_COUNT]

uint32	m_ReputationScoreTics [BG_TEAMS_COUNT]

bool	m_IsInformedNearVictory

uint32	m_HonorTics

uint32	m_ReputationTics

bool	m_TeamScores500Disadvantage [BG_TEAMS_COUNT]

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation