ArenaSeasonMgr Class Reference

#include "ArenaSeasonMgr.h"

Public Types
using	ArenaSeasonRewardGroupsBySeasonContainer = std::unordered_map< uint8, std::vector< ArenaSeasonRewardGroup > >

Public Member Functions
void	LoadRewards ()
void	LoadActiveSeason ()
void	ChangeCurrentSeason (uint8 season)
uint8	GetCurrentSeason ()
void	SetSeasonState (ArenaSeasonState state)
ArenaSeasonState	GetSeasonState ()
void	RewardTeamsForTheSeason (std::shared_ptr< ArenaTeamFilter > teamsFilter)
bool	CanDeleteArenaTeams ()
void	DeleteArenaTeams ()

Static Public Member Functions
static ArenaSeasonMgr *	instance ()

Private Member Functions
uint16	GameEventForArenaSeason (uint8 season)
void	BroadcastUpdatedWorldState ()

Private Attributes
ArenaSeasonRewardGroupsBySeasonContainer	_arenaSeasonRewardGroupsStore
uint8	_currentSeason {}
ArenaSeasonState	_currentSeasonState {}

Detailed Description

Member Typedef Documentation

ArenaSeasonRewardGroupsBySeasonContainer

using ArenaSeasonMgr::ArenaSeasonRewardGroupsBySeasonContainer = std::unordered_map<uint8, std::vector<ArenaSeasonRewardGroup> >

Member Function Documentation

BroadcastUpdatedWorldState()

void ArenaSeasonMgr::BroadcastUpdatedWorldState ( )

private

{
    sMapMgr->DoForAllMaps([](Map* map)
    {
        // Ignore instanceable maps, players will get a fresh state once they change the map.
        if (map->Instanceable())
            return;
 
        map->DoForAllPlayers([&](Player* player)
        {
            uint32 currZone, currArea;
            player->GetZoneAndAreaId(currZone, currArea);
            player->SendInitWorldStates(currZone, currArea);
        });
    });
}

References Map::DoForAllPlayers(), WorldObject::GetZoneAndAreaId(), Map::Instanceable(), Player::SendInitWorldStates(), and sMapMgr.

Referenced by ChangeCurrentSeason(), and SetSeasonState().

CanDeleteArenaTeams()

bool ArenaSeasonMgr::CanDeleteArenaTeams

(

)

{
    std::vector<ArenaSeasonRewardGroup> rewards = _arenaSeasonRewardGroupsStore[GetCurrentSeason()];
    if (rewards.empty())
        return false;
 
    for (auto const& bg : sBattlegroundMgr->GetActiveBattlegrounds())
        if (bg->isRated())
            return false;
 
    return true;
}

References _arenaSeasonRewardGroupsStore, GetCurrentSeason(), and sBattlegroundMgr.

Referenced by DeleteArenaTeams().

ChangeCurrentSeason()

void ArenaSeasonMgr::ChangeCurrentSeason

(

uint8

season

)

{
    if (_currentSeason == season)
        return;
 
    uint16 currentEventID = GameEventForArenaSeason(_currentSeason);
    sGameEventMgr->StopEvent(currentEventID, true);
 
    uint16 newEventID = GameEventForArenaSeason(season);
    sGameEventMgr->StartEvent(newEventID, true);
 
    _currentSeason = season;
    _currentSeasonState = ARENA_SEASON_STATE_IN_PROGRESS;
 
    CharacterDatabase.Execute("UPDATE active_arena_season SET season_id = {}, season_state = {}", _currentSeason, _currentSeasonState);
 
    BroadcastUpdatedWorldState();
}

References _currentSeason, _currentSeasonState, ARENA_SEASON_STATE_IN_PROGRESS, BroadcastUpdatedWorldState(), CharacterDatabase, GameEventForArenaSeason(), and sGameEventMgr.

DeleteArenaTeams()

void ArenaSeasonMgr::DeleteArenaTeams

(

)

{
    if (!CanDeleteArenaTeams())
        return;
 
    // Cleanup queue first.
    std::vector<BattlegroundQueueTypeId> arenasQueueTypes = {BATTLEGROUND_QUEUE_2v2, BATTLEGROUND_QUEUE_3v3, BATTLEGROUND_QUEUE_5v5};
    for (BattlegroundQueueTypeId queueType : arenasQueueTypes)
    {
        auto queue = sBattlegroundMgr->GetBattlegroundQueue(queueType);
        for (auto const& [playerGUID, other] : queue.m_QueuedPlayers)
            queue.RemovePlayer(playerGUID, true);
    }
 
    sArenaTeamMgr->DeleteAllArenaTeams();
}

