#include "Arena.h"

Inheritance diagram for Arena:

Protected Member Functions
	Arena ()

void	AddPlayer (Player *player) override

void	RemovePlayer (Player *) override

void	FillInitialWorldStates (WorldPacket &data) override

void	UpdateArenaWorldState ()

void	HandleKillPlayer (Player player, Player killer) override

Protected Member Functions inherited from Battleground
void	EndNow ()

void	PlayerAddedToBGCheckIfBGIsRunning (Player *player)

void	_ProcessResurrect (uint32 diff)

void	_ProcessProgress (uint32 diff)

void	_ProcessLeave (uint32 diff)

void	_ProcessJoin (uint32 diff)

void	_CheckSafePositions (uint32 diff)

virtual void	RemovePlayer (Player *)

Private Member Functions
void	RemovePlayerAtLeave (Player *player) override

void	CheckWinConditions () override

void	EndBattleground (TeamId winnerTeamId) override

Additional Inherited Members
Public Types inherited from Battleground
typedef std::set< Player * >	SpectatorList

typedef std::map< ObjectGuid, ObjectGuid >	ToBeTeleportedMap

typedef std::map< ObjectGuid, Player * >	BattlegroundPlayerMap

typedef std::unordered_map< ObjectGuid::LowType, BattlegroundScore * >	BattlegroundScoreMap

typedef std::unordered_map< ObjectGuid, ArenaLogEntryData >	ArenaLogEntryDataMap

typedef GuidVector	BGObjects

typedef GuidVector	BGCreatures

Public Member Functions inherited from Battleground
	Battleground ()

virtual	~Battleground ()

void	Update (uint32 diff)

virtual bool	SetupBattleground ()

virtual void	Init ()

virtual void	StartingEventCloseDoors ()

virtual void	StartingEventOpenDoors ()

virtual void	ResetBGSubclass ()

virtual void	DestroyGate (Player , GameObject )

virtual bool	AllNodesConrolledByTeam (TeamId) const

void	StartTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry)

std::string	GetName () const

BattlegroundTypeId	GetBgTypeID (bool GetRandom=false) const

BattlegroundBracketId	GetBracketId () const

uint32	GetInstanceID () const

BattlegroundStatus	GetStatus () const

uint32	GetClientInstanceID () const

uint32	GetStartTime () const

uint32	GetEndTime () const

uint32	GetLastResurrectTime () const

uint32	GetMinLevel () const

uint32	GetMaxLevel () const

uint32	GetMaxPlayersPerTeam () const

uint32	GetMinPlayersPerTeam () const

int32	GetStartDelayTime () const

uint8	GetArenaType () const

PvPTeamId	GetWinner () const

uint32	GetScriptId () const

uint32	GetBonusHonorFromKill (uint32 kills) const

bool	SpiritofCompetitionEvent (PvPTeamId winnerTeamId)

bool	IsRandom ()

void	SetName (std::string_view name)

void	SetBgTypeID (BattlegroundTypeId TypeID)

void	SetRandomTypeID (BattlegroundTypeId TypeID)

void	SetBracket (PvPDifficultyEntry const *bracketEntry)

void	SetInstanceID (uint32 InstanceID)

void	SetStatus (BattlegroundStatus Status)

void	SetClientInstanceID (uint32 InstanceID)

void	SetStartTime (uint32 Time)

void	SetEndTime (uint32 Time)

void	SetLastResurrectTime (uint32 Time)

void	SetLevelRange (uint32 min, uint32 max)

void	SetRated (bool state)

void	SetArenaType (uint8 type)

void	SetArenaorBGType (bool _isArena)

void	SetWinner (PvPTeamId winner)

void	SetScriptId (uint32 scriptId)

void	SetRandom (bool isRandom)

void	ModifyStartDelayTime (int32 diff)

void	SetStartDelayTime (int32 Time)

void	SetMaxPlayersPerTeam (uint32 MaxPlayers)

void	SetMinPlayersPerTeam (uint32 MinPlayers)

