AchievementMgr< T > Singleton Reference

#include <AchievementMgr.h>

Public Member Functions
	AchievementMgr (T *owner)
	~AchievementMgr ()
void	Reset ()
void	LoadFromDB (PreparedQueryResult achievementResult, PreparedQueryResult criteriaResult)
void	SaveToDB (SQLTransaction &trans)
void	ResetAchievementCriteria (AchievementCriteriaTypes type, uint64 miscValue1=0, uint64 miscValue2=0, bool evenIfCriteriaComplete=false)
void	UpdateAchievementCriteria (AchievementCriteriaTypes type, uint64 miscValue1=0, uint64 miscValue2=0, uint64 miscValue3=0, Unit const *unit=NULL, Player *referencePlayer=NULL)
void	CompletedAchievement (AchievementEntry const *entry, Player *referencePlayer)
void	CheckAllAchievementCriteria (Player *referencePlayer)
void	SendAllAchievementData (Player *receiver) const
void	SendAllTrackedCriterias (Player *receiver, std::set< uint32 > const &trackedCriterias) const
void	SendAchievementInfo (Player *receiver, uint32 achievementId=0) const
bool	HasAchieved (uint32 achievementId) const
T *	GetOwner () const
void	UpdateTimedAchievements (uint32 timeDiff)
void	StartTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry, uint32 timeLost=0)
void	RemoveTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry)
uint32	GetAchievementPoints () const
template<>
void	SaveToDB (SQLTransaction &trans)
template<>
void	LoadFromDB (PreparedQueryResult achievementResult, PreparedQueryResult criteriaResult)
template<>
void	Reset ()
template<>
void	StartTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry, uint32 timeLost)
template<>
void	CompletedAchievement (AchievementEntry const *achievement, Player *referencePlayer)
template<>
void	SendAchievementInfo (Player *receiver, uint32) const

Private Types
typedef std::map< uint32, uint32 >	TimedAchievementMap

Private Member Functions
void	SendAchievementEarned (AchievementEntry const *achievement) const
void	SendCriteriaUpdate (AchievementCriteria const *entry, CriteriaProgress const *progress, uint32 timeElapsed, bool timedCompleted) const
CriteriaProgress *	GetCriteriaProgress (AchievementCriteria const *entry)
void	SetCriteriaProgress (AchievementCriteria const *entry, uint64 changeValue, Player *referencePlayer, ProgressType ptype=PROGRESS_SET)
void	RemoveCriteriaProgress (AchievementCriteria const *entry)
void	CompletedCriteriaFor (AchievementEntry const *achievement, Player *referencePlayer)
bool	IsCompletedCriteriaTree (AchievementCriteriaTree const *tree)
bool	IsCompletedCriteria (AchievementCriteria const *achievementCriteria, uint64 requiredAmount)
bool	IsCompletedAchievement (AchievementEntry const *entry)
bool	CanUpdateCriteria (AchievementCriteria const *criteria, AchievementCriteriaTreeList const *trees, uint64 miscValue1, uint64 miscValue2, uint64 miscValue3, Unit const *unit, Player *referencePlayer)
void	SendPacket (WorldPacket const *data) const
bool	ConditionsSatisfied (AchievementCriteria const *criteria, Player *referencePlayer) const
bool	RequirementsSatisfied (AchievementCriteria const *criteria, uint64 miscValue1, uint64 miscValue2, uint64 miscValue3, Unit const *unit, Player *referencePlayer) const
bool	AdditionalRequirementsSatisfied (ModifierTreeNode const *parent, uint64 miscValue1, uint64 miscValue2, Unit const *unit, Player *referencePlayer) const
template<>
void	SendPacket (WorldPacket const *data) const
template<>
void	SendCriteriaUpdate (AchievementCriteria const *criteria, CriteriaProgress const *progress, uint32 timeElapsed, bool timedCompleted) const

Private Attributes
T *	_owner
CriteriaProgressMap	m_criteriaProgress
CompletedAchievementMap	m_completedAchievements
TimedAchievementMap	m_timedAchievements
uint32	_achievementPoints

Member Typedef Documentation

template<class T>

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

private

Constructor & Destructor Documentation

template<class T>

AchievementMgr< T >::AchievementMgr

(

T *

owner

)

: _owner(owner), _achievementPoints(0) { }

template<class T >

AchievementMgr< T >::~AchievementMgr

(

)

{ }

Member Function Documentation

template<class T >

bool AchievementMgr< T >::AdditionalRequirementsSatisfied ( ModifierTreeNode const *  parent, uint64  miscValue1, uint64  miscValue2, Unit const *  unit, Player *  referencePlayer  ) const

private

{
 for (ModifierTreeNode const* node : tree->Children)
 if (!AdditionalRequirementsSatisfied(node, miscValue1, miscValue2, unit, referencePlayer))
 return false;

 uint32 reqType = tree->Entry->Type;
 if (!reqType)
 return true;

 uint32 reqValue = tree->Entry->Asset[0];

 switch (AchievementCriteriaAdditionalCondition(reqType))
 {
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_TARGET_CREATURE_ENTRY: // 4
 if (!unit || unit->GetEntry() != reqValue)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_TARGET_MUST_BE_PLAYER: // 5
 if (!unit || unit->GetTypeId() != TYPEID_PLAYER)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_TARGET_MUST_BE_DEAD: // 6
 if (!unit || unit->IsAlive())
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_TARGET_MUST_BE_ENEMY: // 7
 if (!unit || !referencePlayer->IsHostileTo(unit))
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_SOURCE_HAS_AURA: // 8
 if (!referencePlayer->HasAura(reqValue))
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_TARGET_HAS_AURA: // 10
 if (!unit || !unit->HasAura(reqValue))
 return false;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_TARGET_HAS_AURA_TYPE: // 11
 if (!unit || !unit->HasAuraType(AuraType(reqValue)))
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_ITEM_QUALITY_MIN: // 14
 {
 // miscValue1 is itemid
 ItemTemplate const* const item = sObjectMgr->GetItemTemplate(uint32(miscValue1));
 if (!item || item->GetQuality() < reqValue)
 return false;
 break;
 }
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_ITEM_QUALITY_EQUALS: // 15
 {
 // miscValue1 is itemid
 ItemTemplate const* const item = sObjectMgr->GetItemTemplate(uint32(miscValue1));
 if (!item || item->GetQuality() != reqValue)
 return false;
 break;
 }
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_SOURCE_AREA_OR_ZONE: // 17
 {
 uint32 zoneId, areaId;
 referencePlayer->GetZoneAndAreaId(zoneId, areaId);
 if (zoneId != reqValue && areaId != reqValue)
 return false;
 break;
 }
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_TARGET_AREA_OR_ZONE: // 18
 {
 if (!unit)
 return false;
 uint32 zoneId, areaId;
 unit->GetZoneAndAreaId(zoneId, areaId);
 if (zoneId != reqValue && areaId != reqValue)
 return false;
 break;
 }
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_MAP_DIFFICULTY: // 20
 if (uint32(referencePlayer->GetMap()->GetDifficultyID()) != reqValue)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_ARENA_TYPE:
 {
 Battleground* bg = referencePlayer->GetBattleground();
 if (!bg || !bg->isArena() || bg->GetArenaType() != reqValue)
 return false;
 break;
 }
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_SOURCE_RACE: // 25
 if (referencePlayer->getRace() != reqValue)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_SOURCE_CLASS: // 26
 if (referencePlayer->getClass() != reqValue)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_TARGET_RACE: // 27
 if (!unit || unit->GetTypeId() != TYPEID_PLAYER || unit->getRace() != reqValue)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_TARGET_CLASS: // 28
 if (!unit || unit->GetTypeId() != TYPEID_PLAYER || unit->getClass() != reqValue)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_MAX_GROUP_MEMBERS: // 29
 if (referencePlayer->GetGroup() && referencePlayer->GetGroup()->GetMembersCount() >= reqValue)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_TARGET_CREATURE_TYPE: // 30
 {
 if (!unit)
 return false;
 Creature const* const creature = unit->ToCreature();
 if (!creature || creature->GetCreatureType() != reqValue)
 return false;
 break;
 }
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_SOURCE_MAP: // 32
 if (referencePlayer->GetMapId() != reqValue)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_TITLE_BIT_INDEX: // 38
 // miscValue1 is title's bit index
 if (miscValue1 != reqValue)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_SOURCE_LEVEL: // 39
 if (referencePlayer->getLevel() != reqValue)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_TARGET_LEVEL: // 40
 if (!unit || unit->getLevel() != reqValue)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_TARGET_ZONE: // 41
 if (!unit || unit->GetZoneId() != reqValue)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_TARGET_HEALTH_PERCENT_BELOW: // 46
 if (!unit || unit->GetHealthPct() >= reqValue)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_BATTLE_PET_SPECIES: // 91
 if (miscValue1 != reqValue)
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_GARRISON_FOLLOWER_QUALITY: // 145
 {
 if (!referencePlayer)
 return false;
 Garrison* garrison = referencePlayer->GetGarrison();
 if (!garrison)
 return false;
 Garrison::Follower const* follower = garrison->GetFollower(miscValue1);
 if (!follower || follower->PacketInfo.Quality != reqValue)
 return false;

 break;
 }
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_GARRISON_FOLLOWER_LEVEL: // 146
 {
 if (!referencePlayer)
 return false;
 Garrison* garrison = referencePlayer->GetGarrison();
 if (!garrison)
 return false;
 Garrison::Follower const* follower = garrison->GetFollower(miscValue1);
 if (!follower || follower->PacketInfo.FollowerLevel < reqValue)
 return false;

 break;
 }
 case ACHIEVEMENT_CRITERIA_ADDITIONAL_CONDITION_GARRISON_FOLLOWER_ILVL: // 184
 {
 if (!referencePlayer)
 return false;
 Garrison* garrison = referencePlayer->GetGarrison();
 if (!garrison)
 return false;
 Garrison::Follower const* follower = garrison->GetFollower(miscValue1);
 if (!follower || follower->GetItemLevel() < reqValue)
 return false;
 break;
 }
 default:
 break;
 }
 return true;
}

