#include <AchievementMgr.h>

Public Member Functions
AchievementCriteriaTreeList const *	GetAchievementCriteriaTreesByCriteria (uint32 criteriaId) const

AchievementCriteriaList const &	GetAchievementCriteriaByType (AchievementCriteriaTypes type, bool guild=false) const

AchievementCriteriaList const &	GetTimedAchievementCriteriaByType (AchievementCriteriaTimedTypes type) const

AchievementEntryList const *	GetAchievementByReferencedId (uint32 id) const

AchievementReward const *	GetAchievementReward (AchievementEntry const *achievement) const

AchievementRewardLocale const *	GetAchievementRewardLocale (AchievementEntry const *achievement) const

AchievementCriteriaDataSet const *	GetCriteriaDataSet (AchievementCriteria const *achievementCriteria) const

bool	IsRealmCompleted (AchievementEntry const *achievement, uint32 instanceId) const

void	SetRealmCompleted (AchievementEntry const *achievement, uint32 instanceId)

bool	IsGroupCriteriaType (AchievementCriteriaTypes type) const

template<typename Func >
void	WalkCriteriaTree (AchievementCriteriaTree const *tree, Func const &func) const

void	OnInstanceDestroyed (uint32 instanceId)

void	LoadAchievementCriteriaModifiersTree ()

void	LoadAchievementCriteriaList ()

void	LoadAchievementCriteriaData ()

void	LoadAchievementReferenceList ()

void	LoadCompletedAchievements ()

void	LoadRewards ()

void	LoadRewardLocales ()

AchievementEntry const *	GetAchievement (uint32 achievementId) const

AchievementCriteriaTree const *	GetAchievementCriteriaTree (uint32 criteriaTreeId) const

AchievementCriteria const *	GetAchievementCriteria (uint32 criteriaId) const

Static Public Member Functions
static char const *	GetCriteriaTypeString (AchievementCriteriaTypes type)

static char const *	GetCriteriaTypeString (uint32 type)

static AchievementGlobalMgr *	instance ()

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

Private Member Functions
	AchievementGlobalMgr ()

	~AchievementGlobalMgr ()

Member Typedef Documentation

typedef std::map<uint32 , uint32 > AchievementGlobalMgr::AllCompletedAchievements

private

Constructor & Destructor Documentation

AchievementGlobalMgr::AchievementGlobalMgr ( )

inlineprivate

367 { }

AchievementGlobalMgr::~AchievementGlobalMgr ( )

private

 {
  for (AchievementCriteriaTreeMap::iterator itr = _achievementCriteriaTrees.begin(); itr != _achievementCriteriaTrees.end(); ++itr)
  delete itr->second;
 
  for (AchievementCriteriaMap::iterator itr = _achievementCriteria.begin(); itr != _achievementCriteria.end(); ++itr)
  delete itr->second;
 
  for (ModifierTreeMap::iterator itr = _criteriaModifiers.begin(); itr != _criteriaModifiers.end(); ++itr)
  delete itr->second;
 }

Member Function Documentation

AchievementEntry const * AchievementGlobalMgr::GetAchievement ( uint32 achievementId ) const

 {
  return sAchievementStore.LookupEntry(achievementId);
 }

Here is the caller graph for this function:

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

inline

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

AchievementCriteria const * AchievementGlobalMgr::GetAchievementCriteria ( uint32 criteriaId ) const

 {
  auto itr = _achievementCriteria.find(criteriaId);
  if (itr == _achievementCriteria.end())
  return nullptr;
 
  return itr->second;
 }

Here is the caller graph for this function:

AchievementCriteriaList const& AchievementGlobalMgr::GetAchievementCriteriaByType	(	AchievementCriteriaTypes	type,
		bool	guild = `false`
	)		const

inline

  {
  return guild ? _guildAchievementCriteriasByType[type] : _achievementCriteriasByType[type];
  }

AchievementCriteriaTree const * AchievementGlobalMgr::GetAchievementCriteriaTree ( uint32 criteriaTreeId ) const

 {
  auto itr = _achievementCriteriaTrees.find(criteriaTreeId);
  if (itr == _achievementCriteriaTrees.end())
  return nullptr;
 
  return itr->second;
 }

AchievementCriteriaTreeList const* AchievementGlobalMgr::GetAchievementCriteriaTreesByCriteria ( uint32 criteriaId ) const

inline

  {
  auto itr = _achievementCriteriaTreeByCriteria.find(criteriaId);
  return itr != _achievementCriteriaTreeByCriteria.end() ? &itr->second : nullptr;
  }

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

inline

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

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

inline

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

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

inline

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

char const * AchievementGlobalMgr::GetCriteriaTypeString ( AchievementCriteriaTypes type )

