ArenaTeam Class Reference

#include "ArenaTeam.h"

Inheritance diagram for ArenaTeam:

Public Types
typedef std::list< ArenaTeamMember >	MemberList

Public Member Functions
	ArenaTeam ()
	~ArenaTeam ()
bool	Create (ObjectGuid captainGuid, uint8 type, std::string const &teamName, uint32 backgroundColor, uint8 emblemStyle, uint32 emblemColor, uint8 borderStyle, uint32 borderColor)
void	Disband (WorldSession *session)
void	Disband ()
uint32	GetId () const
uint32	GetType () const
uint8	GetSlot () const
ObjectGuid	GetCaptain () const
std::string const &	GetName () const
const ArenaTeamStats &	GetStats () const
void	SetArenaTeamStats (ArenaTeamStats &stats)
uint32	GetRating () const
uint32	GetAverageMMR (Group *group) const
void	SetCaptain (ObjectGuid guid)
bool	SetName (std::string const &name)
bool	AddMember (ObjectGuid playerGuid)
void	DelMember (ObjectGuid guid, bool cleanDb)
std::size_t	GetMembersSize () const
bool	Empty () const
MemberList::iterator	m_membersBegin ()
MemberList::iterator	m_membersEnd ()
MemberList &	GetMembers ()
bool	IsMember (ObjectGuid guid) const
ArenaTeamMember *	GetMember (ObjectGuid guid)
ArenaTeamMember *	GetMember (std::string const &name)
bool	IsFighting () const
bool	LoadArenaTeamFromDB (QueryResult arenaTeamDataResult)
bool	LoadMembersFromDB (QueryResult arenaTeamMembersResult)
void	LoadStatsFromDB (uint32 ArenaTeamId)
void	SaveToDB (bool forceMemberSave=false)
void	BroadcastPacket (WorldPacket *packet)
void	BroadcastEvent (ArenaTeamEvents event, ObjectGuid guid, uint8 strCount, std::string const &str1, std::string const &str2, std::string const &str3)
void	NotifyStatsChanged ()
void	MassInviteToEvent (WorldSession *session)
void	Roster (WorldSession *session)
void	Query (WorldSession *session)
void	SendStats (WorldSession *session)
void	Inspect (WorldSession *session, ObjectGuid guid)
uint32	GetPoints (uint32 MemberRating)
int32	GetMatchmakerRatingMod (uint32 ownRating, uint32 opponentRating, bool won)
int32	GetRatingMod (uint32 ownRating, uint32 opponentRating, bool won)
float	GetChanceAgainst (uint32 ownRating, uint32 opponentRating)
int32	WonAgainst (uint32 Own_MMRating, uint32 Opponent_MMRating, int32 &rating_change, const Map *bgMap)
void	MemberWon (Player *player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange)
int32	LostAgainst (uint32 Own_MMRating, uint32 Opponent_MMRating, int32 &rating_change, const Map *bgMap)
void	MemberLost (Player *player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange=-12)
void	UpdateArenaPointsHelper (std::map< ObjectGuid, uint32 > &PlayerPoints)
bool	FinishWeek ()
void	FinishGame (int32 mod, const Map *bgMap)
void	SetPreviousOpponents (uint32 arenaTeamId)
uint32	GetPreviousOpponents ()
void	CreateTempArenaTeam (std::vector< Player * > playerList, uint8 type, std::string const &teamName)

Static Public Member Functions
static uint8	GetSlotByType (uint32 type)
static uint8	GetReqPlayersForType (uint32 type)

Static Public Attributes
static std::unordered_map< uint32, uint8 >	ArenaSlotByType
static std::unordered_map< uint8, uint8 >	ArenaReqPlayersForType

Protected Attributes
uint32	TeamId
uint8	Type
std::string	TeamName
ObjectGuid	CaptainGuid
uint32	BackgroundColor
uint8	EmblemStyle
uint32	EmblemColor
uint8	BorderStyle
uint32	BorderColor
MemberList	Members
ArenaTeamStats	Stats
uint32	PreviousOpponents = 0

Detailed Description

Member Typedef Documentation

MemberList

typedef std::list<ArenaTeamMember> ArenaTeam::MemberList

Constructor & Destructor Documentation

ArenaTeam()

ArenaTeam::ArenaTeam

(

)

    : TeamId(0), Type(0), TeamName(), BackgroundColor(0), EmblemStyle(0), EmblemColor(0),
      BorderStyle(0), BorderColor(0)
{
    Stats.WeekGames   = 0;
    Stats.SeasonGames = 0;
    Stats.Rank        = 0;
    Stats.Rating      = sWorld->getIntConfig(CONFIG_ARENA_START_RATING);
    Stats.WeekWins    = 0;
    Stats.SeasonWins  = 0;
}

References CONFIG_ARENA_START_RATING, and sWorld.

~ArenaTeam()

ArenaTeam::~ArenaTeam

(

)

{
}

Member Function Documentation

AddMember()

bool ArenaTeam::AddMember

(

ObjectGuid

playerGuid

)

{
    std::string playerName;
    uint8 playerClass;
 
    // Check if arena team is full (Can't have more than type * 2 players)
    if (GetMembersSize() >= GetType() * 2)
        return false;
 
    // xinef: Get player name and class from player storage or global data storage
    Player* player = ObjectAccessor::FindConnectedPlayer(playerGuid);
    if (player)
    {
        playerClass = player->getClass();
        playerName = player->GetName();
    }
    else
    {
        CharacterCacheEntry const* playerData = sCharacterCache->GetCharacterCacheByGuid(playerGuid);
        if (!playerData)
        {
            return false;
        }
 
        playerName = playerData->Name;
        playerClass = playerData->Class;
    }
 
    if (!sScriptMgr->CanAddMember(this, playerGuid))
        return false;
 
    // Check if player is already in a similar arena team
    if ((player && player->GetArenaTeamId(GetSlot())) || sCharacterCache->GetCharacterArenaTeamIdByGuid(playerGuid, GetSlot()) != 0)
    {
        LOG_ERROR("bg.arena", "Arena: Player {} ({}) already has an arena team of type {}", playerName, playerGuid.ToString(), GetType());
        return false;
    }
 
    // Set player's personal rating
    uint32 personalRating = 0;
 
    if (sWorld->getIntConfig(CONFIG_ARENA_START_PERSONAL_RATING) > 0)
        personalRating = sWorld->getIntConfig(CONFIG_ARENA_START_PERSONAL_RATING);
    else if (GetRating() >= 1000)
        personalRating = 1000;
 
    // xinef: sync query
    // Try to get player's match maker rating from db and fall back to config setting if not found
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MATCH_MAKER_RATING);
    stmt->SetData(0, playerGuid.GetCounter());
    stmt->SetData(1, GetSlot());
    PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
    uint16 matchMakerRating;
    uint16 maxMMR;
    if (result)
    {
        matchMakerRating = (*result)[0].Get<uint16>();
        uint16 Max = (*result)[1].Get<uint16>();
        maxMMR = std::max(Max, matchMakerRating);
    }
    else
    {
        matchMakerRating = sWorld->getIntConfig(CONFIG_ARENA_START_MATCHMAKER_RATING);
        maxMMR = matchMakerRating;
    }
 
    // Remove all player signatures from other petitions
    // This will prevent player from joining too many arena teams and corrupt arena team data integrity
    Player::RemovePetitionsAndSigns(playerGuid, GetType());
 
    // Feed data to the struct
    ArenaTeamMember newMember;
    //newMember.Name             = playerName;
    newMember.Guid             = playerGuid;
    newMember.Class            = playerClass;
    newMember.SeasonGames      = 0;
    newMember.WeekGames        = 0;
    newMember.SeasonWins       = 0;
    newMember.WeekWins         = 0;
    newMember.PersonalRating   = personalRating;
    newMember.MatchMakerRating = matchMakerRating;
    newMember.MaxMMR           = maxMMR;
 
    Members.push_back(newMember);
    sCharacterCache->UpdateCharacterArenaTeamId(playerGuid, GetSlot(), GetId());
 
    // Save player's arena team membership to db
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ARENA_TEAM_MEMBER);
    stmt->SetData(0, TeamId);
    stmt->SetData(1, playerGuid.GetCounter());
    CharacterDatabase.Execute(stmt);
 
    // Inform player if online
    if (player)
    {
        player->SetInArenaTeam(TeamId, GetSlot(), GetType());
        player->SetArenaTeamIdInvited(0);
 
        // Hide promote/remove buttons
        if (CaptainGuid != playerGuid)
            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_MEMBER, 1);
    }
 
    return true;
}

References ARENA_TEAM_MEMBER, CaptainGuid, CHAR_INS_ARENA_TEAM_MEMBER, CHAR_SEL_MATCH_MAKER_RATING, CharacterDatabase, ArenaTeamMember::Class, CharacterCacheEntry::Class, CONFIG_ARENA_START_MATCHMAKER_RATING, CONFIG_ARENA_START_PERSONAL_RATING, ObjectAccessor::FindConnectedPlayer(), Player::GetArenaTeamId(), Unit::getClass(), ObjectGuid::GetCounter(), GetId(), GetMembersSize(), WorldObject::GetName(), GetRating(), GetSlot(), GetType(), ArenaTeamMember::Guid, LOG_ERROR, ArenaTeamMember::MatchMakerRating, Max, ArenaTeamMember::MaxMMR, Members, CharacterCacheEntry::Name, ArenaTeamMember::PersonalRating, Player::RemovePetitionsAndSigns(), sCharacterCache, ArenaTeamMember::SeasonGames, ArenaTeamMember::SeasonWins, Player::SetArenaTeamIdInvited(), Player::SetArenaTeamInfoField(), PreparedStatementBase::SetData(), Player::SetInArenaTeam(), sScriptMgr, sWorld, ObjectGuid::ToString(), ArenaTeamMember::WeekGames, and ArenaTeamMember::WeekWins.

Referenced by Create(), WorldSession::HandleArenaTeamAcceptOpcode(), and WorldSession::HandleTurnInPetitionOpcode().

BroadcastEvent()

void ArenaTeam::BroadcastEvent	(	ArenaTeamEvents	event,
		ObjectGuid	guid,
		uint8	strCount,
		std::string const &	str1,
		std::string const &	str2,
		std::string const &	str3
	)