void	AddToBGFreeSlotQueue ()

void	RemoveFromBGFreeSlotQueue ()

void	DecreaseInvitedCount (TeamId teamId)

void	IncreaseInvitedCount (TeamId teamId)

uint32	GetInvitedCount (TeamId teamId) const

bool	HasFreeSlots () const

uint32	GetFreeSlotsForTeam (TeamId teamId) const

uint32	GetMaxFreeSlots () const

void	AddSpectator (Player *p)

void	RemoveSpectator (Player *p)

bool	HaveSpectators ()

const SpectatorList &	GetSpectators () const

void	AddToBeTeleported (ObjectGuid spectator, ObjectGuid participant)

void	RemoveToBeTeleported (ObjectGuid spectator)

void	SpectatorsSendPacket (WorldPacket &data)

bool	isArena () const

bool	isBattleground () const

bool	isRated () const

BattlegroundPlayerMap const &	GetPlayers () const

uint32	GetPlayersSize () const

void	ReadyMarkerClicked (Player *p)

BattlegroundScoreMap const *	GetPlayerScores () const

std::size_t	GetPlayerScoresSize () const

uint32	GetReviveQueueSize () const

void	AddPlayerToResurrectQueue (ObjectGuid npc_guid, ObjectGuid player_guid)

void	RemovePlayerFromResurrectQueue (Player *player)

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

void	StartBattleground ()

GameObject *	GetBGObject (uint32 type)

Creature *	GetBGCreature (uint32 type)

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

virtual void	FillInitialWorldStates (WorldPacket &)

void	SendPacketToTeam (TeamId teamId, WorldPacket const packet, Player sender=nullptr, bool self=true)

void	SendPacketToAll (WorldPacket const *packet)

void	YellToAll (Creature creature, const char text, uint32 language)

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

void	SendBroadcastText (uint32 id, ChatMsg msgType, WorldObject const *target=nullptr)

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

void	PlaySoundToAll (uint32 soundId)

void	CastSpellOnTeam (uint32 spellId, TeamId teamId)

void	RemoveAuraOnTeam (uint32 spellId, TeamId teamId)

void	RewardHonorToTeam (uint32 honor, TeamId teamId)

void	RewardReputationToTeam (uint32 factionId, uint32 reputation, TeamId teamId)

uint32	GetRealRepFactionForPlayer (uint32 factionId, Player *player)

void	UpdateWorldState (uint32 variable, uint32 value)

void	EndBattleground (PvPTeamId winnerTeamId)

virtual void	EndBattleground (TeamId winnerTeamId)

void	BlockMovement (Player *player)

void	SendWarningToAll (uint32 entry,...)

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

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 (TeamId teamId) const

void	SetBgRaid (TeamId teamId, Group *bg_raid)

void	BuildPvPLogDataPacket (WorldPacket &data)

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

uint32	GetPlayersCountByTeam (TeamId teamId) const

uint32	GetAlivePlayersCountByTeam (TeamId teamId) const

void	UpdatePlayersCountByTeam (TeamId teamId, bool remove)

virtual void	CheckWinConditions ()

void	SetArenaTeamIdForTeam (TeamId teamId, uint32 ArenaTeamId)

uint32	GetArenaTeamIdForTeam (TeamId teamId) const

void	SetArenaMatchmakerRating (TeamId teamId, uint32 MMR)

uint32	GetArenaMatchmakerRating (TeamId teamId) const

virtual void	HandleAreaTrigger (Player *, uint32)

virtual void	HandleKillPlayer (Player player, Player killer)

virtual void	HandleKillUnit (Creature , Player )

virtual void	EventPlayerDroppedFlag (Player *)

virtual void	EventPlayerClickedOnFlag (Player , GameObject )

virtual void	EventPlayerDamagedGO (Player , GameObject , uint32)

virtual void	EventPlayerUsedGO (Player , GameObject )

virtual void	DoAction (uint32, ObjectGuid)

virtual void	HandlePlayerResurrect (Player *)

virtual GraveyardStruct const *	GetClosestGraveyard (Player *player)

