#include "AchievementMgr.h"

Public Member Functions
	AchievementMgr (Player *player)

	~AchievementMgr ()

void	Reset ()

void	LoadFromDB (PreparedQueryResult achievementResult, PreparedQueryResult criteriaResult, PreparedQueryResult offlineUpdatesResult)

void	SaveToDB (CharacterDatabaseTransaction trans)

void	ResetAchievementCriteria (AchievementCriteriaCondition condition, uint32 value, bool evenIfCriteriaComplete=false)

void	UpdateAchievementCriteria (AchievementCriteriaTypes type, uint32 miscValue1=0, uint32 miscValue2=0, Unit *unit=nullptr)

void	CompletedAchievement (AchievementEntry const *entry)

void	CheckAllAchievementCriteria ()

void	SendAllAchievementData () const

void	SendRespondInspectAchievements (Player *player) const

bool	HasAchieved (uint32 achievementId) const

Player *	GetPlayer () const

void	Update (uint32 timeDiff)

void	StartTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry, uint32 timeLost=0)

void	RemoveTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry)

void	RemoveCriteriaProgress (AchievementCriteriaEntry const *entry)

CriteriaProgress *	GetCriteriaProgress (AchievementCriteriaEntry const *entry)

CompletedAchievementMap const &	GetCompletedAchievements ()

Static Public Member Functions
static void	DeleteFromDB (ObjectGuid::LowType lowguid)

Private Types
enum	ProgressType { PROGRESS_SET , PROGRESS_ACCUMULATE , PROGRESS_HIGHEST , PROGRESS_RESET }

typedef std::map< uint32, uint32 >	TimedAchievementMap

Private Member Functions
void	SendAchievementEarned (AchievementEntry const *achievement) const

void	SendCriteriaUpdate (AchievementCriteriaEntry const entry, CriteriaProgress const progress, uint32 timeElapsed, bool timedCompleted) const

void	SetCriteriaProgress (AchievementCriteriaEntry const *entry, uint32 changeValue, ProgressType ptype=PROGRESS_SET)

void	CompletedCriteriaFor (AchievementEntry const *achievement)

bool	IsCompletedCriteria (AchievementCriteriaEntry const achievementCriteria, AchievementEntry const achievement)

bool	IsCompletedAchievement (AchievementEntry const *entry)

bool	CanUpdateCriteria (AchievementCriteriaEntry const criteria, AchievementEntry const achievement)

void	BuildAllDataPacket (WorldPacket *data) const

void	UpdateTimedAchievements (uint32 timeDiff)

void	ProcessOfflineUpdate (AchievementOfflinePlayerUpdate const &update)

void	ProcessOfflineUpdatesQueue ()

Private Attributes
Player *	_player

CriteriaProgressMap	_criteriaProgress

CompletedAchievementMap	_completedAchievements

TimedAchievementMap	_timedAchievements

uint32	_offlineUpdatesDelayTimer

std::vector< AchievementOfflinePlayerUpdate >	_offlineUpdatesQueue

Detailed Description

Member Typedef Documentation

◆ TimedAchievementMap

typedef std::map<uint32, uint32> AchievementMgr::TimedAchievementMap

private

Member Enumeration Documentation

◆ ProgressType

enum AchievementMgr::ProgressType

private

Enumerator
PROGRESS_SET
PROGRESS_ACCUMULATE
PROGRESS_HIGHEST
PROGRESS_RESET

321{ PROGRESS_SET, PROGRESS_ACCUMULATE, PROGRESS_HIGHEST, PROGRESS_RESET };

AchievementMgr::PROGRESS_SET

@ PROGRESS_SET

Definition: AchievementMgr.h:321

AchievementMgr::PROGRESS_HIGHEST

@ PROGRESS_HIGHEST

Definition: AchievementMgr.h:321

AchievementMgr::PROGRESS_ACCUMULATE

@ PROGRESS_ACCUMULATE

Definition: AchievementMgr.h:321

AchievementMgr::PROGRESS_RESET

@ PROGRESS_RESET

Definition: AchievementMgr.h:321

Constructor & Destructor Documentation

◆ AchievementMgr()

AchievementMgr::AchievementMgr ( Player * player )

{
    _player = player;
    _offlineUpdatesDelayTimer = 0;
}

References _offlineUpdatesDelayTimer, and _player.

◆ ~AchievementMgr()

AchievementMgr::~AchievementMgr ( )

488{

489}

Member Function Documentation

◆ BuildAllDataPacket()

void AchievementMgr::BuildAllDataPacket ( WorldPacket * data ) const

private

used by SMSG_RESPOND_INSPECT_ACHIEVEMENT and SMSG_ALL_ACHIEVEMENT_DATA

Todo:: : This should be 1 if it is a failed timed criteria

{
    for (CompletedAchievementMap::const_iterator iter = _completedAchievements.begin(); iter != _completedAchievements.end(); ++iter)
    {
        // Skip hidden achievements
        AchievementEntry const* achievement = sAchievementStore.LookupEntry(iter->first);
        if (!achievement || achievement->flags & ACHIEVEMENT_FLAG_HIDDEN)
            continue;
 
        *data << uint32(iter->first);
        data->AppendPackedTime(iter->second.date);
    }
 
    *data << int32(-1);
    time_t now = GameTime::GetGameTime().count();
 
    for (CriteriaProgressMap::const_iterator iter = _criteriaProgress.begin(); iter != _criteriaProgress.end(); ++iter)
    {
        *data << uint32(iter->first);
        data->appendPackGUID(iter->second.counter);
        *data << GetPlayer()->GetPackGUID();
        *data << uint32(0); 
        data->AppendPackedTime(iter->second.date);
        *data << uint32(now - iter->second.date);
 
        if (sAchievementMgr->IsAverageCriteria(sAchievementCriteriaStore.LookupEntry(iter->first)))
            *data << uint32(now - GetPlayer()->GetCreationTime().count());    // for average achievements
        else
            *data << uint32(now - iter->second.date);
    }
 
    *data << int32(-1);
}

References _completedAchievements, _criteriaProgress, ACHIEVEMENT_FLAG_HIDDEN, ByteBuffer::AppendPackedTime(), ByteBuffer::appendPackGUID(), AchievementEntry::flags, GameTime::GetGameTime(), Object::GetPackGUID(), GetPlayer(), sAchievementCriteriaStore, sAchievementMgr, and sAchievementStore.

Referenced by SendAllAchievementData(), and SendRespondInspectAchievements().

◆ CanUpdateCriteria()

bool AchievementMgr::CanUpdateCriteria	(	AchievementCriteriaEntry const *	criteria,
		AchievementEntry const *	achievement
	)

private

{
    if (DisableMgr::IsDisabledFor(DISABLE_TYPE_ACHIEVEMENT_CRITERIA, criteria->ID, nullptr))
        return false;
 
    if (achievement->mapID != -1 && GetPlayer()->GetMapId() != uint32(achievement->mapID))
        return false;
 
    if ((achievement->requiredFaction == ACHIEVEMENT_FACTION_HORDE    && GetPlayer()->GetTeamId(true) != TEAM_HORDE) ||
            (achievement->requiredFaction == ACHIEVEMENT_FACTION_ALLIANCE && GetPlayer()->GetTeamId(true) != TEAM_ALLIANCE))
        return false;
 
    for (uint32 i = 0; i < MAX_CRITERIA_REQUIREMENTS; ++i)
    {
        if (!criteria->additionalRequirements[i].additionalRequirement_type)
            continue;
 
        switch (criteria->additionalRequirements[i].additionalRequirement_type)
        {
            case ACHIEVEMENT_CRITERIA_CONDITION_BG_MAP:
                if (GetPlayer()->GetMapId() != criteria->additionalRequirements[i].additionalRequirement_value)
                    return false;
                break;
            case ACHIEVEMENT_CRITERIA_CONDITION_NOT_IN_GROUP:
                if (GetPlayer()->GetGroup())
                    return false;
                break;
            default:
                break;
        }
    }
 
    // don't update already completed criteria
    if (IsCompletedCriteria(criteria, achievement))
        return false;
 
    return true;
}

References ACHIEVEMENT_CRITERIA_CONDITION_BG_MAP, ACHIEVEMENT_CRITERIA_CONDITION_NOT_IN_GROUP, ACHIEVEMENT_FACTION_ALLIANCE, ACHIEVEMENT_FACTION_HORDE, AchievementCriteriaEntry::additionalRequirement_type, AchievementCriteriaEntry::additionalRequirement_value, AchievementCriteriaEntry::additionalRequirements, DISABLE_TYPE_ACHIEVEMENT_CRITERIA, GetPlayer(), GetTeamId(), AchievementCriteriaEntry::ID, IsCompletedCriteria(), DisableMgr::IsDisabledFor(), AchievementEntry::mapID, MAX_CRITERIA_REQUIREMENTS, AchievementEntry::requiredFaction, TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by UpdateAchievementCriteria().

◆ CheckAllAchievementCriteria()

void AchievementMgr::CheckAllAchievementCriteria ( )

called at player login. The player might have fulfilled some achievements when the achievement system wasn't working yet.

{
    // suppress sending packets
    for (uint32 i = 0; i < ACHIEVEMENT_CRITERIA_TYPE_TOTAL; ++i)
        UpdateAchievementCriteria(AchievementCriteriaTypes(i));
}

References ACHIEVEMENT_CRITERIA_TYPE_TOTAL, and UpdateAchievementCriteria().

Referenced by Player::CheckAllAchievementCriteria(), and Reset().

◆ CompletedAchievement()

void AchievementMgr::CompletedAchievement ( AchievementEntry const * entry )

Currently there's only one achievement that deals with gender-specific titles. Since no common attributes were found, (not even in titleRewardFlags field) we explicitly check by ID. Maybe in the future we could move the achievement_reward condition fields to the condition system.