{
    WorldPacket data(SMSG_ARENA_TEAM_EVENT, 1 + 1 + 1);
    data << uint8(event);
    data << uint8(strCount);
    switch (strCount)
    {
        case 0:
            break;
        case 1:
            data << str1;
            break;
        case 2:
            data << str1 << str2;
            break;
        case 3:
            data << str1 << str2 << str3;
            break;
        default:
            LOG_ERROR("bg.arena", "Unhandled strCount {} in ArenaTeam::BroadcastEvent", strCount);
            return;
    }
 
    if (guid)
        data << guid;
 
    BroadcastPacket(&data);
 
    LOG_DEBUG("network", "WORLD: Sent SMSG_ARENA_TEAM_EVENT");
}

References BroadcastPacket(), LOG_DEBUG, LOG_ERROR, and SMSG_ARENA_TEAM_EVENT.

Referenced by Disband(), WorldSession::HandleArenaTeamAcceptOpcode(), WorldSession::HandleArenaTeamLeaderOpcode(), WorldSession::HandleArenaTeamLeaveOpcode(), and WorldSession::HandleArenaTeamRemoveOpcode().

BroadcastPacket()

void ArenaTeam::BroadcastPacket

(

WorldPacket *

packet

)

{
    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
        if (Player* player = ObjectAccessor::FindConnectedPlayer(itr->Guid))
            player->GetSession()->SendPacket(packet);
}

References ObjectAccessor::FindConnectedPlayer(), and Members.

Referenced by BroadcastEvent().

Create()

bool ArenaTeam::Create	(	ObjectGuid	captainGuid,
		uint8	type,
		std::string const &	teamName,
		uint32	backgroundColor,
		uint8	emblemStyle,
		uint32	emblemColor,
		uint8	borderStyle,
		uint32	borderColor
	)

{
    // Check if captain is present
    if (!ObjectAccessor::FindConnectedPlayer(captainGuid))
        return false;
 
    // Check if arena team name is already taken
    if (sArenaTeamMgr->GetArenaTeamByName(TeamName))
        return false;
 
    // Generate new arena team id
    TeamId = sArenaTeamMgr->GenerateArenaTeamId();
 
    // Assign member variables
    CaptainGuid = captainGuid;
    Type = type;
    TeamName = teamName;
    BackgroundColor = backgroundColor;
    EmblemStyle = emblemStyle;
    EmblemColor = emblemColor;
    BorderStyle = borderStyle;
    BorderColor = borderColor;
 
    // Save arena team to db
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ARENA_TEAM);
    stmt->SetData(0, TeamId);
    stmt->SetData(1, TeamName);
    stmt->SetData(2, captainGuid.GetCounter());
    stmt->SetData(3, Type);
    stmt->SetData(4, Stats.Rating);
    stmt->SetData(5, BackgroundColor);
    stmt->SetData(6, EmblemStyle);
    stmt->SetData(7, EmblemColor);
    stmt->SetData(8, BorderStyle);
    stmt->SetData(9, BorderColor);
    CharacterDatabase.Execute(stmt);
 
    // Add captain as member
    AddMember(CaptainGuid);
    return true;
}

References AddMember(), BackgroundColor, BorderColor, BorderStyle, CaptainGuid, CHAR_INS_ARENA_TEAM, CharacterDatabase, EmblemColor, EmblemStyle, ObjectAccessor::FindConnectedPlayer(), ObjectGuid::GetCounter(), sArenaTeamMgr, PreparedStatementBase::SetData(), TeamName, and Type.

Referenced by arena_commandscript::HandleArenaCreateCommand(), and WorldSession::HandleTurnInPetitionOpcode().

CreateTempArenaTeam()

void ArenaTeam::CreateTempArenaTeam	(	std::vector< Player * >	playerList,
		uint8	type,
		std::string const &	teamName
	)

{
    auto playerCountInTeam = static_cast<uint32>(playerList.size());
 
    const auto standardArenaType = { ARENA_TYPE_2v2, ARENA_TYPE_3v3, ARENA_TYPE_5v5 };
    bool isStandardArenaType = std::find(std::begin(standardArenaType), std::end(standardArenaType), type) != std::end(standardArenaType);
    if (isStandardArenaType)
        ASSERT(playerCountInTeam == GetReqPlayersForType(type));
 
    // Generate new arena team id
    TeamId = sArenaTeamMgr->GenerateTempArenaTeamId();
 
    // Assign member variables
    CaptainGuid = playerList[0]->GetGUID();
    Type = type;
    TeamName = teamName;
 
    BackgroundColor = 0;
    EmblemStyle = 0;
    EmblemColor = 0;
    BorderStyle = 0;
    BorderColor = 0;
 
    Stats.WeekGames = 0;
    Stats.SeasonGames = 0;
    Stats.Rating = 0;
    Stats.WeekWins = 0;
    Stats.SeasonWins = 0;
 
    for (auto const& _player : playerList)
    {
        ArenaTeam* team = sArenaTeamMgr->GetArenaTeamById(_player->GetArenaTeamId(GetSlotByType(type)));
        if (!team)
            continue;
 
        ArenaTeamMember newMember;
        for (auto const& itr : Members)
            newMember = itr;
 
        Stats.WeekGames += team->Stats.WeekGames;
        Stats.SeasonGames += team->Stats.SeasonGames;
        Stats.Rating += team->GetRating();
        Stats.WeekWins += team->Stats.WeekWins;
        Stats.SeasonWins += team->Stats.SeasonWins;
 
        Members.push_back(newMember);
    }
 
    Stats.WeekGames /= playerCountInTeam;
    Stats.SeasonGames /= playerCountInTeam;
    Stats.Rating /= playerCountInTeam;
    Stats.WeekWins /= playerCountInTeam;
    Stats.SeasonWins /= playerCountInTeam;
}

References ARENA_TYPE_2v2, ARENA_TYPE_3v3, ARENA_TYPE_5v5, ASSERT, BackgroundColor, BorderColor, BorderStyle, CaptainGuid, EmblemColor, EmblemStyle, GetRating(), GetReqPlayersForType(), GetSlotByType(), Members, sArenaTeamMgr, ArenaTeamStats::SeasonGames, ArenaTeamStats::SeasonWins, Stats, TeamName, Type, ArenaTeamMember::WeekGames, ArenaTeamStats::WeekGames, and ArenaTeamStats::WeekWins.

DelMember()

void ArenaTeam::DelMember	(	ObjectGuid	guid,
		bool	cleanDb
	)

{
    Player* player = ObjectAccessor::FindConnectedPlayer(guid);
    Group* group = (player && player->GetGroup()) ? player->GetGroup() : nullptr;
 
    // Remove member from team
    for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
    {
        // Remove queues of members
        if (Player* playerMember = ObjectAccessor::FindConnectedPlayer(itr->Guid))
        {
            if (group && playerMember->GetGroup() && group->GetGUID() == playerMember->GetGroup()->GetGUID())
            {
                if (BattlegroundQueueTypeId bgQueue = BattlegroundMgr::BGQueueTypeId(BATTLEGROUND_AA, GetType()))
                {
                    GroupQueueInfo ginfo;
                    BattlegroundQueue& queue = sBattlegroundMgr->GetBattlegroundQueue(bgQueue);
                    if (queue.GetPlayerGroupInfoData(playerMember->GetGUID(), &ginfo))
                    {
                        if (!ginfo.IsInvitedToBGInstanceGUID)
                        {
                            WorldPacket data;
                            playerMember->RemoveBattlegroundQueueId(bgQueue);
                            sBattlegroundMgr->BuildBattlegroundStatusPacket(&data, nullptr, playerMember->GetBattlegroundQueueIndex(bgQueue), STATUS_NONE, 0, 0, 0, TEAM_NEUTRAL);
                            queue.RemovePlayer(playerMember->GetGUID(), true);
                            playerMember->GetSession()->SendPacket(&data);
                        }
                    }
                }
            }
        }
 
        if (itr->Guid == guid)
        {
            Members.erase(itr);
            sCharacterCache->UpdateCharacterArenaTeamId(guid, GetSlot(), 0);
            break;
        }
    }
 
    // Inform player and remove arena team info from player data
    if (player)
    {
        player->GetSession()->SendArenaTeamCommandResult(ERR_ARENA_TEAM_QUIT_S, GetName(), "", 0);
        // delete all info regarding this team
        for (uint32 i = 0; i < ARENA_TEAM_END; ++i)
            player->SetArenaTeamInfoField(GetSlot(), ArenaTeamInfoType(i), 0);
    }
 
    // Only used for single member deletion, for arena team disband we use a single query for more efficiency
    if (cleanDb)
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ARENA_TEAM_MEMBER);
        stmt->SetData(0, GetId());
        stmt->SetData(1, guid.GetCounter());
        CharacterDatabase.Execute(stmt);
    }
}

References ARENA_TEAM_END, BATTLEGROUND_AA, BattlegroundMgr::BGQueueTypeId(), CHAR_DEL_ARENA_TEAM_MEMBER, CharacterDatabase, ERR_ARENA_TEAM_QUIT_S, ObjectAccessor::FindConnectedPlayer(), ObjectGuid::GetCounter(), Player::GetGroup(), Group::GetGUID(), GetId(), GetName(), BattlegroundQueue::GetPlayerGroupInfoData(), Player::GetSession(), GetSlot(), GetType(), GroupQueueInfo::IsInvitedToBGInstanceGUID, Members, BattlegroundQueue::RemovePlayer(), sBattlegroundMgr, sCharacterCache, WorldSession::SendArenaTeamCommandResult(), Player::SetArenaTeamInfoField(), PreparedStatementBase::SetData(), STATUS_NONE, and TEAM_NEUTRAL.

Referenced by ArenaTeamMgr::DeleteAllArenaTeams(), Disband(), Disband(), WorldSession::HandleArenaTeamLeaveOpcode(), WorldSession::HandleArenaTeamRemoveOpcode(), Player::LeaveAllArenaTeams(), and LoadMembersFromDB().

Disband() [1/2]

void ArenaTeam::Disband

(

)

{
    // Remove all members from arena team
    while (!Members.empty())
        DelMember(Members.front().Guid, false);
 
    // Update database
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ARENA_TEAM);
    stmt->SetData(0, TeamId);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ARENA_TEAM_MEMBERS);
    stmt->SetData(0, TeamId);
    trans->Append(stmt);
 
    CharacterDatabase.CommitTransaction(trans);
 
    // Remove arena team from ObjectMgr
    sArenaTeamMgr->RemoveArenaTeam(TeamId);
}