virtual void	AddPlayer (Player *player)

void	AddOrSetPlayerToCorrectBgGroup (Player *player, TeamId teamId)

virtual void	RemovePlayerAtLeave (Player *player)

void	HandleTriggerBuff (GameObject *gameObject)

void	SetHoliday (bool is_holiday)

void	SpawnBGObject (uint32 type, uint32 respawntime, uint32 forceRespawnDelay=0)

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)

Creature *	AddCreature (uint32 entry, uint32 type, float x, float y, float z, float o, uint32 respawntime=0, MotionTransport *transport=nullptr)

bool	DelCreature (uint32 type)

bool	DelObject (uint32 type)

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

int32	GetObjectType (ObjectGuid guid)

void	DoorOpen (uint32 type)

void	DoorClose (uint32 type)

const char *	GetAcoreString (int32 entry)

virtual bool	HandlePlayerUnderMap (Player *)

bool	IsPlayerInBattleground (ObjectGuid guid) const

bool	ToBeDeleted () const

void	RewardXPAtKill (Player killer, Player victim)

virtual ObjectGuid	GetFlagPickerGUID (TeamId=TEAM_NEUTRAL) const

virtual void	SetDroppedFlagGUID (ObjectGuid, TeamId=TEAM_NEUTRAL)

uint32	GetTeamScore (TeamId teamId) const

virtual TeamId	GetPrematureWinner ()

uint8	GetUniqueBracketId () const

BattlegroundAV *	ToBattlegroundAV ()

BattlegroundAV const *	ToBattlegroundAV () const

BattlegroundWS *	ToBattlegroundWS ()

BattlegroundWS const *	ToBattlegroundWS () const

BattlegroundAB *	ToBattlegroundAB ()

BattlegroundAB const *	ToBattlegroundAB () const

BattlegroundNA *	ToBattlegroundNA ()

BattlegroundNA const *	ToBattlegroundNA () const

BattlegroundBE *	ToBattlegroundBE ()

BattlegroundBE const *	ToBattlegroundBE () const

BattlegroundEY *	ToBattlegroundEY ()

BattlegroundEY const *	ToBattlegroundEY () const

BattlegroundRL *	ToBattlegroundRL ()

BattlegroundRL const *	ToBattlegroundRL () const

BattlegroundSA *	ToBattlegroundSA ()

BattlegroundSA const *	ToBattlegroundSA () const

BattlegroundDS *	ToBattlegroundDS ()

BattlegroundDS const *	ToBattlegroundDS () const

BattlegroundRV *	ToBattlegroundRV ()

BattlegroundRV const *	ToBattlegroundRV () const

BattlegroundIC *	ToBattlegroundIC ()

BattlegroundIC const *	ToBattlegroundIC () const

Static Public Member Functions inherited from Battleground
static TeamId	GetOtherTeamId (TeamId teamId)

Public Attributes inherited from Battleground
GuidSet	readyMarkerClickedSet

ArenaLogEntryDataMap	ArenaLogEntries

BGObjects	BgObjects

BGCreatures	BgCreatures

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 [PVP_TEAMS_COUNT]

ArenaTeamScore	_arenaTeamScores [PVP_TEAMS_COUNT]

uint32	m_UpdateTimer

EventProcessor	_reviveEvents

Detailed Description

Constructor & Destructor Documentation

◆ Arena()

Arena::Arena ( )

protected

{
    StartDelayTimes[BG_STARTING_EVENT_FIRST]  = BG_START_DELAY_1M;
    StartDelayTimes[BG_STARTING_EVENT_SECOND] = BG_START_DELAY_30S;
    StartDelayTimes[BG_STARTING_EVENT_THIRD]  = BG_START_DELAY_15S;
    StartDelayTimes[BG_STARTING_EVENT_FOURTH] = BG_START_DELAY_NONE;
 
    StartMessageIds[BG_STARTING_EVENT_FIRST]  = ARENA_TEXT_START_ONE_MINUTE;
    StartMessageIds[BG_STARTING_EVENT_SECOND] = ARENA_TEXT_START_THIRTY_SECONDS;
    StartMessageIds[BG_STARTING_EVENT_THIRD]  = ARENA_TEXT_START_FIFTEEN_SECONDS;
    StartMessageIds[BG_STARTING_EVENT_FOURTH] = ARENA_TEXT_START_BATTLE_HAS_BEGUN;
}