Here is the call graph for this function:

template<class T >

bool AchievementMgr< T >::CanUpdateCriteria ( AchievementCriteria const *  criteria, AchievementCriteriaTreeList const *  trees, uint64  miscValue1, uint64  miscValue2, uint64  miscValue3, Unit const *  unit, Player *  referencePlayer  )

private

{
 if (DisableMgr::IsDisabledFor(DISABLE_TYPE_ACHIEVEMENT_CRITERIA, criteria->ID, NULL))
 {
 TC_LOG_TRACE("achievement", "CanUpdateCriteria: (Id: %u Type %s) Disabled",
 criteria->ID, AchievementGlobalMgr::GetCriteriaTypeString(criteria->Entry->Type));
 return false;
 }

 bool treeRequirementPassed = false;
 for (AchievementCriteriaTree const* tree : *trees)
 {
 if (HasAchieved(tree->Achievement->ID))
 {
 TC_LOG_TRACE("achievement", "CanUpdateCriteria: (Id: %u Type %s Achievement %u) Achievement already earned",
 criteria->ID, AchievementGlobalMgr::GetCriteriaTypeString(criteria->Entry->Type), tree->Achievement->ID);
 continue;
 }

 if (tree->Achievement->MapID != -1 && referencePlayer->GetMapId() != uint32(tree->Achievement->MapID))
 {
 TC_LOG_TRACE("achievement", "CanUpdateCriteria: (Id: %u Type %s Achievement %u) Wrong map",
 criteria->ID, AchievementGlobalMgr::GetCriteriaTypeString(criteria->Entry->Type), tree->Achievement->ID);
 continue;
 }

 if ((tree->Achievement->Faction == ACHIEVEMENT_FACTION_HORDE && referencePlayer->GetTeam() != HORDE) ||
 (tree->Achievement->Faction == ACHIEVEMENT_FACTION_ALLIANCE && referencePlayer->GetTeam() != ALLIANCE))
 {
 TC_LOG_TRACE("achievement", "CanUpdateCriteria: (Id: %u Type %s Achievement %u) Wrong faction",
 criteria->ID, AchievementGlobalMgr::GetCriteriaTypeString(criteria->Entry->Type), tree->Achievement->ID);
 continue;
 }

 treeRequirementPassed = true;
 break;
 }

 if (!treeRequirementPassed)
 return false;

 if (!RequirementsSatisfied(criteria, miscValue1, miscValue2, miscValue3, unit, referencePlayer))
 {
 TC_LOG_TRACE("achievement", "CanUpdateCriteria: (Id: %u Type %s) Requirements not satisfied",
 criteria->ID, AchievementGlobalMgr::GetCriteriaTypeString(criteria->Entry->Type));
 return false;
 }

 if (criteria->Modifier && !AdditionalRequirementsSatisfied(criteria->Modifier, miscValue1, miscValue2, unit, referencePlayer))
 {
 TC_LOG_TRACE("achievement", "CanUpdateCriteria: (Id: %u Type %s) Additional requirements not satisfied",
 criteria->ID, AchievementGlobalMgr::GetCriteriaTypeString(criteria->Entry->Type));
 return false;
 }

 if (!ConditionsSatisfied(criteria, referencePlayer))
 {
 TC_LOG_TRACE("achievement", "CanUpdateCriteria: (Id: %u Type %s) Conditions not satisfied",
 criteria->ID, AchievementGlobalMgr::GetCriteriaTypeString(criteria->Entry->Type));
 return false;
 }

 return true;
}

Here is the call graph for this function:

template<class T >

void AchievementMgr< T >::CheckAllAchievementCriteria

(

Player *

referencePlayer

)

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), 0, 0, 0, NULL, referencePlayer);
}

template<class T>

void AchievementMgr< T >::CompletedAchievement	(	AchievementEntry const *	entry,
		Player *	referencePlayer
	)

template<>

void AchievementMgr< Player >::CompletedAchievement	(	AchievementEntry const *	achievement,
		Player *	referencePlayer
	)

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 (GetOwner()->IsGameMaster())
 return;

 if (achievement->Flags & ACHIEVEMENT_FLAG_COUNTER || HasAchieved(achievement->ID))
 return;

 if (achievement->Flags & ACHIEVEMENT_FLAG_SHOW_IN_GUILD_NEWS)
 if (Guild* guild = referencePlayer->GetGuild())
 guild->AddGuildNews(GUILD_NEWS_PLAYER_ACHIEVEMENT, referencePlayer->GetGUID(), achievement->Flags & ACHIEVEMENT_FLAG_SHOW_IN_GUILD_HEADER, achievement->ID);

 if (!GetOwner()->GetSession()->PlayerLoading())
 SendAchievementEarned(achievement);

 TC_LOG_DEBUG("achievement", "AchievementMgr::CompletedAchievement(%u). %s %s",
 achievement->ID, GetOwner()->GetGUID().ToString().c_str(), GetOwner()->GetName().c_str());

 CompletedAchievementData& ca = m_completedAchievements[achievement->ID];
 ca.date = time(NULL);
 ca.changed = true;

 sAchievementMgr->SetRealmCompleted(achievement, GetOwner()->GetInstanceId());

 _achievementPoints += achievement->Points;

 UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT, 0, 0, 0, NULL, referencePlayer);
 UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_EARN_ACHIEVEMENT_POINTS, achievement->Points, 0, 0, NULL, referencePlayer);

 // 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 ? GetOwner()->GetByteValue(PLAYER_BYTES_3, PLAYER_BYTES_3_OFFSET_GENDER) : (GetOwner()->GetTeam() == ALLIANCE ? 0 : 1)])
 if (CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(titleId))
 GetOwner()->SetTitle(titleEntry);

 // mail
 if (reward->sender)
 {
 MailDraft draft(reward->mailTemplate);

 if (!reward->mailTemplate)
 {
 // subject and text
 std::string subject = reward->subject;
 std::string text = reward->text;

 LocaleConstant localeConstant = GetOwner()->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);
 }

 SQLTransaction trans = CharacterDatabase.BeginTransaction();

 Item* item = reward->itemId ? Item::CreateItem(reward->itemId, 1, GetOwner()) : NULL;
 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, GetOwner(), MailSender(MAIL_CREATURE, uint64(reward->sender)));
 CharacterDatabase.CommitTransaction(trans);
 }
}

Here is the call graph for this function:

template<class T >

void AchievementMgr< T >::CompletedCriteriaFor ( AchievementEntry const *  achievement, Player *  referencePlayer  )

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, referencePlayer);
}

template<class T >

bool AchievementMgr< T >::ConditionsSatisfied ( AchievementCriteria const *  criteria, Player *  referencePlayer  ) const

private

{
 if (!criteria->Entry->FailEvent)
 return true;

 switch (criteria->Entry->FailEvent)
 {
 case ACHIEVEMENT_CRITERIA_CONDITION_BG_MAP:
 if (!referencePlayer->InBattleground())
 return false;
 break;
 case ACHIEVEMENT_CRITERIA_CONDITION_NOT_IN_GROUP:
 if (referencePlayer->GetGroup())
 return false;
 break;
 default:
 break;
 }

 return true;
}

template<class T>

uint32 AchievementMgr< T >::GetAchievementPoints ( ) const

inline

{ return _achievementPoints; }

Here is the caller graph for this function:

template<class T >

CriteriaProgress * AchievementMgr< T >::GetCriteriaProgress ( AchievementCriteria const *  entry )

private

{
 CriteriaProgressMap::iterator iter = m_criteriaProgress.find(entry->ID);

 if (iter == m_criteriaProgress.end())
 return NULL;

 return &(iter->second);
}

template<class T>