References BATTLEGROUND_QUEUE_2v2, BATTLEGROUND_QUEUE_3v3, BATTLEGROUND_QUEUE_5v5, CanDeleteArenaTeams(), sArenaTeamMgr, and sBattlegroundMgr.

GameEventForArenaSeason()

uint16 ArenaSeasonMgr::GameEventForArenaSeason ( uint8  season )

private

{
    QueryResult result = WorldDatabase.Query("SELECT eventEntry FROM game_event_arena_seasons WHERE season = '{}'", season);
 
    if (!result)
    {
        LOG_ERROR("arenaseasonmgr", "ArenaSeason ({}) must be an existant Arena Season", season);
        return 0;
    }
 
    Field* fields = result->Fetch();
    return fields[0].Get<uint16>();
}

References Field::Get(), LOG_ERROR, and WorldDatabase.

Referenced by ChangeCurrentSeason(), and LoadActiveSeason().

GetCurrentSeason()

uint8 ArenaSeasonMgr::GetCurrentSeason ( )

inline

{ return _currentSeason; }

References _currentSeason.

Referenced by CanDeleteArenaTeams(), and RewardTeamsForTheSeason().

GetSeasonState()

ArenaSeasonState ArenaSeasonMgr::GetSeasonState ( )

inline

{ return _currentSeasonState; }

References _currentSeasonState.

instance()

ArenaSeasonMgr * ArenaSeasonMgr::instance ( )

static

{
    static ArenaSeasonMgr instance;
    return &instance;
}

References instance().

Referenced by instance().

LoadActiveSeason()

void ArenaSeasonMgr::LoadActiveSeason

(

)

{
    QueryResult result = CharacterDatabase.Query("SELECT season_id, season_state FROM active_arena_season");
    ASSERT(result, "active_arena_season can't be empty");
 
    Field* fields = result->Fetch();
    _currentSeason      = fields[0].Get<uint8>();
    _currentSeasonState = static_cast<ArenaSeasonState>(fields[1].Get<uint8>());
 
    uint16 eventID = GameEventForArenaSeason(_currentSeason);
    sGameEventMgr->StartEvent(eventID, true);
 
    LOG_INFO("server.loading", "Arena Season {} loaded...", _currentSeason);
    LOG_INFO("server.loading", " ");
}

References _currentSeason, _currentSeasonState, ASSERT, CharacterDatabase, GameEventForArenaSeason(), Field::Get(), LOG_INFO, and sGameEventMgr.

LoadRewards()

void ArenaSeasonMgr::LoadRewards

(

)