References ARENA_TEXT_START_BATTLE_HAS_BEGUN, ARENA_TEXT_START_FIFTEEN_SECONDS, ARENA_TEXT_START_ONE_MINUTE, ARENA_TEXT_START_THIRTY_SECONDS, BG_START_DELAY_15S, BG_START_DELAY_1M, BG_START_DELAY_30S, BG_START_DELAY_NONE, BG_STARTING_EVENT_FIRST, BG_STARTING_EVENT_FOURTH, BG_STARTING_EVENT_SECOND, BG_STARTING_EVENT_THIRD, Battleground::StartDelayTimes, and Battleground::StartMessageIds.

Member Function Documentation

◆ AddPlayer()

void Arena::AddPlayer ( Player * player )

overrideprotectedvirtual

Reimplemented from Battleground.

{
    Battleground::AddPlayer(player);
    PlayerScores.emplace(player->GetGUID().GetCounter(), new ArenaScore(player->GetGUID(), player->GetBgTeamId()));
 
    if (player->GetBgTeamId() == TEAM_ALLIANCE) // gold
    {
        if (player->GetTeamId() == TEAM_HORDE)
            player->CastSpell(player, SPELL_HORDE_GOLD_FLAG, true);
        else
            player->CastSpell(player, SPELL_ALLIANCE_GOLD_FLAG, true);
    }
    else // green
    {
        if (player->GetTeamId() == TEAM_HORDE)
            player->CastSpell(player, SPELL_HORDE_GREEN_FLAG, true);
        else
            player->CastSpell(player, SPELL_ALLIANCE_GREEN_FLAG, true);
    }
 
    UpdateArenaWorldState();
 
    Group* group = player->GetGroup();
    if (group)
    {
        // Hackfix for crossfaction arenas, recreate group when joining
        // Without this, players in a crossfaction arena group would not be able to cast beneficial spells on their teammates
 
        std::vector<Player*> members;
        bool isCrossfaction = false;
        for (Group::member_citerator mitr = group->GetMemberSlots().begin(); mitr != group->GetMemberSlots().end(); ++mitr)
        {
            Player* member = ObjectAccessor::FindPlayer(mitr->guid);
            if (!member || member->GetGUID() == player->GetGUID())
            {
                continue;
            }
            members.push_back(member);
            if (member->GetTeamId(true) != player->GetTeamId(true))
            {
                isCrossfaction = true;
            }
        }
 
        if (isCrossfaction)
        {
            for (Player* member : members)
            {
                member->RemoveFromGroup();
            }
            group->Disband();
 
            group = new Group();
            SetBgRaid(player->GetBgTeamId(), group);
            group->Create(player);
            sGroupMgr->AddGroup(group);
            for (Player* member : members)
            {
                group->AddMember(member);
            }
        }
    }
}

References Group::AddMember(), Battleground::AddPlayer(), Unit::CastSpell(), Group::Create(), Group::Disband(), ObjectAccessor::FindPlayer(), Player::GetBgTeamId(), ObjectGuid::GetCounter(), Player::GetGroup(), Object::GetGUID(), Group::GetMemberSlots(), Player::GetTeamId(), Battleground::PlayerScores, Battleground::SetBgRaid(), sGroupMgr, SPELL_ALLIANCE_GOLD_FLAG, SPELL_ALLIANCE_GREEN_FLAG, SPELL_HORDE_GOLD_FLAG, SPELL_HORDE_GREEN_FLAG, TEAM_ALLIANCE, TEAM_HORDE, and UpdateArenaWorldState().

◆ CheckWinConditions()

void Arena::CheckWinConditions ( )

