AchievementGlobalMgr Class Reference

#include "AchievementMgr.h"

Public Member Functions
bool	IsStatisticCriteria (AchievementCriteriaEntry const *achievementCriteria) const
bool	IsStatisticAchievement (AchievementEntry const *achievement) const
bool	IsAverageCriteria (AchievementCriteriaEntry const *criteria) const
AchievementCriteriaEntryList const *	GetAchievementCriteriaByType (AchievementCriteriaTypes type) const
AchievementCriteriaEntryList const *	GetSpecialAchievementCriteriaByType (AchievementCriteriaTypes type, uint32 val)
AchievementCriteriaEntryList const *	GetAchievementCriteriaByCondition (AchievementCriteriaCondition condition, uint32 val)
AchievementCriteriaEntryList const &	GetTimedAchievementCriteriaByType (AchievementCriteriaTimedTypes type) const
AchievementCriteriaEntryList const *	GetAchievementCriteriaByAchievement (uint32 id) const
AchievementEntryList const *	GetAchievementByReferencedId (uint32 id) const
AchievementReward const *	GetAchievementReward (AchievementEntry const *achievement) const
AchievementRewardLocale const *	GetAchievementRewardLocale (AchievementEntry const *achievement) const
AchievementCriteriaDataSet const *	GetCriteriaDataSet (AchievementCriteriaEntry const *achievementCriteria) const
bool	IsRealmCompleted (AchievementEntry const *achievement) const
void	SetRealmCompleted (AchievementEntry const *achievement)
void	LoadAchievementCriteriaList ()
void	LoadAchievementCriteriaData ()
void	LoadAchievementReferenceList ()
void	LoadCompletedAchievements ()
void	LoadRewards ()
void	LoadRewardLocales ()
AchievementEntry const *	GetAchievement (uint32 achievementId) const
void	CompletedAchievementForOfflinePlayer (ObjectGuid::LowType playerLowGuid, AchievementEntry const *entry)
void	UpdateAchievementCriteriaForOfflinePlayer (ObjectGuid::LowType playerLowGuid, AchievementCriteriaTypes type, uint32 miscValue1=0, uint32 miscValue2=0)

Static Public Member Functions
static AchievementGlobalMgr *	instance ()

Private Types
typedef std::unordered_map< uint32, SystemTimePoint >	AllCompletedAchievements

Private Member Functions
	AchievementGlobalMgr ()=default
	~AchievementGlobalMgr ()=default

Private Attributes
AchievementCriteriaDataMap	_criteriaDataMap
AchievementCriteriaEntryList	_achievementCriteriasByType [ACHIEVEMENT_CRITERIA_TYPE_TOTAL]
AchievementCriteriaEntryList	_achievementCriteriasByTimedType [ACHIEVEMENT_TIMED_TYPE_MAX]
AchievementCriteriaListByAchievement	_achievementCriteriaListByAchievement
AchievementListByReferencedId	_achievementListByReferencedId
AllCompletedAchievements	_allCompletedAchievements
AchievementRewards	_achievementRewards
AchievementRewardLocales	_achievementRewardLocales
std::map< uint32, AchievementCriteriaEntryList >	_specialList [ACHIEVEMENT_CRITERIA_TYPE_TOTAL]
std::map< uint32, AchievementCriteriaEntryList >	_achievementCriteriasByCondition [ACHIEVEMENT_CRITERIA_CONDITION_TOTAL]

Detailed Description

Member Typedef Documentation

AllCompletedAchievements

typedef std::unordered_map<uint32 , SystemTimePoint > AchievementGlobalMgr::AllCompletedAchievements

private

Constructor & Destructor Documentation

AchievementGlobalMgr()

AchievementGlobalMgr::AchievementGlobalMgr ( )

privatedefault

~AchievementGlobalMgr()

AchievementGlobalMgr::~AchievementGlobalMgr ( )

privatedefault

Member Function Documentation

CompletedAchievementForOfflinePlayer()

void AchievementGlobalMgr::CompletedAchievementForOfflinePlayer	(	ObjectGuid::LowType	playerLowGuid,
		AchievementEntry const *	entry
	)

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_ACHIEVEMENT_OFFLINE_UPDATES);
    stmt->SetData(0, playerLowGuid);
    stmt->SetData(1, ACHIEVEMENT_OFFLINE_PLAYER_UPDATE_TYPE_COMPLETE_ACHIEVEMENT);
    stmt->SetData(2, entry->ID);
    stmt->SetData(3, 0);
    stmt->SetData(4, 0);
    CharacterDatabase.Execute(stmt);
}

References ACHIEVEMENT_OFFLINE_PLAYER_UPDATE_TYPE_COMPLETE_ACHIEVEMENT, CHAR_INS_CHAR_ACHIEVEMENT_OFFLINE_UPDATES, CharacterDatabase, AchievementEntry::ID, and PreparedStatementBase::SetData().

GetAchievement()

AchievementEntry const * AchievementGlobalMgr::GetAchievement

(

uint32

achievementId

)

const

{
    return sAchievementStore.LookupEntry(achievementId);
}

References sAchievementStore.

Referenced by LoadAchievementCriteriaList().

GetAchievementByReferencedId()