T* AchievementMgr< T >::GetOwner ( ) const

inline

{ return _owner; }

Here is the caller graph for this function:

template<class T >

bool AchievementMgr< T >::HasAchieved

(

uint32

achievementId

)

const

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

Here is the caller graph for this function:

template<class T >

bool AchievementMgr< T >::IsCompletedAchievement ( AchievementEntry const *  entry )

private

{
 // counter can never complete
 if (entry->Flags & ACHIEVEMENT_FLAG_COUNTER)
 return false;

 AchievementCriteriaTree const* tree = sAchievementMgr->GetAchievementCriteriaTree(entry->CriteriaTree);
 if (!tree)
 return false;

 // For SUMM achievements, we have to count the progress of each criteria of the achievement.
 // Oddly, the target count is NOT contained in the achievement, but in each individual criteria
 if (entry->Flags & ACHIEVEMENT_FLAG_SUMM)
 {
 uint64 progress = 0;
 sAchievementMgr->WalkCriteriaTree(tree, [this, &progress](AchievementCriteriaTree const* criteriaTree)
 {
 if (criteriaTree->Criteria)
 if (CriteriaProgress const* criteriaProgress = this->GetCriteriaProgress(criteriaTree->Criteria))
 progress += criteriaProgress->counter;
 });
 return progress >= tree->Entry->Amount;
 }

 return IsCompletedCriteriaTree(tree);
}

template<class T >

bool AchievementMgr< T >::IsCompletedCriteria ( AchievementCriteria const *  achievementCriteria, uint64  requiredAmount  )

private

{
 CriteriaProgress const* progress = GetCriteriaProgress(achievementCriteria);
 if (!progress)
 return false;

 switch (AchievementCriteriaTypes(achievementCriteria->Entry->Type))
 {
 case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG:
 case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
 case ACHIEVEMENT_CRITERIA_TYPE_REACH_LEVEL:
 case ACHIEVEMENT_CRITERIA_TYPE_REACH_GUILD_LEVEL:
 case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL:
 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST_COUNT:
 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST_DAILY:
 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
 case ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE:
 case ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE:
 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST:
 case ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING:
 case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
 case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
 case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
 case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
 case ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE:
 case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL_AT_AREA:
 case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL:
 case ACHIEVEMENT_CRITERIA_TYPE_EARN_HONORABLE_KILL:
 case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM:
 case ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA:
 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_PERSONAL_RATING:
 case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:
 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM:
 case ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT:
 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION:
 case ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP:
 case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM:
 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT:
 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT:
 case ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS:
 case ACHIEVEMENT_CRITERIA_TYPE_HK_RACE:
 case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
 case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM:
 case ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_QUEST_REWARD:
 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_MONEY:
 case ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT:
 case ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL:
 case ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT:
 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
 case ACHIEVEMENT_CRITERIA_TYPE_WIN_DUEL:
 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:
 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE:
 case ACHIEVEMENT_CRITERIA_TYPE_USE_LFD_TO_GROUP_WITH_PLAYERS:
 case ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS:
 case ACHIEVEMENT_CRITERIA_TYPE_CURRENCY:
 case ACHIEVEMENT_CRITERIA_TYPE_PLACE_GARRISON_BUILDING:
 case ACHIEVEMENT_CRITERIA_TYPE_OWN_BATTLE_PET_COUNT:
 return progress->counter >= requiredAmount;
 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT:
 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL:
 case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA:
 case ACHIEVEMENT_CRITERIA_TYPE_RECRUIT_GARRISON_FOLLOWER:
 case ACHIEVEMENT_CRITERIA_TYPE_OWN_BATTLE_PET:
 return progress->counter >= 1;
 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL:
 return progress->counter >= (requiredAmount * 75);
 case ACHIEVEMENT_CRITERIA_TYPE_EARN_ACHIEVEMENT_POINTS:
 return progress->counter >= 9000;
 case ACHIEVEMENT_CRITERIA_TYPE_WIN_ARENA:
 return requiredAmount && progress->counter >= requiredAmount;
 case ACHIEVEMENT_CRITERIA_TYPE_ON_LOGIN:
 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_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_QUEST_ABANDONED:
 case ACHIEVEMENT_CRITERIA_TYPE_FLIGHT_PATHS_TAKEN:
 case ACHIEVEMENT_CRITERIA_TYPE_ACCEPTED_SUMMONINGS:
 default:
 break;
 }

 return false;
}

template<class T >

bool AchievementMgr< T >::IsCompletedCriteriaTree ( AchievementCriteriaTree const *  tree )

private

{
 AchievementEntry const* achievement = tree->Achievement;
 if (!achievement)
 return false;

 // 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, GetInstanceId(GetOwner())))
 return false;
 }

 uint64 requiredCount = tree->Entry->Amount;
 uint64 completedCount = 0;
 uint32 op = tree->Entry->Operator;
 bool hasAll = true;

 // Check criteria we depend on first
 for (AchievementCriteriaTree const* node : tree->Children)
 {
 if (IsCompletedCriteriaTree(node))
 ++completedCount;
 else
 hasAll = false;

 if (op & ACHIEVEMENT_CRITERIA_TREE_OPERATOR_ANY && completedCount >= requiredCount)
 {
 if (!tree->Criteria)
 return true;

 break;
 }
 }

 if (op & ACHIEVEMENT_CRITERIA_TREE_OPERATOR_ANY && completedCount < requiredCount)
 return false;

 if (op & ACHIEVEMENT_CRITERIA_TREE_OPERATOR_ALL && !hasAll)
 return false;

 if (!tree->Criteria)
 return true;

 return IsCompletedCriteria(tree->Criteria, requiredCount);
}

Here is the call graph for this function:

template<class T >

void AchievementMgr< T >::LoadFromDB	(	PreparedQueryResult	achievementResult,
		PreparedQueryResult	criteriaResult
	)

{
}

template<>

void AchievementMgr< Player >::LoadFromDB	(	PreparedQueryResult	achievementResult,
		PreparedQueryResult	criteriaResult
	)

{
 if (achievementResult)
 {
 do
 {
 Field* fields = achievementResult->Fetch();
 uint32 achievementid = fields[0].GetUInt16();

 // must not happen: cleanup at server startup in sAchievementMgr->LoadCompletedAchievements()
 AchievementEntry const* achievement = sAchievementMgr->GetAchievement(achievementid);
 if (!achievement)
 continue;

 CompletedAchievementData& ca = m_completedAchievements[achievementid];
 ca.date = time_t(fields[1].GetUInt32());
 ca.changed = false;

 _achievementPoints += achievement->Points;

 // title achievement rewards are retroactive
 if (AchievementReward const* reward = sAchievementMgr->GetAchievementReward(achievement))
 if (uint32 titleId = reward->titleId[Player::TeamForRace(GetOwner()->getRace()) == ALLIANCE ? 0 : 1])
 if (CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(titleId))
 GetOwner()->SetTitle(titleEntry);

 }
 while (achievementResult->NextRow());
 }

 if (criteriaResult)
 {
 time_t now = time(NULL);
 do
 {
 Field* fields = criteriaResult->Fetch();
 uint32 id = fields[0].GetUInt32();
 uint64 counter = fields[1].GetUInt64();
 time_t date = time_t(fields[2].GetUInt32());

 AchievementCriteria const* criteria = sAchievementMgr->GetAchievementCriteria(id);
 if (!criteria)
 {
 // we will remove not existed criteria for all characters
 TC_LOG_ERROR("achievement", "Non-existing achievement criteria %u data removed from table `character_achievement_progress`.", id);

 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_INVALID_ACHIEV_PROGRESS_CRITERIA);
 stmt->setUInt32(0, uint16(id));
 CharacterDatabase.Execute(stmt);

 continue;
 }

 if (criteria->Entry->StartTimer && time_t(date + criteria->Entry->StartTimer) < now)
 continue;

 CriteriaProgress& progress = m_criteriaProgress[id];
 progress.counter = counter;
 progress.date = date;
 progress.changed = false;
 }
 while (criteriaResult->NextRow());
 }
}

Here is the call graph for this function:

template<class T >

void AchievementMgr< T >::RemoveCriteriaProgress ( AchievementCriteria const *  entry )

private

{
 if (!entry)
 return;

 CriteriaProgressMap::iterator criteriaProgress = m_criteriaProgress.find(entry->ID);
 if (criteriaProgress == m_criteriaProgress.end())
 return;

 WorldPackets::Achievement::CriteriaDeleted criteriaDeleted;
 criteriaDeleted.CriteriaID = entry->ID;
 SendPacket(criteriaDeleted.Write());

 m_criteriaProgress.erase(criteriaProgress);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

void AchievementMgr< T >::RemoveTimedAchievement	(	AchievementCriteriaTimedTypes	type,
		uint32	entry
	)

{
 AchievementCriteriaList const& achievementCriteriaList = sAchievementMgr->GetTimedAchievementCriteriaByType(type);
 for (AchievementCriteria const* criteria : achievementCriteriaList)
 {
 if (criteria->Entry->StartAsset != entry)
 continue;

 AchievementCriteriaTreeList const* trees = sAchievementMgr->GetAchievementCriteriaTreesByCriteria(criteria->ID);
 // Remove the timer from all trees
 for (AchievementCriteriaTree const* tree : *trees)
 m_timedAchievements.erase(tree->ID);

 // remove progress
 RemoveCriteriaProgress(criteria);
 }
}

template<class T >

bool AchievementMgr< T >::RequirementsSatisfied ( AchievementCriteria const *  criteria, uint64  miscValue1, uint64  miscValue2, uint64  miscValue3, Unit const *  unit, Player *  referencePlayer  ) const

private

{
 switch (AchievementCriteriaTypes(achievementCriteria->Entry->Type))
 {
 case ACHIEVEMENT_CRITERIA_TYPE_ACCEPTED_SUMMONINGS:
 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST:
 case ACHIEVEMENT_CRITERIA_TYPE_CREATE_AUCTION:
 case ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING:
 case ACHIEVEMENT_CRITERIA_TYPE_FLIGHT_PATHS_TAKEN:
 case ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS:
 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_EARNED_BY_AUCTIONS:
 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_AT_BARBER:
 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_MAIL:
 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_TALENTS:
 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_TRAVELLING:
 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID:
 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_SOLD:
 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALING_RECEIVED:
 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEAL_CAST:
 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_DEALT:
 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_RECEIVED:
 case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL:
 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_MONEY:
 case ACHIEVEMENT_CRITERIA_TYPE_LOSE_DUEL:
 case ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_QUEST_REWARD:
 case ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_VENDORS:
 case ACHIEVEMENT_CRITERIA_TYPE_NUMBER_OF_TALENT_RESETS:
 case ACHIEVEMENT_CRITERIA_TYPE_QUEST_ABANDONED:
 case ACHIEVEMENT_CRITERIA_TYPE_REACH_GUILD_LEVEL:
 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED:
 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED:
 case ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL:
        case ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED:
        case ACHIEVEMENT_CRITERIA_TYPE_TOTAL_HEALING_RECEIVED:
        case ACHIEVEMENT_CRITERIA_TYPE_USE_LFD_TO_GROUP_WITH_PLAYERS:
        case ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP:
        case ACHIEVEMENT_CRITERIA_TYPE_WIN_DUEL:
        case ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA:
        case ACHIEVEMENT_CRITERIA_TYPE_WON_AUCTIONS:
            if (!miscValue1)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT:
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST_DAILY:
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST_COUNT:
        case ACHIEVEMENT_CRITERIA_TYPE_EARN_ACHIEVEMENT_POINTS:
        case ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION:
        case ACHIEVEMENT_CRITERIA_TYPE_GAIN_HONORED_REPUTATION:
        case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REVERED_REPUTATION:
        case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_GOLD_VALUE_OWNED:
        case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_PERSONAL_RATING:
        case ACHIEVEMENT_CRITERIA_TYPE_KNOWN_FACTIONS:
        case ACHIEVEMENT_CRITERIA_TYPE_REACH_LEVEL:
        case ACHIEVEMENT_CRITERIA_TYPE_ON_LOGIN:
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT:
            if (m_completedAchievements.find(achievementCriteria->Entry->Asset.AchievementID) == m_completedAchievements.end())
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG:
            if (!miscValue1 || achievementCriteria->Entry->Asset.MapID != referencePlayer->GetMapId())
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
            if (!miscValue1 || achievementCriteria->Entry->Asset.CreatureID != miscValue1)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL:
        case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL:
            // update at loading or specific skill update
            if (miscValue1 && miscValue1 != achievementCriteria->Entry->Asset.SkillID)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
            if (miscValue1 && miscValue1 != achievementCriteria->Entry->Asset.ZoneID)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND:
        case ACHIEVEMENT_CRITERIA_TYPE_DEATH_AT_MAP:
            if (!miscValue1 || referencePlayer->GetMapId() != achievementCriteria->Entry->Asset.MapID)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_DEATH:
        {
            if (!miscValue1)
                return false;
            break;
        }
        case ACHIEVEMENT_CRITERIA_TYPE_DEATH_IN_DUNGEON:
        {
            if (!miscValue1)
                return false;

            Map const* map = referencePlayer->IsInWorld() ? referencePlayer->GetMap() : sMapMgr->FindMap(referencePlayer->GetMapId(), referencePlayer->GetInstanceId());
            if (!map || !map->IsDungeon())
                return false;

            //FIXME: work only for instances where max == min for players
            if (map->ToInstanceMap()->GetMaxPlayers() != achievementCriteria->Entry->Asset.GroupSize)
                return false;
            break;
        }
        case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE:
            if (!miscValue1 || miscValue1 != achievementCriteria->Entry->Asset.CreatureID)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_PLAYER:
            if (!miscValue1 || !unit || unit->GetTypeId() != TYPEID_PLAYER)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_DEATHS_FROM:
            if (!miscValue1 || miscValue2 != achievementCriteria->Entry->Asset.DamageType)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
        {
            // if miscValues != 0, it contains the questID.
            if (miscValue1)
            {
                if (miscValue1 != achievementCriteria->Entry->Asset.QuestID)
                    return false;
            }
            else
            {
                // login case.
                if (!referencePlayer->GetQuestRewardStatus(achievementCriteria->Entry->Asset.QuestID))
                    return false;
            }

            if (AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria))
                if (!data->Meets(referencePlayer, unit))
                    return false;
            break;
        }
        case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
        case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
        case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
        case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
            if (!miscValue1 || miscValue1 != achievementCriteria->Entry->Asset.SpellID)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL:
            if (miscValue1 && miscValue1 != achievementCriteria->Entry->Asset.SpellID)
                return false;

            if (!referencePlayer->HasSpell(achievementCriteria->Entry->Asset.SpellID))
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:
            // miscValue1 = itemId - miscValue2 = count of item loot
            // miscValue3 = loot_type (note: 0 = LOOT_CORPSE and then it ignored)
            if (!miscValue1 || !miscValue2 || !miscValue3 || miscValue3 != achievementCriteria->Entry->Asset.LootType)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM:
            if (miscValue1 && achievementCriteria->Entry->Asset.ItemID != miscValue1)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:
        case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM:
        case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM:
            if (!miscValue1 || achievementCriteria->Entry->Asset.ItemID != miscValue1)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA:
        {
            WorldMapOverlayEntry const* worldOverlayEntry = sWorldMapOverlayStore.LookupEntry(achievementCriteria->Entry->Asset.WorldMapOverlayID);
            if (!worldOverlayEntry)
                break;

            bool matchFound = false;
            for (int j = 0; j < MAX_WORLD_MAP_OVERLAY_AREA_IDX; ++j)
            {
                AreaTableEntry const* area = sAreaTableStore.LookupEntry(worldOverlayEntry->AreaID[j]);
                if (!area)
                    break;

                if (area->AreaBit < 0)
                    continue;

                uint32 playerIndexOffset = uint32(area->AreaBit) / 32;
                if (playerIndexOffset >= PLAYER_EXPLORED_ZONES_SIZE)
                    continue;

                uint32 mask = 1 << (uint32(area->AreaBit) % 32);
                if (referencePlayer->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + playerIndexOffset) & mask)
                {
                    matchFound = true;
                    break;
                }
            }

            if (!matchFound)
                return false;
            break;
        }
        case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
            if (miscValue1 && miscValue1 != achievementCriteria->Entry->Asset.FactionID)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM:
            // miscValue1 = itemid miscValue2 = itemSlot
            if (!miscValue1 || miscValue2 != achievementCriteria->Entry->Asset.ItemSlot)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT:
        case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT:
        {
            // miscValue1 = itemid miscValue2 = diced value
            if (!miscValue1 || miscValue2 != achievementCriteria->Entry->Asset.RollValue)
                return false;

            ItemTemplate const* proto = sObjectMgr->GetItemTemplate(uint32(miscValue1));
            if (!proto)
                return false;
            break;
        }
        case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
            if (!miscValue1 || miscValue1 != achievementCriteria->Entry->Asset.EmoteID)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE:
        case ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE:
            if (!miscValue1)
                return false;

            if (achievementCriteria->Entry->FailEvent == ACHIEVEMENT_CRITERIA_CONDITION_BG_MAP)
            {
                if (!referencePlayer->InBattleground())
                    return false;

                // map specific case (BG in fact) expected player targeted damage/heal
                if (!unit || unit->GetTypeId() != TYPEID_PLAYER)
                    return false;
            }
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT:
        case ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT:
            if (!miscValue1 || miscValue1 != achievementCriteria->Entry->Asset.GameObjectID)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
        case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE:
            if (miscValue1 && miscValue1 != achievementCriteria->Entry->Asset.SkillID)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_LOOT_EPIC_ITEM:
        case ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM:
        {
            if (!miscValue1)
                return false;
            ItemTemplate const* proto = sObjectMgr->GetItemTemplate(uint32(miscValue1));
            if (!proto || proto->GetQuality() < ITEM_QUALITY_EPIC)
                return false;
            break;
        }
        case ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS:
            if (!miscValue1 || miscValue1 != achievementCriteria->Entry->Asset.ClassID)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_HK_RACE:
            if (!miscValue1 || miscValue1 != achievementCriteria->Entry->Asset.RaceID)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE:
            if (!miscValue1 || miscValue1 != achievementCriteria->Entry->Asset.ObjectiveId)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL_AT_AREA:
            if (!miscValue1 || miscValue1 != achievementCriteria->Entry->Asset.AreaID)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_CURRENCY:
            if (!miscValue1 || !miscValue2 || int64(miscValue2) < 0
                || miscValue1 != achievementCriteria->Entry->Asset.CurrencyID)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_WIN_ARENA:
            if (miscValue1 != achievementCriteria->Entry->Asset.MapID)
                return false;
            break;
        case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_TEAM_RATING:
            return false;
        case ACHIEVEMENT_CRITERIA_TYPE_PLACE_GARRISON_BUILDING:
            if (miscValue1 != achievementCriteria->Entry->Asset.GarrBuildingID)
                return false;
            break;
        default:
            break;
    }
    return true;
}

Here is the call graph for this function:

template<class T >

void AchievementMgr< T >::Reset

(

)

{
}

template<>

void AchievementMgr< Player >::Reset

(

)

{
    for (CompletedAchievementMap::const_iterator iter = m_completedAchievements.begin(); iter != m_completedAchievements.end(); ++iter)
    {
        WorldPackets::Achievement::AchievementDeleted achievementDeleted;
        achievementDeleted.AchievementID = iter->first;
        SendPacket(achievementDeleted.Write());
    }

    for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter != m_criteriaProgress.end(); ++iter)
    {
        WorldPackets::Achievement::CriteriaDeleted criteriaDeleted;
        criteriaDeleted.CriteriaID = iter->first;
        SendPacket(criteriaDeleted.Write());
    }

    m_completedAchievements.clear();
    _achievementPoints = 0;
    m_criteriaProgress.clear();
    DeleteFromDB(GetOwner()->GetGUID());

    // re-fill data
    CheckAllAchievementCriteria(GetOwner());
}

Here is the call graph for this function:

template<class T >

void AchievementMgr< T >::ResetAchievementCriteria	(	AchievementCriteriaTypes	type,
		uint64	miscValue1 = 0,
		uint64	miscValue2 = 0,
		bool	evenIfCriteriaComplete = false
	)

{
    TC_LOG_DEBUG("achievement", "ResetAchievementCriteria(%u, " UI64FMTD ", " UI64FMTD ")", type, miscValue1, miscValue2);

    // disable for gamemasters with GM-mode enabled
    if (GetOwner()->IsGameMaster())
        return;

    AchievementCriteriaList const& achievementCriteriaList = sAchievementMgr->GetAchievementCriteriaByType(type);
    for (AchievementCriteria const* achievementCriteria : achievementCriteriaList)
    {
        if (achievementCriteria->Entry->FailEvent != miscValue1 || (achievementCriteria->Entry->FailAsset && achievementCriteria->Entry->FailAsset != miscValue2))
            continue;

        AchievementCriteriaTreeList const* trees = sAchievementMgr->GetAchievementCriteriaTreesByCriteria(achievementCriteria->ID);
        bool allComplete = true;
        for (AchievementCriteriaTree const* tree : *trees)
        {
            // don't update already completed criteria if not forced or achievement already complete
            if (!(IsCompletedCriteriaTree(tree) && !evenIfCriteriaComplete) || !HasAchieved(tree->Achievement->ID))
            {
                allComplete = false;
                break;
            }
        }

        if (allComplete)
            continue;

        RemoveCriteriaProgress(achievementCriteria);
    }
}

template<class T >

void AchievementMgr< T >::SaveToDB

(

SQLTransaction &

trans

)

{
}

Here is the caller graph for this function:

template<>

void AchievementMgr< Player >::SaveToDB

(

SQLTransaction &

trans

)

{
    if (!m_completedAchievements.empty())
    {
        for (CompletedAchievementMap::iterator iter = m_completedAchievements.begin(); iter != m_completedAchievements.end(); ++iter)
        {
            if (!iter->second.changed)
                continue;

            PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_ACHIEVEMENT_BY_ACHIEVEMENT);
            stmt->setUInt16(0, iter->first);
            stmt->setUInt64(1, GetOwner()->GetGUID().GetCounter());
            trans->Append(stmt);

            stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_ACHIEVEMENT);
            stmt->setUInt64(0, GetOwner()->GetGUID().GetCounter());
            stmt->setUInt16(1, iter->first);
            stmt->setUInt32(2, uint32(iter->second.date));
            trans->Append(stmt);

            iter->second.changed = false;
        }
    }

    if (!m_criteriaProgress.empty())
    {
        for (CriteriaProgressMap::iterator iter = m_criteriaProgress.begin(); iter != m_criteriaProgress.end(); ++iter)
        {
            if (!iter->second.changed)
                continue;

            PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_ACHIEVEMENT_PROGRESS_BY_CRITERIA);
            stmt->setUInt64(0, GetOwner()->GetGUID().GetCounter());
            stmt->setUInt32(1, iter->first);
            trans->Append(stmt);

            if (iter->second.counter)
            {
                stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_ACHIEVEMENT_PROGRESS);
                stmt->setUInt64(0, GetOwner()->GetGUID().GetCounter());
                stmt->setUInt32(1, iter->first);
                stmt->setUInt32(2, iter->second.counter);
                stmt->setUInt32(3, uint32(iter->second.date));
                trans->Append(stmt);
            }

            iter->second.changed = false;
        }
    }
}

Here is the call graph for this function:

template<class T >

void AchievementMgr< T >::SendAchievementEarned ( AchievementEntry const *  achievement ) const

private

{
    // Don't send for achievements with ACHIEVEMENT_FLAG_HIDDEN
    if (achievement->Flags & ACHIEVEMENT_FLAG_HIDDEN)
        return;

    TC_LOG_DEBUG("achievement", "AchievementMgr::SendAchievementEarned(%u)", achievement->ID);

    if (Guild* guild = sGuildMgr->GetGuildById(GetOwner()->GetGuildId()))
    {
        Trinity::BroadcastTextBuilder _builder(GetOwner(), CHAT_MSG_GUILD_ACHIEVEMENT, BROADCAST_TEXT_ACHIEVEMENT_EARNED, GetOwner(), achievement->ID);
        Trinity::LocalizedPacketDo<Trinity::BroadcastTextBuilder> _localizer(_builder);
        guild->BroadcastWorker(_localizer, GetOwner());
    }

    if (achievement->Flags & (ACHIEVEMENT_FLAG_REALM_FIRST_KILL | ACHIEVEMENT_FLAG_REALM_FIRST_REACH))
    {
        // broadcast realm first reached
        WorldPackets::Achievement::ServerFirstAchievement serverFirstAchievement;
        serverFirstAchievement.Name = GetOwner()->GetName();
        serverFirstAchievement.PlayerGUID = GetOwner()->GetGUID();
        serverFirstAchievement.AchievementID = achievement->ID;
        sWorld->SendGlobalMessage(serverFirstAchievement.Write());
    }
    // if player is in world he can tell his friends about new achievement
    else if (GetOwner()->IsInWorld())
    {
        Trinity::BroadcastTextBuilder _builder(GetOwner(), CHAT_MSG_ACHIEVEMENT, BROADCAST_TEXT_ACHIEVEMENT_EARNED, GetOwner(), achievement->ID);
        Trinity::LocalizedPacketDo<Trinity::BroadcastTextBuilder> _localizer(_builder);
        Trinity::PlayerDistWorker<Trinity::LocalizedPacketDo<Trinity::BroadcastTextBuilder> > _worker(GetOwner(), sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY), _localizer);
        GetOwner()->VisitNearbyWorldObject(sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY), _worker);
    }

    WorldPackets::Achievement::AchievementEarned achievementEarned;
    achievementEarned.Sender = GetOwner()->GetGUID();
    achievementEarned.Earner = GetOwner()->GetGUID();
    achievementEarned.EarnerNativeRealm = achievementEarned.EarnerVirtualRealm = GetVirtualRealmAddress();
    achievementEarned.AchievementID = achievement->ID;
    achievementEarned.Time = time(NULL);
    GetOwner()->SendMessageToSetInRange(achievementEarned.Write(), sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY), true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T>

void AchievementMgr< T >::SendAchievementInfo	(	Player *	receiver,
		uint32	achievementId = 0
	)		const

template<>

void AchievementMgr< Player >::SendAchievementInfo	(	Player *	receiver,
		uint32
	)		const

{
    VisibleAchievementCheck filterInvisible;
    WorldPackets::Achievement::RespondInspectAchievements inspectedAchievements;
    inspectedAchievements.Player = GetOwner()->GetGUID();
    inspectedAchievements.Data.Earned.reserve(m_completedAchievements.size());
    inspectedAchievements.Data.Progress.reserve(m_criteriaProgress.size());

    for (auto itr = m_completedAchievements.begin(); itr != m_completedAchievements.end(); ++itr)
    {
        AchievementEntry const* achievement = filterInvisible(*itr);
        if (!achievement)
            continue;

        WorldPackets::Achievement::EarnedAchievement earned;
        earned.Id = itr->first;
        earned.Date = itr->second.date;
        if (!(achievement->Flags & ACHIEVEMENT_FLAG_ACCOUNT))
        {
            earned.Owner = GetOwner()->GetGUID();
            earned.VirtualRealmAddress = earned.NativeRealmAddress = GetVirtualRealmAddress();
        }
        inspectedAchievements.Data.Earned.push_back(earned);
    }

    for (auto itr = m_criteriaProgress.begin(); itr != m_criteriaProgress.end(); ++itr)
    {
        WorldPackets::Achievement::CriteriaProgress progress;
        progress.Id = itr->first;
        progress.Quantity = itr->second.counter;
        progress.Player = itr->second.PlayerGUID;
        progress.Flags = 0;
        progress.Date = itr->second.date;
        progress.TimeFromStart = 0;
        progress.TimeFromCreate = 0;
        inspectedAchievements.Data.Progress.push_back(progress);
    }

    receiver->GetSession()->SendPacket(inspectedAchievements.Write());
}

Here is the call graph for this function:

template<class T >

void AchievementMgr< T >::SendAllAchievementData

(

Player *

receiver

)

const

{
    VisibleAchievementCheck filterInvisible;
    WorldPackets::Achievement::AllAchievementData achievementData;
    achievementData.Data.Earned.reserve(m_completedAchievements.size());
    achievementData.Data.Progress.reserve(m_criteriaProgress.size());

    for (auto itr = m_completedAchievements.begin(); itr != m_completedAchievements.end(); ++itr)
    {
        AchievementEntry const* achievement = filterInvisible(*itr);
        if (!achievement)
            continue;

        WorldPackets::Achievement::EarnedAchievement earned;
        earned.Id = itr->first;
        earned.Date = itr->second.date;
        if (!(achievement->Flags & ACHIEVEMENT_FLAG_ACCOUNT))
        {
            earned.Owner = GetOwner()->GetGUID();
            earned.VirtualRealmAddress = earned.NativeRealmAddress = GetVirtualRealmAddress();
        }
        achievementData.Data.Earned.push_back(earned);
    }

    for (auto itr = m_criteriaProgress.begin(); itr != m_criteriaProgress.end(); ++itr)
    {
        WorldPackets::Achievement::CriteriaProgress progress;
        progress.Id = itr->first;
        progress.Quantity = itr->second.counter;
        progress.Player = itr->second.PlayerGUID;
        progress.Flags = 0;
        progress.Date = itr->second.date;
        progress.TimeFromStart = 0;
        progress.TimeFromCreate = 0;
        achievementData.Data.Progress.push_back(progress);
    }

    SendPacket(achievementData.Write());
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

void AchievementMgr< T >::SendAllTrackedCriterias	(	Player *	receiver,
		std::set< uint32 > const &	trackedCriterias
	)		const

{
}

Here is the caller graph for this function:

template<class T >

void AchievementMgr< T >::SendCriteriaUpdate ( AchievementCriteria const *  entry, CriteriaProgress const *  progress, uint32  timeElapsed, bool  timedCompleted  ) const

private

{
}

template<>

void AchievementMgr< Player >::SendCriteriaUpdate ( AchievementCriteria const *  criteria, CriteriaProgress const *  progress, uint32  timeElapsed, bool  timedCompleted  ) const

private

{
    WorldPackets::Achievement::CriteriaUpdate criteriaUpdate;

    criteriaUpdate.CriteriaID = criteria->ID;
    criteriaUpdate.Quantity = progress->counter;
    criteriaUpdate.PlayerGUID = GetOwner()->GetGUID();
    if (criteria->Entry->StartTimer)
        criteriaUpdate.Flags = timedCompleted ? 1 : 0; // 1 is for keeping the counter at 0 in client

    criteriaUpdate.Flags = 0;
    criteriaUpdate.CurrentTime = progress->date;
    criteriaUpdate.ElapsedTime = timeElapsed;
    criteriaUpdate.CreationTime = 0;

    SendPacket(criteriaUpdate.Write());
}

Here is the call graph for this function:

template<class T >

void AchievementMgr< T >::SendPacket ( WorldPacket const *  data ) const

private

{ }

Here is the caller graph for this function:

template<>

void AchievementMgr< Player >::SendPacket ( WorldPacket const *  data ) const

private

{
    GetOwner()->GetSession()->SendPacket(data);
}

template<class T >

void AchievementMgr< T >::SetCriteriaProgress ( AchievementCriteria const *  entry, uint64  changeValue, Player *  referencePlayer, ProgressType  ptype = PROGRESS_SET  )

private

{
    // Don't allow to cheat - doing timed achievements without timer active
    AchievementCriteriaTreeList const* trees = nullptr;
    if (criteria->Entry->StartTimer)
    {
        trees = sAchievementMgr->GetAchievementCriteriaTreesByCriteria(criteria->ID);
        if (!trees)
            return;

        bool hasTreeForTimed = false;
        for (AchievementCriteriaTree const* tree : *trees)
        {
            auto timedIter = m_timedAchievements.find(tree->ID);
            if (timedIter != m_timedAchievements.end())
            {
                hasTreeForTimed = true;
                break;
            }

        }

        if (!hasTreeForTimed)
            return;
    }

    TC_LOG_DEBUG("achievement", "SetCriteriaProgress(%u, " UI64FMTD ") for (%s)",
                   criteria->ID, changeValue, GetOwner()->GetGUID().ToString().c_str());

    CriteriaProgress* progress = GetCriteriaProgress(criteria);
    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 && !criteria->Entry->StartTimer)
            return;

        progress = &m_criteriaProgress[criteria->ID];
        progress->counter = changeValue;
    }
    else
    {
        uint64 newValue = 0;
        switch (ptype)
        {
            case PROGRESS_SET:
                newValue = changeValue;
                break;
            case PROGRESS_ACCUMULATE:
            {
                // avoid overflow
                uint64 max_value = std::numeric_limits<uint64>::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 (progress->counter == newValue && !criteria->Entry->StartTimer)
            return;

        progress->counter = newValue;
    }

    progress->changed = true;
    progress->date = time(NULL); // set the date to the latest update.
    progress->PlayerGUID = referencePlayer->GetGUID();

    uint32 timeElapsed = 0;

    if (criteria->Entry->StartTimer)
    {
        ASSERT(trees);

        for (AchievementCriteriaTree const* tree : *trees)
        {
            auto timedIter = m_timedAchievements.find(tree->ID);
            if (timedIter != m_timedAchievements.end())
            {
                // Client expects this in packet
                timeElapsed = criteria->Entry->StartTimer - (timedIter->second / IN_MILLISECONDS);

                // Remove the timer, we wont need it anymore
                if (IsCompletedCriteriaTree(tree))
                    m_timedAchievements.erase(timedIter);
            }
        }
    }

    SendCriteriaUpdate(criteria, progress, timeElapsed, true);
}

Here is the call graph for this function:

template<class T >

void AchievementMgr< T >::StartTimedAchievement	(	AchievementCriteriaTimedTypes	type,
		uint32	entry,
		uint32	timeLost = 0
	)

{
}

template<>

void AchievementMgr< Player >::StartTimedAchievement	(	AchievementCriteriaTimedTypes	type,
		uint32	entry,
		uint32	timeLost
	)

{
    AchievementCriteriaList const& achievementCriteriaList = sAchievementMgr->GetTimedAchievementCriteriaByType(type);
    for (AchievementCriteria const* criteria : achievementCriteriaList)
    {
        if (criteria->Entry->StartAsset != entry)
            continue;

        AchievementCriteriaTreeList const* trees = sAchievementMgr->GetAchievementCriteriaTreesByCriteria(criteria->ID);
        bool canStart = false;
        for (AchievementCriteriaTree const* tree : *trees)
        {
            if (m_timedAchievements.find(tree->ID) == m_timedAchievements.end() && !IsCompletedCriteriaTree(tree))
            {
                // Start the timer
                if (criteria->Entry->StartTimer * IN_MILLISECONDS > timeLost)
                {
                    m_timedAchievements[tree->ID] = criteria->Entry->StartTimer * IN_MILLISECONDS - timeLost;
                    canStart = true;
                }
            }
        }

        if (!canStart)
            continue;

        // and at client too
        SetCriteriaProgress(criteria, 0, GetOwner(), PROGRESS_SET);
    }
}

template<class T >

void AchievementMgr< T >::UpdateAchievementCriteria	(	AchievementCriteriaTypes	type,
		uint64	miscValue1 = 0,
		uint64	miscValue2 = 0,
		uint64	miscValue3 = 0,
		Unit const *	unit = NULL,
		Player *	referencePlayer = NULL
	)

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

{
    if (type >= ACHIEVEMENT_CRITERIA_TYPE_TOTAL)
    {
        TC_LOG_DEBUG("achievement", "UpdateAchievementCriteria: Wrong criteria type %u", type);
        return;
    }

    if (!referencePlayer)
    {
        TC_LOG_DEBUG("achievement", "UpdateAchievementCriteria: Player is NULL! Cant update criteria");
        return;
    }

    // disable for gamemasters with GM-mode enabled
    if (referencePlayer->IsGameMaster())
    {
        TC_LOG_DEBUG("achievement", "UpdateAchievementCriteria: [Player %s GM mode on] %s, %s (%u), " UI64FMTD ", " UI64FMTD ", " UI64FMTD
            , referencePlayer->GetName().c_str(), GetOwner()->GetGUID().ToString().c_str(), AchievementGlobalMgr::GetCriteriaTypeString(type), type, miscValue1, miscValue2, miscValue3);
        return;
    }

    TC_LOG_DEBUG("achievement", "UpdateAchievementCriteria: %s, %s (%u), " UI64FMTD ", " UI64FMTD ", " UI64FMTD
        , GetOwner()->GetGUID().ToString().c_str(), AchievementGlobalMgr::GetCriteriaTypeString(type), type, miscValue1, miscValue2, miscValue3);

    // Lua_GetGuildLevelEnabled() is checked in achievement UI to display guild tab
    //if (IsGuild<T>() && !sWorld->getBoolConfig(CONFIG_GUILD_LEVELING_ENABLED))
    //    return;

    AchievementCriteriaList const& achievementCriteriaList = sAchievementMgr->GetAchievementCriteriaByType(type, IsGuild<T>());
    for (AchievementCriteria const* achievementCriteria : achievementCriteriaList)
    {
        AchievementCriteriaTreeList const* trees = sAchievementMgr->GetAchievementCriteriaTreesByCriteria(achievementCriteria->ID);

        if (!CanUpdateCriteria(achievementCriteria, trees, miscValue1, miscValue2, miscValue3, unit, referencePlayer))
            continue;

        // requirements not found in the dbc
        if (AchievementCriteriaDataSet const* data = sAchievementMgr->GetCriteriaDataSet(achievementCriteria))
            if (!data->Meets(referencePlayer, unit, miscValue1))
                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:    /* FIXME: for online player only currently */
            case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED:
            case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED:
            case ACHIEVEMENT_CRITERIA_TYPE_QUEST_ABANDONED:
            case ACHIEVEMENT_CRITERIA_TYPE_FLIGHT_PATHS_TAKEN:
            case ACHIEVEMENT_CRITERIA_TYPE_ACCEPTED_SUMMONINGS:
            case ACHIEVEMENT_CRITERIA_TYPE_LOOT_EPIC_ITEM:
            case ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM:
            case ACHIEVEMENT_CRITERIA_TYPE_DEATH:
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST:
            case ACHIEVEMENT_CRITERIA_TYPE_DEATH_AT_MAP:
            case ACHIEVEMENT_CRITERIA_TYPE_DEATH_IN_DUNGEON:
            case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE:
            case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_PLAYER:
            case ACHIEVEMENT_CRITERIA_TYPE_DEATHS_FROM:
            case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
            case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
            case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
            case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
            case ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA:
            case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:
            case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT:
            case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT:
            case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
            case ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT:
            case ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT:
            case ACHIEVEMENT_CRITERIA_TYPE_WIN_DUEL:
            case ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS:
            case ACHIEVEMENT_CRITERIA_TYPE_HK_RACE:
            case ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE:
            case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL:
            case ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL:
            case ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS:
            case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL_AT_AREA:
            case ACHIEVEMENT_CRITERIA_TYPE_WIN_ARENA: // This also behaves like ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA
            case ACHIEVEMENT_CRITERIA_TYPE_ON_LOGIN:
            case ACHIEVEMENT_CRITERIA_TYPE_PLACE_GARRISON_BUILDING:
            case ACHIEVEMENT_CRITERIA_TYPE_OWN_BATTLE_PET_COUNT:
                SetCriteriaProgress(achievementCriteria, 1, referencePlayer, 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:/* FIXME: for online player only currently */
            case ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED:
            case ACHIEVEMENT_CRITERIA_TYPE_TOTAL_HEALING_RECEIVED:
            case ACHIEVEMENT_CRITERIA_TYPE_USE_LFD_TO_GROUP_WITH_PLAYERS:
            case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG:
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND:
            case ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE:
            case ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE:
                SetCriteriaProgress(achievementCriteria, miscValue1, referencePlayer, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
            case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE_TYPE:
            case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:
            case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM:
            case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM:
            case ACHIEVEMENT_CRITERIA_TYPE_CURRENCY:
                SetCriteriaProgress(achievementCriteria, miscValue2, referencePlayer, PROGRESS_ACCUMULATE);
                break;
            // std case: high value at miscValue1
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_SOLD: /* FIXME: for online player only currently */
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_DEALT:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_RECEIVED:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEAL_CAST:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALING_RECEIVED:
                SetCriteriaProgress(achievementCriteria, miscValue1, referencePlayer, PROGRESS_HIGHEST);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_REACH_LEVEL:
                SetCriteriaProgress(achievementCriteria, referencePlayer->getLevel(), referencePlayer);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL:
                if (uint32 skillvalue = referencePlayer->GetBaseSkillValue(achievementCriteria->Entry->Asset.SkillID))
                    SetCriteriaProgress(achievementCriteria, skillvalue, referencePlayer);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL:
                if (uint32 maxSkillvalue = referencePlayer->GetPureMaxSkillValue(achievementCriteria->Entry->Asset.SkillID))
                    SetCriteriaProgress(achievementCriteria, maxSkillvalue, referencePlayer);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST_COUNT:
                SetCriteriaProgress(achievementCriteria, referencePlayer->GetRewardedQuestCount(), referencePlayer);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST_DAILY:
            {
                time_t nextDailyResetTime = sWorld->GetNextDailyQuestsResetTime();
                CriteriaProgress *progress = GetCriteriaProgress(achievementCriteria);

                if (!miscValue1) // Login case.
                {
                    // reset if player missed one day.
                    if (progress && progress->date < (nextDailyResetTime - 2 * DAY))
                        SetCriteriaProgress(achievementCriteria, 0, referencePlayer, PROGRESS_SET);
                    continue;
                }

                ProgressType progressType;
                if (!progress)
                    // 1st time. Start count.
                    progressType = PROGRESS_SET;
                else if (progress->date < (nextDailyResetTime - 2 * DAY))
                    // last progress is older than 2 days. Player missed 1 day => Restart count.
                    progressType = PROGRESS_SET;
                else if (progress->date < (nextDailyResetTime - DAY))
                    // 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, referencePlayer, progressType);
                break;
            }
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
            {
                uint32 counter = 0;

                const RewardedQuestSet &rewQuests = referencePlayer->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->Entry->Asset.ZoneID)
                        ++counter;
                }
                SetCriteriaProgress(achievementCriteria, counter, referencePlayer);
                break;
            }
            case ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING:
                // miscValue1 is the ingame fallheight*100 as stored in dbc
                SetCriteriaProgress(achievementCriteria, miscValue1, referencePlayer);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
            case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL:
            case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA:
            case ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP:
            case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM:
            case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM:
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT:
            case ACHIEVEMENT_CRITERIA_TYPE_RECRUIT_GARRISON_FOLLOWER:
            case ACHIEVEMENT_CRITERIA_TYPE_OWN_BATTLE_PET:
                SetCriteriaProgress(achievementCriteria, 1, referencePlayer);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT:
                SetCriteriaProgress(achievementCriteria, referencePlayer->GetBankBagSlotCount(), referencePlayer);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
            {
                int32 reputation = referencePlayer->GetReputationMgr().GetReputation(achievementCriteria->Entry->Asset.FactionID);
                if (reputation > 0)
                    SetCriteriaProgress(achievementCriteria, reputation, referencePlayer);
                break;
            }
            case ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION:
                SetCriteriaProgress(achievementCriteria, referencePlayer->GetReputationMgr().GetExaltedFactionCount(), referencePlayer);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
            case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE:
            {
                uint32 spellCount = 0;
                for (PlayerSpellMap::const_iterator spellIter = referencePlayer->GetSpellMap().begin();
                    spellIter != referencePlayer->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->Entry->Asset.SkillID)
                            spellCount++;
                    }
                }
                SetCriteriaProgress(achievementCriteria, spellCount, referencePlayer);
                break;
            }
            case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REVERED_REPUTATION:
                SetCriteriaProgress(achievementCriteria, referencePlayer->GetReputationMgr().GetReveredFactionCount(), referencePlayer);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_GAIN_HONORED_REPUTATION:
                SetCriteriaProgress(achievementCriteria, referencePlayer->GetReputationMgr().GetHonoredFactionCount(), referencePlayer);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_KNOWN_FACTIONS:
                SetCriteriaProgress(achievementCriteria, referencePlayer->GetReputationMgr().GetVisibleFactionCount(), referencePlayer);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_EARN_HONORABLE_KILL:
                SetCriteriaProgress(achievementCriteria, referencePlayer->GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS), referencePlayer);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_GOLD_VALUE_OWNED:
                SetCriteriaProgress(achievementCriteria, referencePlayer->GetMoney(), referencePlayer, PROGRESS_HIGHEST);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_EARN_ACHIEVEMENT_POINTS:
                if (!miscValue1)
                    SetCriteriaProgress(achievementCriteria, _achievementPoints, referencePlayer, PROGRESS_SET);
                else
                    SetCriteriaProgress(achievementCriteria, miscValue1, referencePlayer, PROGRESS_ACCUMULATE);
                break;
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_PERSONAL_RATING:
            {
                uint32 reqTeamType = achievementCriteria->Entry->Asset.TeamType;

                if (miscValue1)
                {
                    if (miscValue2 != reqTeamType)
                        continue;

                    SetCriteriaProgress(achievementCriteria, miscValue1, referencePlayer, PROGRESS_HIGHEST);
                }
                else // login case
                {
                    for (uint32 arena_slot = 0; arena_slot < MAX_ARENA_SLOT; ++arena_slot)
                    {
                        uint32 teamId = referencePlayer->GetArenaTeamId(arena_slot);
                        if (!teamId)
                            continue;

                        ArenaTeam* team = sArenaTeamMgr->GetArenaTeamById(teamId);
                        if (!team || team->GetType() != reqTeamType)
                            continue;

                        if (ArenaTeamMember const* member = team->GetMember(referencePlayer->GetGUID()))
                        {
                            SetCriteriaProgress(achievementCriteria, member->PersonalRating, referencePlayer, PROGRESS_HIGHEST);
                            break;
                        }
                    }
                }
                break;
            }
            case ACHIEVEMENT_CRITERIA_TYPE_REACH_GUILD_LEVEL:
                SetCriteriaProgress(achievementCriteria, miscValue1, referencePlayer);
                break;
            // FIXME: not triggered in code as result, need to implement
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_RAID:
            case ACHIEVEMENT_CRITERIA_TYPE_PLAY_ARENA:
            case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_TEAM_RATING:
            case ACHIEVEMENT_CRITERIA_TYPE_OWN_RANK:
            case ACHIEVEMENT_CRITERIA_TYPE_SPENT_GOLD_GUILD_REPAIRS:
            case ACHIEVEMENT_CRITERIA_TYPE_CRAFT_ITEMS_GUILD:
            case ACHIEVEMENT_CRITERIA_TYPE_CATCH_FROM_POOL:
            case ACHIEVEMENT_CRITERIA_TYPE_BUY_GUILD_BANK_SLOTS:
            case ACHIEVEMENT_CRITERIA_TYPE_EARN_GUILD_ACHIEVEMENT_POINTS:
            case ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_BATTLEGROUND:
            case ACHIEVEMENT_CRITERIA_TYPE_REACH_BG_RATING:
            case ACHIEVEMENT_CRITERIA_TYPE_BUY_GUILD_TABARD:
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_GUILD:
            case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILLS_GUILD:
            case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE_TYPE_GUILD:
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ARCHAEOLOGY_PROJECTS:
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_GUILD_CHALLENGE_TYPE:
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_GUILD_CHALLENGE:
            case ACHIEVEMENT_CRITERIA_TYPE_LFR_DUNGEONS_COMPLETED:
            case ACHIEVEMENT_CRITERIA_TYPE_LFR_LEAVES:
            case ACHIEVEMENT_CRITERIA_TYPE_LFR_VOTE_KICKS_INITIATED_BY_PLAYER:
            case ACHIEVEMENT_CRITERIA_TYPE_LFR_VOTE_KICKS_NOT_INIT_BY_PLAYER:
            case ACHIEVEMENT_CRITERIA_TYPE_BE_KICKED_FROM_LFR:
            case ACHIEVEMENT_CRITERIA_TYPE_COUNT_OF_LFR_QUEUE_BOOSTS_BY_TANK:
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_SCENARIO_COUNT:
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_SCENARIO:
            case ACHIEVEMENT_CRITERIA_TYPE_CAPTURE_BATTLE_PET:
            case ACHIEVEMENT_CRITERIA_TYPE_WIN_PET_BATTLE:
            case ACHIEVEMENT_CRITERIA_TYPE_LEVEL_BATTLE_PET:
            case ACHIEVEMENT_CRITERIA_TYPE_CAPTURE_BATTLE_PET_CREDIT:
            case ACHIEVEMENT_CRITERIA_TYPE_LEVEL_BATTLE_PET_CREDIT:
            case ACHIEVEMENT_CRITERIA_TYPE_ENTER_AREA:
            case ACHIEVEMENT_CRITERIA_TYPE_LEAVE_AREA:
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DUNGEON_ENCOUNTER:
            case ACHIEVEMENT_CRITERIA_TYPE_UPGRADE_GARRISON_BUILDING:
            case ACHIEVEMENT_CRITERIA_TYPE_CONSTRUCT_GARRISON_BUILDING:
            case ACHIEVEMENT_CRITERIA_TYPE_UPGRADE_GARRISON:
            case ACHIEVEMENT_CRITERIA_TYPE_START_GARRISON_MISSION:
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_GARRISON_MISSION_COUNT:
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_GARRISON_MISSION:
            case ACHIEVEMENT_CRITERIA_TYPE_RECRUIT_GARRISON_FOLLOWER_COUNT:
            case ACHIEVEMENT_CRITERIA_TYPE_LEARN_GARRISON_BLUEPRINT_COUNT:
            case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_GARRISON_SHIPMENT:
            case ACHIEVEMENT_CRITERIA_TYPE_RAISE_GARRISON_FOLLOWER_ITEM_LEVEL:
            case ACHIEVEMENT_CRITERIA_TYPE_RAISE_GARRISON_FOLLOWER_LEVEL:
            case ACHIEVEMENT_CRITERIA_TYPE_OWN_TOY:
            case ACHIEVEMENT_CRITERIA_TYPE_OWN_TOY_COUNT:
            case ACHIEVEMENT_CRITERIA_TYPE_OWN_HEIRLOOMS:
                break;                                   // Not implemented yet :(
        }

        for (AchievementCriteriaTree const* tree : *trees)
        {
            if (IsCompletedCriteriaTree(tree))
                CompletedCriteriaFor(tree->Achievement, referencePlayer);

            // 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 (tree->Achievement->Flags & ACHIEVEMENT_FLAG_SUMM)
                if (IsCompletedAchievement(tree->Achievement))
                    CompletedAchievement(tree->Achievement, referencePlayer);

            if (AchievementEntryList const* achRefList = sAchievementMgr->GetAchievementByReferencedId(tree->Achievement->ID))
                for (AchievementEntry const* refAchievement : *achRefList)
                    if (IsCompletedAchievement(refAchievement))
                        CompletedAchievement(refAchievement, referencePlayer);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

void AchievementMgr< T >::UpdateTimedAchievements

(

uint32

timeDiff

)

{
    if (!m_timedAchievements.empty())
    {
        for (TimedAchievementMap::iterator itr = m_timedAchievements.begin(); itr != m_timedAchievements.end();)
        {
            // Time is up, remove timer and reset progress
            if (itr->second <= timeDiff)
            {
                AchievementCriteriaTree const* criteriaTree = sAchievementMgr->GetAchievementCriteriaTree(itr->first);
                if (criteriaTree->Criteria)
                    RemoveCriteriaProgress(criteriaTree->Criteria);

                m_timedAchievements.erase(itr++);
            }
            else
            {
                itr->second -= timeDiff;
                ++itr;
            }
        }
    }
}

Member Data Documentation

template<class T>

uint32 AchievementMgr< T >::_achievementPoints

private

template<class T>

T* AchievementMgr< T >::_owner

private

template<class T>

CompletedAchievementMap AchievementMgr< T >::m_completedAchievements

private

template<class T>

CriteriaProgressMap AchievementMgr< T >::m_criteriaProgress

private

template<class T>

TimedAchievementMap AchievementMgr< T >::m_timedAchievements

private

---

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

• src/server/game/Achievements/AchievementMgr.h
• src/server/game/Achievements/AchievementMgr.cpp