overrideprivatevirtual

Reimplemented from Battleground.

{
    if (!GetAlivePlayersCountByTeam(TEAM_ALLIANCE) && GetPlayersCountByTeam(TEAM_HORDE))
        EndBattleground(TEAM_HORDE);
    else if (GetPlayersCountByTeam(TEAM_ALLIANCE) && !GetAlivePlayersCountByTeam(TEAM_HORDE))
        EndBattleground(TEAM_ALLIANCE);
}

References EndBattleground(), Battleground::GetAlivePlayersCountByTeam(), Battleground::GetPlayersCountByTeam(), TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by HandleKillPlayer(), and RemovePlayer().

◆ EndBattleground()

void Arena::EndBattleground ( TeamId winnerTeamId )

overrideprivatevirtual

Deprecated:: need delete

Reimplemented from Battleground.

{
    if (isRated())
    {
        uint32 startDelay = GetStartDelayTime();
        bool bValidArena = GetStatus() == STATUS_IN_PROGRESS && GetStartTime() >= startDelay + 15000; // pussywizard: only if arena lasted at least 15 secs
 
        uint32 loserTeamRating = 0;
        uint32 loserMatchmakerRating = 0;
        int32  loserChange = 0;
        int32  loserMatchmakerChange = 0;
        uint32 winnerTeamRating = 0;
        uint32 winnerMatchmakerRating = 0;
        int32  winnerChange = 0;
        int32  winnerMatchmakerChange = 0;
 
        ArenaTeam* winnerArenaTeam = sArenaTeamMgr->GetArenaTeamById(GetArenaTeamIdForTeam(winnerTeamId == TEAM_NEUTRAL ? TEAM_HORDE : winnerTeamId));
        ArenaTeam* loserArenaTeam  = sArenaTeamMgr->GetArenaTeamById(GetArenaTeamIdForTeam(winnerTeamId == TEAM_NEUTRAL ? TEAM_ALLIANCE : GetOtherTeamId(winnerTeamId)));
 
        auto SaveArenaLogs = [&]()
        {
            // pussywizard: arena logs in database
            uint32 fightId = sArenaTeamMgr->GetNextArenaLogId();
            uint32 currOnline = sWorld->GetActiveSessionCount();
 
            CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
            CharacterDatabasePreparedStatement* stmt2 = CharacterDatabase.GetPreparedStatement(CHAR_INS_ARENA_LOG_FIGHT);
            stmt2->SetData(0, fightId);
            stmt2->SetData(1, GetArenaType());
            stmt2->SetData(2, ((GetStartTime() <= startDelay ? 0 : GetStartTime() - startDelay) / 1000));
            stmt2->SetData(3, winnerArenaTeam->GetId());
            stmt2->SetData(4, loserArenaTeam->GetId());
            stmt2->SetData(5, (uint16)winnerTeamRating);
            stmt2->SetData(6, (uint16)winnerMatchmakerRating);
            stmt2->SetData(7, (int16)winnerChange);
            stmt2->SetData(8, (uint16)loserTeamRating);
            stmt2->SetData(9, (uint16)loserMatchmakerRating);
            stmt2->SetData(10, (int16)loserChange);
            stmt2->SetData(11, currOnline);
            trans->Append(stmt2);
 
            uint8 memberId = 0;
            for (auto const& [playerGuid, arenaLogEntryData] : ArenaLogEntries)
            {
                auto const& score = PlayerScores.find(playerGuid.GetCounter());
                stmt2 = CharacterDatabase.GetPreparedStatement(CHAR_INS_ARENA_LOG_MEMBERSTATS);
                stmt2->SetData(0, fightId);
                stmt2->SetData(1, ++memberId);
                stmt2->SetData(2, arenaLogEntryData.Name);
                stmt2->SetData(3, arenaLogEntryData.Guid);
                stmt2->SetData(4, arenaLogEntryData.ArenaTeamId);
                stmt2->SetData(5, arenaLogEntryData.Acc);
                stmt2->SetData(6, arenaLogEntryData.IP);
                if (score != PlayerScores.end())
                {
                    stmt2->SetData(7, score->second->GetDamageDone());
                    stmt2->SetData(8, score->second->GetHealingDone());
                    stmt2->SetData(9, score->second->GetKillingBlows());
                }
                else
                {
                    stmt2->SetData(7, 0);
                    stmt2->SetData(8, 0);
                    stmt2->SetData(9, 0);
                }
                trans->Append(stmt2);
            }
 
            CharacterDatabase.CommitTransaction(trans);
        };
 
        if (winnerArenaTeam && loserArenaTeam && winnerArenaTeam != loserArenaTeam)
        {
            loserTeamRating = loserArenaTeam->GetRating();
            loserMatchmakerRating = GetArenaMatchmakerRating(GetOtherTeamId(winnerTeamId));
            winnerTeamRating = winnerArenaTeam->GetRating();
            winnerMatchmakerRating = GetArenaMatchmakerRating(winnerTeamId);
 
            if (winnerTeamId != TEAM_NEUTRAL)
            {
                winnerMatchmakerChange = bValidArena ? winnerArenaTeam->WonAgainst(winnerMatchmakerRating, loserMatchmakerRating, winnerChange, GetBgMap()) : 0;
                loserMatchmakerChange = loserArenaTeam->LostAgainst(loserMatchmakerRating, winnerMatchmakerRating, loserChange, GetBgMap());
 
                sScriptMgr->OnAfterArenaRatingCalculation(this, winnerMatchmakerChange, loserMatchmakerChange, winnerChange, loserChange);
 
                LOG_DEBUG("bg.arena", "match Type: {} --- Winner: old rating: {}, rating gain: {}, old MMR: {}, MMR gain: {} --- Loser: old rating: {}, rating loss: {}, old MMR: {}, MMR loss: {} ---",
                    GetArenaType(), winnerTeamRating, winnerChange, winnerMatchmakerRating, winnerMatchmakerChange,
                    loserTeamRating, loserChange, loserMatchmakerRating, loserMatchmakerChange);
 
                SetArenaMatchmakerRating(winnerTeamId, winnerMatchmakerRating + winnerMatchmakerChange);
                SetArenaMatchmakerRating(GetOtherTeamId(winnerTeamId), loserMatchmakerRating + loserMatchmakerChange);
 
                // bg team that the client expects is different to TeamId
                // alliance 1, horde 0
                uint8 winnerTeam = winnerTeamId == TEAM_ALLIANCE ? PVP_TEAM_ALLIANCE : PVP_TEAM_HORDE;
                uint8 loserTeam = winnerTeamId == TEAM_ALLIANCE ? PVP_TEAM_HORDE : PVP_TEAM_ALLIANCE;
 
                _arenaTeamScores[winnerTeam].Assign(winnerChange, winnerMatchmakerRating, winnerArenaTeam->GetName());
                _arenaTeamScores[loserTeam].Assign(loserChange, loserMatchmakerRating, loserArenaTeam->GetName());
 
                LOG_DEBUG("bg.arena", "Arena match Type: {} for Team1Id: {} - Team2Id: {} ended. WinnerTeamId: {}. Winner rating: +{}, Loser rating: {}",
                    GetArenaType(), GetArenaTeamIdForTeam(TEAM_ALLIANCE), GetArenaTeamIdForTeam(TEAM_HORDE), winnerArenaTeam->GetId(), winnerChange, loserChange);
            }
            else // Deduct 16 points from each teams arena-rating if there are no winners after 45+2 minutes
            {
                // pussywizard: in case of a draw, the following is always true:
                // winnerArenaTeam => TEAM_HORDE, loserArenaTeam => TEAM_ALLIANCE
 
                winnerTeamRating = winnerArenaTeam->GetRating();
                winnerMatchmakerRating = GetArenaMatchmakerRating(TEAM_HORDE);
                loserTeamRating = loserArenaTeam->GetRating();
                loserMatchmakerRating = GetArenaMatchmakerRating(TEAM_ALLIANCE);
                winnerMatchmakerChange = 0;
                loserMatchmakerChange = 0;
                winnerChange = ARENA_TIMELIMIT_POINTS_LOSS;
                loserChange = ARENA_TIMELIMIT_POINTS_LOSS;
 
                _arenaTeamScores[PVP_TEAM_ALLIANCE].Assign(ARENA_TIMELIMIT_POINTS_LOSS, winnerMatchmakerRating, winnerArenaTeam->GetName());
                _arenaTeamScores[PVP_TEAM_HORDE].Assign(ARENA_TIMELIMIT_POINTS_LOSS, loserMatchmakerRating, loserArenaTeam->GetName());
 
                winnerArenaTeam->FinishGame(ARENA_TIMELIMIT_POINTS_LOSS, GetBgMap());
                loserArenaTeam->FinishGame(ARENA_TIMELIMIT_POINTS_LOSS, GetBgMap());
            }
        }
 
        SaveArenaLogs();
 
        uint8 aliveWinners = GetAlivePlayersCountByTeam(winnerTeamId);
 
        for (auto const& [playerGuid, player] : GetPlayers())
        {
            auto const& bgTeamId = player->GetBgTeamId();
 
            // per player calculation
            if (winnerArenaTeam && loserArenaTeam && winnerArenaTeam != loserArenaTeam)
            {
                if (bgTeamId == winnerTeamId)
                {
                    if (bValidArena)
                    {
                        // update achievement BEFORE personal rating update
                        uint32 rating = player->GetArenaPersonalRating(winnerArenaTeam->GetSlot());
                        player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA, rating ? rating : 1);
                        player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_WIN_ARENA, GetMapId());
 
                        // Last standing - Rated 5v5 arena & be solely alive player
                        if (GetArenaType() == ARENA_TYPE_5v5 && aliveWinners == 1 && player->IsAlive())
                        {
                            player->CastSpell(player, SPELL_LAST_MAN_STANDING, true);
                        }
 
                        winnerArenaTeam->MemberWon(player, loserMatchmakerRating, winnerMatchmakerChange);
                    }
                }
                else
                {
                    loserArenaTeam->MemberLost(player, winnerMatchmakerRating, loserMatchmakerChange);
 
                    // Arena lost => reset the win_rated_arena having the "no_lose" condition
                    player->ResetAchievementCriteria(ACHIEVEMENT_CRITERIA_CONDITION_NO_LOSE, 0);
                }
 
                player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_PLAY_ARENA, GetMapId());
            }
        }
 
        // update previous opponents for arena queue
        winnerArenaTeam->SetPreviousOpponents(loserArenaTeam->GetId());
        loserArenaTeam->SetPreviousOpponents(winnerArenaTeam->GetId());
 
        // save the stat changes
        if (bValidArena)
        {
            winnerArenaTeam->SaveToDB();
            winnerArenaTeam->NotifyStatsChanged();
        }
 
        loserArenaTeam->SaveToDB();
        loserArenaTeam->NotifyStatsChanged();
    }
 
    // end battleground
    Battleground::EndBattleground(winnerTeamId);
}