References CHAR_DEL_ARENA_TEAM, CHAR_DEL_ARENA_TEAM_MEMBERS, CharacterDatabase, DelMember(), Members, sArenaTeamMgr, and PreparedStatementBase::SetData().

Disband() [2/2]

void ArenaTeam::Disband

(

WorldSession *

session

)

{
    // Remove all members from arena team
    while (!Members.empty())
        DelMember(Members.front().Guid, false);
 
    // Broadcast update
    if (session)
    {
        BroadcastEvent(ERR_ARENA_TEAM_DISBANDED_S, ObjectGuid::Empty, 2, session->GetPlayerName(), GetName(), "");
    }
 
    // Update database
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ARENA_TEAM);
    stmt->SetData(0, TeamId);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ARENA_TEAM_MEMBERS);
    stmt->SetData(0, TeamId);
    trans->Append(stmt);
 
    CharacterDatabase.CommitTransaction(trans);
 
    // Remove arena team from ObjectMgr
    sArenaTeamMgr->RemoveArenaTeam(TeamId);
}

References BroadcastEvent(), CHAR_DEL_ARENA_TEAM, CHAR_DEL_ARENA_TEAM_MEMBERS, CharacterDatabase, DelMember(), ObjectGuid::Empty, ERR_ARENA_TEAM_DISBANDED_S, GetName(), WorldSession::GetPlayerName(), Members, sArenaTeamMgr, and PreparedStatementBase::SetData().

Referenced by arena_commandscript::HandleArenaDisbandCommand(), WorldSession::HandleArenaTeamLeaveOpcode(), and ArenaTeamMgr::LoadArenaTeams().

Empty()

bool ArenaTeam::Empty ( ) const

inline

{ return Members.empty(); }

References Members.

Referenced by LoadMembersFromDB().

FinishGame()

void ArenaTeam::FinishGame	(	int32	mod,
		const Map *	bgMap
	)

{
    // Rating can only drop to 0
    if (int32(Stats.Rating) + mod < 0)
        Stats.Rating = 0;
    else
    {
        Stats.Rating += mod;
 
        // Check if rating related achivements are met
        for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
            if (Player* member = ObjectAccessor::FindConnectedPlayer(itr->Guid))
                if (member->FindMap() == bgMap)
                    member->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_TEAM_RATING, Stats.Rating, Type);
    }
 
    // Update number of games played per season or week
    Stats.WeekGames += 1;
    Stats.SeasonGames += 1;
 
    // Update team's rank, start with rank 1 and increase until no team with more rating was found
    Stats.Rank = 1;
    ArenaTeamMgr::ArenaTeamContainer::const_iterator i = sArenaTeamMgr->GetArenaTeamMapBegin();
    for (; i != sArenaTeamMgr->GetArenaTeamMapEnd(); ++i)
    {
        if (i->second->GetType() == Type && i->second->GetStats().Rating > Stats.Rating)
            ++Stats.Rank;
    }
}

References ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_TEAM_RATING, ObjectAccessor::FindConnectedPlayer(), Members, sArenaTeamMgr, and Type.

Referenced by Arena::EndBattleground(), LostAgainst(), and WonAgainst().

FinishWeek()

bool ArenaTeam::FinishWeek

(

)

{
    // No need to go further than this
    if (Stats.WeekGames == 0)
        return false;
 
    // Reset team stats
    Stats.WeekGames = 0;
    Stats.WeekWins = 0;
 
    // Reset member stats
    for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
    {
        itr->WeekGames = 0;
        itr->WeekWins = 0;
    }
 
    return true;
}

References Members.

GetAverageMMR()

uint32 ArenaTeam::GetAverageMMR

(

Group *

group

)

const

{
    if (!group)
        return 0;
 
    uint32 matchMakerRating = 0;
    uint32 playerDivider = 0;
    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
    {
        // Skip if player is not online
        if (!ObjectAccessor::FindConnectedPlayer(itr->Guid))
            continue;
 
        // Skip if player is not member of group
        if (!group->IsMember(itr->Guid))
            continue;
 
        matchMakerRating += itr->MatchMakerRating;
        ++playerDivider;
    }
 
    // x/0 = crash
    if (playerDivider == 0)
        playerDivider = 1;
 
    matchMakerRating /= playerDivider;
 
    return matchMakerRating;
}

References ObjectAccessor::FindConnectedPlayer(), Group::IsMember(), and Members.

Referenced by WorldSession::HandleBattlemasterJoinArena().

GetCaptain()

ObjectGuid ArenaTeam::GetCaptain ( ) const

inline

{ return CaptainGuid; }

References CaptainGuid.

Referenced by Player::_LoadArenaTeamInfo(), arena_commandscript::HandleArenaCaptainCommand(), arena_commandscript::HandleArenaCreateCommand(), arena_commandscript::HandleArenaInfoCommand(), WorldSession::HandleArenaTeamAcceptOpcode(), WorldSession::HandleArenaTeamLeaderOpcode(), WorldSession::HandleArenaTeamLeaveOpcode(), WorldSession::HandleArenaTeamRemoveOpcode(), LoadMembersFromDB(), Roster(), and SetCaptain().

GetChanceAgainst()

float ArenaTeam::GetChanceAgainst	(	uint32	ownRating,
		uint32	opponentRating
	)

{
    // Returns the chance to win against a team with the given rating, used in the rating adjustment calculation
    // ELO system
    return 1.0f / (1.0f + (std::exp(std::log(10.0f) * (float)((float)opponentRating - (float)ownRating) / 650.0f)));
}

Referenced by GetMatchmakerRatingMod(), and GetRatingMod().

GetId()

uint32 ArenaTeam::GetId ( ) const

inline

{ return TeamId; }

References TeamId.

Referenced by ArenaTeamMgr::AddArenaTeam(), AddMember(), DelMember(), Arena::EndBattleground(), arena_commandscript::HandleArenaCaptainCommand(), arena_commandscript::HandleArenaCreateCommand(), arena_commandscript::HandleArenaInfoCommand(), arena_commandscript::HandleArenaRenameCommand(), WorldSession::HandleArenaTeamInviteOpcode(), WorldSession::HandleTurnInPetitionOpcode(), Inspect(), LoadMembersFromDB(), Query(), Roster(), SaveToDB(), SendStats(), SetCaptain(), and SetName().

GetMatchmakerRatingMod()

int32 ArenaTeam::GetMatchmakerRatingMod	(	uint32	ownRating,
		uint32	opponentRating,
		bool	won
	)

{
    // 'Chance' calculation - to beat the opponent
    // This is a simulation. Not much info on how it really works
    float chance = GetChanceAgainst(ownRating, opponentRating);
    float won_mod = (won) ? 1.0f : 0.0f;
    float mod = won_mod - chance;
 
    // Work in progress:
    /*
    // This is a simulation, as there is not much info on how it really works
    float confidence_mod = min(1.0f - std::fabs(mod), 0.5f);
 
    // Apply confidence factor to the mod:
    mod *= confidence_factor
 
    // And only after that update the new confidence factor
    confidence_factor -= ((confidence_factor - 1.0f) * confidence_mod) / confidence_factor;
    */
 
    // Real rating modification
    mod *= sWorld->getFloatConfig(CONFIG_ARENA_MATCHMAKER_RATING_MODIFIER);
 
    return (int32)ceil(mod);
}

References CONFIG_ARENA_MATCHMAKER_RATING_MODIFIER, GetChanceAgainst(), and sWorld.

Referenced by LostAgainst(), and WonAgainst().

GetMember() [1/2]

ArenaTeamMember * ArenaTeam::GetMember

(

ObjectGuid

guid

)

{
    for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
        if (itr->Guid == guid)
            return &(*itr);
 
    return nullptr;
}

References Members.

Referenced by Player::_LoadArenaTeamInfo(), GetMember(), WorldSession::HandleArenaTeamLeaderOpcode(), WorldSession::HandleArenaTeamRemoveOpcode(), Inspect(), and AchievementMgr::UpdateAchievementCriteria().

GetMember() [2/2]

ArenaTeamMember * ArenaTeam::GetMember

(

std::string const &

name

)

{
    return GetMember(sCharacterCache->GetCharacterGuidByName(name));
}

References GetMember(), and sCharacterCache.

GetMembers()

MemberList & ArenaTeam::GetMembers ( )

inline

{ return Members; }

References Members.

Referenced by Group::CanJoinBattlegroundQueue(), arena_commandscript::HandleArenaInfoCommand(), ArenaSeasonTeamRewarderImpl::RewardWithAchievements(), and ArenaSeasonTeamRewarderImpl::RewardWithMail().

GetMembersSize()

std::size_t ArenaTeam::GetMembersSize ( ) const

inline

{ return Members.size(); }

References Members.

Referenced by AddMember(), WorldSession::HandleArenaTeamInviteOpcode(), WorldSession::HandleArenaTeamLeaveOpcode(), and Roster().

GetName()

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

inline

{ return TeamName; }

References TeamName.

Referenced by DelMember(), Disband(), Arena::EndBattleground(), arena_commandscript::HandleArenaCaptainCommand(), arena_commandscript::HandleArenaCreateCommand(), arena_commandscript::HandleArenaDisbandCommand(), arena_commandscript::HandleArenaInfoCommand(), WorldSession::HandleArenaTeamAcceptOpcode(), WorldSession::HandleArenaTeamInviteOpcode(), WorldSession::HandleArenaTeamLeaderOpcode(), WorldSession::HandleArenaTeamLeaveOpcode(), WorldSession::HandleArenaTeamRemoveOpcode(), Query(), BattlegroundQueue::SendExitMessageArenaQueue(), and BattlegroundQueue::SendJoinMessageArenaQueue().

GetPoints()

uint32 ArenaTeam::GetPoints

(

uint32

MemberRating

)