{
    uint32 oldMSTime = getMSTime();
 
    std::unordered_map<std::string, ArenaSeasonRewardGroupCriteriaType> stringToArenaSeasonRewardGroupCriteriaType = {
        {"pct", ArenaSeasonRewardGroupCriteriaType::ARENA_SEASON_REWARD_CRITERIA_TYPE_PERCENT_VALUE},
        {"abs", ArenaSeasonRewardGroupCriteriaType::ARENA_SEASON_REWARD_CRITERIA_TYPE_ABSOLUTE_VALUE}
    };
 
    QueryResult result = WorldDatabase.Query("SELECT id, arena_season, criteria_type, min_criteria, max_criteria, reward_mail_template_id, reward_mail_subject, reward_mail_body, gold_reward FROM arena_season_reward_group");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 arena season rewards. DB table `arena_season_reward_group` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    std::unordered_map<uint32, ArenaSeasonRewardGroup> groupsMap;
 
    do
    {
        Field* fields = result->Fetch();
        uint32 id = fields[0].Get<uint32>();
 
        ArenaSeasonRewardGroup group;
        group.season               = fields[1].Get<uint8>();
        group.criteriaType         = stringToArenaSeasonRewardGroupCriteriaType[fields[2].Get<std::string>()];
        group.minCriteria          = fields[3].Get<float>();
        group.maxCriteria          = fields[4].Get<float>();
        group.rewardMailTemplateID = fields[5].Get<uint32>();
        group.rewardMailSubject    = fields[6].Get<std::string>();
        group.rewardMailBody       = fields[7].Get<std::string>();
        group.goldReward           = fields[8].Get<uint32>();
 
        groupsMap[id] = group;
    } while (result->NextRow());
 
    std::unordered_map<std::string, ArenaSeasonRewardType> stringToArenaSeasonRewardType = {
        {"achievement", ArenaSeasonRewardType::ARENA_SEASON_REWARD_TYPE_ACHIEVEMENT},
        {"item", ArenaSeasonRewardType::ARENA_SEASON_REWARD_TYPE_ITEM}
    };
 
    result = WorldDatabase.Query("SELECT group_id, type, entry FROM arena_season_reward");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 arena season rewards. DB table `arena_season_reward` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    do
    {
        Field* fields = result->Fetch();
        uint32 groupId = fields[0].Get<uint32>();
 
        ArenaSeasonReward reward;
        reward.type  = stringToArenaSeasonRewardType[fields[1].Get<std::string>()];
        reward.entry = fields[2].Get<uint32>();
 
        auto itr = groupsMap.find(groupId);
        ASSERT(itr != groupsMap.end(), "Unknown arena_season_reward_group ({}) in arena_season_reward", groupId);
 
        (reward.type == ARENA_SEASON_REWARD_TYPE_ITEM) ?
            groupsMap[groupId].itemRewards.push_back(reward) :
            groupsMap[groupId].achievementRewards.push_back(reward);
 
    } while (result->NextRow());
 
    for (auto const& itr : groupsMap)
        _arenaSeasonRewardGroupsStore[itr.second.season].push_back(itr.second);
 
    LOG_INFO("server.loading", ">> Loaded {} arena season rewards in {} ms", (uint32)groupsMap.size(), GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References _arenaSeasonRewardGroupsStore, ARENA_SEASON_REWARD_CRITERIA_TYPE_ABSOLUTE_VALUE, ARENA_SEASON_REWARD_CRITERIA_TYPE_PERCENT_VALUE, ARENA_SEASON_REWARD_TYPE_ACHIEVEMENT, ARENA_SEASON_REWARD_TYPE_ITEM, ASSERT, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_INFO, LOG_WARN, ArenaSeasonRewardGroup::season, ArenaSeasonReward::type, and WorldDatabase.

RewardTeamsForTheSeason()

void ArenaSeasonMgr::RewardTeamsForTheSeason

(

std::shared_ptr< ArenaTeamFilter >

teamsFilter

)

{
    ArenaSeasonTeamRewarderImpl rewarder = ArenaSeasonTeamRewarderImpl();
    ArenaSeasonRewardDistributor distributor = ArenaSeasonRewardDistributor(&rewarder);
    std::vector<ArenaSeasonRewardGroup> rewards = _arenaSeasonRewardGroupsStore[GetCurrentSeason()];
    ArenaTeamMgr::ArenaTeamContainer filteredTeams = teamsFilter->Filter(sArenaTeamMgr->GetArenaTeams());
    distributor.DistributeRewards(filteredTeams, rewards);
}

References _arenaSeasonRewardGroupsStore, ArenaSeasonRewardDistributor::DistributeRewards(), GetCurrentSeason(), and sArenaTeamMgr.

SetSeasonState()

void ArenaSeasonMgr::SetSeasonState

(

ArenaSeasonState

state

)

{
    if (_currentSeasonState == state)
        return;
 
    _currentSeasonState = state;
 
    CharacterDatabase.Execute("UPDATE active_arena_season SET season_state = {}", _currentSeasonState);
 
    BroadcastUpdatedWorldState();
}

References _currentSeasonState, BroadcastUpdatedWorldState(), and CharacterDatabase.

Member Data Documentation

_arenaSeasonRewardGroupsStore

ArenaSeasonRewardGroupsBySeasonContainer ArenaSeasonMgr::_arenaSeasonRewardGroupsStore

private

Referenced by CanDeleteArenaTeams(), LoadRewards(), and RewardTeamsForTheSeason().

_currentSeason

uint8 ArenaSeasonMgr::_currentSeason {}

private

{};

Referenced by ChangeCurrentSeason(), GetCurrentSeason(), and LoadActiveSeason().

_currentSeasonState

ArenaSeasonState ArenaSeasonMgr::_currentSeasonState {}

private

{};

Referenced by ChangeCurrentSeason(), GetSeasonState(), LoadActiveSeason(), and SetSeasonState().

---

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

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