Referenced by CheckWinConditions().

◆ FillInitialWorldStates()

void Arena::FillInitialWorldStates ( WorldPacket & data )

overrideprotectedvirtual

Reimplemented from Battleground.

Reimplemented in BattlegroundBE, BattlegroundDS, BattlegroundNA, BattlegroundRL, and BattlegroundRV.

{
    data << uint32(ARENA_WORLD_STATE_ALIVE_PLAYERS_GREEN) << uint32(GetAlivePlayersCountByTeam(TEAM_HORDE));
    data << uint32(ARENA_WORLD_STATE_ALIVE_PLAYERS_GOLD) << uint32(GetAlivePlayersCountByTeam(TEAM_ALLIANCE));
}

References ARENA_WORLD_STATE_ALIVE_PLAYERS_GOLD, ARENA_WORLD_STATE_ALIVE_PLAYERS_GREEN, Battleground::GetAlivePlayersCountByTeam(), TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by BattlegroundBE::FillInitialWorldStates(), BattlegroundDS::FillInitialWorldStates(), BattlegroundNA::FillInitialWorldStates(), BattlegroundRL::FillInitialWorldStates(), and BattlegroundRV::FillInitialWorldStates().

◆ HandleKillPlayer()

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

overrideprotectedvirtual

Reimplemented from Battleground.

{
    if (GetStatus() != STATUS_IN_PROGRESS)
        return;
 
    Battleground::HandleKillPlayer(player, killer);
 
    UpdateArenaWorldState();
    CheckWinConditions();
}

References CheckWinConditions(), Battleground::GetStatus(), Battleground::HandleKillPlayer(), STATUS_IN_PROGRESS, and UpdateArenaWorldState().

◆ RemovePlayer()

void Arena::RemovePlayer ( Player * )

overrideprotectedvirtual

Reimplemented from Battleground.

{
    if (GetStatus() == STATUS_WAIT_LEAVE)
        return;
 
    UpdateArenaWorldState();
    CheckWinConditions();
}

References CheckWinConditions(), Battleground::GetStatus(), STATUS_WAIT_LEAVE, and UpdateArenaWorldState().

◆ RemovePlayerAtLeave()

void Arena::RemovePlayerAtLeave ( Player * player )

overrideprivatevirtual

Reimplemented from Battleground.

{
    if (isRated() && GetStatus() == STATUS_IN_PROGRESS)
    {
        if (auto const& member = Acore::Containers::MapGetValuePtr(m_Players, player->GetGUID()))
        {
            // if the player was a match participant, calculate rating
            auto teamId = member->GetBgTeamId();
 
            ArenaTeam* winnerArenaTeam = sArenaTeamMgr->GetArenaTeamById(GetArenaTeamIdForTeam(GetOtherTeamId(teamId)));
            ArenaTeam* loserArenaTeam = sArenaTeamMgr->GetArenaTeamById(GetArenaTeamIdForTeam(teamId));
 
            if (winnerArenaTeam && loserArenaTeam && winnerArenaTeam != loserArenaTeam)
                loserArenaTeam->MemberLost(player, GetArenaMatchmakerRating(GetOtherTeamId(teamId)));
        }
    }
 
    // remove player
    Battleground::RemovePlayerAtLeave(player);
}