{
    // Returns how many points would be awarded with this team type with this rating
    float points;
 
    uint32 rating = memberRating + 150 < Stats.Rating ? memberRating : Stats.Rating;
 
    if (rating <= 1500)
    {
        if (sArenaSeasonMgr->GetCurrentSeason() < 6 && !sWorld->getIntConfig(CONFIG_LEGACY_ARENA_POINTS_CALC))
            points = (float)rating * 0.22f + 14.0f;
        else
            points = 344;
    }
    else
        points = 1511.26f / (1.0f + 1639.28f * std::exp(-0.00412f * (float)rating));
 
    // Type penalties for teams < 5v5
    if (Type == ARENA_TEAM_2v2)
        points *= 0.76f;
    else if (Type == ARENA_TEAM_3v3)
        points *= 0.88f;
 
    sScriptMgr->OnGetArenaPoints(this, points);
 
    points *= sWorld->getRate(RATE_ARENA_POINTS);
 
    return (uint32) points;
}

References ARENA_TEAM_2v2, ARENA_TEAM_3v3, CONFIG_LEGACY_ARENA_POINTS_CALC, RATE_ARENA_POINTS, sArenaSeasonMgr, sScriptMgr, sWorld, and Type.

Referenced by UpdateArenaPointsHelper().

GetPreviousOpponents()

uint32 ArenaTeam::GetPreviousOpponents ( )

inline

{ return PreviousOpponents; }

References PreviousOpponents.

Referenced by WorldSession::HandleBattlemasterJoinArena().

GetRating()

uint32 ArenaTeam::GetRating ( ) const

inline

{ return Stats.Rating; }

Referenced by AddMember(), CreateTempArenaTeam(), Arena::EndBattleground(), arena_commandscript::HandleArenaInfoCommand(), and WorldSession::HandleBattlemasterJoinArena().

GetRatingMod()

int32 ArenaTeam::GetRatingMod	(	uint32	ownRating,
		uint32	opponentRating,
		bool	won
	)

Todo:

: Replace this hack with using the confidence factor (limiting the factor to 2.0f)

{
    // 'Chance' calculation - to beat the opponent
    // This is a simulation. Not much info on how it really works
    float chance = GetChanceAgainst(ownRating, opponentRating);
 
    // Calculate the rating modification
    float mod;
 
    if (won)
    {
        if (ownRating < 1300)
        {
            float win_rating_modifier1 = sWorld->getFloatConfig(CONFIG_ARENA_WIN_RATING_MODIFIER_1);
 
            if (ownRating < 1000)
                mod =  win_rating_modifier1 * (1.0f - chance);
            else
                mod = ((win_rating_modifier1 / 2.0f) + ((win_rating_modifier1 / 2.0f) * (1300.0f - float(ownRating)) / 300.0f)) * (1.0f - chance);
        }
        else
            mod = sWorld->getFloatConfig(CONFIG_ARENA_WIN_RATING_MODIFIER_2) * (1.0f - chance);
    }
    else
        mod = sWorld->getFloatConfig(CONFIG_ARENA_LOSE_RATING_MODIFIER) * (-chance);
 
    return (int32)ceil(mod);
}

References CONFIG_ARENA_LOSE_RATING_MODIFIER, CONFIG_ARENA_WIN_RATING_MODIFIER_1, CONFIG_ARENA_WIN_RATING_MODIFIER_2, GetChanceAgainst(), and sWorld.

Referenced by LostAgainst(), MemberLost(), MemberWon(), and WonAgainst().

GetReqPlayersForType()

uint8 ArenaTeam::GetReqPlayersForType ( uint32  type )

static

{
    auto const& itr = ArenaReqPlayersForType.find(type);
    if (itr == ArenaReqPlayersForType.end())
    {
        LOG_ERROR("bg.arena", "FATAL: Unknown arena type {}!", type);
        return 0xFF;
    }
 
    return ArenaReqPlayersForType.at(type);
}

References ArenaReqPlayersForType, and LOG_ERROR.

Referenced by BattlegroundMgr::CreateNewBattleground(), CreateTempArenaTeam(), Battleground::ReadyMarkerClicked(), and BattlegroundQueue::SendJoinMessageArenaQueue().

GetSlot()

uint8 ArenaTeam::GetSlot ( ) const

inline

{ return GetSlotByType(GetType()); }

References GetSlotByType(), and GetType().

Referenced by AddMember(), DelMember(), Arena::EndBattleground(), WorldSession::HandleArenaTeamAcceptOpcode(), WorldSession::HandleArenaTeamInviteOpcode(), Inspect(), LoadMembersFromDB(), MemberLost(), MemberWon(), SaveToDB(), and SetCaptain().

GetSlotByType()

uint8 ArenaTeam::GetSlotByType ( uint32  type )

static

{
    uint8 slot = 0xFF;
 
    auto const& itr = ArenaSlotByType.find(type);
    if (itr == ArenaSlotByType.end())
    {
        LOG_ERROR("bg.arena", "Unknown arena team type {} for some arena team", type);
        return slot;
    }
 
    slot = ArenaSlotByType.at(type);
 
    // Get the changed slot type
    sScriptMgr->OnGetSlotByType(type, slot);
 
    if (slot != 0xFF)
    {
        return slot;
    }
 
    LOG_ERROR("bg.arena", "Unknown arena team type {} for some arena team", type);
    return 0xFF;
}

References ArenaSlotByType, LOG_ERROR, and sScriptMgr.

Referenced by CreateTempArenaTeam(), GetSlot(), WorldSession::HandleOfferPetitionOpcode(), WorldSession::HandlePetitionSignOpcode(), WorldSession::HandleTurnInPetitionOpcode(), ArenaTeamMember::ModifyPersonalRating(), and AchievementMgr::UpdateAchievementCriteria().

GetStats()

const ArenaTeamStats & ArenaTeam::GetStats ( ) const

inline

{ return Stats; }

References Stats.

Referenced by ArenaSeasonTeamRewarderImpl::RewardWithAchievements(), ArenaSeasonTeamRewarderImpl::RewardWithMail(), and AchievementMgr::UpdateAchievementCriteria().

GetType()

uint32 ArenaTeam::GetType ( ) const

inline

{ return Type; }

References Type.

Referenced by Player::_LoadArenaTeamInfo(), AddMember(), DelMember(), ArenaTeamFilterByTypes::Filter(), GetSlot(), arena_commandscript::HandleArenaCreateCommand(), arena_commandscript::HandleArenaInfoCommand(), WorldSession::HandleArenaTeamInviteOpcode(), WorldSession::HandleArenaTeamLeaveOpcode(), WorldSession::HandleArenaTeamRemoveOpcode(), MemberLost(), MemberWon(), Query(), Roster(), and AchievementMgr::UpdateAchievementCriteria().

Inspect()

void ArenaTeam::Inspect	(	WorldSession *	session,
		ObjectGuid	guid
	)

{
    ArenaTeamMember* member = GetMember(guid);
    if (!member || GetSlot() >= MAX_ARENA_SLOT)
        return;
 
    WorldPacket data(MSG_INSPECT_ARENA_TEAMS, 8 + 1 + 4 * 6);
    data << guid;                                           // player guid
    data << uint8(GetSlot());                               // slot (0...2)
    data << uint32(GetId());                                // arena team id
    data << uint32(Stats.Rating);                           // rating
    data << uint32(Stats.SeasonGames);                      // season played
    data << uint32(Stats.SeasonWins);                       // season wins
    data << uint32(member->SeasonGames);                    // played (count of all games, that the inspected member participated...)
    data << uint32(member->PersonalRating);                 // personal rating
    session->SendPacket(&data);
}

References GetId(), GetMember(), GetSlot(), MAX_ARENA_SLOT, MSG_INSPECT_ARENA_TEAMS, ArenaTeamMember::PersonalRating, ArenaTeamMember::SeasonGames, and WorldSession::SendPacket().

IsFighting()

bool ArenaTeam::IsFighting

(

)

const

{
    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
        if (Player* player = ObjectAccessor::FindPlayer(itr->Guid))
            if (player->GetMap()->IsBattleArena())
                return true;
 
    return false;
}

References ObjectAccessor::FindPlayer(), and Members.

Referenced by arena_commandscript::HandleArenaCaptainCommand(), arena_commandscript::HandleArenaDisbandCommand(), arena_commandscript::HandleArenaRenameCommand(), WorldSession::HandleArenaTeamLeaveOpcode(), and WorldSession::HandleArenaTeamRemoveOpcode().

IsMember()

bool ArenaTeam::IsMember

(

ObjectGuid

guid

)

const

{
    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
        if (itr->Guid == guid)
            return true;
 
    return false;
}

References Members.

Referenced by arena_commandscript::HandleArenaCaptainCommand().

LoadArenaTeamFromDB()

bool ArenaTeam::LoadArenaTeamFromDB

(

QueryResult

arenaTeamDataResult

)

{
    if (!result)
        return false;
 
    Field* fields = result->Fetch();
 
    TeamId            = fields[0].Get<uint32>();
    TeamName          = fields[1].Get<std::string>();
    CaptainGuid       = ObjectGuid::Create<HighGuid::Player>(fields[2].Get<uint32>());
    Type              = fields[3].Get<uint8>();
    BackgroundColor   = fields[4].Get<uint32>();
    EmblemStyle       = fields[5].Get<uint8>();
    EmblemColor       = fields[6].Get<uint32>();
    BorderStyle       = fields[7].Get<uint8>();
    BorderColor       = fields[8].Get<uint32>();
    Stats.Rating      = fields[9].Get<uint16>();
    Stats.WeekGames   = fields[10].Get<uint16>();
    Stats.WeekWins    = fields[11].Get<uint16>();
    Stats.SeasonGames = fields[12].Get<uint16>();
    Stats.SeasonWins  = fields[13].Get<uint16>();
    Stats.Rank        = fields[14].Get<uint32>();
 
    return true;
}

References BackgroundColor, BorderColor, BorderStyle, CaptainGuid, EmblemColor, EmblemStyle, Field::Get(), TeamName, and Type.

Referenced by ArenaTeamMgr::LoadArenaTeams().

LoadMembersFromDB()

bool ArenaTeam::LoadMembersFromDB

(

QueryResult

arenaTeamMembersResult

)