static

 {
  switch (type)
  {
  case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
  return "KILL_CREATURE";
  case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG:
  return "TYPE_WIN_BG";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ARCHAEOLOGY_PROJECTS:
  return "COMPLETE_RESEARCH";
  case ACHIEVEMENT_CRITERIA_TYPE_REACH_LEVEL:
  return "REACH_LEVEL";
  case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL:
  return "REACH_SKILL_LEVEL";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT:
  return "COMPLETE_ACHIEVEMENT";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST_COUNT:
  return "COMPLETE_QUEST_COUNT";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST_DAILY:
  return "COMPLETE_DAILY_QUEST_DAILY";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
  return "COMPLETE_QUESTS_IN_ZONE";
  case ACHIEVEMENT_CRITERIA_TYPE_CURRENCY:
  return "CURRENCY";
  case ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE:
  return "DAMAGE_DONE";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST:
  return "COMPLETE_DAILY_QUEST";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND:
  return "COMPLETE_BATTLEGROUND";
  case ACHIEVEMENT_CRITERIA_TYPE_DEATH_AT_MAP:
  return "DEATH_AT_MAP";
  case ACHIEVEMENT_CRITERIA_TYPE_DEATH:
  return "DEATH";
  case ACHIEVEMENT_CRITERIA_TYPE_DEATH_IN_DUNGEON:
  return "DEATH_IN_DUNGEON";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_RAID:
  return "COMPLETE_RAID";
  case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE:
  return "KILLED_BY_CREATURE";
  case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_PLAYER:
  return "KILLED_BY_PLAYER";
  case ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING:
  return "FALL_WITHOUT_DYING";
  case ACHIEVEMENT_CRITERIA_TYPE_DEATHS_FROM:
  return "DEATHS_FROM";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
  return "COMPLETE_QUEST";
  case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
  return "BE_SPELL_TARGET";
  case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
  return "CAST_SPELL";
  case ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE:
  return "BG_OBJECTIVE_CAPTURE";
  case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL_AT_AREA:
  return "HONORABLE_KILL_AT_AREA";
  case ACHIEVEMENT_CRITERIA_TYPE_WIN_ARENA:
  return "WIN_ARENA";
  case ACHIEVEMENT_CRITERIA_TYPE_PLAY_ARENA:
  return "PLAY_ARENA";
  case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL:
  return "LEARN_SPELL";
  case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL:
  return "HONORABLE_KILL";
  case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM:
  return "OWN_ITEM";
  case ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA:
  return "WIN_RATED_ARENA";
  case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_TEAM_RATING:
  return "HIGHEST_TEAM_RATING";
  case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_PERSONAL_RATING:
  return "HIGHEST_PERSONAL_RATING";
  case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL:
  return "LEARN_SKILL_LEVEL";
  case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:
  return "USE_ITEM";
  case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM:
  return "LOOT_ITEM";
  case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA:
  return "EXPLORE_AREA";
  case ACHIEVEMENT_CRITERIA_TYPE_OWN_RANK:
  return "OWN_RANK";
  case ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT:
  return "BUY_BANK_SLOT";
  case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
  return "GAIN_REPUTATION";
  case ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION:
  return "GAIN_EXALTED_REPUTATION";
  case ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP:
  return "VISIT_BARBER_SHOP";
  case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM:
  return "EQUIP_EPIC_ITEM";
  case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT:
  return "ROLL_NEED_ON_LOOT";
  case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT:
  return "GREED_ON_LOOT";
  case ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS:
  return "HK_CLASS";
  case ACHIEVEMENT_CRITERIA_TYPE_HK_RACE:
  return "HK_RACE";
  case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
  return "DO_EMOTE";
  case ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE:
  return "HEALING_DONE";
  case ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS:
  return "GET_KILLING_BLOWS";
  case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM:
  return "EQUIP_ITEM";
  case ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_VENDORS:
  return "MONEY_FROM_VENDORS";
  case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_TALENTS:
  return "GOLD_SPENT_FOR_TALENTS";
  case ACHIEVEMENT_CRITERIA_TYPE_NUMBER_OF_TALENT_RESETS:
  return "NUMBER_OF_TALENT_RESETS";
  case ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_QUEST_REWARD:
  return "MONEY_FROM_QUEST_REWARD";
  case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_TRAVELLING:
  return "GOLD_SPENT_FOR_TRAVELLING";
  case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_AT_BARBER:
  return "GOLD_SPENT_AT_BARBER";
  case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_MAIL:
  return "GOLD_SPENT_FOR_MAIL";
  case ACHIEVEMENT_CRITERIA_TYPE_LOOT_MONEY:
  return "LOOT_MONEY";
  case ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT:
  return "USE_GAMEOBJECT";
  case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
  return "BE_SPELL_TARGET2";
  case ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL:
  return "SPECIAL_PVP_KILL";
  case ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT:
  return "FISH_IN_GAMEOBJECT";
  case ACHIEVEMENT_CRITERIA_TYPE_ON_LOGIN:
  return "ON_LOGIN";
  case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
  return "LEARN_SKILLLINE_SPELLS";
  case ACHIEVEMENT_CRITERIA_TYPE_WIN_DUEL:
  return "WIN_DUEL";
  case ACHIEVEMENT_CRITERIA_TYPE_LOSE_DUEL:
  return "LOSE_DUEL";
  case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE_TYPE:
  return "KILL_CREATURE_TYPE";
  case ACHIEVEMENT_CRITERIA_TYPE_GOLD_EARNED_BY_AUCTIONS:
  return "GOLD_EARNED_BY_AUCTIONS";
  case ACHIEVEMENT_CRITERIA_TYPE_CREATE_AUCTION:
  return "CREATE_AUCTION";
  case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID:
  return "HIGHEST_AUCTION_BID";
  case ACHIEVEMENT_CRITERIA_TYPE_WON_AUCTIONS:
  return "WON_AUCTIONS";
  case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_SOLD:
  return "HIGHEST_AUCTION_SOLD";
  case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_GOLD_VALUE_OWNED:
  return "HIGHEST_GOLD_VALUE_OWNED";
  case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REVERED_REPUTATION:
  return "GAIN_REVERED_REPUTATION";
  case ACHIEVEMENT_CRITERIA_TYPE_GAIN_HONORED_REPUTATION:
  return "GAIN_HONORED_REPUTATION";
  case ACHIEVEMENT_CRITERIA_TYPE_KNOWN_FACTIONS:
  return "KNOWN_FACTIONS";
  case ACHIEVEMENT_CRITERIA_TYPE_LOOT_EPIC_ITEM:
  return "LOOT_EPIC_ITEM";
  case ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM:
  return "RECEIVE_EPIC_ITEM";
  case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED:
  return "ROLL_NEED";
  case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED:
  return "ROLL_GREED";
  case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_DEALT:
  return "HIT_DEALT";
  case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_RECEIVED:
  return "HIT_RECEIVED";
  case ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED:
  return "TOTAL_DAMAGE_RECEIVED";
  case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEAL_CAST:
  return "HIGHEST_HEAL_CAST";
  case ACHIEVEMENT_CRITERIA_TYPE_TOTAL_HEALING_RECEIVED:
  return "TOTAL_HEALING_RECEIVED";
  case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALING_RECEIVED:
  return "HIGHEST_HEALING_RECEIVED";
  case ACHIEVEMENT_CRITERIA_TYPE_QUEST_ABANDONED:
  return "QUEST_ABANDONED";
  case ACHIEVEMENT_CRITERIA_TYPE_FLIGHT_PATHS_TAKEN:
  return "FLIGHT_PATHS_TAKEN";
  case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:
  return "LOOT_TYPE";
  case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
  return "CAST_SPELL2";
  case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE:
  return "LEARN_SKILL_LINE";
  case ACHIEVEMENT_CRITERIA_TYPE_EARN_HONORABLE_KILL:
  return "EARN_HONORABLE_KILL";
  case ACHIEVEMENT_CRITERIA_TYPE_ACCEPTED_SUMMONINGS:
  return "ACCEPTED_SUMMONINGS";
  case ACHIEVEMENT_CRITERIA_TYPE_EARN_ACHIEVEMENT_POINTS:
  return "EARN_ACHIEVEMENT_POINTS";
  case ACHIEVEMENT_CRITERIA_TYPE_USE_LFD_TO_GROUP_WITH_PLAYERS:
  return "USE_LFD_TO_GROUP_WITH_PLAYERS";
  case ACHIEVEMENT_CRITERIA_TYPE_SPENT_GOLD_GUILD_REPAIRS:
  return "SPENT_GOLD_GUILD_REPAIRS";
  case ACHIEVEMENT_CRITERIA_TYPE_REACH_GUILD_LEVEL:
  return "REACH_GUILD_LEVEL";
  case ACHIEVEMENT_CRITERIA_TYPE_CRAFT_ITEMS_GUILD:
  return "CRAFT_ITEMS_GUILD";
  case ACHIEVEMENT_CRITERIA_TYPE_CATCH_FROM_POOL:
  return "CATCH_FROM_POOL";
  case ACHIEVEMENT_CRITERIA_TYPE_BUY_GUILD_BANK_SLOTS:
  return "BUY_GUILD_BANK_SLOTS";
  case ACHIEVEMENT_CRITERIA_TYPE_EARN_GUILD_ACHIEVEMENT_POINTS:
  return "EARN_GUILD_ACHIEVEMENT_POINTS";
  case ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_BATTLEGROUND:
  return "WIN_RATED_BATTLEGROUND";
  case ACHIEVEMENT_CRITERIA_TYPE_REACH_BG_RATING:
  return "REACH_BG_RATING";
  case ACHIEVEMENT_CRITERIA_TYPE_BUY_GUILD_TABARD:
  return "BUY_GUILD_TABARD";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_GUILD:
  return "COMPLETE_QUESTS_GUILD";
  case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILLS_GUILD:
  return "HONORABLE_KILLS_GUILD";
  case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE_TYPE_GUILD:
  return "KILL_CREATURE_TYPE_GUILD";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_GUILD_CHALLENGE_TYPE:
  return "GUILD_CHALLENGE_TYPE";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_GUILD_CHALLENGE:
  return "GUILD_CHALLENGE";
  case ACHIEVEMENT_CRITERIA_TYPE_LFR_DUNGEONS_COMPLETED:
  return "LFR_DUNGEONS_COMPLETED";
  case ACHIEVEMENT_CRITERIA_TYPE_LFR_LEAVES:
  return "LFR_LEAVES";
  case ACHIEVEMENT_CRITERIA_TYPE_LFR_VOTE_KICKS_INITIATED_BY_PLAYER:
  return "LFR_VOTE_KICKS_INITIATED_BY_PLAYER";
  case ACHIEVEMENT_CRITERIA_TYPE_LFR_VOTE_KICKS_NOT_INIT_BY_PLAYER:
  return "LFR_VOTE_KICKS_NOT_INIT_BY_PLAYER";
  case ACHIEVEMENT_CRITERIA_TYPE_BE_KICKED_FROM_LFR:
  return "BE_KICKED_FROM_LFR";
  case ACHIEVEMENT_CRITERIA_TYPE_COUNT_OF_LFR_QUEUE_BOOSTS_BY_TANK:
  return "COUNT_OF_LFR_QUEUE_BOOSTS_BY_TANK";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_SCENARIO_COUNT:
  return "COMPLETE_SCENARIO_COUNT";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_SCENARIO:
  return "COMPLETE_SCENARIO";
  case ACHIEVEMENT_CRITERIA_TYPE_OWN_BATTLE_PET:
  return "OWN_BATTLE_PET";
  case ACHIEVEMENT_CRITERIA_TYPE_OWN_BATTLE_PET_COUNT:
  return "OWN_BATTLE_PET_COUNT";
  case ACHIEVEMENT_CRITERIA_TYPE_CAPTURE_BATTLE_PET:
  return "CAPTURE_BATTLE_PET";
  case ACHIEVEMENT_CRITERIA_TYPE_WIN_PET_BATTLE:
  return "WIN_PET_BATTLE";
  case ACHIEVEMENT_CRITERIA_TYPE_LEVEL_BATTLE_PET:
  return "LEVEL_BATTLE_PET";
  case ACHIEVEMENT_CRITERIA_TYPE_CAPTURE_BATTLE_PET_CREDIT:
  return "CAPTURE_BATTLE_PET_CREDIT";
  case ACHIEVEMENT_CRITERIA_TYPE_LEVEL_BATTLE_PET_CREDIT:
  return "LEVEL_BATTLE_PET_CREDIT";
  case ACHIEVEMENT_CRITERIA_TYPE_ENTER_AREA:
  return "ENTER_AREA";
  case ACHIEVEMENT_CRITERIA_TYPE_LEAVE_AREA:
  return "LEAVE_AREA";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DUNGEON_ENCOUNTER:
  return "COMPLETE_DUNGEON_ENCOUNTER";
  case ACHIEVEMENT_CRITERIA_TYPE_PLACE_GARRISON_BUILDING:
  return "PLACE_GARRISON_BUILDING";
  case ACHIEVEMENT_CRITERIA_TYPE_UPGRADE_GARRISON_BUILDING:
  return "UPGRADE_GARRISON_BUILDING";
  case ACHIEVEMENT_CRITERIA_TYPE_CONSTRUCT_GARRISON_BUILDING:
  return "CONSTRUCT_GARRISON_BUILDING";
  case ACHIEVEMENT_CRITERIA_TYPE_UPGRADE_GARRISON:
  return "UPGRADE_GARRISON";
  case ACHIEVEMENT_CRITERIA_TYPE_START_GARRISON_MISSION:
  return "START_GARRISON_MISSION";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_GARRISON_MISSION_COUNT:
  return "COMPLETE_GARRISON_MISSION_COUNT";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_GARRISON_MISSION:
  return "COMPLETE_GARRISON_MISSION";
  case ACHIEVEMENT_CRITERIA_TYPE_RECRUIT_GARRISON_FOLLOWER_COUNT:
  return "RECRUIT_GARRISON_FOLLOWER_COUNT";
  case ACHIEVEMENT_CRITERIA_TYPE_LEARN_GARRISON_BLUEPRINT_COUNT:
  return "LEARN_GARRISON_BLUEPRINT_COUNT";
  case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_GARRISON_SHIPMENT:
  return "COMPLETE_GARRISON_SHIPMENT";
  case ACHIEVEMENT_CRITERIA_TYPE_RAISE_GARRISON_FOLLOWER_ITEM_LEVEL:
  return "RAISE_GARRISON_FOLLOWER_ITEM_LEVEL";
  case ACHIEVEMENT_CRITERIA_TYPE_RAISE_GARRISON_FOLLOWER_LEVEL:
  return "RAISE_GARRISON_FOLLOWER_LEVEL";
  case ACHIEVEMENT_CRITERIA_TYPE_OWN_TOY:
  return "OWN_TOY";
  case ACHIEVEMENT_CRITERIA_TYPE_OWN_TOY_COUNT:
  return "OWN_TOY_COUNT";
  case ACHIEVEMENT_CRITERIA_TYPE_RECRUIT_GARRISON_FOLLOWER:
  return "RECRUIT_GARRISON_FOLLOWER";
  case ACHIEVEMENT_CRITERIA_TYPE_OWN_HEIRLOOMS:
  return "OWN_HEIRLOOMS";
  }
  return "MISSING_TYPE";
 }