AchievementEntryList const * AchievementGlobalMgr::GetAchievementByReferencedId ( uint32  id ) const

inline

    {
        AchievementListByReferencedId::const_iterator itr = _achievementListByReferencedId.find(id);
        return itr != _achievementListByReferencedId.end() ? &itr->second : nullptr;
    }

References _achievementListByReferencedId.

Referenced by IsAverageCriteria().

GetAchievementCriteriaByAchievement()

AchievementCriteriaEntryList const * AchievementGlobalMgr::GetAchievementCriteriaByAchievement ( uint32  id ) const

inline

    {
        AchievementCriteriaListByAchievement::const_iterator itr = _achievementCriteriaListByAchievement.find(id);
        return itr != _achievementCriteriaListByAchievement.end() ? &itr->second : nullptr;
    }

References _achievementCriteriaListByAchievement.

GetAchievementCriteriaByCondition()

AchievementCriteriaEntryList const * AchievementGlobalMgr::GetAchievementCriteriaByCondition ( AchievementCriteriaCondition  condition, uint32  val  )

inline

    {
        if (_achievementCriteriasByCondition[condition].find(val) != _achievementCriteriasByCondition[condition].end())
            return &_achievementCriteriasByCondition[condition][val];
        return nullptr;
    }

References _achievementCriteriasByCondition.

GetAchievementCriteriaByType()

AchievementCriteriaEntryList const * AchievementGlobalMgr::GetAchievementCriteriaByType ( AchievementCriteriaTypes  type ) const

inline

    {
        return &_achievementCriteriasByType[type];
    }

References _achievementCriteriasByType.

GetAchievementReward()

AchievementReward const * AchievementGlobalMgr::GetAchievementReward ( AchievementEntry const *  achievement ) const

inline

    {
        AchievementRewards::const_iterator iter = _achievementRewards.find(achievement->ID);
        return iter != _achievementRewards.end() ? &iter->second : nullptr;
    }

References _achievementRewards, and AchievementEntry::ID.

GetAchievementRewardLocale()

AchievementRewardLocale const * AchievementGlobalMgr::GetAchievementRewardLocale ( AchievementEntry const *  achievement ) const

inline

    {
        AchievementRewardLocales::const_iterator iter = _achievementRewardLocales.find(achievement->ID);
        return iter != _achievementRewardLocales.end() ? &iter->second : nullptr;
    }

References _achievementRewardLocales, and AchievementEntry::ID.

GetCriteriaDataSet()

AchievementCriteriaDataSet const * AchievementGlobalMgr::GetCriteriaDataSet ( AchievementCriteriaEntry const *  achievementCriteria ) const

inline

    {
        AchievementCriteriaDataMap::const_iterator iter = _criteriaDataMap.find(achievementCriteria->ID);
        return iter != _criteriaDataMap.end() ? &iter->second : nullptr;
    }

References _criteriaDataMap, and AchievementCriteriaEntry::ID.

Referenced by LoadAchievementCriteriaData().

GetSpecialAchievementCriteriaByType()

AchievementCriteriaEntryList const * AchievementGlobalMgr::GetSpecialAchievementCriteriaByType ( AchievementCriteriaTypes  type, uint32  val  )

inline

    {
        if (_specialList[type].find(val) != _specialList[type].end())
            return &_specialList[type][val];
        return nullptr;
    }

References _specialList.

GetTimedAchievementCriteriaByType()

AchievementCriteriaEntryList const & AchievementGlobalMgr::GetTimedAchievementCriteriaByType ( AchievementCriteriaTimedTypes  type ) const

inline

    {
        return _achievementCriteriasByTimedType[type];
    }

References _achievementCriteriasByTimedType.

instance()

AchievementGlobalMgr * AchievementGlobalMgr::instance ( )

static

{
    static AchievementGlobalMgr instance;
    return &instance;
}

References instance().

Referenced by instance().

IsAverageCriteria()

bool AchievementGlobalMgr::IsAverageCriteria

(

AchievementCriteriaEntry const *

criteria

)

const

{
    auto referencedAchievement = sAchievementStore.LookupEntry(criteria->referredAchievement);
 
    if (!referencedAchievement)
        return false;
 
    if (referencedAchievement->flags & ACHIEVEMENT_FLAG_AVERAGE)
        return true;
 
    if (AchievementEntryList const* achRefList = GetAchievementByReferencedId(referencedAchievement->ID))
        for (AchievementEntryList::const_iterator itr = achRefList->begin(); itr != achRefList->end(); ++itr)
            if ((*itr)->flags & ACHIEVEMENT_FLAG_AVERAGE)
                return true;
 
    return false;
}

References ACHIEVEMENT_FLAG_AVERAGE, GetAchievementByReferencedId(), AchievementCriteriaEntry::referredAchievement, and sAchievementStore.

IsRealmCompleted()

bool AchievementGlobalMgr::IsRealmCompleted

(

AchievementEntry const *

achievement

)

const