{
    // disable for gamemasters with GM-mode enabled
    if (_player->IsGameMaster())
    {
        LOG_INFO("achievement", "Not available in GM mode.");
        ChatHandler(_player->GetSession()).PSendSysMessage("Not available in GM mode");
        return;
    }
 
    if (!sScriptMgr->OnBeforeAchievementComplete(GetPlayer(), achievement))
    {
        return;
    }
 
    if (achievement->flags & ACHIEVEMENT_FLAG_COUNTER || HasAchieved(achievement->ID))
        return;
 
    LOG_DEBUG("achievement", "AchievementMgr::CompletedAchievement({})", achievement->ID);
 
    SendAchievementEarned(achievement);
    CompletedAchievementData& ca = _completedAchievements[achievement->ID];
    ca.date = GameTime::GetGameTime().count();
    ca.changed = true;
 
    sScriptMgr->OnAchievementComplete(GetPlayer(), achievement);
 
    // pussywizard: set all progress counters to 0, so progress will be deleted from db during save
    {
        bool allRefsCompleted = true;
        uint32 achiCheckId = achievement->refAchievement ? achievement->refAchievement : achievement->ID;
 
        if (AchievementEntryList const* achRefList = sAchievementMgr->GetAchievementByReferencedId(achiCheckId))
            for (AchievementEntryList::const_iterator itr = achRefList->begin(); itr != achRefList->end(); ++itr)
                if (!IsCompletedAchievement(*itr))
                {
                    allRefsCompleted = false;
                    break;
                }
 
        if (allRefsCompleted)
            if (AchievementCriteriaEntryList const* cList = sAchievementMgr->GetAchievementCriteriaByAchievement(achiCheckId))
                for (AchievementCriteriaEntryList::const_iterator itr = cList->begin(); itr != cList->end(); ++itr)
                    if (CriteriaProgress* progress = GetCriteriaProgress(*itr))
                    {
                        progress->changed = true;
                        progress->counter = 0;
                    }
    }
 
    if (achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_REACH | ACHIEVEMENT_FLAG_REALM_FIRST_KILL) && AccountMgr::IsPlayerAccount(_player->GetSession()->GetSecurity()))
        sAchievementMgr->SetRealmCompleted(achievement);
 
    UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT, achievement->ID);
    UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_EARN_ACHIEVEMENT_POINTS, achievement->points);
 
    // reward items and titles if any
    AchievementReward const* reward = sAchievementMgr->GetAchievementReward(achievement);
 
    // no rewards
    if (!reward)
        return;
 
    // titles
    if (uint32 titleId = reward->titleId[achievement->ID == 1793 ? GetPlayer()->getGender() : uint8(GetPlayer()->GetTeamId())])
        if (CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(titleId))
            GetPlayer()->SetTitle(titleEntry);
 
    // mail
    if (reward->sender)
    {
        MailDraft draft(reward->mailTemplate);
 
        if (!reward->mailTemplate)
        {
            std::string subject = reward->subject;
            std::string text = reward->text;
 
            LocaleConstant localeConstant = GetPlayer()->GetSession()->GetSessionDbLocaleIndex();
            if (localeConstant != LOCALE_enUS)
            {
                if (AchievementRewardLocale const* loc = sAchievementMgr->GetAchievementRewardLocale(achievement))
                {
                    ObjectMgr::GetLocaleString(loc->Subject, localeConstant, subject);
                    ObjectMgr::GetLocaleString(loc->Text, localeConstant, text);
                }
            }
 
            draft = MailDraft(subject, text);
        }
 
        CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
        Item* item = reward->itemId ? Item::CreateItem(reward->itemId, 1, GetPlayer()) : nullptr;
        if (item)
        {
            // save new item before send
            item->SaveToDB(trans);                               // save for prevent lost at next mail load, if send fail then item will deleted
 
            // item
            draft.AddItem(item);
        }
 
        draft.SendMailTo(trans, GetPlayer(), MailSender(MAIL_CREATURE, reward->sender));
        CharacterDatabase.CommitTransaction(trans);
    }
}

References _completedAchievements, _player, ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT, ACHIEVEMENT_CRITERIA_TYPE_EARN_ACHIEVEMENT_POINTS, ACHIEVEMENT_FLAG_COUNTER, ACHIEVEMENT_FLAG_REALM_FIRST_KILL, ACHIEVEMENT_FLAG_REALM_FIRST_REACH, MailDraft::AddItem(), CompletedAchievementData::changed, CharacterDatabase, Item::CreateItem(), CompletedAchievementData::date, AchievementEntry::flags, GetCriteriaProgress(), GameTime::GetGameTime(), ObjectMgr::GetLocaleString(), GetPlayer(), WorldSession::GetSecurity(), Player::GetSession(), WorldSession::GetSessionDbLocaleIndex(), GetTeamId(), HasAchieved(), AchievementEntry::ID, IsCompletedAchievement(), Player::IsGameMaster(), AccountMgr::IsPlayerAccount(), AchievementReward::itemId, LOCALE_enUS, LOG_DEBUG, LOG_INFO, MAIL_CREATURE, AchievementReward::mailTemplate, AchievementEntry::points, ChatHandler::PSendSysMessage(), AchievementEntry::refAchievement, sAchievementMgr, Item::SaveToDB(), sCharTitlesStore, SendAchievementEarned(), AchievementReward::sender, MailDraft::SendMailTo(), Player::SetTitle(), sScriptMgr, AchievementReward::subject, AchievementReward::text, AchievementReward::titleId, and UpdateAchievementCriteria().

Referenced by Player::CompletedAchievement(), CompletedCriteriaFor(), ProcessOfflineUpdate(), and UpdateAchievementCriteria().

◆ CompletedCriteriaFor()

void AchievementMgr::CompletedCriteriaFor ( AchievementEntry const * achievement )

private

{
    // counter can never complete
    if (achievement->flags & ACHIEVEMENT_FLAG_COUNTER)
        return;
 
    // already completed and stored
    if (HasAchieved(achievement->ID))
        return;
 
    if (IsCompletedAchievement(achievement))
        CompletedAchievement(achievement);
}

References ACHIEVEMENT_FLAG_COUNTER, CompletedAchievement(), AchievementEntry::flags, HasAchieved(), AchievementEntry::ID, and IsCompletedAchievement().

Referenced by UpdateAchievementCriteria().

◆ DeleteFromDB()

void AchievementMgr::DeleteFromDB ( ObjectGuid::LowType lowguid )

static

{
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_ACHIEVEMENT);
    stmt->SetData(0, lowguid);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_ACHIEVEMENT_PROGRESS);
    stmt->SetData(0, lowguid);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_ACHIEVEMENT_OFFLINE_UPDATES);
    stmt->SetData(0, lowguid);
    trans->Append(stmt);
 
    CharacterDatabase.CommitTransaction(trans);
}

References CHAR_DEL_CHAR_ACHIEVEMENT, CHAR_DEL_CHAR_ACHIEVEMENT_OFFLINE_UPDATES, CHAR_DEL_CHAR_ACHIEVEMENT_PROGRESS, CharacterDatabase, and PreparedStatementBase::SetData().

Referenced by reset_commandscript::HandleResetAchievementsCommand(), and Reset().

◆ GetCompletedAchievements()

CompletedAchievementMap const & AchievementMgr::GetCompletedAchievements ( )

{
    return _completedAchievements;
}

References _completedAchievements.

◆ GetCriteriaProgress()

CriteriaProgress * AchievementMgr::GetCriteriaProgress ( AchievementCriteriaEntry const * entry )

{
    CriteriaProgressMap::iterator iter = _criteriaProgress.find(entry->ID);
 
    if (iter == _criteriaProgress.end())
        return nullptr;
 
    return &(iter->second);
}

References _criteriaProgress, and AchievementCriteriaEntry::ID.

Referenced by CompletedAchievement(), IsCompletedAchievement(), IsCompletedCriteria(), SetCriteriaProgress(), and UpdateAchievementCriteria().

◆ GetPlayer()

Player * AchievementMgr::GetPlayer ( ) const

inline

310{ return _player; }

References _player.

Referenced by BuildAllDataPacket(), CanUpdateCriteria(), CompletedAchievement(), LoadFromDB(), ProcessOfflineUpdate(), ProcessOfflineUpdatesQueue(), SaveToDB(), SendAchievementEarned(), SendAllAchievementData(), SendCriteriaUpdate(), SendRespondInspectAchievements(), SetCriteriaProgress(), and UpdateAchievementCriteria().

◆ HasAchieved()

bool AchievementMgr::HasAchieved ( uint32 achievementId ) const

{
    return _completedAchievements.find(achievementId) != _completedAchievements.end();
}

References _completedAchievements.

Referenced by CompletedAchievement(), CompletedCriteriaFor(), Player::HasAchieved(), IsCompletedCriteria(), ResetAchievementCriteria(), and UpdateAchievementCriteria().

◆ IsCompletedAchievement()

bool AchievementMgr::IsCompletedAchievement ( AchievementEntry const * entry )

private

{
    // counter can never complete
    if (entry->flags & ACHIEVEMENT_FLAG_COUNTER)
        return false;
 
    // for achievement with referenced achievement criterias get from referenced and counter from self
    uint32 achievmentForTestId = entry->refAchievement ? entry->refAchievement : entry->ID;
    uint32 achievmentForTestCount = entry->count;
 
    AchievementCriteriaEntryList const* cList = sAchievementMgr->GetAchievementCriteriaByAchievement(achievmentForTestId);
    if (!cList)
        return false;
    uint32 count = 0;
 
    // For SUMM achievements, we have to count the progress of each criteria of the achievement.
    // Oddly, the target count is NOT countained in the achievement, but in each individual criteria
    if (entry->flags & ACHIEVEMENT_FLAG_SUMM)
    {
        for (AchievementCriteriaEntryList::const_iterator itr = cList->begin(); itr != cList->end(); ++itr)
        {
            AchievementCriteriaEntry const* criteria = *itr;
 
            CriteriaProgress const* progress = GetCriteriaProgress(criteria);
            if (!progress)
                continue;
 
            count += progress->counter;
 
            // for counters, field4 contains the main count requirement
            if (count >= criteria->raw.count)
                return true;
        }
        return false;
    }
 
    // Default case - need complete all or
    bool completed_all = true;
    for (AchievementCriteriaEntryList::const_iterator itr = cList->begin(); itr != cList->end(); ++itr)
    {
        AchievementCriteriaEntry const* criteria = *itr;
 
        bool completed = IsCompletedCriteria(criteria, entry);
 
        // found an uncompleted criteria, but DONT return false yet - there might be a completed criteria with ACHIEVEMENT_CRITERIA_COMPLETE_FLAG_ALL
        if (completed)
            ++count;
        else
            completed_all = false;
 
        // completed as have req. count of completed criterias
        if (achievmentForTestCount > 0 && achievmentForTestCount <= count)
            return true;
    }
 
    // all criterias completed requirement
    if (completed_all && achievmentForTestCount == 0)
        return true;
 
    return false;
}

References ACHIEVEMENT_FLAG_COUNTER, ACHIEVEMENT_FLAG_SUMM, AchievementEntry::count, AchievementCriteriaEntry::count, CriteriaProgress::counter, AchievementEntry::flags, GetCriteriaProgress(), AchievementEntry::ID, IsCompletedCriteria(), AchievementCriteriaEntry::raw, AchievementEntry::refAchievement, and sAchievementMgr.

Referenced by CompletedAchievement(), CompletedCriteriaFor(), IsCompletedCriteria(), and UpdateAchievementCriteria().

◆ IsCompletedCriteria()

bool AchievementMgr::IsCompletedCriteria	(	AchievementCriteriaEntry const *	achievementCriteria,
		AchievementEntry const *	achievement
	)

private

{
    // counter can never complete
    if (achievement->flags & ACHIEVEMENT_FLAG_COUNTER)
        return false;
 
    if (achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_REACH | ACHIEVEMENT_FLAG_REALM_FIRST_KILL))
    {
        // someone on this realm has already completed that achievement
        if (sAchievementMgr->IsRealmCompleted(achievement))
            return false;
    }
 
    // pussywizard: progress will be deleted after getting the achievement (optimization)
    // finished achievement should indicate criteria completed, since not finding progress would start some timed achievements and probably other things
    if (HasAchieved(achievement->ID))
    {
        bool completed = true;
 
        // completed only after all referenced achievements are also completed
        if (AchievementEntryList const* achRefList = sAchievementMgr->GetAchievementByReferencedId(achievement->ID))
            for (AchievementEntryList::const_iterator itr = achRefList->begin(); itr != achRefList->end(); ++itr)
                if (!IsCompletedAchievement(*itr))
                {
                    completed = false;
                    break;
                }
 
        if (completed)
            return true;
    }
 
    CriteriaProgress const* progress = GetCriteriaProgress(achievementCriteria);
    if (!progress)
        return false;
 
    if (!sScriptMgr->IsCompletedCriteria(this, achievementCriteria, achievement, progress))
        return false;
 
    switch (achievementCriteria->requiredType)
    {
        case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG:
            return progress->counter >= achievementCriteria->win_bg.winCount;
        case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
            return progress->counter >= achievementCriteria->kill_creature.creatureCount;
        case ACHIEVEMENT_CRITERIA_TYPE_REACH_LEVEL:
            return progress->counter >= achievementCriteria->reach_level.level;
        case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL:
            return progress->counter >= achievementCriteria->reach_skill_level.skillLevel;
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT:
            return progress->counter >= 1;
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST_COUNT:
            return progress->counter >= achievementCriteria->complete_quest_count.totalQuestCount;
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST_DAILY:
            return progress->counter >= achievementCriteria->complete_daily_quest_daily.numberOfDays;
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
            return progress->counter >= achievementCriteria->complete_quests_in_zone.questCount;
        case ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE:
        case ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE:
            return progress->counter >= achievementCriteria->healing_done.count;
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST:
            return progress->counter >= achievementCriteria->complete_daily_quest.questCount;
        case ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING:
            return progress->counter >= achievementCriteria->fall_without_dying.fallHeight;
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
            return progress->counter >= 1;
        case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
        case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
            return progress->counter >= achievementCriteria->be_spell_target.spellCount;
        case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
        case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
            return progress->counter >= achievementCriteria->cast_spell.castCount;
        case ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE:
            return progress->counter >= achievementCriteria->bg_objective.completeCount;
        case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL_AT_AREA:
            return progress->counter >= achievementCriteria->honorable_kill_at_area.killCount;
        case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL:
            return progress->counter >= 1;
        case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL:
        case ACHIEVEMENT_CRITERIA_TYPE_EARN_HONORABLE_KILL:
            return progress->counter >= achievementCriteria->honorable_kill.killCount;
        case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM:
            return progress->counter >= achievementCriteria->own_item.itemCount;
        case ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA:
            return progress->counter >= achievementCriteria->win_rated_arena.count;
        case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_PERSONAL_RATING:
            return progress->counter >= achievementCriteria->highest_personal_rating.PersonalRating;
        case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL:
            return progress->counter >= (achievementCriteria->learn_skill_level.skillLevel * 75);
        case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:
            return progress->counter >= achievementCriteria->use_item.itemCount;
        case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM:
            return progress->counter >= achievementCriteria->loot_item.itemCount;
        case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA:
            return progress->counter >= 1;
        case ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT:
            return progress->counter >= achievementCriteria->buy_bank_slot.numberOfSlots;
        case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
            return progress->counter >= achievementCriteria->gain_reputation.reputationAmount;
        case ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION:
            return progress->counter >= achievementCriteria->gain_exalted_reputation.numberOfExaltedFactions;
        case ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP:
            return progress->counter >= achievementCriteria->visit_barber.numberOfVisits;
        case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM:
            return progress->counter >= achievementCriteria->equip_epic_item.count;
        case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT:
        case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT:
            return progress->counter >= achievementCriteria->roll_greed_on_loot.count;
        case ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS:
            return progress->counter >= achievementCriteria->hk_class.count;
        case ACHIEVEMENT_CRITERIA_TYPE_HK_RACE:
            return progress->counter >= achievementCriteria->hk_race.count;
        case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
            return progress->counter >= achievementCriteria->do_emote.count;
        case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM:
            return progress->counter >= achievementCriteria->equip_item.count;
        case ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_QUEST_REWARD:
            return progress->counter >= achievementCriteria->quest_reward_money.goldInCopper;
        case ACHIEVEMENT_CRITERIA_TYPE_LOOT_MONEY:
            return progress->counter >= achievementCriteria->loot_money.goldInCopper;
        case ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT:
            return progress->counter >= achievementCriteria->use_gameobject.useCount;
        case ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL:
            return progress->counter >= achievementCriteria->special_pvp_kill.killCount;
        case ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT:
            return progress->counter >= achievementCriteria->fish_in_gameobject.lootCount;
        case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
            return progress->counter >= achievementCriteria->learn_skillline_spell.spellCount;
        case ACHIEVEMENT_CRITERIA_TYPE_WIN_DUEL:
            return progress->counter >= achievementCriteria->win_duel.duelCount;
        case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:
            return progress->counter >= achievementCriteria->loot_type.lootTypeCount;
        case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE:
            return progress->counter >= achievementCriteria->learn_skill_line.spellCount;
        case ACHIEVEMENT_CRITERIA_TYPE_EARN_ACHIEVEMENT_POINTS:
            return progress->counter >= 9000;
        case ACHIEVEMENT_CRITERIA_TYPE_USE_LFD_TO_GROUP_WITH_PLAYERS:
            return progress->counter >= achievementCriteria->use_lfg.dungeonsComplete;
        case ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS:
            return progress->counter >= achievementCriteria->get_killing_blow.killCount;
        case ACHIEVEMENT_CRITERIA_TYPE_ON_LOGIN:
            return true;
        case ACHIEVEMENT_CRITERIA_TYPE_WIN_ARENA:
            return achievementCriteria->win_arena.count && progress->counter >= achievementCriteria->win_arena.count;
        case ACHIEVEMENT_CRITERIA_TYPE_OWN_RANK:
            return true;
        // handle all statistic-only criteria here
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND:
        case ACHIEVEMENT_CRITERIA_TYPE_DEATH_AT_MAP:
        case ACHIEVEMENT_CRITERIA_TYPE_DEATH:
        case ACHIEVEMENT_CRITERIA_TYPE_DEATH_IN_DUNGEON:
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_RAID:
        case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE:
        case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_PLAYER:
        case ACHIEVEMENT_CRITERIA_TYPE_DEATHS_FROM:
        case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_TEAM_RATING:
        case ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_VENDORS:
        case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_TALENTS:
        case ACHIEVEMENT_CRITERIA_TYPE_NUMBER_OF_TALENT_RESETS:
        case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_AT_BARBER:
        case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_MAIL:
        case ACHIEVEMENT_CRITERIA_TYPE_LOSE_DUEL:
        case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE_TYPE:
        case ACHIEVEMENT_CRITERIA_TYPE_GOLD_EARNED_BY_AUCTIONS:
        case ACHIEVEMENT_CRITERIA_TYPE_CREATE_AUCTION:
        case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID:
        case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_SOLD:
        case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_GOLD_VALUE_OWNED:
        case ACHIEVEMENT_CRITERIA_TYPE_WON_AUCTIONS:
        case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REVERED_REPUTATION:
        case ACHIEVEMENT_CRITERIA_TYPE_GAIN_HONORED_REPUTATION:
        case ACHIEVEMENT_CRITERIA_TYPE_KNOWN_FACTIONS:
        case ACHIEVEMENT_CRITERIA_TYPE_LOOT_EPIC_ITEM:
        case ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM:
        case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED:
        case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED:
        case ACHIEVEMENT_CRITERIA_TYPE_ROLL_DISENCHANT:
        case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALTH:
        case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_SPELLPOWER:
        case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_ARMOR:
        case ACHIEVEMENT_CRITERIA_TYPE_QUEST_ABANDONED:
        case ACHIEVEMENT_CRITERIA_TYPE_FLIGHT_PATHS_TAKEN:
        case ACHIEVEMENT_CRITERIA_TYPE_ACCEPTED_SUMMONINGS:
        case ACHIEVEMENT_CRITERIA_TYPE_PLAY_ARENA:
        default:
            break;
    }
    return false;
}

Referenced by CanUpdateCriteria(), IsCompletedAchievement(), ResetAchievementCriteria(), SetCriteriaProgress(), StartTimedAchievement(), and UpdateAchievementCriteria().

◆ LoadFromDB()

void AchievementMgr::LoadFromDB	(	PreparedQueryResult	achievementResult,
		PreparedQueryResult	criteriaResult,
		PreparedQueryResult	offlineUpdatesResult
	)

{
    if (achievementResult)
    {
        do
        {
            Field* fields = achievementResult->Fetch();
            uint32 achievementid = fields[0].Get<uint16>();
 
            // must not happen: cleanup at server startup in sAchievementMgr->LoadCompletedAchievements()
            AchievementEntry const* achievement = sAchievementStore.LookupEntry(achievementid);
            if (!achievement)
                continue;
 
            CompletedAchievementData& ca = _completedAchievements[achievementid];
            ca.date = time_t(fields[1].Get<uint32>());
            ca.changed = false;
 
            // title achievement rewards are retroactive
            if (AchievementReward const* reward = sAchievementMgr->GetAchievementReward(achievement))
                if (uint32 titleId = reward->titleId[Player::TeamIdForRace(GetPlayer()->getRace())])
                    if (CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(titleId))
                        if (!GetPlayer()->HasTitle(titleEntry))
                            GetPlayer()->SetTitle(titleEntry);
        } while (achievementResult->NextRow());
    }
 
    if (criteriaResult)
    {
        do
        {
            Field* fields = criteriaResult->Fetch();
            uint32 id      = fields[0].Get<uint16>();
            uint32 counter = fields[1].Get<uint32>();
            time_t date    = time_t(fields[2].Get<uint32>());
 
            AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(id);
            if (!criteria)
            {
                // we will remove not existed criteria for all characters
                LOG_ERROR("achievement", "Non-existing achievement criteria {} data removed from table `character_achievement_progress`.", id);
 
                CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_INVALID_ACHIEV_PROGRESS_CRITERIA);
 
                stmt->SetData(0, uint16(id));
 
                CharacterDatabase.Execute(stmt);
 
                continue;
            }
 
            if (criteria->timeLimit && time_t(date + criteria->timeLimit) < GameTime::GetGameTime().count())
                continue;
 
            CriteriaProgress& progress = _criteriaProgress[id];
            progress.counter = counter;
            progress.date    = date;
            progress.changed = false;
        } while (criteriaResult->NextRow());
    }
 
    if (offlineUpdatesResult)
    {
        uint32 count = 0;
        do
        {
            Field* fields = offlineUpdatesResult->Fetch();
 
            AchievementOfflinePlayerUpdate update;
            update.updateType = static_cast<AchievementOfflinePlayerUpdateType>(fields[0].Get<uint8>());
            update.arg1       = fields[1].Get<uint32>();
            update.arg2       = fields[2].Get<uint32>();
            update.arg3       = fields[3].Get<uint32>();
 
            _offlineUpdatesQueue.push_back(update);
 
            ++count;
        } while (offlineUpdatesResult->NextRow());
 
        if (count > 0)
            _offlineUpdatesDelayTimer = 5 * SECOND * IN_MILLISECONDS;
    }
}

References _completedAchievements, _criteriaProgress, _offlineUpdatesDelayTimer, _offlineUpdatesQueue, AchievementOfflinePlayerUpdate::arg1, AchievementOfflinePlayerUpdate::arg2, AchievementOfflinePlayerUpdate::arg3, CriteriaProgress::changed, CompletedAchievementData::changed, CHAR_DEL_INVALID_ACHIEV_PROGRESS_CRITERIA, CharacterDatabase, CriteriaProgress::counter, CriteriaProgress::date, CompletedAchievementData::date, Field::Get(), GameTime::GetGameTime(), GetPlayer(), IN_MILLISECONDS, LOG_ERROR, sAchievementCriteriaStore, sAchievementMgr, sAchievementStore, sCharTitlesStore, SECOND, PreparedStatementBase::SetData(), Player::SetTitle(), Player::TeamIdForRace(), AchievementCriteriaEntry::timeLimit, and AchievementOfflinePlayerUpdate::updateType.

Referenced by Player::LoadFromDB().

◆ ProcessOfflineUpdate()

void AchievementMgr::ProcessOfflineUpdate ( AchievementOfflinePlayerUpdate const & update )

private

{
    switch (update.updateType)
    {
        case ACHIEVEMENT_OFFLINE_PLAYER_UPDATE_TYPE_COMPLETE_ACHIEVEMENT:
        {
            AchievementEntry const* achievement = sAchievementStore.LookupEntry(update.arg1);
 
            ASSERT(achievement, "Not found achievement to complete for offline achievements update. Wrong arg1 ({}) value?", update.arg1);
 
            CompletedAchievement(achievement);
            break;
        }
        case ACHIEVEMENT_OFFLINE_PLAYER_UPDATE_TYPE_UPDATE_CRITERIA:
        {
            AchievementCriteriaTypes criteriaType = static_cast<AchievementCriteriaTypes>(update.arg1);
            UpdateAchievementCriteria(criteriaType, update.arg2, update.arg3);
            break;
        }
        default:
            ASSERT(false, "Unknown offline achievement update type ({}) for player - {}", update.updateType, GetPlayer()->GetGUID().GetCounter());
            break;
    }
}

References ACHIEVEMENT_OFFLINE_PLAYER_UPDATE_TYPE_COMPLETE_ACHIEVEMENT, ACHIEVEMENT_OFFLINE_PLAYER_UPDATE_TYPE_UPDATE_CRITERIA, AchievementOfflinePlayerUpdate::arg1, AchievementOfflinePlayerUpdate::arg2, AchievementOfflinePlayerUpdate::arg3, ASSERT, CompletedAchievement(), GetPlayer(), sAchievementStore, UpdateAchievementCriteria(), and AchievementOfflinePlayerUpdate::updateType.

Referenced by ProcessOfflineUpdatesQueue().

◆ ProcessOfflineUpdatesQueue()

void AchievementMgr::ProcessOfflineUpdatesQueue ( )

private

{
    if (_offlineUpdatesQueue.empty())
        return;
 
    for (auto const& update : _offlineUpdatesQueue)
        ProcessOfflineUpdate(update);
 
    _offlineUpdatesQueue.clear();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_ACHIEVEMENT_OFFLINE_UPDATES);
    stmt->SetData(0, GetPlayer()->GetGUID().GetCounter());
    CharacterDatabase.Execute(stmt);
}

References _offlineUpdatesQueue, CHAR_DEL_CHAR_ACHIEVEMENT_OFFLINE_UPDATES, CharacterDatabase, GetPlayer(), ProcessOfflineUpdate(), and PreparedStatementBase::SetData().

Referenced by Update().

◆ RemoveCriteriaProgress()

void AchievementMgr::RemoveCriteriaProgress ( AchievementCriteriaEntry const * entry )

{
    CriteriaProgressMap::iterator criteriaProgress = _criteriaProgress.find(entry->ID);
    if (criteriaProgress == _criteriaProgress.end())
        return;
 
    WorldPacket data(SMSG_CRITERIA_DELETED, 4);
    data << uint32(entry->ID);
    _player->SendDirectMessage(&data);
 
    _criteriaProgress.erase(criteriaProgress);
}

References _criteriaProgress, _player, AchievementCriteriaEntry::ID, Player::SendDirectMessage(), and SMSG_CRITERIA_DELETED.

Referenced by RemoveTimedAchievement(), ResetAchievementCriteria(), and UpdateTimedAchievements().

◆ RemoveTimedAchievement()

void AchievementMgr::RemoveTimedAchievement	(	AchievementCriteriaTimedTypes	type,
		uint32	entry
	)

{
    AchievementCriteriaEntryList const& achievementCriteriaList = sAchievementMgr->GetTimedAchievementCriteriaByType(type);
    for (AchievementCriteriaEntryList::const_iterator i = achievementCriteriaList.begin(); i != achievementCriteriaList.end(); ++i)
    {
        if ((*i)->timerStartEvent != entry)
            continue;
 
        TimedAchievementMap::iterator timedIter = _timedAchievements.find((*i)->ID);
        // We don't have timer for this achievement
        if (timedIter == _timedAchievements.end())
            continue;
 
        // remove progress
        RemoveCriteriaProgress(*i);
 
        // Remove the timer
        _timedAchievements.erase(timedIter);
    }
}

References _timedAchievements, RemoveCriteriaProgress(), and sAchievementMgr.

Referenced by Player::RemoveTimedAchievement().

◆ Reset()

void AchievementMgr::Reset ( )

{
    for (CompletedAchievementMap::const_iterator iter = _completedAchievements.begin(); iter != _completedAchievements.end(); ++iter)
    {
        WorldPacket data(SMSG_ACHIEVEMENT_DELETED, 4);
        data << uint32(iter->first);
        _player->SendDirectMessage(&data);
    }
 
    for (CriteriaProgressMap::const_iterator iter = _criteriaProgress.begin(); iter != _criteriaProgress.end(); ++iter)
    {
        WorldPacket data(SMSG_CRITERIA_DELETED, 4);
        data << uint32(iter->first);
        _player->SendDirectMessage(&data);
    }
 
    _completedAchievements.clear();
    _criteriaProgress.clear();
    DeleteFromDB(_player->GetGUID().GetCounter());
 
    // re-fill data
    CheckAllAchievementCriteria();
}

References _completedAchievements, _criteriaProgress, _player, CheckAllAchievementCriteria(), DeleteFromDB(), ObjectGuid::GetCounter(), Object::GetGUID(), Player::SendDirectMessage(), SMSG_ACHIEVEMENT_DELETED, and SMSG_CRITERIA_DELETED.

Referenced by Player::ResetAchievements().

◆ ResetAchievementCriteria()

void AchievementMgr::ResetAchievementCriteria	(	AchievementCriteriaCondition	condition,
		uint32	value,
		bool	evenIfCriteriaComplete = `false`
	)

{
    // disable for gamemasters with GM-mode enabled
    if (_player->IsGameMaster())
        return;
 
    LOG_DEBUG("achievement", "AchievementMgr::ResetAchievementCriteria({}, {}, {})", condition, value, evenIfCriteriaComplete);
 
    AchievementCriteriaEntryList const* achievementCriteriaList = sAchievementMgr->GetAchievementCriteriaByCondition(condition, value);
    if (!achievementCriteriaList)
        return;
 
    for (AchievementCriteriaEntryList::const_iterator i = achievementCriteriaList->begin(); i != achievementCriteriaList->end(); ++i)
    {
        AchievementCriteriaEntry const* achievementCriteria = (*i);
        AchievementEntry const* achievement = sAchievementStore.LookupEntry(achievementCriteria->referredAchievement);
        if (!achievement)
            continue;
 
        // don't update already completed criteria if not forced or achievement already complete
        if ((IsCompletedCriteria(achievementCriteria, achievement) && !evenIfCriteriaComplete) || HasAchieved(achievement->ID))
            continue;
 
        RemoveCriteriaProgress(achievementCriteria);
    }
}

References _player, HasAchieved(), AchievementEntry::ID, IsCompletedCriteria(), Player::IsGameMaster(), LOG_DEBUG, AchievementCriteriaEntry::referredAchievement, RemoveCriteriaProgress(), sAchievementMgr, and sAchievementStore.

Referenced by Player::ResetAchievementCriteria().

◆ SaveToDB()

void AchievementMgr::SaveToDB ( CharacterDatabaseTransaction trans )

{
    if (!_completedAchievements.empty())
    {
        for (CompletedAchievementMap::iterator iter = _completedAchievements.begin(); iter != _completedAchievements.end(); ++iter)
        {
            if (!iter->second.changed)
                continue;
 
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_ACHIEVEMENT_BY_ACHIEVEMENT);
            stmt->SetData(0, iter->first);
            stmt->SetData(1, GetPlayer()->GetGUID().GetCounter());
            trans->Append(stmt);
 
            stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_ACHIEVEMENT);
            stmt->SetData(0, GetPlayer()->GetGUID().GetCounter());
            stmt->SetData(1, iter->first);
            stmt->SetData(2, uint32(iter->second.date));
            trans->Append(stmt);
 
            iter->second.changed = false;
 
            sScriptMgr->OnAchievementSave(trans, GetPlayer(), iter->first, iter->second);
        }
    }
 
    if (!_criteriaProgress.empty())
    {
        for (CriteriaProgressMap::iterator iter = _criteriaProgress.begin(); iter != _criteriaProgress.end(); ++iter)
        {
            if (!iter->second.changed)
                continue;
 
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_ACHIEVEMENT_PROGRESS_BY_CRITERIA);
            stmt->SetData(0, GetPlayer()->GetGUID().GetCounter());
            stmt->SetData(1, iter->first);
            trans->Append(stmt);
 
            // pussywizard: insert only for (counter != 0) is very important! this is how criteria of completed achievements gets deleted from db (by setting counter to 0); if conflicted during merge - contact me
            if (iter->second.counter)
            {
                stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_ACHIEVEMENT_PROGRESS);
                stmt->SetData(0, GetPlayer()->GetGUID().GetCounter());
                stmt->SetData(1, iter->first);
                stmt->SetData(2, iter->second.counter);
                stmt->SetData(3, uint32(iter->second.date));
                trans->Append(stmt);
            }
 
            iter->second.changed = false;
 
            sScriptMgr->OnCriteriaSave(trans, GetPlayer(), iter->first, iter->second);
        }
    }
}

References _completedAchievements, _criteriaProgress, CHAR_DEL_CHAR_ACHIEVEMENT_BY_ACHIEVEMENT, CHAR_DEL_CHAR_ACHIEVEMENT_PROGRESS_BY_CRITERIA, CHAR_INS_CHAR_ACHIEVEMENT, CHAR_INS_CHAR_ACHIEVEMENT_PROGRESS, CharacterDatabase, GetPlayer(), PreparedStatementBase::SetData(), and sScriptMgr.

Referenced by Player::SaveToDB().

◆ SendAchievementEarned()

void AchievementMgr::SendAchievementEarned ( AchievementEntry const * achievement ) const

private

{
    if (GetPlayer()->GetSession()->PlayerLoading())
        return;
 
    // Don't send for achievements with ACHIEVEMENT_FLAG_TRACKING
    if (achievement->flags & ACHIEVEMENT_FLAG_HIDDEN)
        return;
 
    LOG_DEBUG("achievement", "AchievementMgr::SendAchievementEarned({})", achievement->ID);
 
    Guild* guild = sGuildMgr->GetGuildById(GetPlayer()->GetGuildId());
    if (guild)
    {
        Acore::BroadcastTextBuilder _builder(GetPlayer(), CHAT_MSG_GUILD_ACHIEVEMENT, BROADCAST_TEXT_ACHIEVEMENT_EARNED, GetPlayer()->getGender(), GetPlayer(), achievement->ID);
        Acore::LocalizedPacketDo<Acore::BroadcastTextBuilder> _localizer(_builder);
        guild->BroadcastWorker(_localizer, GetPlayer());
    }
 
    if (achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_KILL | ACHIEVEMENT_FLAG_REALM_FIRST_REACH))
    {
        // If guild exists - send its name to the server
        // If guild does not exist - send player's name to the server
        if (achievement->flags & ACHIEVEMENT_FLAG_REALM_FIRST_KILL && guild)
        {
            WorldPacket data(SMSG_SERVER_FIRST_ACHIEVEMENT, guild->GetName().size() + 1 + 8 + 4 + 4);
            data << guild->GetName();
            data << GetPlayer()->GetGUID();
            data << uint32(achievement->ID);
            data << uint32(0);                                  // display name as plain string in chat (always 0 for guild)
            sWorld->SendGlobalMessage(&data);
        }
        else
        {
            TeamId teamId = GetPlayer()->GetTeamId();
 
            // broadcast realm first reached
            WorldPacket data(SMSG_SERVER_FIRST_ACHIEVEMENT, GetPlayer()->GetName().size() + 1 + 8 + 4 + 4);
            data << GetPlayer()->GetName();
            data << GetPlayer()->GetGUID();
            data << uint32(achievement->ID);
            std::size_t linkTypePos = data.wpos();
            data << uint32(1);                                  // display name as clickable link in chat
            sWorld->SendGlobalMessage(&data, nullptr, teamId);
 
            data.put<uint32>(linkTypePos, 0);                   // display name as plain string in chat
            sWorld->SendGlobalMessage(&data, nullptr, teamId == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE);
        }
    }
    // if player is in world he can tell his friends about new achievement
    else if (GetPlayer()->IsInWorld())
    {
        CellCoord p = Acore::ComputeCellCoord(GetPlayer()->GetPositionX(), GetPlayer()->GetPositionY());
 
        Cell cell(p);
        cell.SetNoCreate();
 
        Acore::BroadcastTextBuilder _builder(GetPlayer(), CHAT_MSG_ACHIEVEMENT, BROADCAST_TEXT_ACHIEVEMENT_EARNED, GetPlayer()->getGender(), GetPlayer(), achievement->ID);
        Acore::LocalizedPacketDo<Acore::BroadcastTextBuilder> _localizer(_builder);
        Acore::PlayerDistWorker<Acore::LocalizedPacketDo<Acore::BroadcastTextBuilder>> _worker(GetPlayer(), sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY), _localizer);
        TypeContainerVisitor<Acore::PlayerDistWorker<Acore::LocalizedPacketDo<Acore::BroadcastTextBuilder> >, WorldTypeMapContainer > message(_worker);
        Cell::VisitWorldObjects(GetPlayer(), _worker, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY));
    }
 
    WorldPacket data(SMSG_ACHIEVEMENT_EARNED, 8 + 4 + 8);
    data << GetPlayer()->GetPackGUID();
    data << uint32(achievement->ID);
    data.AppendPackedTime(GameTime::GetGameTime().count());
    data << uint32(0);
    GetPlayer()->SendMessageToSetInRange(&data, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY), true);
}

References ACHIEVEMENT_FLAG_HIDDEN, ACHIEVEMENT_FLAG_REALM_FIRST_KILL, ACHIEVEMENT_FLAG_REALM_FIRST_REACH, ByteBuffer::AppendPackedTime(), BROADCAST_TEXT_ACHIEVEMENT_EARNED, Guild::BroadcastWorker(), CHAT_MSG_ACHIEVEMENT, CHAT_MSG_GUILD_ACHIEVEMENT, Acore::ComputeCellCoord(), CONFIG_LISTEN_RANGE_SAY, AchievementEntry::flags, GameTime::GetGameTime(), Object::GetGUID(), WorldObject::GetName(), Guild::GetName(), Object::GetPackGUID(), GetPlayer(), Player::GetTeamId(), AchievementEntry::ID, Object::IsInWorld(), LOG_DEBUG, ByteBuffer::put(), Player::SendMessageToSetInRange(), Cell::SetNoCreate(), sGuildMgr, SMSG_ACHIEVEMENT_EARNED, SMSG_SERVER_FIRST_ACHIEVEMENT, sWorld, TEAM_ALLIANCE, TEAM_HORDE, Cell::VisitWorldObjects(), and ByteBuffer::wpos().

Referenced by CompletedAchievement().

◆ SendAllAchievementData()

void AchievementMgr::SendAllAchievementData ( ) const

{
    WorldPacket data(SMSG_ALL_ACHIEVEMENT_DATA, _completedAchievements.size() * 8 + 4 + _criteriaProgress.size() * 38 + 4);
    BuildAllDataPacket(&data);
    GetPlayer()->GetSession()->SendPacket(&data);
}

References _completedAchievements, _criteriaProgress, BuildAllDataPacket(), GetPlayer(), Player::GetSession(), WorldSession::SendPacket(), and SMSG_ALL_ACHIEVEMENT_DATA.

Referenced by Player::SendInitialPacketsBeforeAddToMap().

◆ SendCriteriaUpdate()

void AchievementMgr::SendCriteriaUpdate	(	AchievementCriteriaEntry const *	entry,
		CriteriaProgress const *	progress,
		uint32	timeElapsed,
		bool	timedCompleted
	)		const

private

{
    WorldPacket data(SMSG_CRITERIA_UPDATE, 8 + 4 + 8);
    data << uint32(entry->ID);
 
    // the counter is packed like a packed Guid
    data.appendPackGUID(progress->counter);
 
    data << GetPlayer()->GetPackGUID();
    if (!entry->timeLimit)
        data << uint32(0);
    else
        data << uint32(timedCompleted ? 0 : 1); // 1 is for keeping the counter at 0 in client
    data.AppendPackedTime(progress->date);
    data << uint32(timeElapsed);    // time elapsed in seconds
 
    if (sAchievementMgr->IsAverageCriteria(entry))
        data << uint32(GameTime::GetGameTime().count() - GetPlayer()->GetCreationTime().count());    // for average achievements
    else
        data << uint32(timeElapsed);    // time elapsed in seconds
 
    GetPlayer()->SendDirectMessage(&data);
}

References ByteBuffer::AppendPackedTime(), ByteBuffer::appendPackGUID(), CriteriaProgress::counter, CriteriaProgress::date, GameTime::GetGameTime(), Object::GetPackGUID(), GetPlayer(), AchievementCriteriaEntry::ID, sAchievementMgr, Player::SendDirectMessage(), SMSG_CRITERIA_UPDATE, and AchievementCriteriaEntry::timeLimit.

Referenced by SetCriteriaProgress().

◆ SendRespondInspectAchievements()

void AchievementMgr::SendRespondInspectAchievements ( Player * player ) const

{
    WorldPacket data(SMSG_RESPOND_INSPECT_ACHIEVEMENTS, 9 + _completedAchievements.size() * 8 + 4 + _criteriaProgress.size() * 38 + 4);
    data << GetPlayer()->GetPackGUID();
    BuildAllDataPacket(&data);
    player->GetSession()->SendPacket(&data);
}

References _completedAchievements, _criteriaProgress, BuildAllDataPacket(), Object::GetPackGUID(), GetPlayer(), Player::GetSession(), WorldSession::SendPacket(), and SMSG_RESPOND_INSPECT_ACHIEVEMENTS.

Referenced by Player::SendRespondInspectAchievements().

◆ SetCriteriaProgress()

void AchievementMgr::SetCriteriaProgress	(	AchievementCriteriaEntry const *	entry,
		uint32	changeValue,
		ProgressType	ptype = `PROGRESS_SET`
	)

private

{
    // Don't allow to cheat - doing timed achievements without timer active
    TimedAchievementMap::iterator timedIter = _timedAchievements.find(entry->ID);
    if (entry->timeLimit && timedIter == _timedAchievements.end())
        return;
 
    if (!sScriptMgr->OnBeforeCriteriaProgress(GetPlayer(), entry))
    {
        return;
    }
 
    LOG_DEBUG("achievement", "AchievementMgr::SetCriteriaProgress({}, {}) for {}", entry->ID, changeValue, _player->GetGUID().ToString());
 
    CriteriaProgress* progress = GetCriteriaProgress(entry);
    if (!progress)
    {
        // not create record for 0 counter but allow it for timed achievements
        // we will need to send 0 progress to client to start the timer
        if (changeValue == 0 && !entry->timeLimit)
            return;
 
        progress = &_criteriaProgress[entry->ID];
        progress->counter = changeValue;
    }
    else
    {
        uint32 newValue = 0;
        switch (ptype)
        {
            case PROGRESS_SET:
            case PROGRESS_RESET:
                newValue = changeValue;
                break;
            case PROGRESS_ACCUMULATE:
                {
                    // avoid overflow
                    uint32 max_value = std::numeric_limits<uint32>::max();
                    newValue = max_value - progress->counter > changeValue ? progress->counter + changeValue : max_value;
                    break;
                }
            case PROGRESS_HIGHEST:
                newValue = progress->counter < changeValue ? changeValue : progress->counter;
                break;
        }
 
        // not update (not mark as changed) if counter will have same value
        if (ptype != PROGRESS_RESET && progress->counter == newValue && !entry->timeLimit)
            return;
 
        progress->counter = newValue;
    }
 
    progress->changed = true;
    progress->date = GameTime::GetGameTime().count(); // set the date to the latest update.
 
    uint32 timeElapsed = 0;
    bool timedCompleted = false;
 
    if (entry->timeLimit)
    {
        // has to exist else we wouldn't be here
        timedCompleted = IsCompletedCriteria(entry, sAchievementStore.LookupEntry(entry->referredAchievement));
        // Client expects this in packet
        timeElapsed = entry->timeLimit - (timedIter->second / IN_MILLISECONDS);
 
        // Remove the timer, we wont need it anymore
        if (timedCompleted)
            _timedAchievements.erase(timedIter);
    }
 
    SendCriteriaUpdate(entry, progress, timeElapsed, true);
 
    sScriptMgr->OnCriteriaProgress(GetPlayer(), entry);
}

References _criteriaProgress, _player, _timedAchievements, CriteriaProgress::changed, CriteriaProgress::counter, CriteriaProgress::date, GetCriteriaProgress(), GameTime::GetGameTime(), Object::GetGUID(), GetPlayer(), AchievementCriteriaEntry::ID, IN_MILLISECONDS, IsCompletedCriteria(), LOG_DEBUG, PROGRESS_ACCUMULATE, PROGRESS_HIGHEST, PROGRESS_RESET, PROGRESS_SET, AchievementCriteriaEntry::referredAchievement, sAchievementStore, SendCriteriaUpdate(), sScriptMgr, AchievementCriteriaEntry::timeLimit, and ObjectGuid::ToString().

Referenced by StartTimedAchievement(), and UpdateAchievementCriteria().

◆ StartTimedAchievement()

void AchievementMgr::StartTimedAchievement	(	AchievementCriteriaTimedTypes	type,
		uint32	entry,
		uint32	timeLost = `0`
	)

{
    AchievementCriteriaEntryList const& achievementCriteriaList = sAchievementMgr->GetTimedAchievementCriteriaByType(type);
    for (AchievementCriteriaEntryList::const_iterator i = achievementCriteriaList.begin(); i != achievementCriteriaList.end(); ++i)
    {
        if ((*i)->timerStartEvent != entry)
            continue;
 
        AchievementEntry const* achievement = sAchievementStore.LookupEntry((*i)->referredAchievement);
        if (_timedAchievements.find((*i)->ID) == _timedAchievements.end() && !IsCompletedCriteria(*i, achievement))
        {
            // Start the timer
            if ((*i)->timeLimit * IN_MILLISECONDS > timeLost)
            {
                _timedAchievements[(*i)->ID] = (*i)->timeLimit * IN_MILLISECONDS - timeLost;
 
                // and at client too
                SetCriteriaProgress(*i, 0, PROGRESS_SET);
            }
        }
    }
}

References _timedAchievements, IN_MILLISECONDS, IsCompletedCriteria(), PROGRESS_SET, sAchievementMgr, sAchievementStore, and SetCriteriaProgress().

Referenced by Player::StartTimedAchievement().

◆ Update()

void AchievementMgr::Update ( uint32 timeDiff )

{
    if (_offlineUpdatesDelayTimer > 0)
    {
        if (timeDiff >= _offlineUpdatesDelayTimer)
        {
            _offlineUpdatesDelayTimer = 0;
            ProcessOfflineUpdatesQueue();
        }
        else
            _offlineUpdatesDelayTimer -= timeDiff;
    }
 
    UpdateTimedAchievements(timeDiff);
}

References _offlineUpdatesDelayTimer, ProcessOfflineUpdatesQueue(), and UpdateTimedAchievements().

Referenced by Player::Update().

◆ UpdateAchievementCriteria()

void AchievementMgr::UpdateAchievementCriteria	(	AchievementCriteriaTypes	type,
		uint32	miscValue1 = `0`,
		uint32	miscValue2 = `0`,
		Unit *	unit = `nullptr`
	)

this function will be called whenever the user might have done a criteria relevant action

{
    // disable for gamemasters with GM-mode enabled
    if (_player->IsGameMaster())
        return;
 
    if (type >= ACHIEVEMENT_CRITERIA_TYPE_TOTAL)
    {
        LOG_DEBUG("achievement", "UpdateAchievementCriteria: Wrong criteria type {}", type);
        return;
    }
 
    LOG_DEBUG("achievement", "AchievementMgr::UpdateAchievementCriteria({}, {}, {})", type, miscValue1, miscValue2);
 
    AchievementCriteriaEntryList const* achievementCriteriaList = nullptr;
 
    switch (type)
    {
        case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
        case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG:
        case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL:
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT:
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND:
        case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE:
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
        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_AT_AREA:
        case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL:
        case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM:
        case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL:
        case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:
        case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM:
        case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA:
        case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
        case ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS:
        case ACHIEVEMENT_CRITERIA_TYPE_HK_RACE:
        case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
        case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM:
        case ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT:
        case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
        case ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT:
        case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
        case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:
        case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
        case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE:
            if (miscValue1)
            {
                achievementCriteriaList = sAchievementMgr->GetSpecialAchievementCriteriaByType(type, miscValue1);
                break;
            }
            achievementCriteriaList = sAchievementMgr->GetAchievementCriteriaByType(type);
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM:
            if (miscValue2)
            {
                achievementCriteriaList = sAchievementMgr->GetSpecialAchievementCriteriaByType(type, miscValue2);
                break;
            }
            achievementCriteriaList = sAchievementMgr->GetAchievementCriteriaByType(type);
            break;
        default:
            achievementCriteriaList = sAchievementMgr->GetAchievementCriteriaByType(type);
            break;
    }
 
    if (!achievementCriteriaList)
        return;
 
    sScriptMgr->OnBeforeCheckCriteria(this, achievementCriteriaList);
 
    for (AchievementCriteriaEntryList::const_iterator i = achievementCriteriaList->begin(); i != achievementCriteriaList->end(); ++i)
    {
        AchievementCriteriaEntry const* achievementCriteria = (*i);
        AchievementEntry const* achievement = sAchievementStore.LookupEntry(achievementCriteria->referredAchievement);
        if (!achievement)
            continue;
 
        if (!CanUpdateCriteria(achievementCriteria, achievement))
            continue;
 
        if (!sScriptMgr->CanCheckCriteria(this, achievementCriteria))
            continue;
 
        switch (type)
        {
            // std. case: increment at 1
            case ACHIEVEMENT_CRITERIA_TYPE_NUMBER_OF_TALENT_RESETS:
            case ACHIEVEMENT_CRITERIA_TYPE_LOSE_DUEL:
            case ACHIEVEMENT_CRITERIA_TYPE_CREATE_AUCTION:
            case ACHIEVEMENT_CRITERIA_TYPE_WON_AUCTIONS:
            case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED:
            case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED:
            case ACHIEVEMENT_CRITERIA_TYPE_ROLL_DISENCHANT:
            case ACHIEVEMENT_CRITERIA_TYPE_QUEST_ABANDONED:
            case ACHIEVEMENT_CRITERIA_TYPE_FLIGHT_PATHS_TAKEN:
            case ACHIEVEMENT_CRITERIA_TYPE_ACCEPTED_SUMMONINGS:
                // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                if (!miscValue1)
                    continue;
                SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                break;
            // std case: increment at miscvalue1
            case ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_VENDORS:
            case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_TALENTS:
            case ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_QUEST_REWARD:
            case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_TRAVELLING:
            case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_AT_BARBER:
            case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_MAIL:
            case ACHIEVEMENT_CRITERIA_TYPE_LOOT_MONEY:
            case ACHIEVEMENT_CRITERIA_TYPE_GOLD_EARNED_BY_AUCTIONS:
            case ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED:
            case ACHIEVEMENT_CRITERIA_TYPE_TOTAL_HEALING_RECEIVED:
            case ACHIEVEMENT_CRITERIA_TYPE_USE_LFD_TO_GROUP_WITH_PLAYERS:
                // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                if (!miscValue1)
                    continue;
                SetCriteriaProgress(achievementCriteria, miscValue1, PROGRESS_ACCUMULATE);
                break;
            // std case: high value at miscvalue1
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_SOLD:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_DEALT:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_RECEIVED:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEAL_CASTED:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALING_RECEIVED:
                // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                if (!miscValue1)
                    continue;
                SetCriteriaProgress(achievementCriteria, miscValue1, PROGRESS_HIGHEST);
                break;
 
            // specialized cases
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST:
                {
                    // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                    if (!miscValue1)
                        continue;
 
                    if (achievement->categoryId == CATEGORY_CHILDRENS_WEEK)
                    {
                        AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                        if (!data || !data->Meets(GetPlayer(), nullptr))
                            continue;
                    }
 
                    SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG:
                {
                    // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                    if (!miscValue1)
                        continue;
                    if (achievementCriteria->win_bg.bgMapID != GetPlayer()->GetMapId())
                        continue;
 
                    // those requirements couldn't be found in the dbc
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data || !data->Meets(GetPlayer(), unit))
                        continue;
 
                    SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
                {
                    // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                    if (!miscValue1)
                        continue;
                    if (achievementCriteria->kill_creature.creatureID != miscValue1)
                        continue;
 
                    // those requirements couldn't be found in the dbc
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data || !data->Meets(GetPlayer(), unit))
                        continue;
 
                    SetCriteriaProgress(achievementCriteria, miscValue2, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE_TYPE:
                {
                    // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                    if (!miscValue2)
                        continue;
 
                    // those requirements couldn't be found in the dbc
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data || !data->Meets(GetPlayer(), unit, miscValue1))
                        continue;
 
                    SetCriteriaProgress(achievementCriteria, miscValue2, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_REACH_LEVEL:
                if (AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria))
                    if (!data->Meets(GetPlayer(), unit))
                        continue;
                SetCriteriaProgress(achievementCriteria, GetPlayer()->GetLevel());
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL:
                // update at loading or specific skill update
                if (miscValue1 && miscValue1 != achievementCriteria->reach_skill_level.skillID)
                    continue;
                if (uint32 skillvalue = GetPlayer()->GetBaseSkillValue(achievementCriteria->reach_skill_level.skillID))
                    SetCriteriaProgress(achievementCriteria, skillvalue);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL:
                // update at loading or specific skill update
                if (miscValue1 && miscValue1 != achievementCriteria->learn_skill_level.skillID)
                    continue;
                if (uint32 maxSkillvalue = GetPlayer()->GetPureMaxSkillValue(achievementCriteria->learn_skill_level.skillID))
                    SetCriteriaProgress(achievementCriteria, maxSkillvalue);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT:
                if ((miscValue1 && achievementCriteria->complete_achievement.linkedAchievement == miscValue1) || (!miscValue1 && GetPlayer()->HasAchieved(achievementCriteria->complete_achievement.linkedAchievement)))
                    SetCriteriaProgress(achievementCriteria, 1);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST_COUNT:
                {
                    SetCriteriaProgress(achievementCriteria, GetPlayer()->GetRewardedQuestCount());
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST_DAILY:
                {
                    Seconds nextDailyResetTime = sWorld->GetNextDailyQuestsResetTime();
                    CriteriaProgress* progress = GetCriteriaProgress(achievementCriteria);
 
                    if (!miscValue1) // Login case.
                    {
                        // reset if player missed one day.
                        if (progress && Seconds(progress->date) < (nextDailyResetTime - 2_days))
                            SetCriteriaProgress(achievementCriteria, 0, PROGRESS_SET);
                        continue;
                    }
 
                    ProgressType progressType;
                    if (!progress)
                        // 1st time. Start count.
                        progressType = PROGRESS_SET;
                    else if (Seconds(progress->date) < (nextDailyResetTime - 2_days))
                        // last progress is older than 2 days. Player missed 1 day => Retart count.
                        progressType = PROGRESS_RESET;
                    else if (Seconds(progress->date) < (nextDailyResetTime - 1_days))
                        // last progress is between 1 and 2 days. => 1st time of the day.
                        progressType = PROGRESS_ACCUMULATE;
                    else
                        // last progress is within the day before the reset => Already counted today.
                        continue;
 
                    SetCriteriaProgress(achievementCriteria, 1, progressType);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
                {
                    // speedup for non-login case
                    if (miscValue1 && miscValue1 != achievementCriteria->complete_quests_in_zone.zoneID)
                        continue;
 
                    uint32 counter = 0;
 
                    const RewardedQuestSet& rewQuests = GetPlayer()->getRewardedQuests();
                    for (RewardedQuestSet::const_iterator itr = rewQuests.begin(); itr != rewQuests.end(); ++itr)
                    {
                        Quest const* quest = sObjectMgr->GetQuestTemplate(*itr);
                        if (quest && quest->GetZoneOrSort() >= 0 && uint32(quest->GetZoneOrSort()) == achievementCriteria->complete_quests_in_zone.zoneID && !(quest->HasSpecialFlag(QUEST_SPECIAL_FLAGS_NO_LOREMASTER_COUNT)))
                            ++counter;
                    }
                    SetCriteriaProgress(achievementCriteria, counter);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND:
                // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                if (!miscValue1)
                    continue;
                if (GetPlayer()->GetMapId() != achievementCriteria->complete_battleground.mapID)
                    continue;
                SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_DEATH_AT_MAP:
                // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                if (!miscValue1)
                    continue;
                if (GetPlayer()->GetMapId() != achievementCriteria->death_at_map.mapID)
                    continue;
                SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_DEATH:
                {
                    // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                    if (!miscValue1)
                        continue;
                    // skip wrong arena achievements, if not achievIdByArenaSlot then normal total death counter
                    bool notfit = false;
                    for (int j = 0; j < MAX_ARENA_SLOT; ++j)
                    {
                        if (achievIdByArenaSlot[j] == achievement->ID)
                        {
                            Battleground* bg = GetPlayer()->GetBattleground();
                            if (!bg || !bg->isArena() || ArenaTeam::GetSlotByType(bg->GetArenaType()) != j)
                                notfit = true;
 
                            break;
                        }
                    }
                    if (notfit)
                        continue;
 
                    SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_DEATH_IN_DUNGEON:
                {
                    // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                    if (!miscValue1)
                        continue;
 
                    Map const* map = GetPlayer()->IsInWorld() ? GetPlayer()->GetMap() : sMapMgr->FindMap(GetPlayer()->GetMapId(), GetPlayer()->GetInstanceId());
                    if (!map || !map->IsDungeon())
                        continue;
 
                    // search case
                    bool found = false;
                    for (int j = 0; achievIdForDungeon[j][0]; ++j)
                    {
                        if (achievIdForDungeon[j][0] == achievement->ID)
                        {
                            if (map->IsRaid())
                            {
                                // if raid accepted (ignore difficulty)
                                if (!achievIdForDungeon[j][2])
                                    break;                      // for
                            }
                            else if (GetPlayer()->GetDungeonDifficulty() == DUNGEON_DIFFICULTY_NORMAL)
                            {
                                // dungeon in normal mode accepted
                                if (!achievIdForDungeon[j][1])
                                    break;                      // for
                            }
                            else
                            {
                                // dungeon in heroic mode accepted
                                if (!achievIdForDungeon[j][3])
                                    break;                      // for
                            }
 
                            found = true;
                            break;                              // for
                        }
                    }
                    if (!found)
                        continue;
 
                    //FIXME: work only for instances where max == min for players
                    if (map->ToInstanceMap()->GetMaxPlayers() != achievementCriteria->death_in_dungeon.manLimit)
                        continue;
                    SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_RAID:
                {
                    // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                    if (!miscValue1)
                        continue;
 
                    Map const* map = GetPlayer()->IsInWorld() ? GetPlayer()->GetMap() : sMapMgr->FindMap(GetPlayer()->GetMapId(), GetPlayer()->GetInstanceId());
                    if (!map || !map->IsDungeon())
                        continue;
 
                    if (map->ToInstanceMap()->GetMaxPlayers() != achievementCriteria->complete_raid.groupSize)
                        continue;
                    SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE:
                // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                if (!miscValue1)
                    continue;
                if (miscValue1 != achievementCriteria->killed_by_creature.creatureEntry)
                    continue;
                SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_PLAYER:
                // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                if (!miscValue1)
                    continue;
 
                // if team check required: must kill by opposition faction
                if (achievement->ID == 318 && miscValue2 == GetPlayer()->GetTeamId())
                    continue;
 
                SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING:
                {
                    // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                    if (!miscValue1)
                        continue;
 
                    // those requirements couldn't be found in the dbc
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data || !data->Meets(GetPlayer(), unit))
                        continue;
 
                    // miscvalue1 is the ingame fallheight*100 as stored in dbc
                    SetCriteriaProgress(achievementCriteria, miscValue1);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_DEATHS_FROM:
                // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                if (!miscValue1)
                    continue;
                if (miscValue2 != achievementCriteria->death_from.type)
                    continue;
                SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
                {
                    // if miscvalues != 0, it contains the questID.
                    if (miscValue1)
                    {
                        if (miscValue1 != achievementCriteria->complete_quest.questID)
                            continue;
                    }
                    else
                    {
                        // login case.
                        if (!GetPlayer()->GetQuestRewardStatus(achievementCriteria->complete_quest.questID))
                            continue;
                    }
 
                    if (AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria))
                        if (!data->Meets(GetPlayer(), unit))
                            continue;
 
                    SetCriteriaProgress(achievementCriteria, 1);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
            case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
                {
                    if (!miscValue1 || miscValue1 != achievementCriteria->be_spell_target.spellID)
                        continue;
 
                    // those requirements couldn't be found in the dbc
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data)
                        continue;
 
                    if (!data->Meets(GetPlayer(), unit))
                        continue;
 
                    SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
            case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
                {
                    if (!miscValue1 || miscValue1 != achievementCriteria->cast_spell.spellID)
                        continue;
 
                    // those requirements couldn't be found in the dbc
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data)
                        continue;
 
                    if (!data->Meets(GetPlayer(), unit))
                        continue;
 
                    SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL:
                if (miscValue1 && miscValue1 != achievementCriteria->learn_spell.spellID)
                    continue;
 
                if (GetPlayer()->HasSpell(achievementCriteria->learn_spell.spellID))
                    SetCriteriaProgress(achievementCriteria, 1);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:
                {
                    // miscvalue1=loot_type (note: 0 = LOOT_CORPSE and then it ignored)
                    // miscvalue2=count of item loot
                    if (!miscValue1 || !miscValue2)
                        continue;
                    if (miscValue1 != achievementCriteria->loot_type.lootType)
                        continue;
 
                    // zone specific
                    if (achievementCriteria->loot_type.lootTypeCount == 1)
                    {
                        // those requirements couldn't be found in the dbc
                        AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                        if (!data || !data->Meets(GetPlayer(), unit))
                            continue;
                    }
 
                    SetCriteriaProgress(achievementCriteria, miscValue2, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM:
                // speedup for non-login case
                if (miscValue1 && achievementCriteria->own_item.itemID != miscValue1)
                    continue;
                SetCriteriaProgress(achievementCriteria, miscValue2, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA:
                if (!miscValue1)                            // no update at login
                    continue;
 
                // additional requirements
                if (achievementCriteria->additionalRequirements[0].additionalRequirement_type == ACHIEVEMENT_CRITERIA_CONDITION_NO_LOSE)
                {
                    // those requirements couldn't be found in the dbc
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data || !data->Meets(GetPlayer(), unit, miscValue1))
                    {
                        // reset the progress as we have a win without the requirement.
                        SetCriteriaProgress(achievementCriteria, 0);
                        continue;
                    }
                }
 
                SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:
                // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                if (!miscValue1)
                    continue;
 
                if (achievementCriteria->use_item.itemID != miscValue1)
                    continue;
 
                // Children's Week achievements have extra requirements
                //if (achievement->categoryId == CATEGORY_CHILDRENS_WEEK || achievement->ID == 1291) // Lonely?
                {
                    // Xinef: skip progress only if data exists and is not meet
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (data && !data->Meets(GetPlayer(), nullptr))
                        continue;
                }
 
                SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM:
                // You _have_ to loot that item, just owning it when logging in does _not_ count!
                if (!miscValue1)
                    continue;
                if (miscValue1 != achievementCriteria->own_item.itemID)
                    continue;
                SetCriteriaProgress(achievementCriteria, miscValue2, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA:
                {
                    WorldMapOverlayEntry const* worldOverlayEntry = sWorldMapOverlayStore.LookupEntry(achievementCriteria->explore_area.areaReference);
                    if (!worldOverlayEntry)
                        break;
 
                    bool matchFound = false;
                    for (int j = 0; j < MAX_WORLD_MAP_OVERLAY_AREA_IDX; ++j)
                    {
                        AreaTableEntry const* area = sAreaTableStore.LookupEntry(worldOverlayEntry->areatableID[j]);
                        if (!area)
                            break;
 
                        uint32 playerIndexOffset = uint32(area->exploreFlag) / 32;
                        if (playerIndexOffset >= PLAYER_EXPLORED_ZONES_SIZE)
                            continue;
 
                        uint32 mask = 1 << (uint32(area->exploreFlag) % 32);
                        if (GetPlayer()->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + playerIndexOffset) & mask)
                        {
                            matchFound = true;
                            break;
                        }
                    }
 
                    if (matchFound)
                        SetCriteriaProgress(achievementCriteria, 1);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT:
                SetCriteriaProgress(achievementCriteria, GetPlayer()->GetBankBagSlotCount());
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
                {
                    // skip faction check only at loading
                    if (miscValue1 && miscValue1 != achievementCriteria->gain_reputation.factionID)
                        continue;
 
                    int32 reputation = GetPlayer()->GetReputationMgr().GetReputation(achievementCriteria->gain_reputation.factionID);
                    if (reputation > 0)
                        SetCriteriaProgress(achievementCriteria, reputation);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION:
                {
                    SetCriteriaProgress(achievementCriteria, GetPlayer()->GetReputationMgr().GetExaltedFactionCount());
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP:
                {
                    // skip for login case
                    if (!miscValue1)
                        continue;
                    SetCriteriaProgress(achievementCriteria, 1);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM:
                {
                    // miscvalue1 = itemid
                    // miscvalue2 = itemSlot
                    if (!miscValue1)
                        continue;
 
                    if (miscValue2 != achievementCriteria->equip_epic_item.itemSlot)
                        continue;
 
                    // check item level and quality via achievement_criteria_data
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data || !data->Meets(GetPlayer(), 0, miscValue1))
                        continue;
 
                    SetCriteriaProgress(achievementCriteria, 1);
                    break;
                }
 
            case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT:
            case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT:
                {
                    // miscvalue1 = itemid
                    // miscvalue2 = diced value
                    if (!miscValue1)
                        continue;
                    if (miscValue2 != achievementCriteria->roll_greed_on_loot.rollValue)
                        continue;
 
                    ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(miscValue1);
                    if (!pProto)
                        continue;
 
                    // check item level via achievement_criteria_data
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data || !data->Meets(GetPlayer(), 0, pProto->ItemLevel))
                        continue;
 
                    SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
                {
                    // miscvalue1 = emote
                    if (!miscValue1)
                        continue;
                    if (miscValue1 != achievementCriteria->do_emote.emoteID)
                        continue;
                    if (achievementCriteria->do_emote.count)
                    {
                        // those requirements couldn't be found in the dbc
                        AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                        if (!data || !data->Meets(GetPlayer(), unit))
                            continue;
                    }
 
                    SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE:
            case ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE:
                {
                    if (!miscValue1)
                        continue;
 
                    if (achievementCriteria->additionalRequirements[0].additionalRequirement_type == ACHIEVEMENT_CRITERIA_CONDITION_BG_MAP)
                    {
                        if (GetPlayer()->GetMapId() != achievementCriteria->additionalRequirements[0].additionalRequirement_value)
                            continue;
 
                        // map specific case (BG in fact) expected player targeted damage/heal
                        if (!unit || !unit->IsPlayer())
                            continue;
                    }
 
                    SetCriteriaProgress(achievementCriteria, miscValue1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM:
                // miscvalue1 = item_id
                if (!miscValue1)
                    continue;
                if (miscValue1 != achievementCriteria->equip_item.itemID)
                    continue;
 
                SetCriteriaProgress(achievementCriteria, 1);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT:
                // miscvalue1 = go entry
                if (!miscValue1)
                    continue;
                if (miscValue1 != achievementCriteria->use_gameobject.goEntry)
                    continue;
 
                SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT:
                if (!miscValue1)
                    continue;
                if (miscValue1 != achievementCriteria->fish_in_gameobject.goEntry)
                    continue;
 
                SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
                {
                    if (miscValue1 && miscValue1 != achievementCriteria->learn_skillline_spell.skillLine)
                        continue;
 
                    uint32 spellCount = 0;
                    for (PlayerSpellMap::const_iterator spellIter = GetPlayer()->GetSpellMap().begin(); spellIter != GetPlayer()->GetSpellMap().end(); ++spellIter)
                    {
                        SkillLineAbilityMapBounds bounds = sSpellMgr->GetSkillLineAbilityMapBounds(spellIter->first);
                        for (SkillLineAbilityMap::const_iterator skillIter = bounds.first; skillIter != bounds.second; ++skillIter)
                        {
                            if (skillIter->second->SkillLine == achievementCriteria->learn_skillline_spell.skillLine)
                            {
                                // xinef: do not add couter twice if by any chance skill is listed twice in dbc (eg. skill 777 and spell 22717)
                                ++spellCount;
                                break;
                            }
                        }
                    }
 
                    SetCriteriaProgress(achievementCriteria, spellCount);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_WIN_DUEL:
                // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                if (!miscValue1)
                    continue;
 
                if (achievementCriteria->win_duel.duelCount)
                {
                    // those requirements couldn't be found in the dbc
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data)
                        continue;
 
                    if (!data->Meets(GetPlayer(), unit))
                        continue;
                }
 
                SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REVERED_REPUTATION:
                SetCriteriaProgress(achievementCriteria, GetPlayer()->GetReputationMgr().GetReveredFactionCount());
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_GAIN_HONORED_REPUTATION:
                SetCriteriaProgress(achievementCriteria, GetPlayer()->GetReputationMgr().GetHonoredFactionCount());
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_KNOWN_FACTIONS:
                SetCriteriaProgress(achievementCriteria, GetPlayer()->GetReputationMgr().GetVisibleFactionCount());
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_LOOT_EPIC_ITEM:
            case ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM:
                {
                    // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
                    if (!miscValue1)
                        continue;
                    ItemTemplate const* proto = sObjectMgr->GetItemTemplate(miscValue1);
                    if (!proto || proto->Quality < ITEM_QUALITY_EPIC)
                        continue;
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data || !data->Meets(GetPlayer(), unit, miscValue1))
                        continue;
                    SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE:
                {
                    if (miscValue1 && miscValue1 != achievementCriteria->learn_skill_line.skillLine)
                        continue;
 
                    uint32 spellCount = 0;
                    for (PlayerSpellMap::const_iterator spellIter = GetPlayer()->GetSpellMap().begin(); spellIter != GetPlayer()->GetSpellMap().end(); ++spellIter)
                    {
                        SkillLineAbilityMapBounds bounds = sSpellMgr->GetSkillLineAbilityMapBounds(spellIter->first);
                        for (SkillLineAbilityMap::const_iterator skillIter = bounds.first; skillIter != bounds.second; ++skillIter)
                        {
                            if (skillIter->second->SkillLine == achievementCriteria->learn_skill_line.skillLine)
                            {
                                // xinef: do not add couter twice if by any chance skill is listed twice in dbc (eg. skill 777 and spell 22717)
                                ++spellCount;
                                break;
                            }
                        }
                    }
 
                    SetCriteriaProgress(achievementCriteria, spellCount);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_EARN_HONORABLE_KILL:
                SetCriteriaProgress(achievementCriteria, GetPlayer()->GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS));
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS:
                if (!miscValue1 || miscValue1 != achievementCriteria->hk_class.classID)
                    continue;
 
                SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_HK_RACE:
                if (!miscValue1 || miscValue1 != achievementCriteria->hk_race.raceID)
                    continue;
 
                SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_GOLD_VALUE_OWNED:
                SetCriteriaProgress(achievementCriteria, GetPlayer()->GetMoney(), PROGRESS_HIGHEST);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_EARN_ACHIEVEMENT_POINTS:
                {
                    if (!miscValue1)
                    {
                        uint32 points = 0;
                        for (CompletedAchievementMap::iterator itr = _completedAchievements.begin(); itr != _completedAchievements.end(); ++itr)
                            if (AchievementEntry const* pAchievement = sAchievementStore.LookupEntry(itr->first))
                                points += pAchievement->points;
                        SetCriteriaProgress(achievementCriteria, points, PROGRESS_SET);
                    }
                    else
                        SetCriteriaProgress(achievementCriteria, miscValue1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE:
                {
                    if (!miscValue1 || miscValue1 != achievementCriteria->bg_objective.objectiveId)
                        continue;
 
                    // those requirements couldn't be found in the dbc
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data || !data->Meets(GetPlayer(), unit))
                        continue;
 
                    SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL:
            case ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL:
            case ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS:
                {
                    // skip login update
                    if (!miscValue1)
                        continue;
 
                    // those requirements couldn't be found in the dbc
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data || !data->Meets(GetPlayer(), unit))
                        continue;
 
                    SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL_AT_AREA:
                {
                    if (!miscValue1 || miscValue1 != achievementCriteria->honorable_kill_at_area.areaID)
                        continue;
 
                    SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_TEAM_RATING:
                {
                    uint32 reqTeamType = achievementCriteria->highest_team_rating.teamtype;
 
                    if (miscValue1)
                    {
                        if (miscValue2 != reqTeamType)
                            continue;
 
                        SetCriteriaProgress(achievementCriteria, miscValue1, PROGRESS_HIGHEST);
                    }
                    else    // login case
                    {
                        for (uint32 arena_slot = 0; arena_slot < MAX_ARENA_SLOT; ++arena_slot)
                        {
                            uint32 arenaTeamId = GetPlayer()->GetArenaTeamId(arena_slot);
                            if (!arenaTeamId)
                                continue;
 
                            ArenaTeam* team = sArenaTeamMgr->GetArenaTeamById(arenaTeamId);
                            if (!team || team->GetType() != reqTeamType)
                                continue;
 
                            SetCriteriaProgress(achievementCriteria, team->GetStats().Rating, PROGRESS_HIGHEST);
                            break;
                        }
                    }
 
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_PERSONAL_RATING:
                {
                    uint32 reqTeamType = achievementCriteria->highest_personal_rating.teamtype;
 
                    if (miscValue1)
                    {
                        if (miscValue2 != reqTeamType)
                            continue;
 
                        SetCriteriaProgress(achievementCriteria, miscValue1, PROGRESS_HIGHEST);
                    }
                    else    // login case
                    {
                        for (uint32 arena_slot = 0; arena_slot < MAX_ARENA_SLOT; ++arena_slot)
                        {
                            uint32 arenaTeamId = GetPlayer()->GetArenaTeamId(arena_slot);
                            if (!arenaTeamId)
                                continue;
 
                            ArenaTeam* team = sArenaTeamMgr->GetArenaTeamById(arenaTeamId);
                            if (!team || team->GetType() != reqTeamType)
                                continue;
 
                            if (ArenaTeamMember const* member = team->GetMember(GetPlayer()->GetGUID()))
                            {
                                SetCriteriaProgress(achievementCriteria, member->PersonalRating, PROGRESS_HIGHEST);
                                break;
                            }
                        }
                    }
 
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_ON_LOGIN:
                {
                    // This criteria is only called directly after login - with expected miscvalue1 == 1
                    if (!miscValue1)
                        continue;
 
                    // They have no proper requirements in dbc
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data || !data->Meets(GetPlayer(), unit))
                        continue;
 
                    SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_PLAY_ARENA:
            case ACHIEVEMENT_CRITERIA_TYPE_WIN_ARENA: // This also behaves like ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA
                {
                    // those requirements couldn't be found in the dbc
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data || !data->Meets(GetPlayer(), nullptr))
                        continue;
 
                    // Check map id requirement
                    if (miscValue1 == achievementCriteria->win_arena.mapID)
                        SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
                    break;
                }
            case ACHIEVEMENT_CRITERIA_TYPE_OWN_RANK:
                {
                    // those requirements couldn't be found in the dbc
                    AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria);
                    if (!data || !data->Meets(GetPlayer(), nullptr))
                        continue;
 
                    SetCriteriaProgress(achievementCriteria, 1);
                    break;
                }
            // std case: not exist in DBC, not triggered in code as result
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALTH:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_SPELLPOWER:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_ARMOR:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_POWER:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_STAT:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_RATING:
                break;
            // FIXME: not triggered in code as result, need to implement
            case ACHIEVEMENT_CRITERIA_TYPE_TOTAL:
                break;                                   // Not implemented yet :(
        }
 
        if (IsCompletedCriteria(achievementCriteria, achievement))
            CompletedCriteriaFor(achievement);
 
        // check again the completeness for SUMM and REQ COUNT achievements,
        // as they don't depend on the completed criteria but on the sum of the progress of each individual criteria
        if (achievement->flags & ACHIEVEMENT_FLAG_SUMM)
            if (IsCompletedAchievement(achievement))
                CompletedAchievement(achievement);
 
        if (AchievementEntryList const* achRefList = sAchievementMgr->GetAchievementByReferencedId(achievement->ID))
            for (AchievementEntryList::const_iterator itr = achRefList->begin(); itr != achRefList->end(); ++itr)
                if (IsCompletedAchievement(*itr))
                    CompletedAchievement(*itr);
    }
}

Referenced by CheckAllAchievementCriteria(), CompletedAchievement(), ProcessOfflineUpdate(), and Player::UpdateAchievementCriteria().

◆ UpdateTimedAchievements()

void AchievementMgr::UpdateTimedAchievements ( uint32 timeDiff )

private

{
    if (!_timedAchievements.empty())
    {
        for (TimedAchievementMap::iterator itr = _timedAchievements.begin(); itr != _timedAchievements.end();)
        {
            // Time is up, remove timer and reset progress
            if (itr->second <= timeDiff)
            {
                AchievementCriteriaEntry const* entry = sAchievementCriteriaStore.LookupEntry(itr->first);
                RemoveCriteriaProgress(entry);
                _timedAchievements.erase(itr++);
            }
            else
            {
                itr->second -= timeDiff;
                ++itr;
            }
        }
    }
}

References _timedAchievements, RemoveCriteriaProgress(), and sAchievementCriteriaStore.

Referenced by Update().

Member Data Documentation

◆ _completedAchievements

CompletedAchievementMap AchievementMgr::_completedAchievements

private

Referenced by BuildAllDataPacket(), CompletedAchievement(), GetCompletedAchievements(), HasAchieved(), LoadFromDB(), Reset(), SaveToDB(), SendAllAchievementData(), SendRespondInspectAchievements(), and UpdateAchievementCriteria().

◆ _criteriaProgress

CriteriaProgressMap AchievementMgr::_criteriaProgress

private

Referenced by BuildAllDataPacket(), GetCriteriaProgress(), LoadFromDB(), RemoveCriteriaProgress(), Reset(), SaveToDB(), SendAllAchievementData(), SendRespondInspectAchievements(), and SetCriteriaProgress().

◆ _offlineUpdatesDelayTimer

uint32 AchievementMgr::_offlineUpdatesDelayTimer

private

Referenced by AchievementMgr(), LoadFromDB(), and Update().

◆ _offlineUpdatesQueue

std::vector<AchievementOfflinePlayerUpdate> AchievementMgr::_offlineUpdatesQueue

private

Referenced by LoadFromDB(), and ProcessOfflineUpdatesQueue().

◆ _player

Player* AchievementMgr::_player

private

Referenced by AchievementMgr(), CompletedAchievement(), GetPlayer(), RemoveCriteriaProgress(), Reset(), ResetAchievementCriteria(), SetCriteriaProgress(), and UpdateAchievementCriteria().

◆ _timedAchievements

TimedAchievementMap AchievementMgr::_timedAchievements

private

Referenced by RemoveTimedAchievement(), SetCriteriaProgress(), StartTimedAchievement(), and UpdateTimedAchievements().

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ TimedAchievementMap

Member Enumeration Documentation

◆ ProgressType

Constructor & Destructor Documentation

◆ AchievementMgr()

◆ ~AchievementMgr()

Member Function Documentation

◆ BuildAllDataPacket()

◆ CanUpdateCriteria()

◆ CheckAllAchievementCriteria()

◆ CompletedAchievement()

◆ CompletedCriteriaFor()

◆ DeleteFromDB()

◆ GetCompletedAchievements()

◆ GetCriteriaProgress()

◆ GetPlayer()

◆ HasAchieved()

◆ IsCompletedAchievement()

◆ IsCompletedCriteria()

◆ LoadFromDB()

◆ ProcessOfflineUpdate()

◆ ProcessOfflineUpdatesQueue()

◆ RemoveCriteriaProgress()

◆ RemoveTimedAchievement()

◆ Reset()

◆ ResetAchievementCriteria()

◆ SaveToDB()

◆ SendAchievementEarned()

◆ SendAllAchievementData()

◆ SendCriteriaUpdate()

◆ SendRespondInspectAchievements()

◆ SetCriteriaProgress()

◆ StartTimedAchievement()

◆ Update()

◆ UpdateAchievementCriteria()

◆ UpdateTimedAchievements()

Member Data Documentation

◆ _completedAchievements

◆ _criteriaProgress

◆ _offlineUpdatesDelayTimer

◆ _offlineUpdatesQueue

◆ _player

◆ _timedAchievements