Here is the caller graph for this function:

char const * AchievementGlobalMgr::GetCriteriaTypeString ( uint32 type )

static

 {
  return GetCriteriaTypeString(AchievementCriteriaTypes(type));
 }

Here is the call graph for this function:

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

inline

  {
  return _achievementCriteriasByTimedType[type];
  }

AchievementGlobalMgr * AchievementGlobalMgr::instance ( )

static

 {
  static AchievementGlobalMgr instance;
  return &instance;
 }

bool AchievementGlobalMgr::IsGroupCriteriaType ( AchievementCriteriaTypes type ) const

inline

  {
  switch (type)
  {
  case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
  case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG:
  case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET: // NYI
  case ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA:
  case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2: // NYI
  case ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_BATTLEGROUND: // NYI
  return true;
  default:
  break;
  }
 
  return false;
  }

bool AchievementGlobalMgr::IsRealmCompleted	(	AchievementEntry const *	achievement,
		uint32	instanceId
	)		const

inline

  {
  AllCompletedAchievements::const_iterator itr = _allCompletedAchievements.find(achievement->ID);
  if (itr == _allCompletedAchievements.end())
  return false;
 
  if (achievement->Flags & ACHIEVEMENT_FLAG_REALM_FIRST_KILL)
  return itr->second != instanceId;
 
  return true;
  }