{
    auto itr = _allCompletedAchievements.find(achievement->ID);
    if (itr == _allCompletedAchievements.end())
        return false;
 
    if (itr->second == SystemTimePoint::min())
        return false;
 
    if (!sScriptMgr->IsRealmCompleted(this, achievement, itr->second))
        return false;
 
    if (itr->second == SystemTimePoint::max())
        return true;
 
    // Allow completing the realm first kill for entire minute after first person did it
    // it may allow more than one group to achieve it (highly unlikely)
    // but apparently this is how blizz handles it as well
    if (achievement->flags & ACHIEVEMENT_FLAG_REALM_FIRST_KILL)
        return (GameTime::GetSystemTime() - itr->second) > 1min;
 
    sScriptMgr->SetRealmCompleted(achievement);
 
    return true;
}

References _allCompletedAchievements, ACHIEVEMENT_FLAG_REALM_FIRST_KILL, AchievementEntry::flags, GameTime::GetSystemTime(), AchievementEntry::ID, and sScriptMgr.

Referenced by SetRealmCompleted().

IsStatisticAchievement()

bool AchievementGlobalMgr::IsStatisticAchievement

(

AchievementEntry const *

achievement

)

const

{
    if (!achievement)
        return false;
 
    AchievementCategoryEntry const* cat = sAchievementCategoryStore.LookupEntry(achievement->categoryId);
    do
    {
        switch (cat->ID)
        {
            case ACHIEVEMENT_CATEGORY_STATISTICS:
                return true;
            case ACHIEVEMENT_CATEOGRY_GENERAL:
                return false;
            default:
                cat = sAchievementCategoryStore.LookupEntry(cat->parentCategory);
                break;
        }
    } while (cat);
 
    return false;
}

References ACHIEVEMENT_CATEGORY_STATISTICS, ACHIEVEMENT_CATEOGRY_GENERAL, AchievementEntry::categoryId, AchievementCategoryEntry::ID, AchievementCategoryEntry::parentCategory, and sAchievementCategoryStore.

Referenced by IsStatisticCriteria().

IsStatisticCriteria()

bool AchievementGlobalMgr::IsStatisticCriteria

(

AchievementCriteriaEntry const *

achievementCriteria

)

const

{
    return IsStatisticAchievement(sAchievementStore.LookupEntry(achievementCriteria->referredAchievement));
}

References IsStatisticAchievement(), AchievementCriteriaEntry::referredAchievement, and sAchievementStore.

LoadAchievementCriteriaData()

void AchievementGlobalMgr::LoadAchievementCriteriaData

(

)

{
    uint32 oldMSTime = getMSTime();
 
    _criteriaDataMap.clear();                              // need for reload case
 
    QueryResult result = WorldDatabase.Query("SELECT criteria_id, type, value1, value2, ScriptName FROM achievement_criteria_data");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 additional achievement criteria data. DB table `achievement_criteria_data` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
 
    do
    {
        Field* fields = result->Fetch();
        uint32 criteria_id = fields[0].Get<uint32>();
 
        AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(criteria_id);
 
        if (!criteria)
        {
            LOG_ERROR("sql.sql", "Table `achievement_criteria_data` has data for non-existing criteria (Entry: {}), ignore.", criteria_id);
            continue;
        }
 
        uint32 dataType = fields[1].Get<uint8>();
        std::string scriptName = fields[4].Get<std::string>();
        uint32 scriptId = 0;
        if (scriptName.length()) // not empty
        {
            if (dataType != ACHIEVEMENT_CRITERIA_DATA_TYPE_SCRIPT)
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` has ScriptName set for non-scripted data type (Entry: {}, type {}), useless data.", criteria_id, dataType);
            else
                scriptId = sObjectMgr->GetScriptId(scriptName);
        }
 
        AchievementCriteriaData data(dataType, fields[2].Get<uint32>(), fields[3].Get<uint32>(), scriptId);
 
        if (!data.IsValid(criteria))
            continue;
 
        // this will allocate empty data set storage
        AchievementCriteriaDataSet& dataSet = _criteriaDataMap[criteria_id];
        dataSet.SetCriteriaId(criteria_id);
 
        // add real data only for not NONE data types
        if (data.dataType != ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE)
            dataSet.Add(data);
 
        // counting data by and data types
        ++count;
    } while (result->NextRow());
 
    // post loading checks
    for (uint32 entryId = 0; entryId < sAchievementCriteriaStore.GetNumRows(); ++entryId)
    {
        AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(entryId);
        if (!criteria)
            continue;
 
        switch (criteria->requiredType)
        {
            case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
            case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG:
            case ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING:
            case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
            case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
            case ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE:
            case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL:
            case ACHIEVEMENT_CRITERIA_TYPE_OWN_RANK:
            case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM:
            case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT:
            case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT:
            case ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS:
            case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
            case ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL:
            case ACHIEVEMENT_CRITERIA_TYPE_ON_LOGIN:
            case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE_TYPE:
            case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
                // achievement requires db data
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
                {
                    AchievementEntry const* achievement = sAchievementStore.LookupEntry(criteria->referredAchievement);
                    if (!achievement)
                        continue;
 
                    // exist many achievements with this criteria, use at this moment hardcoded check to skil simple case
                    if (achievement->ID == 1282)
                        break;
 
                    continue;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA: // need skip generic cases
                if (criteria->additionalRequirements[0].additionalRequirement_type != ACHIEVEMENT_CRITERIA_CONDITION_NO_LOSE)
                    continue;
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:        // need skip generic cases
                if (criteria->do_emote.count == 0)
                    continue;
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_WIN_DUEL:        // skip statistics
                if (criteria->win_duel.duelCount == 0)
                    continue;
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:       // need skip generic cases
                if (criteria->loot_type.lootTypeCount != 1)
                    continue;
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST:
            case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:        // only Children's Week achievements
                {
                    AchievementEntry const* achievement = sAchievementStore.LookupEntry(criteria->referredAchievement);
                    if (!achievement)
                        continue;
                    if (achievement->categoryId != CATEGORY_CHILDRENS_WEEK)
                        continue;
                    break;
                }
            default:                                        // type not use DB data, ignore
                continue;
        }
 
        if (!GetCriteriaDataSet(criteria) && !sDisableMgr->IsDisabledFor(DISABLE_TYPE_ACHIEVEMENT_CRITERIA, entryId, nullptr))
            LOG_ERROR("sql.sql", "Table `achievement_criteria_data` does not have expected data for criteria (Entry: {} Type: {}) for achievement {}.", criteria->ID, criteria->requiredType, criteria->referredAchievement);
    }
 
    LOG_INFO("server.loading", ">> Loaded {} additional achievement criteria data in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References _criteriaDataMap, ACHIEVEMENT_CRITERIA_CONDITION_NO_LOSE, ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE, ACHIEVEMENT_CRITERIA_DATA_TYPE_SCRIPT, ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2, ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL, ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2, ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST, ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST, ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE, ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM, ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING, ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS, ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL, ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE, ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE_TYPE, ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE, ACHIEVEMENT_CRITERIA_TYPE_ON_LOGIN, ACHIEVEMENT_CRITERIA_TYPE_OWN_RANK, ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT, ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT, ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL, ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM, ACHIEVEMENT_CRITERIA_TYPE_WIN_BG, ACHIEVEMENT_CRITERIA_TYPE_WIN_DUEL, ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA, AchievementCriteriaDataSet::Add(), AchievementCriteriaEntry::additionalRequirement_type, AchievementCriteriaEntry::additionalRequirements, CATEGORY_CHILDRENS_WEEK, AchievementEntry::categoryId, AchievementCriteriaEntry::count, AchievementCriteriaData::dataType, DISABLE_TYPE_ACHIEVEMENT_CRITERIA, AchievementCriteriaEntry::do_emote, AchievementCriteriaEntry::duelCount, Field::Get(), GetCriteriaDataSet(), getMSTime(), GetMSTimeDiffToNow(), AchievementEntry::ID, AchievementCriteriaEntry::ID, AchievementCriteriaData::IsValid(), LOG_ERROR, LOG_INFO, LOG_WARN, AchievementCriteriaEntry::loot_type, AchievementCriteriaEntry::lootTypeCount, AchievementCriteriaEntry::referredAchievement, AchievementCriteriaEntry::requiredType, sAchievementCriteriaStore, sAchievementStore, sDisableMgr, AchievementCriteriaDataSet::SetCriteriaId(), sObjectMgr, AchievementCriteriaEntry::win_duel, and WorldDatabase.

LoadAchievementCriteriaList()

void AchievementGlobalMgr::LoadAchievementCriteriaList

(

)

{
    uint32 oldMSTime = getMSTime();
 
    if (sAchievementCriteriaStore.GetNumRows() == 0)
    {
        LOG_WARN("server.loading", ">> Loaded 0 achievement criteria.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 loaded = 0;
    for (uint32 entryId = 0; entryId < sAchievementCriteriaStore.GetNumRows(); ++entryId)
    {
        AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(entryId);
        if (!criteria)
            continue;
 
        if (!GetAchievement(criteria->referredAchievement))
        {
            LOG_DEBUG("server.loading", "Achievement {} referenced by criteria {} doesn't exist, criteria not loaded.", criteria->referredAchievement, criteria->ID);
            continue;
        }
 
        _achievementCriteriasByType[criteria->requiredType].push_back(criteria);
        _achievementCriteriaListByAchievement[criteria->referredAchievement].push_back(criteria);
 
        if (criteria->additionalRequirements[0].additionalRequirement_type != ACHIEVEMENT_CRITERIA_CONDITION_NONE)
            _achievementCriteriasByCondition[criteria->additionalRequirements[0].additionalRequirement_type][criteria->additionalRequirements[0].additionalRequirement_value].push_back(criteria);
        if (criteria->additionalRequirements[1].additionalRequirement_type != ACHIEVEMENT_CRITERIA_CONDITION_NONE &&
                criteria->additionalRequirements[1].additionalRequirement_type != criteria->additionalRequirements[0].additionalRequirement_type)
            _achievementCriteriasByCondition[criteria->additionalRequirements[1].additionalRequirement_type][criteria->additionalRequirements[1].additionalRequirement_value].push_back(criteria);
 
        switch (criteria->requiredType)
        {
            case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
                _specialList[criteria->requiredType][criteria->kill_creature.creatureID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG:
                _specialList[criteria->requiredType][criteria->win_bg.bgMapID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL:
                _specialList[criteria->requiredType][criteria->reach_skill_level.skillID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT:
                _specialList[criteria->requiredType][criteria->complete_achievement.linkedAchievement].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
                _specialList[criteria->requiredType][criteria->complete_quests_in_zone.zoneID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND:
                _specialList[criteria->requiredType][criteria->complete_battleground.mapID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE:
                _specialList[criteria->requiredType][criteria->killed_by_creature.creatureEntry].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
                _specialList[criteria->requiredType][criteria->complete_quest.questID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
                _specialList[criteria->requiredType][criteria->be_spell_target.spellID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
                _specialList[criteria->requiredType][criteria->cast_spell.spellID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE:
                _specialList[criteria->requiredType][criteria->bg_objective.objectiveId].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL_AT_AREA:
                _specialList[criteria->requiredType][criteria->honorable_kill_at_area.areaID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL:
                _specialList[criteria->requiredType][criteria->learn_spell.spellID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM:
                _specialList[criteria->requiredType][criteria->own_item.itemID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL:
                _specialList[criteria->requiredType][criteria->learn_skill_level.skillID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:
                _specialList[criteria->requiredType][criteria->use_item.itemID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM:
                _specialList[criteria->requiredType][criteria->own_item.itemID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA:
                {
                    WorldMapOverlayEntry const* worldOverlayEntry = sWorldMapOverlayStore.LookupEntry(criteria->explore_area.areaReference);
                    if (!worldOverlayEntry)
                        break;
 
                    for (uint8 j = 0; j < MAX_WORLD_MAP_OVERLAY_AREA_IDX; ++j)
                        if (worldOverlayEntry->areatableID[j])
                        {
                            bool valid = true;
                            for (uint8 i = 0; i < j; ++i)
                                if (worldOverlayEntry->areatableID[j] == worldOverlayEntry->areatableID[i])
                                    valid = false;
                            if (valid)
                                _specialList[criteria->requiredType][worldOverlayEntry->areatableID[j]].push_back(criteria);
                        }
                }
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
                _specialList[criteria->requiredType][criteria->gain_reputation.factionID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM:
                _specialList[criteria->requiredType][criteria->equip_epic_item.itemSlot].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS:
                _specialList[criteria->requiredType][criteria->hk_class.classID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_HK_RACE:
                _specialList[criteria->requiredType][criteria->hk_race.raceID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
                _specialList[criteria->requiredType][criteria->do_emote.emoteID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM:
                _specialList[criteria->requiredType][criteria->equip_item.itemID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT:
                _specialList[criteria->requiredType][criteria->use_gameobject.goEntry].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
                _specialList[criteria->requiredType][criteria->be_spell_target.spellID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT:
                _specialList[criteria->requiredType][criteria->fish_in_gameobject.goEntry].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
                _specialList[criteria->requiredType][criteria->learn_skillline_spell.skillLine].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:
                _specialList[criteria->requiredType][criteria->loot_type.lootType].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
                _specialList[criteria->requiredType][criteria->cast_spell.spellID].push_back(criteria);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE:
                _specialList[criteria->requiredType][criteria->learn_skill_line.skillLine].push_back(criteria);
                break;
        }
 
        if (criteria->timeLimit)
            _achievementCriteriasByTimedType[criteria->timedType].push_back(criteria);
 
        ++loaded;
    }
 
    LOG_INFO("server.loading", ">> Loaded {} achievement criteria in {} ms", loaded, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References _achievementCriteriaListByAchievement, _achievementCriteriasByCondition, _achievementCriteriasByTimedType, _achievementCriteriasByType, _specialList, ACHIEVEMENT_CRITERIA_CONDITION_NONE, ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2, ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL, ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2, ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT, ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND, ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST, ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE, ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE, ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM, ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM, ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA, ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT, ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION, ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS, ACHIEVEMENT_CRITERIA_TYPE_HK_RACE, ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL_AT_AREA, ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE, ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE, ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL, ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE, ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS, ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL, ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM, ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE, ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM, ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL, ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT, ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM, ACHIEVEMENT_CRITERIA_TYPE_WIN_BG, AchievementCriteriaEntry::additionalRequirement_type, AchievementCriteriaEntry::additionalRequirement_value, AchievementCriteriaEntry::additionalRequirements, AchievementCriteriaEntry::areaID, AchievementCriteriaEntry::areaReference, WorldMapOverlayEntry::areatableID, AchievementCriteriaEntry::be_spell_target, AchievementCriteriaEntry::bg_objective, AchievementCriteriaEntry::bgMapID, AchievementCriteriaEntry::cast_spell, AchievementCriteriaEntry::classID, AchievementCriteriaEntry::complete_achievement, AchievementCriteriaEntry::complete_battleground, AchievementCriteriaEntry::complete_quest, AchievementCriteriaEntry::complete_quests_in_zone, AchievementCriteriaEntry::creatureEntry, AchievementCriteriaEntry::creatureID, AchievementCriteriaEntry::do_emote, AchievementCriteriaEntry::emoteID, AchievementCriteriaEntry::equip_epic_item, AchievementCriteriaEntry::equip_item, AchievementCriteriaEntry::explore_area, AchievementCriteriaEntry::factionID, AchievementCriteriaEntry::fish_in_gameobject, AchievementCriteriaEntry::gain_reputation, GetAchievement(), getMSTime(), GetMSTimeDiffToNow(), AchievementCriteriaEntry::goEntry, AchievementCriteriaEntry::hk_class, AchievementCriteriaEntry::hk_race, AchievementCriteriaEntry::honorable_kill_at_area, AchievementCriteriaEntry::ID, AchievementCriteriaEntry::itemID, AchievementCriteriaEntry::itemSlot, AchievementCriteriaEntry::kill_creature, AchievementCriteriaEntry::killed_by_creature, AchievementCriteriaEntry::learn_skill_level, AchievementCriteriaEntry::learn_skill_line, AchievementCriteriaEntry::learn_skillline_spell, AchievementCriteriaEntry::learn_spell, AchievementCriteriaEntry::linkedAchievement, LOG_DEBUG, LOG_INFO, LOG_WARN, AchievementCriteriaEntry::loot_type, AchievementCriteriaEntry::lootType, AchievementCriteriaEntry::mapID, MAX_WORLD_MAP_OVERLAY_AREA_IDX, AchievementCriteriaEntry::objectiveId, AchievementCriteriaEntry::own_item, AchievementCriteriaEntry::questID, AchievementCriteriaEntry::raceID, AchievementCriteriaEntry::reach_skill_level, AchievementCriteriaEntry::referredAchievement, AchievementCriteriaEntry::requiredType, sAchievementCriteriaStore, AchievementCriteriaEntry::skillID, AchievementCriteriaEntry::skillLine, AchievementCriteriaEntry::spellID, sWorldMapOverlayStore, AchievementCriteriaEntry::timedType, AchievementCriteriaEntry::timeLimit, AchievementCriteriaEntry::use_gameobject, AchievementCriteriaEntry::use_item, AchievementCriteriaEntry::win_bg, and AchievementCriteriaEntry::zoneID.

LoadAchievementReferenceList()

void AchievementGlobalMgr::LoadAchievementReferenceList

(

)

{
    uint32 oldMSTime = getMSTime();
 
    if (sAchievementStore.GetNumRows() == 0)
    {
        LOG_WARN("server.loading", ">> Loaded 0 achievement references.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
 
    for (uint32 entryId = 0; entryId < sAchievementStore.GetNumRows(); ++entryId)
    {
        AchievementEntry const* achievement = sAchievementStore.LookupEntry(entryId);
        if (!achievement || !achievement->refAchievement)
            continue;
 
        _achievementListByReferencedId[achievement->refAchievement].push_back(achievement);
        ++count;
    }
 
    LOG_INFO("server.loading", ">> Loaded {} achievement references in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References _achievementListByReferencedId, getMSTime(), GetMSTimeDiffToNow(), LOG_INFO, LOG_WARN, AchievementEntry::refAchievement, and sAchievementStore.

LoadCompletedAchievements()

void AchievementGlobalMgr::LoadCompletedAchievements

(

)

{
    uint32 oldMSTime = getMSTime();
 
    QueryResult result = CharacterDatabase.Query("SELECT achievement FROM character_achievement GROUP BY achievement");
 
    // Populate _allCompletedAchievements with all realm first achievement ids to make multithreaded access safer
    // while it will not prevent races, it will prevent crashes that happen because std::unordered_map key was added
    // instead the only potential race will happen on value associated with the key
    for (uint32 i = 0; i < sAchievementStore.GetNumRows(); ++i)
        if (AchievementEntry const* achievement = sAchievementStore.LookupEntry(i))
            if (achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_REACH | ACHIEVEMENT_FLAG_REALM_FIRST_KILL))
                _allCompletedAchievements[achievement->ID] = SystemTimePoint::min();
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 completed achievements. DB table `character_achievement` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    do
    {
        Field* fields = result->Fetch();
 
        uint16 achievementId = fields[0].Get<uint16>();
        const AchievementEntry* achievement = sAchievementStore.LookupEntry(achievementId);
        if (!achievement)
        {
            // Remove non existent achievements from all characters
            LOG_ERROR("achievement", "Non-existing achievement {} data removed from table `character_achievement`.", achievementId);
 
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_INVALID_ACHIEVMENT);
 
            stmt->SetData(0, uint16(achievementId));
            CharacterDatabase.Execute(stmt);
 
            continue;
        }
        else if (achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_REACH | ACHIEVEMENT_FLAG_REALM_FIRST_KILL))
            _allCompletedAchievements[achievementId] =  SystemTimePoint::max();
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} completed achievements in {} ms", (unsigned long)_allCompletedAchievements.size(), GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References _allCompletedAchievements, ACHIEVEMENT_FLAG_REALM_FIRST_KILL, ACHIEVEMENT_FLAG_REALM_FIRST_REACH, CHAR_DEL_INVALID_ACHIEVMENT, CharacterDatabase, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, sAchievementStore, and PreparedStatementBase::SetData().

LoadRewardLocales()

void AchievementGlobalMgr::LoadRewardLocales

(

)

{
    uint32 oldMSTime = getMSTime();
 
    _achievementRewardLocales.clear();                       // need for reload case
 
    //                                               0   1       2        3
    QueryResult result = WorldDatabase.Query("SELECT ID, Locale, Subject, Text FROM achievement_reward_locale");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 achievement reward locale strings.  DB table `achievement_reward_locale` is empty");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    do
    {
        Field* fields = result->Fetch();
 
        uint32 ID = fields[0].Get<uint32>();
        if (_achievementRewards.find(ID) == _achievementRewards.end())
        {
            LOG_ERROR("sql.sql", "Table `achievement_reward_locale` (Entry: {}) has locale strings for non-existing achievement reward.", ID);
            continue;
        }
 
        LocaleConstant locale = GetLocaleByName(fields[1].Get<std::string>());
        if (locale == LOCALE_enUS)
            continue;
 
        AchievementRewardLocale& data = _achievementRewardLocales[ID];
        ObjectMgr::AddLocaleString(fields[2].Get<std::string>(), locale, data.Subject);
        ObjectMgr::AddLocaleString(fields[3].Get<std::string>(), locale, data.Text);
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} Achievement Reward Locale Strings in {} ms", (unsigned long)_achievementRewardLocales.size(), GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References _achievementRewardLocales, _achievementRewards, ObjectMgr::AddLocaleString(), Field::Get(), GetLocaleByName(), getMSTime(), GetMSTimeDiffToNow(), LOCALE_enUS, LOG_ERROR, LOG_INFO, LOG_WARN, AchievementRewardLocale::Subject, AchievementRewardLocale::Text, and WorldDatabase.

LoadRewards()

void AchievementGlobalMgr::LoadRewards

(

)

{
    uint32 oldMSTime = getMSTime();
 
    _achievementRewards.clear();                           // need for reload case
 
    //                                               0      1        2        3     4       5        6     7
    QueryResult result = WorldDatabase.Query("SELECT ID, TitleA, TitleH, ItemID, Sender, Subject, Body, MailTemplateID FROM achievement_reward");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 achievement rewards. DB table `achievement_reward` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
 
    do
    {
        Field* fields = result->Fetch();
        uint32 entry = fields[0].Get<uint32>();
        AchievementEntry const* achievement = sAchievementStore.LookupEntry(entry);
        if (!achievement)
        {
            LOG_ERROR("sql.sql", "Table `achievement_reward` has wrong achievement (Entry: {}). Ignoring.", entry);
            continue;
        }
 
        AchievementReward reward;
        reward.titleId[0]   = fields[1].Get<uint32>(); // Alliance title
        reward.titleId[1]   = fields[2].Get<uint32>(); // Horde title
        reward.itemId       = fields[3].Get<uint32>();
        reward.sender       = fields[4].Get<uint32>(); // The sender of the mail (a creature from creature_template)
        reward.subject      = fields[5].Get<std::string>();
        reward.text         = fields[6].Get<std::string>(); // Body in DB
        reward.mailTemplate = fields[7].Get<uint32>();
 
        // Must reward a title or send a mail else, skip it.
        if (!reward.titleId[0] && !reward.titleId[1] && !reward.sender)
        {
            LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: {}) does not have any title or item reward data. Ignoring.", entry);
            continue;
        }
 
        if (achievement->requiredFaction == ACHIEVEMENT_FACTION_ANY && (!reward.titleId[0] ^ !reward.titleId[1]))
            LOG_DEBUG("achievement", "Table `achievement_reward` (Entry: {}) has title (A: {} H: {}) set for only one team.", entry, reward.titleId[0], reward.titleId[1]);
 
        if (reward.titleId[0])
        {
            CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(reward.titleId[0]);
            if (!titleEntry)
            {
                LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: {}) has invalid title id ({}) in `title_A`. Setting it to 0.", entry, reward.titleId[0]);
                reward.titleId[0] = 0;
            }
        }
 
        if (reward.titleId[1])
        {
            CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(reward.titleId[1]);
            if (!titleEntry)
            {
                LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: {}) has invalid title id ({}) in `title_H`. Setting it to 0.", entry, reward.titleId[1]);
                reward.titleId[1] = 0;
            }
        }
 
        // Check mail data before item for report including wrong item case
        if (reward.sender)
        {
            if (!sObjectMgr->GetCreatureTemplate(reward.sender))
            {
                LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: {}) has invalid creature_template entry {} as Sender. Will not send the mail reward.", entry, reward.sender);
                reward.sender = 0;
            }
        }
        else
        {
            if (reward.itemId)
                LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: {}) has itemId reward set but does not have Sender data set. Item will not be sent.", entry);
 
            if (!reward.subject.empty())
                LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: {}) has mail Subject but does not have Sender data set.", entry); // Maybe add "Mail will not be sent." ?
 
            if (!reward.text.empty())
                LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: {}) has mail text (Body) set but does not have Sender data set.", entry); // Maybe add "Mail will not be sent." ?
 
            if (reward.mailTemplate)
                LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: {}) has mailTemplate set does not have Sender data set.", entry); // Maybe add "Mail will not be sent." ?
        }
 
        if (reward.mailTemplate)
        {
            if (!sMailTemplateStore.LookupEntry(reward.mailTemplate))
            {
                LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: {}) has invalid mailTemplate ({}) (check the DBC).", entry, reward.mailTemplate);
                reward.mailTemplate = 0;
            }
            else if (!reward.subject.empty() || !reward.text.empty())
                LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: {}) has mailTemplate ({}) and mail Subject/Body. To use the column mailTemplate, Subject and Body must be empty.", entry, reward.mailTemplate);
        }
 
        if (reward.itemId)
        {
            if (!sObjectMgr->GetItemTemplate(reward.itemId))
            {
                // Not sure it's an error, it's probably an outDebug instead, because we can simply send a mail with no reward, right?
                LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: {}) has invalid item_template id {}. Reward mail will not contain any item.", entry, reward.itemId);
                reward.itemId = 0;
            }
        }
 
        _achievementRewards[entry] = reward;
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} achievement rewards in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References _achievementRewards, ACHIEVEMENT_FACTION_ANY, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), AchievementReward::itemId, LOG_DEBUG, LOG_ERROR, LOG_INFO, LOG_WARN, AchievementReward::mailTemplate, sAchievementStore, sCharTitlesStore, AchievementReward::sender, sMailTemplateStore, sObjectMgr, AchievementReward::subject, AchievementReward::text, AchievementReward::titleId, and WorldDatabase.

SetRealmCompleted()

void AchievementGlobalMgr::SetRealmCompleted

(

AchievementEntry const *

achievement

)

{
    if (IsRealmCompleted(achievement))
        return;
 
    _allCompletedAchievements[achievement->ID] = GameTime::GetSystemTime();
}

References _allCompletedAchievements, GameTime::GetSystemTime(), AchievementEntry::ID, and IsRealmCompleted().

UpdateAchievementCriteriaForOfflinePlayer()

void AchievementGlobalMgr::UpdateAchievementCriteriaForOfflinePlayer	(	ObjectGuid::LowType	playerLowGuid,
		AchievementCriteriaTypes	type,
		uint32	miscValue1 = 0,
		uint32	miscValue2 = 0
	)

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_ACHIEVEMENT_OFFLINE_UPDATES);
    stmt->SetData(0, playerLowGuid);
    stmt->SetData(1, ACHIEVEMENT_OFFLINE_PLAYER_UPDATE_TYPE_UPDATE_CRITERIA);
    stmt->SetData(2, type);
    stmt->SetData(3, miscValue1);
    stmt->SetData(4, miscValue2);
    CharacterDatabase.Execute(stmt);
}

References ACHIEVEMENT_OFFLINE_PLAYER_UPDATE_TYPE_UPDATE_CRITERIA, CHAR_INS_CHAR_ACHIEVEMENT_OFFLINE_UPDATES, CharacterDatabase, and PreparedStatementBase::SetData().

Member Data Documentation

_achievementCriteriaListByAchievement

AchievementCriteriaListByAchievement AchievementGlobalMgr::_achievementCriteriaListByAchievement

private

Referenced by GetAchievementCriteriaByAchievement(), and LoadAchievementCriteriaList().

_achievementCriteriasByCondition

std::map<uint32, AchievementCriteriaEntryList> AchievementGlobalMgr::_achievementCriteriasByCondition[ACHIEVEMENT_CRITERIA_CONDITION_TOTAL]

private

Referenced by GetAchievementCriteriaByCondition(), and LoadAchievementCriteriaList().

_achievementCriteriasByTimedType

AchievementCriteriaEntryList AchievementGlobalMgr::_achievementCriteriasByTimedType[ACHIEVEMENT_TIMED_TYPE_MAX]

private

Referenced by GetTimedAchievementCriteriaByType(), and LoadAchievementCriteriaList().

_achievementCriteriasByType

AchievementCriteriaEntryList AchievementGlobalMgr::_achievementCriteriasByType[ACHIEVEMENT_CRITERIA_TYPE_TOTAL]

private

Referenced by GetAchievementCriteriaByType(), and LoadAchievementCriteriaList().

_achievementListByReferencedId

AchievementListByReferencedId AchievementGlobalMgr::_achievementListByReferencedId

private

Referenced by GetAchievementByReferencedId(), and LoadAchievementReferenceList().

_achievementRewardLocales

AchievementRewardLocales AchievementGlobalMgr::_achievementRewardLocales

private

Referenced by GetAchievementRewardLocale(), and LoadRewardLocales().

_achievementRewards

AchievementRewards AchievementGlobalMgr::_achievementRewards

private

Referenced by GetAchievementReward(), LoadRewardLocales(), and LoadRewards().

_allCompletedAchievements

AllCompletedAchievements AchievementGlobalMgr::_allCompletedAchievements

private

Referenced by IsRealmCompleted(), LoadCompletedAchievements(), and SetRealmCompleted().

_criteriaDataMap

AchievementCriteriaDataMap AchievementGlobalMgr::_criteriaDataMap

private

Referenced by GetCriteriaDataSet(), and LoadAchievementCriteriaData().

_specialList

std::map<uint32, AchievementCriteriaEntryList> AchievementGlobalMgr::_specialList[ACHIEVEMENT_CRITERIA_TYPE_TOTAL]

private

Referenced by GetSpecialAchievementCriteriaByType(), and LoadAchievementCriteriaList().

---

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

• azerothcore-wotlk/src/server/game/Achievements/AchievementMgr.h
• azerothcore-wotlk/src/server/game/Achievements/AchievementMgr.cpp