{
    if (!result)
        return false;
 
    bool captainPresentInTeam = false;
 
    do
    {
        Field* fields = result->Fetch();
 
        // Prevent crash if db records are broken when all members in result are already processed and current team doesn't have any members
        if (!fields)
            break;
 
        uint32 arenaTeamId = fields[0].Get<uint32>();
 
        // We loaded all members for this arena_team already, break cycle
        if (arenaTeamId > TeamId)
            break;
 
        ArenaTeamMember newMember;
        newMember.Guid             = ObjectGuid::Create<HighGuid::Player>(fields[1].Get<uint32>());
        newMember.WeekGames        = fields[2].Get<uint16>();
        newMember.WeekWins         = fields[3].Get<uint16>();
        newMember.SeasonGames      = fields[4].Get<uint16>();
        newMember.SeasonWins       = fields[5].Get<uint16>();
        //newMember.Name             = fields[6].Get<std::string>();
        newMember.Class            = fields[7].Get<uint8>();
        newMember.PersonalRating   = fields[8].Get<uint16>();
        newMember.MatchMakerRating = fields[9].Get<uint16>() > 0 ? fields[9].Get<uint16>() : sWorld->getIntConfig(CONFIG_ARENA_START_MATCHMAKER_RATING);
        newMember.MaxMMR           = std::max(fields[10].Get<uint16>(), newMember.MatchMakerRating);
 
        // Delete member if character information is missing
        if (fields[6].Get<std::string>().empty())
        {
            LOG_ERROR("sql.sql", "ArenaTeam {} has member with empty name - probably player {} doesn't exist, deleting him from memberlist!", arenaTeamId, newMember.Guid.ToString());
            this->DelMember(newMember.Guid, true);
            continue;
        }
 
        // Check if team team has a valid captain
        if (newMember.Guid == GetCaptain())
            captainPresentInTeam = true;
 
        // Put the player in the team
        Members.push_back(newMember);
        sCharacterCache->UpdateCharacterArenaTeamId(newMember.Guid, GetSlot(), GetId());
    } while (result->NextRow());
 
    if (Empty() || !captainPresentInTeam)
    {
        // Arena team is empty or captain is not in team, delete from db
        LOG_DEBUG("bg.battleground", "ArenaTeam {} does not have any members or its captain is not in team, disbanding it...", TeamId);
        return false;
    }
 
    return true;
}

References ArenaTeamMember::Class, CONFIG_ARENA_START_MATCHMAKER_RATING, DelMember(), Empty(), Field::Get(), GetCaptain(), GetId(), GetSlot(), ArenaTeamMember::Guid, LOG_DEBUG, LOG_ERROR, ArenaTeamMember::MatchMakerRating, ArenaTeamMember::MaxMMR, Members, ArenaTeamMember::PersonalRating, sCharacterCache, ArenaTeamMember::SeasonGames, ArenaTeamMember::SeasonWins, sWorld, ObjectGuid::ToString(), ArenaTeamMember::WeekGames, and ArenaTeamMember::WeekWins.

Referenced by ArenaTeamMgr::LoadArenaTeams().

LoadStatsFromDB()

void ArenaTeam::LoadStatsFromDB

(

uint32

ArenaTeamId

)

LostAgainst()

int32 ArenaTeam::LostAgainst	(	uint32	Own_MMRating,
		uint32	Opponent_MMRating,
		int32 &	rating_change,
		const Map *	bgMap
	)

{
    // Called when the team has lost
    // Change in Matchmaker Rating
    int32 mod = GetMatchmakerRatingMod(Own_MMRating, Opponent_MMRating, false);
 
    // Change in Team Rating
    rating_change = GetRatingMod(Stats.Rating, Opponent_MMRating, false);
 
    // Modify the team stats accordingly
    FinishGame(rating_change, bgMap);
 
    // return the rating change, used to display it on the results screen
    return mod;
}

References FinishGame(), GetMatchmakerRatingMod(), and GetRatingMod().

Referenced by Arena::EndBattleground().

m_membersBegin()

MemberList::iterator ArenaTeam::m_membersBegin ( )

inline

{ return Members.begin(); }

References Members.

m_membersEnd()

MemberList::iterator ArenaTeam::m_membersEnd ( )

inline

{ return Members.end(); }

References Members.

MassInviteToEvent()

void ArenaTeam::MassInviteToEvent

(

WorldSession *

session

)

{
    WorldPacket data(SMSG_CALENDAR_ARENA_TEAM, (Members.size() - 1) * (4 + 8 + 1));
    data << uint32(Members.size() - 1);
 
    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
    {
        if (itr->Guid != session->GetPlayer()->GetGUID())
        {
            data << itr->Guid.WriteAsPacked();
            data << uint8(0); // unk
        }
    }
 
    session->SendPacket(&data);
}

References Object::GetGUID(), WorldSession::GetPlayer(), Members, WorldSession::SendPacket(), and SMSG_CALENDAR_ARENA_TEAM.

MemberLost()

void ArenaTeam::MemberLost	(	Player *	player,
		uint32	againstMatchmakerRating,
		int32	MatchmakerRatingChange = -12
	)

{
    // Called for each participant of a match after losing
    for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
    {
        if (itr->Guid == player->GetGUID())
        {
            // Update personal rating
            int32 mod = GetRatingMod(itr->PersonalRating, againstMatchmakerRating, false);
            itr->ModifyPersonalRating(player, mod, GetType());
 
            // Update matchmaker rating
            itr->ModifyMatchmakerRating(MatchmakerRatingChange, GetSlot());
 
            // Update personal played stats
            itr->WeekGames += 1;
            itr->SeasonGames += 1;
 
            // update the unit fields
            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_WEEK,  itr->WeekGames);
            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_SEASON,  itr->SeasonGames);
            return;
        }
    }
}

References ARENA_TEAM_GAMES_SEASON, ARENA_TEAM_GAMES_WEEK, Object::GetGUID(), GetRatingMod(), GetSlot(), GetType(), Members, and Player::SetArenaTeamInfoField().

Referenced by Arena::EndBattleground(), and Arena::RemovePlayerAtLeave().

MemberWon()

void ArenaTeam::MemberWon	(	Player *	player,
		uint32	againstMatchmakerRating,
		int32	MatchmakerRatingChange
	)

{
    // called for each participant after winning a match
    for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
    {
        if (itr->Guid == player->GetGUID())
        {
            // update personal rating
            int32 mod = GetRatingMod(itr->PersonalRating, againstMatchmakerRating, true);
            sScriptMgr->OnBeforeUpdatingPersonalRating(mod, GetType());
            itr->ModifyPersonalRating(player, mod, GetType());
 
            // update matchmaker rating (pussywizard: but don't allow it to go over team rating)
            if (itr->MatchMakerRating < Stats.Rating)
            {
                mod = std::min(MatchmakerRatingChange, Stats.Rating - itr->MatchMakerRating);
                sScriptMgr->OnBeforeUpdatingPersonalRating(mod, GetType());
                itr->ModifyMatchmakerRating(mod, GetSlot());
            }
 
            // update personal stats
            itr->WeekGames += 1;
            itr->SeasonGames += 1;
            itr->SeasonWins += 1;
            itr->WeekWins += 1;
            // update unit fields
            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_WEEK, itr->WeekGames);
            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_SEASON, itr->SeasonGames);
            return;
        }
    }
}

References ARENA_TEAM_GAMES_SEASON, ARENA_TEAM_GAMES_WEEK, Object::GetGUID(), GetRatingMod(), GetSlot(), GetType(), Members, Player::SetArenaTeamInfoField(), and sScriptMgr.

Referenced by Arena::EndBattleground().

NotifyStatsChanged()

void ArenaTeam::NotifyStatsChanged

(

)

{
    // This is called after a rated match ended
    // Updates arena team stats for every member of the team (not only the ones who participated!)
    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
        if (Player* player = ObjectAccessor::FindConnectedPlayer(itr->Guid))
            SendStats(player->GetSession());
}

References ObjectAccessor::FindConnectedPlayer(), Members, and SendStats().

Referenced by Arena::EndBattleground().

Query()

void ArenaTeam::Query

(

WorldSession *

session

)

{
    WorldPacket data(SMSG_ARENA_TEAM_QUERY_RESPONSE, 4 * 7 + GetName().size() + 1);
    data << uint32(GetId());                                // team id
    data << GetName();                                      // team name
    data << uint32(GetType());                              // arena team type (2=2x2, 3=3x3 or 5=5x5)
    data << uint32(BackgroundColor);                        // background color
    data << uint32(EmblemStyle);                            // emblem style
    data << uint32(EmblemColor);                            // emblem color
    data << uint32(BorderStyle);                            // border style
    data << uint32(BorderColor);                            // border color
    session->SendPacket(&data);
    LOG_DEBUG("network", "WORLD: Sent SMSG_ARENA_TEAM_QUERY_RESPONSE");
}

References BackgroundColor, BorderColor, BorderStyle, EmblemColor, EmblemStyle, GetId(), GetName(), GetType(), LOG_DEBUG, WorldSession::SendPacket(), and SMSG_ARENA_TEAM_QUERY_RESPONSE.

Roster()

void ArenaTeam::Roster

(

WorldSession *

session

)

{
    Player* player = nullptr;
 
    uint8 unk308 = 0;
    std::string tempName;
 
    WorldPacket data(SMSG_ARENA_TEAM_ROSTER, 100);
    data << uint32(GetId());                                // team id
    data << uint8(unk308);                                  // 308 unknown value but affect packet structure
    data << uint32(GetMembersSize());                       // members count
    data << uint32(GetType());                              // arena team type?
 
    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
    {
        player = ObjectAccessor::FindConnectedPlayer(itr->Guid);
 
        data << itr->Guid;                                  // guid
        data << uint8((player ? 1 : 0));                    // online flag
        tempName = "";
        sCharacterCache->GetCharacterNameByGuid(itr->Guid, tempName);
        data << tempName;                                  // member name
        data << uint32((itr->Guid == GetCaptain() ? 0 : 1));// captain flag 0 captain 1 member
        data << uint8((player ? player->GetLevel() : 0));           // unknown, level?
        data << uint8(itr->Class);                         // class
        data << uint32(itr->WeekGames);                    // played this week
        data << uint32(itr->WeekWins);                     // wins this week
        data << uint32(itr->SeasonGames);                  // played this season
        data << uint32(itr->SeasonWins);                   // wins this season
        data << uint32(itr->PersonalRating);               // personal rating
        if (unk308)
        {
            data << float(0.0f);                           // 308 unk
            data << float(0.0f);                           // 308 unk
        }
    }
 
    session->SendPacket(&data);
    LOG_DEBUG("network", "WORLD: Sent SMSG_ARENA_TEAM_ROSTER");
}

References ObjectAccessor::FindConnectedPlayer(), GetCaptain(), GetId(), Unit::GetLevel(), GetMembersSize(), GetType(), LOG_DEBUG, Members, sCharacterCache, WorldSession::SendPacket(), and SMSG_ARENA_TEAM_ROSTER.

SaveToDB()

void ArenaTeam::SaveToDB

(

bool

forceMemberSave = false

)

{
    if (!sScriptMgr->CanSaveToDB(this))
        return;
 
    // Save team and member stats to db
    // Called after a match has ended or when calculating arena_points
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ARENA_TEAM_STATS);
    stmt->SetData(0, Stats.Rating);
    stmt->SetData(1, Stats.WeekGames);
    stmt->SetData(2, Stats.WeekWins);
    stmt->SetData(3, Stats.SeasonGames);
    stmt->SetData(4, Stats.SeasonWins);
    stmt->SetData(5, Stats.Rank);
    stmt->SetData(6, GetId());
    trans->Append(stmt);
 
    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
    {
        // Save the effort and go
        if (itr->WeekGames == 0 && !forceMemberSave)
            continue;
 
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ARENA_TEAM_MEMBER);
        stmt->SetData(0, itr->PersonalRating);
        stmt->SetData(1, itr->WeekGames);
        stmt->SetData(2, itr->WeekWins);
        stmt->SetData(3, itr->SeasonGames);
        stmt->SetData(4, itr->SeasonWins);
        stmt->SetData(5, GetId());
        stmt->SetData(6, itr->Guid.GetCounter());
        trans->Append(stmt);
 
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_CHARACTER_ARENA_STATS);
        stmt->SetData(0, itr->Guid.GetCounter());
        stmt->SetData(1, GetSlot());
        stmt->SetData(2, itr->MatchMakerRating);
        stmt->SetData(3, itr->MaxMMR);
        trans->Append(stmt);
    }
 
    CharacterDatabase.CommitTransaction(trans);
}

References CHAR_REP_CHARACTER_ARENA_STATS, CHAR_UPD_ARENA_TEAM_MEMBER, CHAR_UPD_ARENA_TEAM_STATS, CharacterDatabase, GetId(), GetSlot(), Members, PreparedStatementBase::SetData(), and sScriptMgr.

Referenced by Arena::EndBattleground().

SendStats()

void ArenaTeam::SendStats

(

WorldSession *

session

)

{
    WorldPacket data(SMSG_ARENA_TEAM_STATS, 4 * 7);
    data << uint32(GetId());                                // team id
    data << uint32(Stats.Rating);                           // rating
    data << uint32(Stats.WeekGames);                        // games this week
    data << uint32(Stats.WeekWins);                         // wins this week
    data << uint32(Stats.SeasonGames);                      // played this season
    data << uint32(Stats.SeasonWins);                       // wins this season
    data << uint32(Stats.Rank);                             // rank
    session->SendPacket(&data);
}

References GetId(), WorldSession::SendPacket(), and SMSG_ARENA_TEAM_STATS.

Referenced by NotifyStatsChanged().

SetArenaTeamStats()

void ArenaTeam::SetArenaTeamStats ( ArenaTeamStats &  stats )

inline

{ Stats = stats; }

Referenced by ArenaTeamWithRating().

SetCaptain()

void ArenaTeam::SetCaptain

(

ObjectGuid

guid

)

{
    // Disable remove/promote buttons
    Player* oldCaptain = ObjectAccessor::FindConnectedPlayer(GetCaptain());
    if (oldCaptain)
        oldCaptain->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_MEMBER, 1);
 
    // Set new captain
    CaptainGuid = guid;
 
    // Update database
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ARENA_TEAM_CAPTAIN);
    stmt->SetData(0, guid.GetCounter());
    stmt->SetData(1, GetId());
    CharacterDatabase.Execute(stmt);
 
    // Enable remove/promote buttons
    if (Player* newCaptain = ObjectAccessor::FindConnectedPlayer(guid))
    {
        newCaptain->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_MEMBER, 0);
        /*if (oldCaptain)
        {
            LOG_DEBUG("bg.battleground", "Player: {} [{}] promoted player: {} [{}] to leader of arena team [Id: {}] [Type: {}].",
                oldCaptain->GetName(), oldCaptain->GetGUID().ToString(), newCaptain->GetName(),
                newCaptain->GetGUID().ToString(), GetId(), GetType());
        }*/
    }
}

References ARENA_TEAM_MEMBER, CaptainGuid, CHAR_UPD_ARENA_TEAM_CAPTAIN, CharacterDatabase, ObjectAccessor::FindConnectedPlayer(), GetCaptain(), ObjectGuid::GetCounter(), GetId(), GetSlot(), Player::SetArenaTeamInfoField(), and PreparedStatementBase::SetData().

Referenced by arena_commandscript::HandleArenaCaptainCommand(), and WorldSession::HandleArenaTeamLeaderOpcode().

SetName()

bool ArenaTeam::SetName

(

std::string const &

name

)

{
    if (TeamName == name || name.empty() || name.length() > 24 || !ObjectMgr::IsValidCharterName(name))
        return false;
 
    TeamName = name;
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ARENA_TEAM_NAME);
    stmt->SetData(0, TeamName);
    stmt->SetData(1, GetId());
    CharacterDatabase.Execute(stmt);
    return true;
}

References CHAR_UPD_ARENA_TEAM_NAME, CharacterDatabase, GetId(), ObjectMgr::IsValidCharterName(), PreparedStatementBase::SetData(), and TeamName.

Referenced by arena_commandscript::HandleArenaRenameCommand().

SetPreviousOpponents()

void ArenaTeam::SetPreviousOpponents ( uint32  arenaTeamId )

inline

{ PreviousOpponents = arenaTeamId; }

References PreviousOpponents.

Referenced by Arena::EndBattleground().

UpdateArenaPointsHelper()

void ArenaTeam::UpdateArenaPointsHelper

(

std::map< ObjectGuid, uint32 > &

PlayerPoints

)

{
    // Called after a match has ended and the stats are already modified
    // Helper function for arena point distribution (this way, when distributing, no actual calculation is required, just a few comparisons)
    // 10 played games per week is a minimum
    if (Stats.WeekGames < sWorld->getIntConfig(CONFIG_ARENA_GAMES_REQUIRED))
        return;
 
    // To get points, a player has to participate in at least 30% of the matches
    uint32 requiredGames = (uint32)ceil(Stats.WeekGames * 0.3f);
 
    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)
    {
        // The player participated in enough games, update his points
        uint32 pointsToAdd = 0;
        if (itr->WeekGames >= requiredGames)
            pointsToAdd = GetPoints(itr->PersonalRating);
 
        std::map<ObjectGuid, uint32>::iterator plr_itr = playerPoints.find(itr->Guid);
        if (plr_itr != playerPoints.end())
        {
            // Check if there is already more points
            if (plr_itr->second < pointsToAdd)
                playerPoints[itr->Guid] = pointsToAdd;
        }
        else
            playerPoints[itr->Guid] = pointsToAdd;
    }
}

References CONFIG_ARENA_GAMES_REQUIRED, GetPoints(), Members, and sWorld.

WonAgainst()

int32 ArenaTeam::WonAgainst	(	uint32	Own_MMRating,
		uint32	Opponent_MMRating,
		int32 &	rating_change,
		const Map *	bgMap
	)

{
    // Called when the team has won
    // Change in Matchmaker rating
    int32 mod = GetMatchmakerRatingMod(Own_MMRating, Opponent_MMRating, true);
 
    // Change in Team Rating
    rating_change = GetRatingMod(Stats.Rating, Opponent_MMRating, true);
 
    // Modify the team stats accordingly
    FinishGame(rating_change, bgMap);
 
    // Update number of wins per season and week
    Stats.WeekWins += 1;
    Stats.SeasonWins += 1;
 
    // Return the rating change, used to display it on the results screen
    return mod;
}

References FinishGame(), GetMatchmakerRatingMod(), and GetRatingMod().

Referenced by Arena::EndBattleground().

Member Data Documentation

ArenaReqPlayersForType

std::unordered_map< uint8, uint8 > ArenaTeam::ArenaReqPlayersForType

static

Initial value:

=
{
    { ARENA_TYPE_2v2, 4},
    { ARENA_TYPE_3v3, 6},
    { ARENA_TYPE_5v5, 10}
}

{
    ERR_ARENA_TEAM_CREATE_S                 = 0x00,
    ERR_ARENA_TEAM_INVITE_SS                = 0x01,
    ERR_ARENA_TEAM_QUIT_S                   = 0x03,
    ERR_ARENA_TEAM_FOUNDER_S                = 0x0E
};
 
enum ArenaTeamCommandErrors
{
    ERR_ARENA_TEAM_INTERNAL                 = 0x01,
    ERR_ALREADY_IN_ARENA_TEAM               = 0x02,
    ERR_ALREADY_IN_ARENA_TEAM_S             = 0x03,
    ERR_INVITED_TO_ARENA_TEAM               = 0x04,
    ERR_ALREADY_INVITED_TO_ARENA_TEAM_S     = 0x05,
    ERR_ARENA_TEAM_NAME_INVALID             = 0x06,
    ERR_ARENA_TEAM_NAME_EXISTS_S            = 0x07,
    ERR_ARENA_TEAM_LEADER_LEAVE_S           = 0x08,
    ERR_ARENA_TEAM_PERMISSIONS              = 0x08,
    ERR_ARENA_TEAM_PLAYER_NOT_IN_TEAM       = 0x09,
    ERR_ARENA_TEAM_PLAYER_NOT_IN_TEAM_SS    = 0x0A,
    ERR_ARENA_TEAM_PLAYER_NOT_FOUND_S       = 0x0B,
    ERR_ARENA_TEAM_NOT_ALLIED               = 0x0C,
    ERR_ARENA_TEAM_IGNORING_YOU_S           = 0x13,
    ERR_ARENA_TEAM_TARGET_TOO_LOW_S         = 0x15,
    ERR_ARENA_TEAM_TARGET_TOO_HIGH_S        = 0x16,
    ERR_ARENA_TEAM_TOO_MANY_MEMBERS_S       = 0x17,
    ERR_ARENA_TEAM_NOT_FOUND                = 0x1B,
    ERR_ARENA_TEAMS_LOCKED                  = 0x1E
};
 