void AchievementGlobalMgr::LoadAchievementCriteriaData ( )

 {
  uint32 oldMSTime = getMSTime();
 
  _criteriaDataMap.clear(); // need for reload case
 
  QueryResult result = WorldDatabase.Query("SELECT criteria_id, type, value1, value2, ScriptName FROM achievement_criteria_data");
 
  if (!result)
  {
  TC_LOG_INFO("server.loading", ">> Loaded 0 additional achievement criteria data. DB table `achievement_criteria_data` is empty.");
  return;
  }
 
  uint32 count = 0;
 
  do
  {
  Field* fields = result->Fetch();
  uint32 criteria_id = fields[0].GetUInt32();
 
  AchievementCriteria const* criteria = sAchievementMgr->GetAchievementCriteria(criteria_id);
 
  if (!criteria)
  {
  TC_LOG_ERROR("sql.sql", "Table `achievement_criteria_data` has data for non-existing criteria (Entry: %u), ignore.", criteria_id);
  continue;
  }
 
  uint32 dataType = fields[1].GetUInt8();
  std::string scriptName = fields[4].GetString();
  uint32 scriptId = 0;
  if (!scriptName.empty())
  {
  if (dataType != ACHIEVEMENT_CRITERIA_DATA_TYPE_SCRIPT)
  TC_LOG_ERROR("sql.sql", "Table `achievement_criteria_data` has ScriptName set for non-scripted data type (Entry: %u, type %u), useless data.", criteria_id, dataType);
  else
  scriptId = sObjectMgr->GetScriptId(scriptName);
  }
 
  AchievementCriteriaData data(dataType, fields[2].GetUInt32(), fields[3].GetUInt32(), scriptId);
 
  if (!data.IsValid(criteria))
  continue;
 
  // this will allocate empty data set storage
  AchievementCriteriaDataSet& dataSet = _criteriaDataMap[criteria_id];
  dataSet.SetCriteriaId(criteria_id);
 
  // add real data only for not NONE data types
  if (data.dataType != ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE)
  dataSet.Add(data);
 
  // counting data by and data types
  ++count;
  }
  while (result->NextRow());
 
  TC_LOG_INFO("server.loading", ">> Loaded %u additional achievement criteria data in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
 }

Here is the call graph for this function:

void AchievementGlobalMgr::LoadAchievementCriteriaList ( )

 {
  uint32 oldMSTime = getMSTime();
 
  if (sCriteriaTreeStore.GetNumRows() == 0)
  {
  TC_LOG_ERROR("server.loading", ">> Loaded 0 achievement criteria.");
  return;
  }
 
  std::unordered_map<uint32 /*criteriaTreeID*/, AchievementEntry const*> achievementCriteriaTreeIds;
  for (uint32 i = 0; i < sAchievementStore.GetNumRows(); ++i)
  if (AchievementEntry const* achievement = sAchievementStore.LookupEntry(i))
  if (achievement->CriteriaTree)
  achievementCriteriaTreeIds[achievement->CriteriaTree] = achievement;
 
  // Load criteria tree nodes
  for (uint32 i = 0; i < sCriteriaTreeStore.GetNumRows(); ++i)
  {
  CriteriaTreeEntry const* tree = sCriteriaTreeStore.LookupEntry(i);
  if (!tree)
  continue;
 
  // Find linked achievement
  auto achievementItr = achievementCriteriaTreeIds.find(tree->ID);
  CriteriaTreeEntry const* cur = tree;
  while (achievementItr == achievementCriteriaTreeIds.end())
  {
  if (!cur->Parent)
  break;
 
  cur = sCriteriaTreeStore.LookupEntry(cur->Parent);
  if (!cur)
  break;
 
  achievementItr = achievementCriteriaTreeIds.find(cur->ID);
  }
 
  if (achievementItr == achievementCriteriaTreeIds.end())
  continue;
 
  AchievementCriteriaTree* achievementCriteriaTree = new AchievementCriteriaTree();
  achievementCriteriaTree->ID = i;
  achievementCriteriaTree->Achievement = achievementItr->second;
  achievementCriteriaTree->Entry = tree;
 
  _achievementCriteriaTrees[achievementCriteriaTree->Entry->ID] = achievementCriteriaTree;
  }
 
  // Build tree
  for (auto itr = _achievementCriteriaTrees.begin(); itr != _achievementCriteriaTrees.end(); ++itr)
  {
  if (!itr->second->Entry->Parent)
  continue;
 
  auto parent = _achievementCriteriaTrees.find(itr->second->Entry->Parent);
  if (parent != _achievementCriteriaTrees.end())
  {
  parent->second->Children.push_back(itr->second);
  while (parent != _achievementCriteriaTrees.end())
  {
  auto cur = parent;
  parent = _achievementCriteriaTrees.find(parent->second->Entry->Parent);
  if (parent == _achievementCriteriaTrees.end())
  {
  if (sCriteriaStore.LookupEntry(itr->second->Entry->CriteriaID))
  _achievementCriteriaTreeByCriteria[itr->second->Entry->CriteriaID].push_back(cur->second);
  }
  }
  }
  else if (sCriteriaStore.LookupEntry(itr->second->Entry->CriteriaID))
  _achievementCriteriaTreeByCriteria[itr->second->Entry->CriteriaID].push_back(itr->second);
  }
 
  // Load criteria
  uint32 criterias = 0;
  uint32 guildCriterias = 0;
  for (uint32 i = 0; i < sCriteriaStore.GetNumRows(); ++i)
  {
  CriteriaEntry const* criteria = sCriteriaStore.LookupEntry(i);
  if (!criteria)
  continue;
 
  auto treeItr = _achievementCriteriaTreeByCriteria.find(i);
  if (treeItr == _achievementCriteriaTreeByCriteria.end())
  continue;
 
  AchievementCriteria* achievementCriteria = new AchievementCriteria();
  achievementCriteria->ID = i;
  achievementCriteria->Entry = criteria;
  auto mod = _criteriaModifiers.find(criteria->ModifierTreeId);
  if (mod != _criteriaModifiers.end())
  achievementCriteria->Modifier = mod->second;
 
  _achievementCriteria[achievementCriteria->ID] = achievementCriteria;
 
  for (AchievementCriteriaTree const* tree : treeItr->second)
  {
  if (tree->Achievement->Flags & ACHIEVEMENT_FLAG_GUILD)
  achievementCriteria->FlagsCu |= ACHIEVEMENT_CRITERIA_FLAG_CU_GUILD;
  else if (tree->Achievement->Flags & ACHIEVEMENT_FLAG_ACCOUNT)
  achievementCriteria->FlagsCu |= ACHIEVEMENT_CRITERIA_FLAG_CU_ACCOUNT;
  else
  achievementCriteria->FlagsCu |= ACHIEVEMENT_CRITERIA_FLAG_CU_PLAYER;
  }
 
  if (achievementCriteria->FlagsCu & ACHIEVEMENT_CRITERIA_FLAG_CU_GUILD)
  {
  ++guildCriterias;
  _guildAchievementCriteriasByType[criteria->Type].push_back(achievementCriteria);
  }
 
  if (achievementCriteria->FlagsCu & (ACHIEVEMENT_CRITERIA_FLAG_CU_PLAYER | ACHIEVEMENT_CRITERIA_FLAG_CU_ACCOUNT))
  {
  ++criterias;
  _achievementCriteriasByType[criteria->Type].push_back(achievementCriteria);
  }
 
  if (criteria->StartTimer)
  _achievementCriteriasByTimedType[criteria->StartEvent].push_back(achievementCriteria);
  }
 
  for (auto& p : _achievementCriteriaTrees)
  const_cast<AchievementCriteriaTree*>(p.second)->Criteria = GetAchievementCriteria(p.second->Entry->CriteriaID);
 
  TC_LOG_INFO("server.loading", ">> Loaded %u achievement criteria and %u guild achievement crieteria in %u ms", criterias, guildCriterias, GetMSTimeDiffToNow(oldMSTime));
 }

Here is the call graph for this function:

void AchievementGlobalMgr::LoadAchievementCriteriaModifiersTree ( )

 {
  uint32 oldMSTime = getMSTime();
 
  if (sModifierTreeStore.GetNumRows() == 0)
  {
  TC_LOG_ERROR("server.loading", ">> Loaded 0 achievement criteria modifiers.");
  return;
  }
 
  // Load modifier tree nodes
  for (uint32 i = 0; i < sModifierTreeStore.GetNumRows(); ++i)
  {
  ModifierTreeEntry const* tree = sModifierTreeStore.LookupEntry(i);
  if (!tree)
  continue;
 
  ModifierTreeNode* node = new ModifierTreeNode();
  node->Entry = tree;
  _criteriaModifiers[node->Entry->ID] = node;
  }
 
  // Build tree
  for (auto itr = _criteriaModifiers.begin(); itr != _criteriaModifiers.end(); ++itr)
  {
  if (!itr->second->Entry->Parent)
  continue;
 
  auto parent = _criteriaModifiers.find(itr->second->Entry->Parent);
  if (parent != _criteriaModifiers.end())
  parent->second->Children.push_back(itr->second);
  }
 
  TC_LOG_INFO("server.loading", ">> Loaded %u achievement criteria modifiers in %u ms", uint32(_criteriaModifiers.size()), GetMSTimeDiffToNow(oldMSTime));
 }

Here is the call graph for this function:

void AchievementGlobalMgr::LoadAchievementReferenceList ( )

 {
  uint32 oldMSTime = getMSTime();
 
  if (sAchievementStore.GetNumRows() == 0)
  {
  TC_LOG_INFO("server.loading", ">> Loaded 0 achievement references.");
  return;
  }
 
  uint32 count = 0;
 
  for (uint32 entryId = 0; entryId < sAchievementStore.GetNumRows(); ++entryId)
  {
  AchievementEntry const* achievement = sAchievementMgr->GetAchievement(entryId);
  if (!achievement || !achievement->SharesCriteria)
  continue;
 
  _achievementListByReferencedId[achievement->SharesCriteria].push_back(achievement);
  ++count;
  }
 
  // Once Bitten, Twice Shy (10 player) - Icecrown Citadel
  if (AchievementEntry const* achievement = sAchievementMgr->GetAchievement(4539))
  const_cast<AchievementEntry*>(achievement)->MapID = 631; // Correct map requirement (currently has Ulduar); 6.0.3 note - it STILL has ulduar requirement
 
  TC_LOG_INFO("server.loading", ">> Loaded %u achievement references in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
 }

Here is the call graph for this function:

void AchievementGlobalMgr::LoadCompletedAchievements ( )

 {
  uint32 oldMSTime = getMSTime();
 
  QueryResult result = CharacterDatabase.Query("SELECT achievement FROM character_achievement GROUP BY achievement");
 
  if (!result)
  {
  TC_LOG_INFO("server.loading", ">> Loaded 0 realm first completed achievements. DB table `character_achievement` is empty.");
  return;
  }
 
  do
  {
  Field* fields = result->Fetch();
 
  uint16 achievementId = fields[0].GetUInt16();
  const AchievementEntry* achievement = sAchievementMgr->GetAchievement(achievementId);
  if (!achievement)
  {
  // Remove non existent achievements from all characters
  TC_LOG_ERROR("achievement", "Non-existing achievement %u data removed from table `character_achievement`.", achievementId);
 
  PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_INVALID_ACHIEVMENT);
  stmt->setUInt16(0, uint16(achievementId));
  CharacterDatabase.Execute(stmt);
 
  continue;
  }
  else if (achievement->Flags & (ACHIEVEMENT_FLAG_REALM_FIRST_REACH | ACHIEVEMENT_FLAG_REALM_FIRST_KILL))
  _allCompletedAchievements[achievementId] = uint32(0xFFFFFFFF);
  }
  while (result->NextRow());
 
  TC_LOG_INFO("server.loading", ">> Loaded %lu realm first completed achievements in %u ms", (unsigned long)_allCompletedAchievements.size(), GetMSTimeDiffToNow(oldMSTime));
 }

Here is the call graph for this function:

void AchievementGlobalMgr::LoadRewardLocales ( )

 {
  uint32 oldMSTime = getMSTime();
 
  _achievementRewardLocales.clear(); // need for reload case
 
  QueryResult result = WorldDatabase.Query("SELECT entry, subject_loc1, text_loc1, subject_loc2, text_loc2, subject_loc3, text_loc3, subject_loc4, text_loc4, "
  "subject_loc5, text_loc5, subject_loc6, text_loc6, subject_loc7, text_loc7, subject_loc8, text_loc8"
  " FROM locales_achievement_reward");
 
  if (!result)
  {
  TC_LOG_INFO("server.loading", ">> Loaded 0 achievement reward locale strings. DB table `locales_achievement_reward` is empty");
  return;
  }
 
  do
  {
  Field* fields = result->Fetch();
 
  uint32 entry = fields[0].GetUInt32();
 
  if (_achievementRewards.find(entry) == _achievementRewards.end())
  {
  TC_LOG_ERROR("sql.sql", "Table `locales_achievement_reward` (Entry: %u) has locale strings for non-existing achievement reward.", entry);
  continue;
  }
 
  AchievementRewardLocale& data = _achievementRewardLocales[entry];
 
  for (uint8 i = OLD_TOTAL_LOCALES - 1; i > 0; --i)
  {
  LocaleConstant locale = (LocaleConstant) i;
  ObjectMgr::AddLocaleString(fields[1 + 2 * (i - 1)].GetString(), locale, data.subject);
  ObjectMgr::AddLocaleString(fields[1 + 2 * (i - 1) + 1].GetString(), locale, data.text);
  }
  }
  while (result->NextRow());
 
  TC_LOG_INFO("server.loading", ">> Loaded %u achievement reward locale strings in %u ms", uint32(_achievementRewardLocales.size()), GetMSTimeDiffToNow(oldMSTime));
 }

Here is the call graph for this function:

void AchievementGlobalMgr::LoadRewards ( )

 {
  uint32 oldMSTime = getMSTime();
 
  _achievementRewards.clear(); // need for reload case
 
  // 0 1 2 3 4 5 6 7
  QueryResult result = WorldDatabase.Query("SELECT entry, title_A, title_H, item, sender, subject, text, mailTemplate FROM achievement_reward");
 
  if (!result)
  {
  TC_LOG_ERROR("server.loading", ">> Loaded 0 achievement rewards. DB table `achievement_reward` is empty.");
  return;
  }
 
  uint32 count = 0;
 
  do
  {
  Field* fields = result->Fetch();
  uint32 entry = fields[0].GetUInt32();
  AchievementEntry const* achievement = GetAchievement(entry);
  if (!achievement)
  {
  TC_LOG_ERROR("sql.sql", "Table `achievement_reward` has wrong achievement (Entry: %u), ignored.", entry);
  continue;
  }
 
  AchievementReward reward;
  reward.titleId[0] = fields[1].GetUInt32();
  reward.titleId[1] = fields[2].GetUInt32();
  reward.itemId = fields[3].GetUInt32();
  reward.sender = fields[4].GetUInt32();
  reward.subject = fields[5].GetString();
  reward.text = fields[6].GetString();
  reward.mailTemplate = fields[7].GetUInt32();
 
  // must be title or mail at least
  if (!reward.titleId[0] && !reward.titleId[1] && !reward.sender)
  {
  TC_LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: %u) does not have title or item reward data, ignored.", entry);
  continue;
  }
 
  if (achievement->Faction == ACHIEVEMENT_FACTION_ANY && (!reward.titleId[0] ^ !reward.titleId[1]))
  TC_LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: %u) has title (A: %u H: %u) for only one team.", entry, reward.titleId[0], reward.titleId[1]);
 
  if (reward.titleId[0])
  {
  CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(reward.titleId[0]);
  if (!titleEntry)
  {
  TC_LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: %u) has invalid title id (%u) in `title_A`, set to 0", entry, reward.titleId[0]);
  reward.titleId[0] = 0;
  }
  }
 
  if (reward.titleId[1])
  {
  CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(reward.titleId[1]);
  if (!titleEntry)
  {
  TC_LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: %u) has invalid title id (%u) in `title_H`, set to 0", entry, reward.titleId[1]);
  reward.titleId[1] = 0;
  }
  }
 
  //check mail data before item for report including wrong item case
  if (reward.sender)
  {
  if (!sObjectMgr->GetCreatureTemplate(reward.sender))
  {
  TC_LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: %u) has invalid creature entry %u as sender, mail reward skipped.", entry, reward.sender);
  reward.sender = 0;
  }
  }
  else
  {
  if (reward.itemId)
  TC_LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: %u) does not have sender data but has item reward, item will not be rewarded.", entry);
 
  if (!reward.subject.empty())
  TC_LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: %u) does not have sender data but has mail subject.", entry);
 
  if (!reward.text.empty())
  TC_LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: %u) does not have sender data but has mail text.", entry);
 
  if (reward.mailTemplate)
  TC_LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: %u) does not have sender data but has mailTemplate.", entry);
  }
 
  if (reward.mailTemplate)
  {
  if (!sMailTemplateStore.LookupEntry(reward.mailTemplate))
  {
  TC_LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: %u) has invalid mailTemplate (%u).", entry, reward.mailTemplate);
  reward.mailTemplate = 0;
  }
  else if (!reward.subject.empty() || !reward.text.empty())
  TC_LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: %u) has mailTemplate (%u) and mail subject/text.", entry, reward.mailTemplate);
  }
 
  if (reward.itemId)
  {
  if (!sObjectMgr->GetItemTemplate(reward.itemId))
  {
  TC_LOG_ERROR("sql.sql", "Table `achievement_reward` (Entry: %u) has invalid item id %u, reward mail will not contain item.", entry, reward.itemId);
  reward.itemId = 0;
  }
  }
 
  _achievementRewards[entry] = reward;
  ++count;
  }
  while (result->NextRow());
 
  TC_LOG_INFO("server.loading", ">> Loaded %u achievement rewards in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
 }