References Battleground::GetArenaMatchmakerRating(), Battleground::GetArenaTeamIdForTeam(), Object::GetGUID(), Battleground::GetOtherTeamId(), Battleground::GetStatus(), Battleground::isRated(), Battleground::m_Players, Acore::Containers::MapGetValuePtr(), ArenaTeam::MemberLost(), Battleground::RemovePlayerAtLeave(), sArenaTeamMgr, and STATUS_IN_PROGRESS.

◆ UpdateArenaWorldState()

void Arena::UpdateArenaWorldState ( )

protected

{
    UpdateWorldState(ARENA_WORLD_STATE_ALIVE_PLAYERS_GREEN, GetAlivePlayersCountByTeam(TEAM_HORDE));
    UpdateWorldState(ARENA_WORLD_STATE_ALIVE_PLAYERS_GOLD, GetAlivePlayersCountByTeam(TEAM_ALLIANCE));
}

References ARENA_WORLD_STATE_ALIVE_PLAYERS_GOLD, ARENA_WORLD_STATE_ALIVE_PLAYERS_GREEN, Battleground::GetAlivePlayersCountByTeam(), TEAM_ALLIANCE, TEAM_HORDE, and Battleground::UpdateWorldState().

Referenced by AddPlayer(), HandleKillPlayer(), and RemovePlayer().

Protected Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Arena()

Member Function Documentation

◆ AddPlayer()

◆ CheckWinConditions()

◆ EndBattleground()

◆ FillInitialWorldStates()

◆ HandleKillPlayer()

◆ RemovePlayer()

◆ RemovePlayerAtLeave()

◆ UpdateArenaWorldState()