enum ArenaTeamEvents
{
    ERR_ARENA_TEAM_JOIN_SS                  = 3,            // player name + arena team name
    ERR_ARENA_TEAM_LEAVE_SS                 = 4,            // player name + arena team name
    ERR_ARENA_TEAM_REMOVE_SSS               = 5,            // player name + arena team name + captain name
    ERR_ARENA_TEAM_LEADER_IS_SS             = 6,            // player name + arena team name
    ERR_ARENA_TEAM_LEADER_CHANGED_SSS       = 7,            // old captain + new captain + arena team name
    ERR_ARENA_TEAM_DISBANDED_S              = 8             // captain name + arena team name
};
 
// PLAYER_FIELD_ARENA_TEAM_INFO_1_1 offsets
enum ArenaTeamInfoType : uint8
{
    ARENA_TEAM_ID                = 0,
    ARENA_TEAM_TYPE              = 1,                       // new in 3.2 - team type?
    ARENA_TEAM_MEMBER            = 2,                       // 0 - captain, 1 - member
    ARENA_TEAM_GAMES_WEEK        = 3,
    ARENA_TEAM_GAMES_SEASON      = 4,
    ARENA_TEAM_WINS_SEASON       = 5,
    ARENA_TEAM_PERSONAL_RATING   = 6,
    ARENA_TEAM_END               = 7
};
 
/*
need info how to send these ones:
ERR_ARENA_TEAM_YOU_JOIN_S - client show it automatically when accept invite
ERR_ARENA_TEAM_TARGET_TOO_LOW_S
ERR_ARENA_TEAM_TOO_MANY_MEMBERS_S
ERR_ARENA_TEAM_LEVEL_TOO_LOW_I
*/
 
// EnumUtils: DESCRIBE THIS
enum ArenaTeamTypes
{
    ARENA_TEAM_2v2      = 2,
    ARENA_TEAM_3v3      = 3,
    ARENA_TEAM_5v5      = 5
};
 
enum ArenaSlot
{
    ARENA_SLOT_2v2,
    ARENA_SLOT_3v3,
    ARENA_SLOT_5v5
};
 
struct ArenaTeamMember
{
    ObjectGuid Guid;
    std::string Name;
    uint8 Class;
    uint16 WeekGames;
    uint16 WeekWins;
    uint16 SeasonGames;
    uint16 SeasonWins;
    uint16 PersonalRating;
    uint16 MatchMakerRating;
    uint16 MaxMMR;
 
    void ModifyPersonalRating(Player* player, int32 mod, uint32 type);
    void ModifyMatchmakerRating(int32 mod, uint32 slot);
};
 
struct ArenaTeamStats
{
    uint16 Rating;
    uint16 WeekGames;
    uint16 WeekWins;
    uint16 SeasonGames;
    uint16 SeasonWins;
    uint32 Rank;
};
 
#define MAX_ARENA_SLOT 4                                    // 0..2 slots
 
class ArenaTeam
{
public:
    ArenaTeam();
    ~ArenaTeam();
 
    bool Create(ObjectGuid captainGuid, uint8 type, std::string const& teamName, uint32 backgroundColor, uint8 emblemStyle, uint32 emblemColor, uint8 borderStyle, uint32 borderColor);
    void Disband(WorldSession* session);
    void Disband();
 
    typedef std::list<ArenaTeamMember> MemberList;
 
    [[nodiscard]] uint32 GetId() const              { return TeamId; }
    [[nodiscard]] uint32 GetType() const            { return Type; }
    [[nodiscard]] uint8  GetSlot() const            { return GetSlotByType(GetType()); }
    static uint8 GetSlotByType(uint32 type);
    static uint8 GetReqPlayersForType(uint32 type);
    [[nodiscard]] ObjectGuid GetCaptain() const { return CaptainGuid; }
    [[nodiscard]] std::string const& GetName() const       { return TeamName; }
    [[nodiscard]] const ArenaTeamStats& GetStats() const { return Stats; }
    void SetArenaTeamStats(ArenaTeamStats& stats) { Stats = stats; }
 
    [[nodiscard]] uint32 GetRating() const          { return Stats.Rating; }
    uint32 GetAverageMMR(Group* group) const;
 
    void SetCaptain(ObjectGuid guid);
    bool SetName(std::string const& name);
    bool AddMember(ObjectGuid playerGuid);
 
    // Shouldn't be ObjectGuid, because than can reference guid from members on Disband
    // and this method removes given record from list. So invalid reference can happen.
    void DelMember(ObjectGuid guid, bool cleanDb);
 
    [[nodiscard]] std::size_t GetMembersSize() const         { return Members.size(); }
    [[nodiscard]] bool   Empty() const                  { return Members.empty(); }
    MemberList::iterator m_membersBegin() { return Members.begin(); }
    MemberList::iterator m_membersEnd()   { return Members.end(); }
    MemberList& GetMembers() { return Members; }
    [[nodiscard]] bool IsMember(ObjectGuid guid) const;
 
    ArenaTeamMember* GetMember(ObjectGuid guid);
    ArenaTeamMember* GetMember(std::string const& name);
 
    [[nodiscard]] bool IsFighting() const;
 
    bool LoadArenaTeamFromDB(QueryResult arenaTeamDataResult);
    bool LoadMembersFromDB(QueryResult arenaTeamMembersResult);
    void LoadStatsFromDB(uint32 ArenaTeamId);
    void SaveToDB(bool forceMemberSave = false);
 
    void BroadcastPacket(WorldPacket* packet);
    void BroadcastEvent(ArenaTeamEvents event, ObjectGuid guid, uint8 strCount, std::string const& str1, std::string const& str2, std::string const& str3);
    void NotifyStatsChanged();
 
    void MassInviteToEvent(WorldSession* session);
 
    void Roster(WorldSession* session);
    void Query(WorldSession* session);
    void SendStats(WorldSession* session);
    void Inspect(WorldSession* session, ObjectGuid guid);
 
    uint32 GetPoints(uint32 MemberRating);
    int32  GetMatchmakerRatingMod(uint32 ownRating, uint32 opponentRating, bool won);
    int32  GetRatingMod(uint32 ownRating, uint32 opponentRating, bool won);
    float  GetChanceAgainst(uint32 ownRating, uint32 opponentRating);
    int32  WonAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, const Map* bgMap);
    void   MemberWon(Player* player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange);
    int32  LostAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, const Map* bgMap);
    void   MemberLost(Player* player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange = -12);
 
    void UpdateArenaPointsHelper(std::map<ObjectGuid, uint32>& PlayerPoints);
 
    bool FinishWeek(); // returns true if arena team played this week
    void FinishGame(int32 mod, const Map* bgMap);
 
    void SetPreviousOpponents(uint32 arenaTeamId) { PreviousOpponents = arenaTeamId; }
    uint32 GetPreviousOpponents() { return PreviousOpponents; }
 
    void CreateTempArenaTeam(std::vector<Player*> playerList, uint8 type, std::string const& teamName);
 
    // Containers
    static std::unordered_map<uint32, uint8> ArenaSlotByType; // Slot -> Type
    static std::unordered_map<uint8, uint8> ArenaReqPlayersForType; // Type -> Players count
 
protected:
    uint32      TeamId;
    uint8       Type;
    std::string TeamName;
    ObjectGuid  CaptainGuid;
 
    uint32 BackgroundColor; // ARGB format
    uint8  EmblemStyle;     // icon id
    uint32 EmblemColor;     // ARGB format
    uint8  BorderStyle;     // border image id
    uint32 BorderColor;     // ARGB format
 
    MemberList     Members;
    ArenaTeamStats Stats;
 
    uint32 PreviousOpponents = 0;
};
#endif

Referenced by GetReqPlayersForType().

ArenaSlotByType

std::unordered_map< uint32, uint8 > ArenaTeam::ArenaSlotByType

static

Initial value:

=
{
    { ARENA_TEAM_2v2, ARENA_SLOT_2v2},
    { ARENA_TEAM_3v3, ARENA_SLOT_3v3},
    { ARENA_TEAM_5v5, ARENA_SLOT_5v5}
}

{
    ERR_ARENA_TEAM_CREATE_S                 = 0x00,
    ERR_ARENA_TEAM_INVITE_SS                = 0x01,
    ERR_ARENA_TEAM_QUIT_S                   = 0x03,
    ERR_ARENA_TEAM_FOUNDER_S                = 0x0E
};
 
enum ArenaTeamCommandErrors
{
    ERR_ARENA_TEAM_INTERNAL                 = 0x01,
    ERR_ALREADY_IN_ARENA_TEAM               = 0x02,
    ERR_ALREADY_IN_ARENA_TEAM_S             = 0x03,
    ERR_INVITED_TO_ARENA_TEAM               = 0x04,
    ERR_ALREADY_INVITED_TO_ARENA_TEAM_S     = 0x05,
    ERR_ARENA_TEAM_NAME_INVALID             = 0x06,
    ERR_ARENA_TEAM_NAME_EXISTS_S            = 0x07,
    ERR_ARENA_TEAM_LEADER_LEAVE_S           = 0x08,
    ERR_ARENA_TEAM_PERMISSIONS              = 0x08,
    ERR_ARENA_TEAM_PLAYER_NOT_IN_TEAM       = 0x09,
    ERR_ARENA_TEAM_PLAYER_NOT_IN_TEAM_SS    = 0x0A,
    ERR_ARENA_TEAM_PLAYER_NOT_FOUND_S       = 0x0B,
    ERR_ARENA_TEAM_NOT_ALLIED               = 0x0C,
    ERR_ARENA_TEAM_IGNORING_YOU_S           = 0x13,
    ERR_ARENA_TEAM_TARGET_TOO_LOW_S         = 0x15,
    ERR_ARENA_TEAM_TARGET_TOO_HIGH_S        = 0x16,
    ERR_ARENA_TEAM_TOO_MANY_MEMBERS_S       = 0x17,
    ERR_ARENA_TEAM_NOT_FOUND                = 0x1B,
    ERR_ARENA_TEAMS_LOCKED                  = 0x1E
};
 
enum ArenaTeamEvents
{
    ERR_ARENA_TEAM_JOIN_SS                  = 3,            // player name + arena team name
    ERR_ARENA_TEAM_LEAVE_SS                 = 4,            // player name + arena team name
    ERR_ARENA_TEAM_REMOVE_SSS               = 5,            // player name + arena team name + captain name
    ERR_ARENA_TEAM_LEADER_IS_SS             = 6,            // player name + arena team name
    ERR_ARENA_TEAM_LEADER_CHANGED_SSS       = 7,            // old captain + new captain + arena team name
    ERR_ARENA_TEAM_DISBANDED_S              = 8             // captain name + arena team name
};
 
// PLAYER_FIELD_ARENA_TEAM_INFO_1_1 offsets
enum ArenaTeamInfoType : uint8
{
    ARENA_TEAM_ID                = 0,
    ARENA_TEAM_TYPE              = 1,                       // new in 3.2 - team type?
    ARENA_TEAM_MEMBER            = 2,                       // 0 - captain, 1 - member
    ARENA_TEAM_GAMES_WEEK        = 3,
    ARENA_TEAM_GAMES_SEASON      = 4,
    ARENA_TEAM_WINS_SEASON       = 5,
    ARENA_TEAM_PERSONAL_RATING   = 6,
    ARENA_TEAM_END               = 7
};
 
/*
need info how to send these ones:
ERR_ARENA_TEAM_YOU_JOIN_S - client show it automatically when accept invite
ERR_ARENA_TEAM_TARGET_TOO_LOW_S
ERR_ARENA_TEAM_TOO_MANY_MEMBERS_S
ERR_ARENA_TEAM_LEVEL_TOO_LOW_I
*/
 
// EnumUtils: DESCRIBE THIS
enum ArenaTeamTypes
{
    ARENA_TEAM_2v2      = 2,
    ARENA_TEAM_3v3      = 3,
    ARENA_TEAM_5v5      = 5
};
 
enum ArenaSlot
{
    ARENA_SLOT_2v2,
    ARENA_SLOT_3v3,
    ARENA_SLOT_5v5
};
 
struct ArenaTeamMember
{
    ObjectGuid Guid;
    std::string Name;
    uint8 Class;
    uint16 WeekGames;
    uint16 WeekWins;
    uint16 SeasonGames;
    uint16 SeasonWins;
    uint16 PersonalRating;
    uint16 MatchMakerRating;
    uint16 MaxMMR;
 
    void ModifyPersonalRating(Player* player, int32 mod, uint32 type);
    void ModifyMatchmakerRating(int32 mod, uint32 slot);
};
 
struct ArenaTeamStats
{
    uint16 Rating;
    uint16 WeekGames;
    uint16 WeekWins;
    uint16 SeasonGames;
    uint16 SeasonWins;
    uint32 Rank;
};
 
#define MAX_ARENA_SLOT 4                                    // 0..2 slots
 
class ArenaTeam
{
public:
    ArenaTeam();
    ~ArenaTeam();
 
    bool Create(ObjectGuid captainGuid, uint8 type, std::string const& teamName, uint32 backgroundColor, uint8 emblemStyle, uint32 emblemColor, uint8 borderStyle, uint32 borderColor);
    void Disband(WorldSession* session);
    void Disband();
 
    typedef std::list<ArenaTeamMember> MemberList;
 
    [[nodiscard]] uint32 GetId() const              { return TeamId; }
    [[nodiscard]] uint32 GetType() const            { return Type; }
    [[nodiscard]] uint8  GetSlot() const            { return GetSlotByType(GetType()); }
    static uint8 GetSlotByType(uint32 type);
    static uint8 GetReqPlayersForType(uint32 type);
    [[nodiscard]] ObjectGuid GetCaptain() const { return CaptainGuid; }
    [[nodiscard]] std::string const& GetName() const       { return TeamName; }
    [[nodiscard]] const ArenaTeamStats& GetStats() const { return Stats; }
    void SetArenaTeamStats(ArenaTeamStats& stats) { Stats = stats; }
 
    [[nodiscard]] uint32 GetRating() const          { return Stats.Rating; }
    uint32 GetAverageMMR(Group* group) const;
 
    void SetCaptain(ObjectGuid guid);
    bool SetName(std::string const& name);
    bool AddMember(ObjectGuid playerGuid);
 
    // Shouldn't be ObjectGuid, because than can reference guid from members on Disband
    // and this method removes given record from list. So invalid reference can happen.
    void DelMember(ObjectGuid guid, bool cleanDb);
 
    [[nodiscard]] std::size_t GetMembersSize() const         { return Members.size(); }
    [[nodiscard]] bool   Empty() const                  { return Members.empty(); }
    MemberList::iterator m_membersBegin() { return Members.begin(); }
    MemberList::iterator m_membersEnd()   { return Members.end(); }
    MemberList& GetMembers() { return Members; }
    [[nodiscard]] bool IsMember(ObjectGuid guid) const;
 
    ArenaTeamMember* GetMember(ObjectGuid guid);
    ArenaTeamMember* GetMember(std::string const& name);
 
    [[nodiscard]] bool IsFighting() const;
 
    bool LoadArenaTeamFromDB(QueryResult arenaTeamDataResult);
    bool LoadMembersFromDB(QueryResult arenaTeamMembersResult);
    void LoadStatsFromDB(uint32 ArenaTeamId);
    void SaveToDB(bool forceMemberSave = false);
 
    void BroadcastPacket(WorldPacket* packet);
    void BroadcastEvent(ArenaTeamEvents event, ObjectGuid guid, uint8 strCount, std::string const& str1, std::string const& str2, std::string const& str3);
    void NotifyStatsChanged();
 
    void MassInviteToEvent(WorldSession* session);
 
    void Roster(WorldSession* session);
    void Query(WorldSession* session);
    void SendStats(WorldSession* session);
    void Inspect(WorldSession* session, ObjectGuid guid);
 
    uint32 GetPoints(uint32 MemberRating);
    int32  GetMatchmakerRatingMod(uint32 ownRating, uint32 opponentRating, bool won);
    int32  GetRatingMod(uint32 ownRating, uint32 opponentRating, bool won);
    float  GetChanceAgainst(uint32 ownRating, uint32 opponentRating);
    int32  WonAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, const Map* bgMap);
    void   MemberWon(Player* player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange);
    int32  LostAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, const Map* bgMap);
    void   MemberLost(Player* player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange = -12);
 
    void UpdateArenaPointsHelper(std::map<ObjectGuid, uint32>& PlayerPoints);
 
    bool FinishWeek(); // returns true if arena team played this week
    void FinishGame(int32 mod, const Map* bgMap);
 
    void SetPreviousOpponents(uint32 arenaTeamId) { PreviousOpponents = arenaTeamId; }
    uint32 GetPreviousOpponents() { return PreviousOpponents; }
 
    void CreateTempArenaTeam(std::vector<Player*> playerList, uint8 type, std::string const& teamName);
 
    // Containers
    static std::unordered_map<uint32, uint8> ArenaSlotByType; // Slot -> Type
    static std::unordered_map<uint8, uint8> ArenaReqPlayersForType; // Type -> Players count
 
protected:
    uint32      TeamId;
    uint8       Type;
    std::string TeamName;
    ObjectGuid  CaptainGuid;
 
    uint32 BackgroundColor; // ARGB format
    uint8  EmblemStyle;     // icon id
    uint32 EmblemColor;     // ARGB format
    uint8  BorderStyle;     // border image id
    uint32 BorderColor;     // ARGB format
 
    MemberList     Members;
    ArenaTeamStats Stats;
 
    uint32 PreviousOpponents = 0;
};
#endif

Referenced by Player::_LoadArenaTeamInfo(), and GetSlotByType().

BackgroundColor

uint32 ArenaTeam::BackgroundColor

protected

Referenced by Create(), CreateTempArenaTeam(), LoadArenaTeamFromDB(), and Query().

BorderColor

uint32 ArenaTeam::BorderColor

protected

Referenced by Create(), CreateTempArenaTeam(), LoadArenaTeamFromDB(), and Query().

BorderStyle

uint8 ArenaTeam::BorderStyle

protected

Referenced by Create(), CreateTempArenaTeam(), LoadArenaTeamFromDB(), and Query().

CaptainGuid

ObjectGuid ArenaTeam::CaptainGuid

protected

Referenced by AddMember(), Create(), CreateTempArenaTeam(), GetCaptain(), LoadArenaTeamFromDB(), and SetCaptain().

EmblemColor

uint32 ArenaTeam::EmblemColor

protected

Referenced by Create(), CreateTempArenaTeam(), LoadArenaTeamFromDB(), and Query().

EmblemStyle

uint8 ArenaTeam::EmblemStyle

protected

Referenced by Create(), CreateTempArenaTeam(), LoadArenaTeamFromDB(), and Query().

Members

MemberList ArenaTeam::Members

protected

Referenced by AddMember(), BroadcastPacket(), CreateTempArenaTeam(), DelMember(), Disband(), Disband(), Empty(), FinishGame(), FinishWeek(), GetAverageMMR(), GetMember(), GetMembers(), GetMembersSize(), IsFighting(), IsMember(), LoadMembersFromDB(), m_membersBegin(), m_membersEnd(), MassInviteToEvent(), MemberLost(), MemberWon(), NotifyStatsChanged(), Roster(), SaveToDB(), and UpdateArenaPointsHelper().

PreviousOpponents

uint32 ArenaTeam::PreviousOpponents = 0

protected

Referenced by GetPreviousOpponents(), and SetPreviousOpponents().

Stats

ArenaTeamStats ArenaTeam::Stats

protected

Referenced by CreateTempArenaTeam(), and GetStats().

TeamId

uint32 ArenaTeam::TeamId

protected

Referenced by GetId().

TeamName

std::string ArenaTeam::TeamName

protected

Referenced by Create(), CreateTempArenaTeam(), GetName(), LoadArenaTeamFromDB(), and SetName().

Type

uint8 ArenaTeam::Type

protected

Referenced by Create(), CreateTempArenaTeam(), FinishGame(), GetPoints(), GetType(), LoadArenaTeamFromDB(), and ArenaTeamTest::SetType().

---

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

• azerothcore-wotlk/src/server/game/Battlegrounds/ArenaTeam.h
• azerothcore-wotlk/src/server/game/Battlegrounds/ArenaTeam.cpp