Here is the call graph for this function:

void AchievementGlobalMgr::OnInstanceDestroyed ( uint32 instanceId )

 {
     for (auto& realmCompletion : _allCompletedAchievements)
         if (realmCompletion.second == instanceId)
             realmCompletion.second = uint32(0xFFFFFFFF);
 }

void AchievementGlobalMgr::SetRealmCompleted	(	AchievementEntry const *	achievement,
		uint32	instanceId
	)

inline

         {
             if (IsRealmCompleted(achievement, instanceId))
                 return;
 
             _allCompletedAchievements[achievement->ID] = instanceId;
         }

template<typename Func >

void AchievementGlobalMgr::WalkCriteriaTree	(	AchievementCriteriaTree const *	tree,
		Func const &	func
	)		const

inline

         {
             for (AchievementCriteriaTree const* node : tree->Children)
                 WalkCriteriaTree(node, func);
 
             func(tree);
         }

Member Data Documentation

AchievementCriteriaMap AchievementGlobalMgr::_achievementCriteria

private

AchievementCriteriaList AchievementGlobalMgr::_achievementCriteriasByTimedType[ACHIEVEMENT_TIMED_TYPE_MAX]

private

AchievementCriteriaList AchievementGlobalMgr::_achievementCriteriasByType[ACHIEVEMENT_CRITERIA_TYPE_TOTAL]

