TrinityCore: Battleground Class Reference

Battleground::m_InvitedAlliance

Definition: SharedDefines.h:1000

uint32 m_InvitedAlliance

Definition: Battleground.h:600

Here is the caller graph for this function:

bool Battleground::DelCreature ( uint32 type )

 {
     if (!BgCreatures[type])
         return true;
 
     if (Creature* creature = GetBgMap()->GetCreature(BgCreatures[type]))
     {
         creature->AddObjectToRemoveList();
         BgCreatures[type].Clear();
         return true;
     }
 
     TC_LOG_ERROR("bg.battleground", "Battleground::DelCreature: creature (type: %u, %s) not found for BG (map: %u, instance id: %u)!",
         type, BgCreatures[type].ToString().c_str(), m_MapId, m_InstanceID);
     BgCreatures[type].Clear();
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Battleground::DelObject ( uint32 type )

 {
     if (!BgObjects[type])
         return true;
 
     if (GameObject* obj = GetBgMap()->GetGameObject(BgObjects[type]))
     {
         obj->SetRespawnTime(0);                                 // not save respawn time
         obj->Delete();
         BgObjects[type].Clear();
         return true;
     }
     TC_LOG_ERROR("bg.battleground", "Battleground::DelObject: gameobject (type: %u, %s) not found for BG (map: %u, instance id: %u)!",
         type, BgObjects[type].ToString().c_str(), m_MapId, m_InstanceID);
     BgObjects[type].Clear();
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void Battleground::DestroyGate	(	Player *	,
		GameObject *
	)

inlinevirtual

Reimplemented in BattlegroundIC, and BattlegroundSA.

252 { }

virtual void Battleground::DoAction	(	uint32	,
		ObjectGuid
	)

inlinevirtual

434 { }

void Battleground::DoorClose ( uint32 type )

 {
     if (GameObject* obj = GetBgMap()->GetGameObject(BgObjects[type]))
     {
         // If doors are open, close it
         if (obj->getLootState() == GO_ACTIVATED && obj->GetGoState() != GO_STATE_READY)
         {
             obj->SetLootState(GO_READY);
             obj->SetGoState(GO_STATE_READY);
         }
     }
     else
         TC_LOG_ERROR("bg.battleground", "Battleground::DoorClose: door gameobject (type: %u, %s) not found for BG (map: %u, instance id: %u)!",
             type, BgObjects[type].ToString().c_str(), m_MapId, m_InstanceID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Battleground::DoorOpen ( uint32 type )

 {
     if (GameObject* obj = GetBgMap()->GetGameObject(BgObjects[type]))
     {
         obj->SetLootState(GO_ACTIVATED);
         obj->SetGoState(GO_STATE_ACTIVE);
     }
     else
         TC_LOG_ERROR("bg.battleground", "Battleground::DoorOpen: door gameobject (type: %u, %s) not found for BG (map: %u, instance id: %u)!",
             type, BgObjects[type].ToString().c_str(), m_MapId, m_InstanceID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Battleground::EndBattleground ( uint32 winner )

virtual

Reimplemented in BattlegroundAV, BattlegroundIC, BattlegroundSA, BattlegroundEY, BattlegroundAB, BattlegroundWS, and Arena.

 {
     RemoveFromBGFreeSlotQueue();
 
     int32 winmsg_id = 0;
     bool guildAwarded = false;
 
     if (winner == ALLIANCE)
     {
         winmsg_id = isBattleground() ? LANG_BG_A_WINS : LANG_ARENA_GOLD_WINS;
 
         PlaySoundToAll(SOUND_ALLIANCE_WINS);                // alliance wins sound
 
         SetWinner(BG_TEAM_ALLIANCE);
     }
     else if (winner == HORDE)
     {
         winmsg_id = isBattleground() ? LANG_BG_H_WINS : LANG_ARENA_GREEN_WINS;
 
         PlaySoundToAll(SOUND_HORDE_WINS);                   // horde wins sound
 
         SetWinner(BG_TEAM_HORDE);
     }
     else
     {
         SetWinner(BG_TEAM_NEUTRAL);
     }
 
     PreparedStatement* stmt = nullptr;
     uint64 battlegroundId = 1;
     if (isBattleground() && sWorld->getBoolConfig(CONFIG_BATTLEGROUND_STORE_STATISTICS_ENABLE))
     {
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PVPSTATS_MAXID);
         PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
         if (result)
         {
             Field* fields = result->Fetch();
             battlegroundId = fields[0].GetUInt64() + 1;
         }
 
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_PVPSTATS_BATTLEGROUND);
         stmt->setUInt64(0, battlegroundId);
         stmt->setUInt8(1, GetWinner());
         stmt->setUInt8(2, GetUniqueBracketId());
         stmt->setUInt8(3, GetTypeID(true));
         CharacterDatabase.Execute(stmt);
     }
 
     SetStatus(STATUS_WAIT_LEAVE);
     //we must set it this way, because end time is sent in packet!
     SetRemainingTime(TIME_AUTOCLOSE_BATTLEGROUND);
 
     WorldPackets::Battleground::PVPLogData pvpLogData;
     BuildPvPLogDataPacket(pvpLogData);
 
     BattlegroundQueueTypeId bgQueueTypeId = BattlegroundMgr::BGQueueTypeId(GetTypeID(), GetArenaType());
 
     for (BattlegroundPlayerMap::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
     {
         uint32 team = itr->second.Team;
 
         Player* player = _GetPlayer(itr, "EndBattleground");
         if (!player)
             continue;
 
         // 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();
         }
         else
         {
             //needed cause else in av some creatures will kill the players at the end
             player->CombatStop();
             player->getHostileRefManager().deleteReferences();
         }
 
         // remove temporary currency bonus auras before rewarding player
         player->RemoveAura(SPELL_HONORABLE_DEFENDER_25Y);
         player->RemoveAura(SPELL_HONORABLE_DEFENDER_60Y);
 
         uint32 winnerKills = player->GetRandomWinner() ? sWorld->getIntConfig(CONFIG_BG_REWARD_WINNER_HONOR_LAST) : sWorld->getIntConfig(CONFIG_BG_REWARD_WINNER_HONOR_FIRST);
         uint32 loserKills = player->GetRandomWinner() ? sWorld->getIntConfig(CONFIG_BG_REWARD_LOSER_HONOR_LAST) : sWorld->getIntConfig(CONFIG_BG_REWARD_LOSER_HONOR_FIRST);
 
         if (isBattleground() && sWorld->getBoolConfig(CONFIG_BATTLEGROUND_STORE_STATISTICS_ENABLE))
         {
             stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_PVPSTATS_PLAYER);
             BattlegroundScoreMap::const_iterator score = PlayerScores.find(player->GetGUID());
 
             stmt->setUInt32(0,  battlegroundId);
             stmt->setUInt64(1,  player->GetGUID().GetCounter());
             stmt->setBool  (2,  team == winner);
             stmt->setUInt32(3,  score->second->GetKillingBlows());
             stmt->setUInt32(4,  score->second->GetDeaths());
             stmt->setUInt32(5,  score->second->GetHonorableKills());
             stmt->setUInt32(6,  score->second->GetBonusHonor());
             stmt->setUInt32(7,  score->second->GetDamageDone());
             stmt->setUInt32(8,  score->second->GetHealingDone());
             stmt->setUInt32(9,  score->second->GetAttr1());
             stmt->setUInt32(10, score->second->GetAttr2());
             stmt->setUInt32(11, score->second->GetAttr3());
             stmt->setUInt32(12, score->second->GetAttr4());
             stmt->setUInt32(13, score->second->GetAttr5());
 
             CharacterDatabase.Execute(stmt);
         }
 
         // Reward winner team
         if (team == winner)
         {
             if (IsRandom() || BattlegroundMgr::IsBGWeekend(GetTypeID()))
             {
                 UpdatePlayerScore(player, SCORE_BONUS_HONOR, GetBonusHonorFromKill(winnerKills));
                 if (!player->GetRandomWinner())
                 {
                     // 100cp awarded for the first random battleground won each day
                     player->ModifyCurrency(CURRENCY_TYPE_CONQUEST_META_ARENA, sWorld->getIntConfig(CONFIG_BG_REWARD_WINNER_CONQUEST_FIRST));
                     player->SetRandomWinner(true);
                 }
             }
             else // 50cp awarded for each non-rated battleground won
                 player->ModifyCurrency(CURRENCY_TYPE_CONQUEST_META_ARENA, sWorld->getIntConfig(CONFIG_BG_REWARD_WINNER_CONQUEST_LAST));
 
             player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_WIN_BG, 1);
             if (!guildAwarded)
             {
                 guildAwarded = true;
                 if (ObjectGuid::LowType guildId = GetBgMap()->GetOwnerGuildId(player->GetBGTeam()))
                 {
                     if (Guild* guild = sGuildMgr->GetGuildById(guildId))
                         guild->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_WIN_BG, 1, 0, 0, NULL, player);
                 }
             }
         }
         else
         {
             if (IsRandom() || BattlegroundMgr::IsBGWeekend(GetTypeID()))
                 UpdatePlayerScore(player, SCORE_BONUS_HONOR, GetBonusHonorFromKill(loserKills));
         }
 
         player->ResetAllPowers();
         player->CombatStopWithPets(true);
 
         BlockMovement(player);
 
         player->SendDirectMessage(pvpLogData.Write());
 
         WorldPackets::Battleground::BattlefieldStatusActive battlefieldStatus;
         sBattlegroundMgr->BuildBattlegroundStatusActive(&battlefieldStatus, this, player, player->GetBattlegroundQueueIndex(bgQueueTypeId), player->GetBattlegroundQueueJoinTime(bgQueueTypeId), GetArenaType());
         player->SendDirectMessage(battlefieldStatus.Write());
 
         player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND, 1);
     }
 
     if (winmsg_id)
         SendMessageToAll(winmsg_id, CHAT_MSG_BG_SYSTEM_NEUTRAL);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Battleground::EndNow ( )

protected

 {
     RemoveFromBGFreeSlotQueue();
     SetStatus(STATUS_WAIT_LEAVE);
     SetRemainingTime(0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void Battleground::EventPlayerClickedOnFlag	(	Player *	,
		GameObject *
	)

inlinevirtual

Reimplemented in BattlegroundAV, BattlegroundIC, BattlegroundSA, BattlegroundEY, BattlegroundAB, and BattlegroundWS.

428 { }

Here is the caller graph for this function:

virtual void Battleground::EventPlayerDroppedFlag ( Player * )

inlinevirtual

Reimplemented in BattlegroundEY, and BattlegroundWS.

427 { }

void Battleground::EventPlayerLoggedIn ( Player * player )

 {
     ObjectGuid guid = player->GetGUID();
     // player is correct pointer
     for (GuidDeque::iterator itr = m_OfflineQueue.begin(); itr != m_OfflineQueue.end(); ++itr)
     {
         if (*itr == guid)
         {
             m_OfflineQueue.erase(itr);
             break;
         }
     }
     m_Players[guid].OfflineRemoveTime = 0;
     PlayerAddedToBGCheckIfBGIsRunning(player);
     // if battleground is starting, then add preparation aura
     // we don't have to do that, because preparation aura isn't removed when player logs out
 }

Here is the call graph for this function:

void Battleground::EventPlayerLoggedOut ( Player * player )

 {
     ObjectGuid guid = player->GetGUID();
     if (!IsPlayerInBattleground(guid))  // Check if this player really is in battleground (might be a GM who teleported inside)
         return;
 
     // player is correct pointer, it is checked in WorldSession::LogoutPlayer()
     m_OfflineQueue.push_back(player->GetGUID());
     m_Players[guid].OfflineRemoveTime = sWorld->GetGameTime() + MAX_OFFLINE_TIME;
     if (GetStatus() == STATUS_IN_PROGRESS)
     {
         // drop flag and handle other cleanups
         RemovePlayer(player, guid, GetPlayerTeam(guid));
 
         // 1 player is logging out, if it is the last, then end arena!
         if (isArena())
             if (GetAlivePlayersCountByTeam(player->GetBGTeam()) <= 1 && GetPlayersCountByTeam(GetOtherTeam(player->GetBGTeam())))
                 EndBattleground(GetOtherTeam(player->GetBGTeam()));
     }
 }

Here is the call graph for this function:

virtual void Battleground::FillInitialWorldStates ( WorldPackets::WorldState::InitWorldStates & )

inlinevirtual

Reimplemented in BattlegroundAV, BattlegroundIC, BattlegroundSA, BattlegroundEY, BattlegroundAB, BattlegroundWS, BattlegroundDS, BattlegroundRV, BattlegroundBE, BattlegroundNA, Arena, and BattlegroundRL.

367 { }

BattlegroundMap* Battleground::FindBgMap ( ) const

inline

357 { return m_Map; }

Battleground::m_Map

BattlegroundMap * m_Map

Definition: Battleground.h:624

Here is the caller graph for this function:

uint32 Battleground::GetAlivePlayersCountByTeam ( uint32 Team ) const

 {
     int count = 0;
     for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
     {
         if (itr->second.Team == Team)
         {
             Player* player = ObjectAccessor::FindPlayer(itr->first);
             if (player && player->IsAlive() && !player->HasByteFlag(UNIT_FIELD_BYTES_2, 3, FORM_SPIRITOFREDEMPTION))
                 ++count;
         }
     }
     return count;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Battleground::GetArenaMatchmakerRating ( uint32 Team ) const

inline

417 { return m_ArenaTeamMMR[GetTeamIndexByTeamId(Team)]; }

static TeamId GetTeamIndexByTeamId(uint32 Team)

Definition: Battleground.h:399

Battleground::m_ArenaTeamMMR

Definition: SharedDefines.h:997

uint32 m_ArenaTeamMMR[BG_TEAMS_COUNT]

Definition: Battleground.h:612

Here is the caller graph for this function:

uint32 Battleground::GetArenaTeamIdByIndex ( uint32 index ) const

inline

415 { return m_ArenaTeamIds[index]; }

Battleground::m_ArenaTeamIds

uint32 m_ArenaTeamIds[BG_TEAMS_COUNT]

Definition: Battleground.h:610

Here is the caller graph for this function:

uint32 Battleground::GetArenaTeamIdForTeam ( uint32 Team ) const

inline

414 { return m_ArenaTeamIds[GetTeamIndexByTeamId(Team)]; }

static TeamId GetTeamIndexByTeamId(uint32 Team)

Definition: Battleground.h:399

Battleground::m_ArenaTeamIds

Definition: SharedDefines.h:997

uint32 m_ArenaTeamIds[BG_TEAMS_COUNT]

Definition: Battleground.h:610

Here is the caller graph for this function:

uint8 Battleground::GetArenaType ( ) const

inline

281 { return m_ArenaType; }

Battleground::m_ArenaType

uint8 m_ArenaType

Definition: Battleground.h:580

Here is the caller graph for this function:

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

 {
     Creature* creature = GetBgMap()->GetCreature(BgCreatures[type]);
     if (!creature)
     {
         if (logError)
             TC_LOG_ERROR("bg.battleground", "Battleground::GetBGCreature: creature (type: %u, %s) not found for BG (map: %u, instance id: %u)!",
                 type, BgCreatures[type].ToString().c_str(), m_MapId, m_InstanceID);
         else
             TC_LOG_INFO("bg.battleground", "Battleground::GetBGCreature: creature (type: %u, %s) not found for BG (map: %u, instance id: %u)!",
                 type, BgCreatures[type].ToString().c_str(), m_MapId, m_InstanceID);
     }
     return creature;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

BattlegroundMap* Battleground::GetBgMap ( ) const

inline

356 { ASSERT(m_Map); return m_Map; }

Battleground::m_Map

BattlegroundMap * m_Map

Definition: Battleground.h:624

ASSERT

#define ASSERT

Definition: Errors.h:55

Here is the caller graph for this function:

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

 {
     GameObject* obj = GetBgMap()->GetGameObject(BgObjects[type]);
     if (!obj)
     {
         if (logError)
             TC_LOG_ERROR("bg.battleground", "Battleground::GetBGObject: gameobject (type: %u, %s) not found for BG (map: %u, instance id: %u)!",
                 type, BgObjects[type].ToString().c_str(), m_MapId, m_InstanceID);
         else
             TC_LOG_INFO("bg.battleground", "Battleground::GetBGObject: gameobject (type: %u, %s) not found for BG (map: %u, instance id: %u)!",
                 type, BgObjects[type].ToString().c_str(), m_MapId, m_InstanceID);
     }
     return obj;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Group* Battleground::GetBgRaid ( uint32 TeamID ) const

inline

393 { return TeamID == ALLIANCE ? m_BgRaids[TEAM_ALLIANCE] : m_BgRaids[TEAM_HORDE]; }

Battleground::m_BracketId

Definition: SharedDefines.h:1000

Battleground::m_BgRaids

Group * m_BgRaids[BG_TEAMS_COUNT]

Definition: Battleground.h:604

TEAM_ALLIANCE

Definition: SharedDefines.h:992

TEAM_HORDE

Definition: SharedDefines.h:993

Here is the caller graph for this function:

uint32 Battleground::GetBonusHonorFromKill ( uint32 kills ) const

 {
     //variable kills means how many honorable kills you scored (so we need kills * honor_for_one_kill)
     uint32 maxLevel = std::min<uint32>(GetMaxLevel(), 80U);
     return Trinity::Honor::hk_honor_at_level(maxLevel, float(kills));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

BattlegroundBracketId Battleground::GetBracketId ( ) const

inline

264 { return m_BracketId; }

BattlegroundBracketId m_BracketId

Definition: Battleground.h:579

Here is the caller graph for this function:

uint32 Battleground::GetClientInstanceID ( ) const

inline

267 { return m_ClientInstanceID; }

Battleground::m_ClientInstanceID

uint32 m_ClientInstanceID

Definition: Battleground.h:572

Here is the caller graph for this function:

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

virtual

Reimplemented in BattlegroundAV, BattlegroundIC, BattlegroundSA, BattlegroundEY, BattlegroundAB, and BattlegroundWS.

 {
     return sObjectMgr->GetClosestGraveYard(player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(), player->GetMapId(), player->GetTeam());
 }

Here is the caller graph for this function:

uint32 Battleground::GetElapsedTime ( ) const

inline

268 { return m_StartTime; }

Battleground::m_StartTime

uint32 m_StartTime

Definition: Battleground.h:573

Here is the caller graph for this function:

virtual ObjectGuid Battleground::GetFlagPickerGUID ( int32 = -1 ) const

inlinevirtual

Reimplemented in BattlegroundEY, and BattlegroundWS.

481 { return ObjectGuid::Empty; }

ObjectGuid::Empty

static ObjectGuid const Empty

Definition: ObjectGuid.h:196

uint32 Battleground::GetFreeSlotsForTeam ( uint32 Team ) const

 {
     // if BG is starting and CONFIG_BATTLEGROUND_INVITATION_TYPE == BG_QUEUE_INVITATION_TYPE_NO_BALANCE, invite anyone
     if (GetStatus() == STATUS_WAIT_JOIN && sWorld->getIntConfig(CONFIG_BATTLEGROUND_INVITATION_TYPE) == BG_QUEUE_INVITATION_TYPE_NO_BALANCE)
         return (GetInvitedCount(Team) < GetMaxPlayersPerTeam()) ? GetMaxPlayersPerTeam() - GetInvitedCount(Team) : 0;
 
     // if BG is already started or CONFIG_BATTLEGROUND_INVITATION_TYPE != BG_QUEUE_INVITATION_TYPE_NO_BALANCE, do not allow to join too much players of one faction
     uint32 otherTeamInvitedCount;
     uint32 thisTeamInvitedCount;
     uint32 otherTeamPlayersCount;
     uint32 thisTeamPlayersCount;
 
     if (Team == ALLIANCE)
     {
         thisTeamInvitedCount  = GetInvitedCount(ALLIANCE);
         otherTeamInvitedCount = GetInvitedCount(HORDE);
         thisTeamPlayersCount  = GetPlayersCountByTeam(ALLIANCE);
         otherTeamPlayersCount = GetPlayersCountByTeam(HORDE);
     }
     else
     {
         thisTeamInvitedCount  = GetInvitedCount(HORDE);
         otherTeamInvitedCount = GetInvitedCount(ALLIANCE);
         thisTeamPlayersCount  = GetPlayersCountByTeam(HORDE);
         otherTeamPlayersCount = GetPlayersCountByTeam(ALLIANCE);
     }
     if (GetStatus() == STATUS_IN_PROGRESS || GetStatus() == STATUS_WAIT_JOIN)
     {
         // difference based on ppl invited (not necessarily entered battle)
         // default: allow 0
         uint32 diff = 0;
 
         // allow join one person if the sides are equal (to fill up bg to minPlayerPerTeam)
         if (otherTeamInvitedCount == thisTeamInvitedCount)
             diff = 1;
         // allow join more ppl if the other side has more players
         else if (otherTeamInvitedCount > thisTeamInvitedCount)
             diff = otherTeamInvitedCount - thisTeamInvitedCount;
 
         // difference based on max players per team (don't allow inviting more)
         uint32 diff2 = (thisTeamInvitedCount < GetMaxPlayersPerTeam()) ? GetMaxPlayersPerTeam() - thisTeamInvitedCount : 0;
 
         // difference based on players who already entered
         // default: allow 0
         uint32 diff3 = 0;
         // allow join one person if the sides are equal (to fill up bg minPlayerPerTeam)
         if (otherTeamPlayersCount == thisTeamPlayersCount)
             diff3 = 1;
         // allow join more ppl if the other side has more players
         else if (otherTeamPlayersCount > thisTeamPlayersCount)
             diff3 = otherTeamPlayersCount - thisTeamPlayersCount;
         // or other side has less than minPlayersPerTeam
         else if (thisTeamInvitedCount <= GetMinPlayersPerTeam())
             diff3 = GetMinPlayersPerTeam() - thisTeamInvitedCount + 1;
 
         // return the minimum of the 3 differences
 
         // min of diff and diff 2
         diff = std::min(diff, diff2);
         // min of diff, diff2 and diff3
         return std::min(diff, diff3);
     }
     return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Battleground::GetInstanceID ( ) const

inline

265 { return m_InstanceID; }

Battleground::m_InstanceID

uint32 m_InstanceID

Definition: Battleground.h:570

Here is the caller graph for this function:

uint32 Battleground::GetInvitedCount ( uint32 team ) const

inline

322 { return (team == ALLIANCE) ? m_InvitedAlliance : m_InvitedHorde; }

Battleground::m_InvitedHorde

uint32 m_InvitedHorde

Definition: Battleground.h:601

Battleground::m_InvitedAlliance

Definition: SharedDefines.h:1000

uint32 m_InvitedAlliance

Definition: Battleground.h:600

Here is the caller graph for this function:

uint32 Battleground::GetLastResurrectTime ( ) const

inline

270 { return m_LastResurrectTime; }

Battleground::m_LastResurrectTime

uint32 m_LastResurrectTime

Definition: Battleground.h:578

Here is the caller graph for this function:

uint32 Battleground::GetMapId ( ) const

inline

352 { return m_MapId; }

Battleground::m_MapId

uint32 m_MapId

Definition: Battleground.h:623

Here is the caller graph for this function:

uint32 Battleground::GetMaxLevel ( ) const

inline

275 { return m_LevelMax; }

Battleground::m_LevelMax

uint32 m_LevelMax

Definition: Battleground.h:616

Here is the caller graph for this function:

uint32 Battleground::GetMaxPlayers ( ) const

inline

271 { return m_MaxPlayers; }

Battleground::m_MaxPlayers

uint32 m_MaxPlayers

Definition: Battleground.h:618

Here is the caller graph for this function:

uint32 Battleground::GetMaxPlayersPerTeam ( ) const

inline

277 { return m_MaxPlayersPerTeam; }

Battleground::m_MaxPlayersPerTeam

uint32 m_MaxPlayersPerTeam

Definition: Battleground.h:617

Here is the caller graph for this function:

uint32 Battleground::GetMinLevel ( ) const

inline

274 { return m_LevelMin; }

Battleground::m_LevelMin

uint32 m_LevelMin

Definition: Battleground.h:615

Here is the caller graph for this function:

uint32 Battleground::GetMinPlayers ( ) const

inline

272 { return m_MinPlayers; }

Battleground::m_MinPlayers

uint32 m_MinPlayers

Definition: Battleground.h:620

uint32 Battleground::GetMinPlayersPerTeam ( ) const

inline

278 { return m_MinPlayersPerTeam; }

Battleground::m_MinPlayersPerTeam

uint32 m_MinPlayersPerTeam

Definition: Battleground.h:619

Here is the caller graph for this function:

std::string const& Battleground::GetName ( ) const

inline

261 { return m_Name; }

Battleground::m_Name

std::string m_Name

Definition: Battleground.h:589

Here is the caller graph for this function:

int32 Battleground::GetObjectType ( ObjectGuid guid )

 {
     for (uint32 i = 0; i < BgObjects.size(); ++i)
         if (BgObjects[i] == guid)
             return i;
     TC_LOG_ERROR("bg.battleground", "Battleground::GetObjectType: player used gameobject (%s) which is not in internal data for BG (map: %u, instance id: %u), cheating?",
         guid.ToString().c_str(), m_MapId, m_InstanceID);
     return -1;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Battleground::GetOtherTeam ( uint32 teamId ) const

 {
     return teamId ? ((teamId == ALLIANCE) ? HORDE : ALLIANCE) : 0;
 }

Here is the caller graph for this function:

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

inlineprotectedvirtual

Reimplemented in BattlegroundEY, and BattlegroundWS.

540 { }

Here is the caller graph for this function:

BattlegroundPlayerMap const& Battleground::GetPlayers ( ) const

inline

331 { return m_Players; }

Battleground::m_Players

BattlegroundPlayerMap m_Players

Definition: Battleground.h:548

Here is the caller graph for this function:

uint32 Battleground::GetPlayerScoresSize ( ) const

inline

335 { return uint32(PlayerScores.size()); }

G3D::uint32

uint32_t uint32

Definition: g3dmath.h:168

Battleground::PlayerScores

BattlegroundScoreMap PlayerScores

Definition: Battleground.h:543

Here is the caller graph for this function:

uint32 Battleground::GetPlayersCountByTeam ( uint32 Team ) const

inline

400 { return m_PlayersCount[GetTeamIndexByTeamId(Team)]; }

static TeamId GetTeamIndexByTeamId(uint32 Team)

Definition: Battleground.h:399

Battleground::m_PlayersCount

Definition: SharedDefines.h:997

uint32 m_PlayersCount[BG_TEAMS_COUNT]

Definition: Battleground.h:607

Here is the caller graph for this function:

uint32 Battleground::GetPlayersSize ( ) const

inline

332 { return uint32(m_Players.size()); }

Battleground::m_Players

BattlegroundPlayerMap m_Players

Definition: Battleground.h:548

G3D::uint32

uint32_t uint32

Definition: g3dmath.h:168

Here is the caller graph for this function:

uint32 Battleground::GetPlayerTeam ( ObjectGuid guid ) const

 {
     BattlegroundPlayerMap::const_iterator itr = m_Players.find(guid);
     if (itr != m_Players.end())
         return itr->second.Team;
     return 0;
 }

Here is the caller graph for this function:

uint32 Battleground::GetPrematureWinner ( )

virtual

Reimplemented in BattlegroundAV, BattlegroundEY, BattlegroundAB, and BattlegroundWS.

 {
     uint32 winner = 0;
     if (GetPlayersCountByTeam(ALLIANCE) >= GetMinPlayersPerTeam())
         winner = ALLIANCE;
     else if (GetPlayersCountByTeam(HORDE) >= GetMinPlayersPerTeam())
         winner = HORDE;
 
     return winner;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint64 Battleground::GetQueueId ( ) const

inline

262 { return m_queueId; }

Battleground::m_queueId

uint64 m_queueId

Definition: Battleground.h:590

Here is the caller graph for this function:

uint32 Battleground::GetRemainingTime ( ) const

inline

269 { return m_EndTime; }

Battleground::m_EndTime

int32 m_EndTime

Definition: Battleground.h:577

Here is the caller graph for this function:

uint32 Battleground::GetReviveQueueSize ( ) const

inline

337 { return uint32(m_ReviveQueue.size()); }

Battleground::m_ReviveQueue

std::map< ObjectGuid, GuidVector > m_ReviveQueue

Definition: Battleground.h:550

G3D::uint32

uint32_t uint32

Definition: g3dmath.h:168

Here is the caller graph for this function:

uint32 Battleground::GetScriptId ( ) const

inline

283 { return ScriptId; }

Battleground::ScriptId

uint32 ScriptId

Definition: Battleground.h:627

int32 Battleground::GetStartDelayTime ( ) const

inline

280 { return m_StartDelayTime; }

Battleground::m_StartDelayTime

int32 m_StartDelayTime

Definition: Battleground.h:585

Here is the caller graph for this function:

float Battleground::GetStartMaxDist ( ) const

inline

363 { return m_StartMaxDist; }

Battleground::m_StartMaxDist

float m_StartMaxDist

Definition: Battleground.h:626

Here is the caller graph for this function:

BattlegroundStatus Battleground::GetStatus ( ) const

inline

266 { return m_Status; }

Battleground::m_Status

BattlegroundStatus m_Status

Definition: Battleground.h:571

static TeamId Battleground::GetTeamIndexByTeamId ( uint32 Team )

inlinestatic

399 { return Team == ALLIANCE ? TEAM_ALLIANCE : TEAM_HORDE; }

Definition: SharedDefines.h:1000

Battleground::m_RandomTypeID

Definition: SharedDefines.h:997

TEAM_ALLIANCE

Definition: SharedDefines.h:992

TEAM_HORDE

Definition: SharedDefines.h:993

Here is the caller graph for this function:

uint32 Battleground::GetTeamScore ( uint32 TeamID ) const

 {
     if (teamId == TEAM_ALLIANCE || teamId == TEAM_HORDE)
         return m_TeamScores[teamId];
 
     TC_LOG_ERROR("bg.battleground", "GetTeamScore with wrong Team %u for BG %u", teamId, GetTypeID());
     return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Position const * Battleground::GetTeamStartPosition ( TeamId teamId ) const

 {
     ASSERT(teamId < TEAM_NEUTRAL);
     return &StartPosition[teamId];
 }

Here is the caller graph for this function:

BattlegroundTypeId Battleground::GetTypeID ( bool GetRandom = false ) const

inline

263 { return GetRandom ? m_RandomTypeID : m_TypeID; }

BattlegroundTypeId m_RandomTypeID

Definition: Battleground.h:569

Battleground::m_TypeID

BattlegroundTypeId m_TypeID

Definition: Battleground.h:568

Here is the caller graph for this function:

uint8 Battleground::GetUniqueBracketId ( ) const

 {
     return uint8(GetMinLevel() / 5) - 1; // 10 - 1, 15 - 2, 20 - 3, etc.
 }

Here is the call graph for this function:

Here is the caller graph for this function:

BattlegroundTeamId Battleground::GetWinner ( ) const

inline

282 { return _winnerTeamId; }

Battleground::_winnerTeamId

BattlegroundTeamId _winnerTeamId

Definition: Battleground.h:584

Here is the caller graph for this function:

void Battleground::HandleAreaTrigger	(	Player *	player,
		uint32	trigger,
		bool
	)

virtual

Reimplemented in BattlegroundAV, BattlegroundIC, BattlegroundSA, BattlegroundEY, BattlegroundAB, BattlegroundWS, BattlegroundRV, BattlegroundDS, BattlegroundBE, BattlegroundNA, and BattlegroundRL.

 {
     TC_LOG_DEBUG("bg.battleground", "Unhandled AreaTrigger %u in Battleground %u. Player coords (x: %f, y: %f, z: %f)",
                    trigger, player->GetMapId(), player->GetPositionX(), player->GetPositionY(), player->GetPositionZ());
 }

Here is the caller graph for this function:

void Battleground::HandleKillPlayer	(	Player *	player,
		Player *	killer
	)

virtual

Reimplemented in BattlegroundAV, BattlegroundIC, BattlegroundEY, BattlegroundWS, and Arena.

 {
     // Keep in mind that for arena this will have to be changed a bit
 
     // Add +1 deaths
     UpdatePlayerScore(victim, SCORE_DEATHS, 1);
     // Add +1 kills to group and +1 killing_blows to killer
     if (killer)
     {
         // Don't reward credit for killing ourselves, like fall damage of hellfire (warlock)
         if (killer == victim)
             return;
 
         UpdatePlayerScore(killer, SCORE_HONORABLE_KILLS, 1);
         UpdatePlayerScore(killer, SCORE_KILLING_BLOWS, 1);
 
         for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
         {
             Player* creditedPlayer = ObjectAccessor::FindPlayer(itr->first);
             if (!creditedPlayer || creditedPlayer == killer)
                 continue;
 
             if (creditedPlayer->GetTeam() == killer->GetTeam() && creditedPlayer->IsAtGroupRewardDistance(victim))
                 UpdatePlayerScore(creditedPlayer, SCORE_HONORABLE_KILLS, 1);
         }
     }
 
     if (!isArena())
     {
         // To be able to remove insignia -- ONLY IN Battlegrounds
         victim->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE);
         RewardXPAtKill(killer, victim);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void Battleground::HandleKillUnit	(	Creature *	,
		Player *
	)

inlinevirtual

Reimplemented in BattlegroundAV, BattlegroundIC, and BattlegroundSA.

424 { }

virtual void Battleground::HandlePlayerResurrect ( Player * )

inlinevirtual

Reimplemented in BattlegroundIC.

436 { }

virtual bool Battleground::HandlePlayerUnderMap ( Player * )

inlinevirtual

468 { return false; }

virtual void Battleground::HandleQuestComplete	(	uint32	,
		Player *
	)

inlinevirtual

Reimplemented in BattlegroundAV.

483 { }

void Battleground::HandleTriggerBuff ( ObjectGuid go_guid )

 {
     GameObject* obj = GetBgMap()->GetGameObject(go_guid);
     if (!obj || obj->GetGoType() != GAMEOBJECT_TYPE_TRAP || !obj->isSpawned())
         return;
 
     // Change buff type, when buff is used:
     int32 index = BgObjects.size() - 1;
     while (index >= 0 && BgObjects[index] != go_guid)
         index--;
     if (index < 0)
     {
         TC_LOG_ERROR("bg.battleground", "Battleground::HandleTriggerBuff: cannot find buff gameobject (%s, entry: %u, type: %u) in internal data for BG (map: %u, instance id: %u)!",
             go_guid.ToString().c_str(), obj->GetEntry(), obj->GetGoType(), m_MapId, m_InstanceID);
         return;
     }
 
     // Randomly select new buff
     uint8 buff = urand(0, 2);
     uint32 entry = obj->GetEntry();
     if (m_BuffChange && entry != Buff_Entries[buff])
     {
         // Despawn current buff
         SpawnBGObject(index, RESPAWN_ONE_DAY);
         // Set index for new one
         for (uint8 currBuffTypeIndex = 0; currBuffTypeIndex < 3; ++currBuffTypeIndex)
             if (entry == Buff_Entries[currBuffTypeIndex])
             {
                 index -= currBuffTypeIndex;
                 index += buff;
             }
     }
 
     SpawnBGObject(index, BUFF_RESPAWN_TIME);
 }

Here is the call graph for this function:

bool Battleground::HasFreeSlots ( ) const

 {
     return GetPlayersSize() < GetMaxPlayers();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Battleground::IncreaseInvitedCount ( uint32 team )

inline

319 { (team == ALLIANCE) ? ++m_InvitedAlliance : ++m_InvitedHorde; }

Battleground::m_InvitedHorde

uint32 m_InvitedHorde

Definition: Battleground.h:601

Battleground::m_InvitedAlliance

Definition: SharedDefines.h:1000

uint32 m_InvitedAlliance

Definition: Battleground.h:600

Here is the caller graph for this function:

virtual bool Battleground::IsAllNodesControlledByTeam ( uint32 ) const

inlinevirtual

Reimplemented in BattlegroundIC, BattlegroundEY, and BattlegroundAB.

255 { return false; }

bool Battleground::isArena ( ) const

inline

326 { return m_IsArena; }

Battleground::m_IsArena

bool m_IsArena

Definition: Battleground.h:583

Here is the caller graph for this function:

bool Battleground::isBattleground ( ) const

inline

327 { return !m_IsArena; }

Battleground::m_IsArena

bool m_IsArena

Definition: Battleground.h:583

Here is the caller graph for this function:

bool Battleground::IsPlayerInBattleground ( ObjectGuid guid ) const

 {
     BattlegroundPlayerMap::const_iterator itr = m_Players.find(guid);
     if (itr != m_Players.end())
         return true;
     return false;
 }

Here is the caller graph for this function:

bool Battleground::IsRandom ( ) const

inline

285 { return m_IsRandom; }

Battleground::m_IsRandom

bool m_IsRandom

Definition: Battleground.h:559

Here is the caller graph for this function:

bool Battleground::isRated ( ) const

inline

328 { return m_IsRated; }

Battleground::m_IsRated

bool m_IsRated

Definition: Battleground.h:586

Here is the caller graph for this function:

virtual bool Battleground::IsSpellAllowed	(	uint32	,
		Player const *
	)		const

inlinevirtual

Reimplemented in BattlegroundIC, and BattlegroundSA.

485 { return true; }

void Battleground::ModifyStartDelayTime ( int diff )

inline

309 { m_StartDelayTime -= diff; }

Battleground::m_StartDelayTime

int32 m_StartDelayTime

Definition: Battleground.h:585

Here is the caller graph for this function:

void Battleground::PlayerAddedToBGCheckIfBGIsRunning ( Player * player )

protected

 {
     if (GetStatus() != STATUS_WAIT_LEAVE)
         return;
 
     WorldPackets::Battleground::PVPLogData pvpLogData;
     BattlegroundQueueTypeId bgQueueTypeId = BattlegroundMgr::BGQueueTypeId(GetTypeID(), GetArenaType());
 
     BlockMovement(player);
 
     BuildPvPLogDataPacket(pvpLogData);
     player->SendDirectMessage(pvpLogData.Write());
 
     WorldPackets::Battleground::BattlefieldStatusActive battlefieldStatus;
     sBattlegroundMgr->BuildBattlegroundStatusActive(&battlefieldStatus, this, player, player->GetBattlegroundQueueIndex(bgQueueTypeId), player->GetBattlegroundQueueJoinTime(bgQueueTypeId), GetArenaType());
     player->SendDirectMessage(battlefieldStatus.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Battleground::PlaySoundToAll ( uint32 SoundID )

 {
     SendPacketToAll(WorldPackets::Misc::PlaySound(ObjectGuid::Empty, soundID).Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Battleground::PlaySoundToTeam	(	uint32	SoundID,
		uint32	TeamID
	)

 {
     for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
     {
         if (Player* player = _GetPlayerForTeam(teamID, itr, "PlaySoundToTeam"))
             player->SendDirectMessage(WorldPackets::Misc::PlaySound(ObjectGuid::Empty, soundID).Write());
     }
 }

Here is the call graph for this function:

virtual void Battleground::PostUpdateImpl ( uint32 )

inlineprotectedvirtual

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 in BattlegroundAV, BattlegroundIC, BattlegroundSA, BattlegroundEY, BattlegroundAB, BattlegroundWS, BattlegroundRV, and BattlegroundDS.

531 { }

Here is the caller graph for this function:

virtual bool Battleground::PreUpdateImpl ( uint32 )

inlineprotectedvirtual

Pre-update hook.

Will be called before battleground update is started. Depending on the result of this call actual update body may be skipped.

Parameters

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

Returns: true if update must be performed, false otherwise.

See also: Update(), PostUpdateImpl().

518 { return true; }

Here is the caller graph for this function:

virtual void Battleground::ProcessEvent	(	WorldObject *	,
		uint32	,
		WorldObject *	= `NULL`
	)

inlinevirtual

Reimplemented in BattlegroundSA.

431 { }

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

 {
     if (!entry)
         return;
 
     va_list ap;
     va_start(ap, source);
 
     Trinity::BattlegroundChatBuilder bg_builder(type, entry, source, &ap);
     Trinity::LocalizedPacketDo<Trinity::BattlegroundChatBuilder> bg_do(bg_builder);
     BroadcastWorker(bg_do);
 
     va_end(ap);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Battleground::RelocateDeadPlayers ( ObjectGuid guideGuid )

Relocate all players in ReviveQueue to the closest graveyard.

 {
     // Those who are waiting to resurrect at this node are taken to the closest own node's graveyard
     GuidVector& ghostList = m_ReviveQueue[guideGuid];
     if (!ghostList.empty())
     {
         WorldSafeLocsEntry const* closestGrave = NULL;
         for (GuidVector::const_iterator itr = ghostList.begin(); itr != ghostList.end(); ++itr)
         {
             Player* player = ObjectAccessor::FindPlayer(*itr);
             if (!player)
                 continue;
 
             if (!closestGrave)
                 closestGrave = GetClosestGraveYard(player);
 
             if (closestGrave)
                 player->TeleportTo(GetMapId(), closestGrave->Loc.X, closestGrave->Loc.Y, closestGrave->Loc.Z, player->GetOrientation());
         }
         ghostList.clear();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Battleground::RemoveAuraOnTeam	(	uint32	SpellID,
		uint32	TeamID
	)

 {
     for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
         if (Player* player = _GetPlayerForTeam(TeamID, itr, "RemoveAuraOnTeam"))
             player->RemoveAura(SpellID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Battleground::RemoveFromBGFreeSlotQueue ( )

 {
     if (m_InBGFreeSlotQueue)
     {
         sBattlegroundMgr->RemoveFromBGFreeSlotQueue(m_TypeID, m_InstanceID);
         m_InBGFreeSlotQueue = false;
     }
 }

Here is the caller graph for this function:

virtual void Battleground::RemovePlayer	(	Player *	,
		ObjectGuid	,
		uint32
	)

inlineprotectedvirtual

Reimplemented in BattlegroundAV, BattlegroundIC, BattlegroundSA, BattlegroundEY, BattlegroundAB, BattlegroundWS, and Arena.

545 { }

Here is the caller graph for this function:

void Battleground::RemovePlayerAtLeave	(	ObjectGuid	guid,
		bool	Transport,
		bool	SendPacket
	)

virtual

Reimplemented in Arena.

 {
     uint32 team = GetPlayerTeam(guid);
     bool participant = false;
     // Remove from lists/maps
     BattlegroundPlayerMap::iterator itr = m_Players.find(guid);
     if (itr != m_Players.end())
     {
         UpdatePlayersCountByTeam(team, true);               // -1 player
         m_Players.erase(itr);
         // check if the player was a participant of the match, or only entered through gm command (goname)
         participant = true;
     }
 
     BattlegroundScoreMap::iterator itr2 = PlayerScores.find(guid);
     if (itr2 != PlayerScores.end())
     {
         delete itr2->second;                                // delete player's score
         PlayerScores.erase(itr2);
     }
 
     RemovePlayerFromResurrectQueue(guid);
 
     Player* player = ObjectAccessor::FindPlayer(guid);
 
     if (player)
     {
         // should remove spirit of redemption
         if (player->HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))
             player->RemoveAurasByType(SPELL_AURA_MOD_SHAPESHIFT);
 
         player->RemoveAurasByType(SPELL_AURA_MOUNTED);
 
         if (!player->IsAlive())                              // resurrect on exit
         {
             player->ResurrectPlayer(1.0f);
             player->SpawnCorpseBones();
         }
     }
     else
     {
         SQLTransaction trans(nullptr);
         Player::OfflineResurrect(guid, trans);
     }
 
     RemovePlayer(player, guid, team);                           // BG subclass specific code
 
     BattlegroundTypeId bgTypeId = GetTypeID();
     BattlegroundQueueTypeId bgQueueTypeId = BattlegroundMgr::BGQueueTypeId(GetTypeID(), GetArenaType());
 
     if (participant) // if the player was a match participant, remove auras, calc rating, update queue
     {
         if (player)
         {
             player->ClearAfkReports();
 
             // if arena, remove the specific arena auras
             if (isArena())
             {
                 bgTypeId = BATTLEGROUND_AA;                   // set the bg type to all arenas (it will be used for queue refreshing)
 
                 // unsummon current and summon old pet if there was one and there isn't a current pet
                 player->RemovePet(NULL, PET_SAVE_NOT_IN_SLOT);
                 player->ResummonPetTemporaryUnSummonedIfAny();
             }
 
             if (SendPacket)
             {
                 WorldPackets::Battleground::BattlefieldStatusNone battlefieldStatus;
                 sBattlegroundMgr->BuildBattlegroundStatusNone(&battlefieldStatus, player, player->GetBattlegroundQueueIndex(bgQueueTypeId), player->GetBattlegroundQueueJoinTime(bgQueueTypeId), m_ArenaType);
                 player->SendDirectMessage(battlefieldStatus.Write());
             }
 
             // this call is important, because player, when joins to battleground, this method is not called, so it must be called when leaving bg
             player->RemoveBattlegroundQueueId(bgQueueTypeId);
         }
 
         // remove from raid group if player is member
         if (Group* group = GetBgRaid(team))
         {
             if (!group->RemoveMember(guid))                // group was disbanded
                 SetBgRaid(team, NULL);
         }
         DecreaseInvitedCount(team);
         //we should update battleground queue, but only if bg isn't ending
         if (isBattleground() && GetStatus() < STATUS_WAIT_LEAVE)
         {
             // a player has left the battleground, so there are free slots -> add to queue
             AddToBGFreeSlotQueue();
             sBattlegroundMgr->ScheduleQueueUpdate(0, 0, bgQueueTypeId, bgTypeId, GetBracketId());
         }
 
         // Let others know
         WorldPackets::Battleground::BattlegroundPlayerLeft playerLeft;
         playerLeft.Guid = guid;
         SendPacketToTeam(team, playerLeft.Write(), player, false);
     }
 
     if (player)
     {
         // Do next only if found in battleground
         player->SetBattlegroundId(0, BATTLEGROUND_TYPE_NONE);  // We're not in BG.
         // reset destination bg team
         player->SetBGTeam(0);
 
         if (Transport)
             player->TeleportToBGEntryPoint();
 
         TC_LOG_DEBUG("bg.battleground", "Removed player %s from Battleground.", player->GetName().c_str());
     }
 
     //battleground object will be deleted next Battleground::Update() call
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Battleground::RemovePlayerFromResurrectQueue ( ObjectGuid player_guid )

 {
     for (std::map<ObjectGuid, GuidVector>::iterator itr = m_ReviveQueue.begin(); itr != m_ReviveQueue.end(); ++itr)
     {
         for (GuidVector::iterator itr2 = itr->second.begin(); itr2 != itr->second.end(); ++itr2)
         {
             if (*itr2 == player_guid)
             {
                 itr->second.erase(itr2);
                 if (Player* player = ObjectAccessor::FindPlayer(player_guid))
                     player->RemoveAurasDueToSpell(SPELL_WAITING_FOR_RESURRECT);
                 return;
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Battleground::Reset ( )

virtual

Reimplemented in BattlegroundSA, BattlegroundEY, BattlegroundAB, and BattlegroundWS.

 {
     SetWinner(BG_TEAM_NEUTRAL);
     SetStatus(STATUS_WAIT_QUEUE);
     SetElapsedTime(0);
     SetRemainingTime(0);
     SetLastResurrectTime(0);
     m_Events = 0;
 
     if (m_InvitedAlliance > 0 || m_InvitedHorde > 0)
         TC_LOG_ERROR("bg.battleground", "Battleground::Reset: one of the counters is not 0 (alliance: %u, horde: %u) for BG (map: %u, instance id: %u)!",
             m_InvitedAlliance, m_InvitedHorde, m_MapId, m_InstanceID);
 
     m_InvitedAlliance = 0;
     m_InvitedHorde = 0;
     m_InBGFreeSlotQueue = false;
 
     m_Players.clear();
 
     for (BattlegroundScoreMap::const_iterator itr = PlayerScores.begin(); itr != PlayerScores.end(); ++itr)
         delete itr->second;
     PlayerScores.clear();
 
     for (uint8 i = 0; i < BG_TEAMS_COUNT; ++i)
         _arenaTeamScores[i].Reset();
 
     ResetBGSubclass();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void Battleground::ResetBGSubclass ( )

inlinevirtual

Reimplemented in BattlegroundAV.

250 { } // must be implemented in BG subclass

Here is the caller graph for this function:

void Battleground::RewardHonorToTeam	(	uint32	Honor,
		uint32	TeamID
	)

 {
     for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
         if (Player* player = _GetPlayerForTeam(TeamID, itr, "RewardHonorToTeam"))
             UpdatePlayerScore(player, SCORE_BONUS_HONOR, Honor);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     FactionEntry const* factionEntry = sFactionStore.LookupEntry(faction_id);
     if (!factionEntry)
         return;
 
     for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
     {
         Player* player = _GetPlayerForTeam(TeamID, itr, "RewardReputationToTeam");
         if (!player)
             continue;
 
         uint32 repGain = Reputation;
         AddPct(repGain, player->GetTotalAuraModifier(SPELL_AURA_MOD_REPUTATION_GAIN));
         AddPct(repGain, player->GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_FACTION_REPUTATION_GAIN, faction_id));
         player->GetReputationMgr().ModifyReputation(factionEntry, repGain);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Battleground::RewardXPAtKill	(	Player *	killer,
		Player *	victim
	)

 {
     if (sWorld->getBoolConfig(CONFIG_BG_XP_FOR_KILL) && killer && victim)
         killer->RewardPlayerAndGroupAtKill(victim, true);
 }

Here is the caller graph for this function:

void Battleground::SendChatMessage	(	Creature *	source,
		uint8	textId,
		WorldObject *	target = `NULL`
	)

 {
     sCreatureTextMgr->SendChat(source, textId, target);
 }

Here is the caller graph for this function:

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

 {
     Trinity::Battleground2ChatBuilder bg_builder(type, entry, source, arg1, arg2);
     Trinity::LocalizedPacketDo<Trinity::Battleground2ChatBuilder> bg_do(bg_builder);
     BroadcastWorker(bg_do);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!entry)
         return;
 
     Trinity::BattlegroundChatBuilder bg_builder(type, entry, source);
     Trinity::LocalizedPacketDo<Trinity::BattlegroundChatBuilder> bg_do(bg_builder);
     BroadcastWorker(bg_do);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Battleground::SendPacketToAll ( WorldPacket const * packet ) const

 {
     for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
         if (Player* player = _GetPlayer(itr, "SendPacketToAll"))
             player->SendDirectMessage(packet);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
     {
         if (Player* player = _GetPlayerForTeam(TeamID, itr, "SendPacketToTeam"))
         {
             if (self || sender != player)
                 player->SendDirectMessage(packet);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Battleground::SetArenaMatchmakerRating	(	uint32	Team,
		uint32	MMR
	)

inline

416 { m_ArenaTeamMMR[GetTeamIndexByTeamId(Team)] = MMR; }

static TeamId GetTeamIndexByTeamId(uint32 Team)

Definition: Battleground.h:399

Battleground::m_ArenaTeamMMR

Definition: SharedDefines.h:997

uint32 m_ArenaTeamMMR[BG_TEAMS_COUNT]

Definition: Battleground.h:612

Here is the caller graph for this function:

void Battleground::SetArenaorBGType ( bool _isArena )

inline

305 { m_IsArena = _isArena; }

Battleground::m_IsArena

bool m_IsArena

Definition: Battleground.h:583

Here is the caller graph for this function:

void Battleground::SetArenaTeamIdForTeam	(	uint32	Team,
		uint32	ArenaTeamId
	)

inline

413 { m_ArenaTeamIds[GetTeamIndexByTeamId(Team)] = ArenaTeamId; }

static TeamId GetTeamIndexByTeamId(uint32 Team)

Definition: Battleground.h:399