private

AchievementCriteriaTreeByCriteriaMap AchievementGlobalMgr::_achievementCriteriaTreeByCriteria

private

AchievementCriteriaTreeMap AchievementGlobalMgr::_achievementCriteriaTrees

private

AchievementListByReferencedId AchievementGlobalMgr::_achievementListByReferencedId

private

AchievementRewardLocales AchievementGlobalMgr::_achievementRewardLocales

private

AchievementRewards AchievementGlobalMgr::_achievementRewards

private

AllCompletedAchievements AchievementGlobalMgr::_allCompletedAchievements

private

AchievementCriteriaDataMap AchievementGlobalMgr::_criteriaDataMap

private

ModifierTreeMap AchievementGlobalMgr::_criteriaModifiers

private

AchievementCriteriaList AchievementGlobalMgr::_guildAchievementCriteriasByType[ACHIEVEMENT_CRITERIA_TYPE_TOTAL]

private

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

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

Private Attributes
AchievementCriteriaDataMap	_criteriaDataMap

AchievementCriteriaTreeMap	_achievementCriteriaTrees

AchievementCriteriaMap	_achievementCriteria

ModifierTreeMap	_criteriaModifiers

AchievementCriteriaTreeByCriteriaMap	_achievementCriteriaTreeByCriteria

AchievementCriteriaList	_achievementCriteriasByType [ACHIEVEMENT_CRITERIA_TYPE_TOTAL]

AchievementCriteriaList	_guildAchievementCriteriasByType [ACHIEVEMENT_CRITERIA_TYPE_TOTAL]

AchievementCriteriaList	_achievementCriteriasByTimedType [ACHIEVEMENT_TIMED_TYPE_MAX]

AchievementListByReferencedId	_achievementListByReferencedId

AllCompletedAchievements	_allCompletedAchievements

AchievementRewards	_achievementRewards

AchievementRewardLocales	_achievementRewardLocales

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation