public/azerothcore-wotlk
1
0
Fork 0
mirror of https://github.com/liyunfan1223/azerothcore-wotlk.git synced 2026-08-08 15:58:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor(Core/Achievement): Remove Hungarian notation (#13991)

Browse Source
This commit is contained in:
Maelthyr
2022-12-02 09:52:25 +01:00
committed by GitHub
parent d2f440c3e8
commit 735fb46ce6
2 changed files with 136 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

200
src/server/game/Achievements/AchievementMgr.cpp
View File

@@ -470,8 +470,8 @@ bool AchievementCriteriaData::Meets(uint32 criteria_id, Player const* source, Un
bool AchievementCriteriaDataSet::Meets(Player const* source, Unit const* target, uint32 miscvalue /*= 0*/) const bool AchievementCriteriaDataSet::Meets(Player const* source, Unit const* target, uint32 miscvalue /*= 0*/) const
{ {
for (Storage::const_iterator itr = storage.begin(); itr != storage.end(); ++itr) for (Storage::const_iterator itr = _storage.begin(); itr != _storage.end(); ++itr)
if (!itr->Meets(criteria_id, source, target, miscvalue)) if (!itr->Meets(_criteria_id, source, target, miscvalue))
return false; return false;
return true; return true;
@@ -479,7 +479,7 @@ bool AchievementCriteriaDataSet::Meets(Player const* source, Unit const* target,
AchievementMgr::AchievementMgr(Player* player) AchievementMgr::AchievementMgr(Player* player)
{ {
m_player = player; _player = player;
} }
AchievementMgr::~AchievementMgr() AchievementMgr::~AchievementMgr()
@@ -488,23 +488,23 @@ AchievementMgr::~AchievementMgr()
void AchievementMgr::Reset() void AchievementMgr::Reset()
{ {
for (CompletedAchievementMap::const_iterator iter = m_completedAchievements.begin(); iter != m_completedAchievements.end(); ++iter) for (CompletedAchievementMap::const_iterator iter = _completedAchievements.begin(); iter != _completedAchievements.end(); ++iter)
{ {
WorldPacket data(SMSG_ACHIEVEMENT_DELETED, 4); WorldPacket data(SMSG_ACHIEVEMENT_DELETED, 4);
data << uint32(iter->first); data << uint32(iter->first);
m_player->SendDirectMessage(&data); _player->SendDirectMessage(&data);
} }
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter != m_criteriaProgress.end(); ++iter) for (CriteriaProgressMap::const_iterator iter = _criteriaProgress.begin(); iter != _criteriaProgress.end(); ++iter)
{ {
WorldPacket data(SMSG_CRITERIA_DELETED, 4); WorldPacket data(SMSG_CRITERIA_DELETED, 4);
data << uint32(iter->first); data << uint32(iter->first);
m_player->SendDirectMessage(&data); _player->SendDirectMessage(&data);
} }
m_completedAchievements.clear(); _completedAchievements.clear();
m_criteriaProgress.clear(); _criteriaProgress.clear();
DeleteFromDB(m_player->GetGUID().GetCounter()); DeleteFromDB(_player->GetGUID().GetCounter());
// re-fill data // re-fill data
CheckAllAchievementCriteria(); CheckAllAchievementCriteria();
@@ -513,7 +513,7 @@ void AchievementMgr::Reset()
void AchievementMgr::ResetAchievementCriteria(AchievementCriteriaCondition condition, uint32 value, bool evenIfCriteriaComplete) void AchievementMgr::ResetAchievementCriteria(AchievementCriteriaCondition condition, uint32 value, bool evenIfCriteriaComplete)
{ {
// disable for gamemasters with GM-mode enabled // disable for gamemasters with GM-mode enabled
if (m_player->IsGameMaster()) if (_player->IsGameMaster())
return; return;
LOG_DEBUG("achievement", "AchievementMgr::ResetAchievementCriteria({}, {}, {})", condition, value, evenIfCriteriaComplete); LOG_DEBUG("achievement", "AchievementMgr::ResetAchievementCriteria({}, {}, {})", condition, value, evenIfCriteriaComplete);
@@ -554,9 +554,9 @@ void AchievementMgr::DeleteFromDB(ObjectGuid::LowType lowguid)
void AchievementMgr::SaveToDB(CharacterDatabaseTransaction trans) void AchievementMgr::SaveToDB(CharacterDatabaseTransaction trans)
{ {
if (!m_completedAchievements.empty()) if (!_completedAchievements.empty())
{ {
for (CompletedAchievementMap::iterator iter = m_completedAchievements.begin(); iter != m_completedAchievements.end(); ++iter) for (CompletedAchievementMap::iterator iter = _completedAchievements.begin(); iter != _completedAchievements.end(); ++iter)
{ {
if (!iter->second.changed) if (!iter->second.changed)
continue; continue;
@@ -578,9 +578,9 @@ void AchievementMgr::SaveToDB(CharacterDatabaseTransaction trans)
} }
} }
if (!m_criteriaProgress.empty()) if (!_criteriaProgress.empty())
{ {
for (CriteriaProgressMap::iterator iter = m_criteriaProgress.begin(); iter != m_criteriaProgress.end(); ++iter) for (CriteriaProgressMap::iterator iter = _criteriaProgress.begin(); iter != _criteriaProgress.end(); ++iter)
{ {
if (!iter->second.changed) if (!iter->second.changed)
continue; continue;
@@ -622,7 +622,7 @@ void AchievementMgr::LoadFromDB(PreparedQueryResult achievementResult, PreparedQ
if (!achievement) if (!achievement)
continue; continue;
CompletedAchievementData& ca = m_completedAchievements[achievementid]; CompletedAchievementData& ca = _completedAchievements[achievementid];
ca.date = time_t(fields[1].Get<uint32>()); ca.date = time_t(fields[1].Get<uint32>());
ca.changed = false; ca.changed = false;
@@ -662,7 +662,7 @@ void AchievementMgr::LoadFromDB(PreparedQueryResult achievementResult, PreparedQ
if (criteria->timeLimit && time_t(date + criteria->timeLimit) < GameTime::GetGameTime().count()) if (criteria->timeLimit && time_t(date + criteria->timeLimit) < GameTime::GetGameTime().count())
continue; continue;
CriteriaProgress& progress = m_criteriaProgress[id]; CriteriaProgress& progress = _criteriaProgress[id];
progress.counter = counter; progress.counter = counter;
progress.date = date; progress.date = date;
progress.changed = false; progress.changed = false;
@@ -789,7 +789,7 @@ static const uint32 achievIdForDungeon[][4] =
void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, uint32 miscValue1 /*= 0*/, uint32 miscValue2 /*= 0*/, Unit* unit /*= nullptr*/) void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, uint32 miscValue1 /*= 0*/, uint32 miscValue2 /*= 0*/, Unit* unit /*= nullptr*/)
{ {
// disable for gamemasters with GM-mode enabled // disable for gamemasters with GM-mode enabled
if (m_player->IsGameMaster()) if (_player->IsGameMaster())
return; return;
if (type >= ACHIEVEMENT_CRITERIA_TYPE_TOTAL) if (type >= ACHIEVEMENT_CRITERIA_TYPE_TOTAL)
@@ -1596,7 +1596,7 @@ void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, ui
if (!miscValue1) if (!miscValue1)
{ {
uint32 points = 0; uint32 points = 0;
for (CompletedAchievementMap::iterator itr = m_completedAchievements.begin(); itr != m_completedAchievements.end(); ++itr) for (CompletedAchievementMap::iterator itr = _completedAchievements.begin(); itr != _completedAchievements.end(); ++itr)
if (AchievementEntry const* pAchievement = sAchievementStore.LookupEntry(itr->first)) if (AchievementEntry const* pAchievement = sAchievementStore.LookupEntry(itr->first))
points += pAchievement->points; points += pAchievement->points;
SetCriteriaProgress(achievementCriteria, points, PROGRESS_SET); SetCriteriaProgress(achievementCriteria, points, PROGRESS_SET);
@@ -2027,9 +2027,9 @@ bool AchievementMgr::IsCompletedAchievement(AchievementEntry const* entry)
CriteriaProgress* AchievementMgr::GetCriteriaProgress(AchievementCriteriaEntry const* entry) CriteriaProgress* AchievementMgr::GetCriteriaProgress(AchievementCriteriaEntry const* entry)
{ {
CriteriaProgressMap::iterator iter = m_criteriaProgress.find(entry->ID); CriteriaProgressMap::iterator iter = _criteriaProgress.find(entry->ID);
if (iter == m_criteriaProgress.end()) if (iter == _criteriaProgress.end())
return nullptr; return nullptr;
return &(iter->second); return &(iter->second);
@@ -2038,8 +2038,8 @@ CriteriaProgress* AchievementMgr::GetCriteriaProgress(AchievementCriteriaEntry c
void AchievementMgr::SetCriteriaProgress(AchievementCriteriaEntry const* entry, uint32 changeValue, ProgressType ptype) void AchievementMgr::SetCriteriaProgress(AchievementCriteriaEntry const* entry, uint32 changeValue, ProgressType ptype)
{ {
// Don't allow to cheat - doing timed achievements without timer active // Don't allow to cheat - doing timed achievements without timer active
TimedAchievementMap::iterator timedIter = m_timedAchievements.find(entry->ID); TimedAchievementMap::iterator timedIter = _timedAchievements.find(entry->ID);
if (entry->timeLimit && timedIter == m_timedAchievements.end()) if (entry->timeLimit && timedIter == _timedAchievements.end())
return; return;
if (!sScriptMgr->OnBeforeCriteriaProgress(GetPlayer(), entry)) if (!sScriptMgr->OnBeforeCriteriaProgress(GetPlayer(), entry))
@@ -2047,7 +2047,7 @@ void AchievementMgr::SetCriteriaProgress(AchievementCriteriaEntry const* entry,
return; return;
} }
LOG_DEBUG("achievement", "AchievementMgr::SetCriteriaProgress({}, {}) for {}", entry->ID, changeValue, m_player->GetGUID().ToString()); LOG_DEBUG("achievement", "AchievementMgr::SetCriteriaProgress({}, {}) for {}", entry->ID, changeValue, _player->GetGUID().ToString());
CriteriaProgress* progress = GetCriteriaProgress(entry); CriteriaProgress* progress = GetCriteriaProgress(entry);
if (!progress) if (!progress)
@@ -2057,7 +2057,7 @@ void AchievementMgr::SetCriteriaProgress(AchievementCriteriaEntry const* entry,
if (changeValue == 0 && !entry->timeLimit) if (changeValue == 0 && !entry->timeLimit)
return; return;
progress = &m_criteriaProgress[entry->ID]; progress = &_criteriaProgress[entry->ID];
progress->counter = changeValue; progress->counter = changeValue;
} }
else else
@@ -2103,7 +2103,7 @@ void AchievementMgr::SetCriteriaProgress(AchievementCriteriaEntry const* entry,
// Remove the timer, we wont need it anymore // Remove the timer, we wont need it anymore
if (timedCompleted) if (timedCompleted)
m_timedAchievements.erase(timedIter); _timedAchievements.erase(timedIter);
} }
SendCriteriaUpdate(entry, progress, timeElapsed, true); SendCriteriaUpdate(entry, progress, timeElapsed, true);
@@ -2113,29 +2113,29 @@ void AchievementMgr::SetCriteriaProgress(AchievementCriteriaEntry const* entry,
void AchievementMgr::RemoveCriteriaProgress(const AchievementCriteriaEntry* entry) void AchievementMgr::RemoveCriteriaProgress(const AchievementCriteriaEntry* entry)
{ {
CriteriaProgressMap::iterator criteriaProgress = m_criteriaProgress.find(entry->ID); CriteriaProgressMap::iterator criteriaProgress = _criteriaProgress.find(entry->ID);
if (criteriaProgress == m_criteriaProgress.end()) if (criteriaProgress == _criteriaProgress.end())
return; return;
WorldPacket data(SMSG_CRITERIA_DELETED, 4); WorldPacket data(SMSG_CRITERIA_DELETED, 4);
data << uint32(entry->ID); data << uint32(entry->ID);
m_player->SendDirectMessage(&data); _player->SendDirectMessage(&data);
m_criteriaProgress.erase(criteriaProgress); _criteriaProgress.erase(criteriaProgress);
} }
void AchievementMgr::UpdateTimedAchievements(uint32 timeDiff) void AchievementMgr::UpdateTimedAchievements(uint32 timeDiff)
{ {
if (!m_timedAchievements.empty()) if (!_timedAchievements.empty())
{ {
for (TimedAchievementMap::iterator itr = m_timedAchievements.begin(); itr != m_timedAchievements.end();) for (TimedAchievementMap::iterator itr = _timedAchievements.begin(); itr != _timedAchievements.end();)
{ {
// Time is up, remove timer and reset progress // Time is up, remove timer and reset progress
if (itr->second <= timeDiff) if (itr->second <= timeDiff)
{ {
AchievementCriteriaEntry const* entry = sAchievementCriteriaStore.LookupEntry(itr->first); AchievementCriteriaEntry const* entry = sAchievementCriteriaStore.LookupEntry(itr->first);
RemoveCriteriaProgress(entry); RemoveCriteriaProgress(entry);
m_timedAchievements.erase(itr++); _timedAchievements.erase(itr++);
} }
else else
{ {
@@ -2155,12 +2155,12 @@ void AchievementMgr::StartTimedAchievement(AchievementCriteriaTimedTypes type, u
continue; continue;
AchievementEntry const* achievement = sAchievementStore.LookupEntry((*i)->referredAchievement); AchievementEntry const* achievement = sAchievementStore.LookupEntry((*i)->referredAchievement);
if (m_timedAchievements.find((*i)->ID) == m_timedAchievements.end() && !IsCompletedCriteria(*i, achievement)) if (_timedAchievements.find((*i)->ID) == _timedAchievements.end() && !IsCompletedCriteria(*i, achievement))
{ {
// Start the timer // Start the timer
if ((*i)->timeLimit * IN_MILLISECONDS > timeLost) if ((*i)->timeLimit * IN_MILLISECONDS > timeLost)
{ {
m_timedAchievements[(*i)->ID] = (*i)->timeLimit * IN_MILLISECONDS - timeLost; _timedAchievements[(*i)->ID] = (*i)->timeLimit * IN_MILLISECONDS - timeLost;
// and at client too // and at client too
SetCriteriaProgress(*i, 0, PROGRESS_SET); SetCriteriaProgress(*i, 0, PROGRESS_SET);
@@ -2177,26 +2177,26 @@ void AchievementMgr::RemoveTimedAchievement(AchievementCriteriaTimedTypes type,
if ((*i)->timerStartEvent != entry) if ((*i)->timerStartEvent != entry)
continue; continue;
TimedAchievementMap::iterator timedIter = m_timedAchievements.find((*i)->ID); TimedAchievementMap::iterator timedIter = _timedAchievements.find((*i)->ID);
// We don't have timer for this achievement // We don't have timer for this achievement
if (timedIter == m_timedAchievements.end()) if (timedIter == _timedAchievements.end())
continue; continue;
// remove progress // remove progress
RemoveCriteriaProgress(*i); RemoveCriteriaProgress(*i);
// Remove the timer // Remove the timer
m_timedAchievements.erase(timedIter); _timedAchievements.erase(timedIter);
} }
} }
void AchievementMgr::CompletedAchievement(AchievementEntry const* achievement) void AchievementMgr::CompletedAchievement(AchievementEntry const* achievement)
{ {
// disable for gamemasters with GM-mode enabled // disable for gamemasters with GM-mode enabled
if (m_player->IsGameMaster()) if (_player->IsGameMaster())
{ {
LOG_INFO("achievement", "Not available in GM mode."); LOG_INFO("achievement", "Not available in GM mode.");
ChatHandler(m_player->GetSession()).PSendSysMessage("Not available in GM mode"); ChatHandler(_player->GetSession()).PSendSysMessage("Not available in GM mode");
return; return;
} }
@@ -2211,7 +2211,7 @@ void AchievementMgr::CompletedAchievement(AchievementEntry const* achievement)
LOG_DEBUG("achievement", "AchievementMgr::CompletedAchievement({})", achievement->ID); LOG_DEBUG("achievement", "AchievementMgr::CompletedAchievement({})", achievement->ID);
SendAchievementEarned(achievement); SendAchievementEarned(achievement);
CompletedAchievementData& ca = m_completedAchievements[achievement->ID]; CompletedAchievementData& ca = _completedAchievements[achievement->ID];
ca.date = GameTime::GetGameTime().count(); ca.date = GameTime::GetGameTime().count();
ca.changed = true; ca.changed = true;
@@ -2240,7 +2240,7 @@ void AchievementMgr::CompletedAchievement(AchievementEntry const* achievement)
} }
} }
if (achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_REACH | ACHIEVEMENT_FLAG_REALM_FIRST_KILL) && AccountMgr::IsPlayerAccount(m_player->GetSession()->GetSecurity())) if (achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_REACH | ACHIEVEMENT_FLAG_REALM_FIRST_KILL) && AccountMgr::IsPlayerAccount(_player->GetSession()->GetSecurity()))
sAchievementMgr->SetRealmCompleted(achievement); sAchievementMgr->SetRealmCompleted(achievement);
UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT, achievement->ID); UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT, achievement->ID);
@@ -2304,14 +2304,14 @@ void AchievementMgr::CompletedAchievement(AchievementEntry const* achievement)
void AchievementMgr::SendAllAchievementData() const void AchievementMgr::SendAllAchievementData() const
{ {
WorldPacket data(SMSG_ALL_ACHIEVEMENT_DATA, m_completedAchievements.size() * 8 + 4 + m_criteriaProgress.size() * 38 + 4); WorldPacket data(SMSG_ALL_ACHIEVEMENT_DATA, _completedAchievements.size() * 8 + 4 + _criteriaProgress.size() * 38 + 4);
BuildAllDataPacket(&data); BuildAllDataPacket(&data);
GetPlayer()->GetSession()->SendPacket(&data); GetPlayer()->GetSession()->SendPacket(&data);
} }
void AchievementMgr::SendRespondInspectAchievements(Player* player) const void AchievementMgr::SendRespondInspectAchievements(Player* player) const
{ {
WorldPacket data(SMSG_RESPOND_INSPECT_ACHIEVEMENTS, 9 + m_completedAchievements.size() * 8 + 4 + m_criteriaProgress.size() * 38 + 4); WorldPacket data(SMSG_RESPOND_INSPECT_ACHIEVEMENTS, 9 + _completedAchievements.size() * 8 + 4 + _criteriaProgress.size() * 38 + 4);
data << GetPlayer()->GetPackGUID(); data << GetPlayer()->GetPackGUID();
BuildAllDataPacket(&data); BuildAllDataPacket(&data);
player->GetSession()->SendPacket(&data); player->GetSession()->SendPacket(&data);
@@ -2322,7 +2322,7 @@ void AchievementMgr::SendRespondInspectAchievements(Player* player) const
*/ */
void AchievementMgr::BuildAllDataPacket(WorldPacket* data) const void AchievementMgr::BuildAllDataPacket(WorldPacket* data) const
{ {
for (CompletedAchievementMap::const_iterator iter = m_completedAchievements.begin(); iter != m_completedAchievements.end(); ++iter) for (CompletedAchievementMap::const_iterator iter = _completedAchievements.begin(); iter != _completedAchievements.end(); ++iter)
{ {
// Skip hidden achievements // Skip hidden achievements
AchievementEntry const* achievement = sAchievementStore.LookupEntry(iter->first); AchievementEntry const* achievement = sAchievementStore.LookupEntry(iter->first);
@@ -2336,7 +2336,7 @@ void AchievementMgr::BuildAllDataPacket(WorldPacket* data) const
*data << int32(-1); *data << int32(-1);
time_t now = GameTime::GetGameTime().count(); time_t now = GameTime::GetGameTime().count();
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter != m_criteriaProgress.end(); ++iter) for (CriteriaProgressMap::const_iterator iter = _criteriaProgress.begin(); iter != _criteriaProgress.end(); ++iter)
{ {
*data << uint32(iter->first); *data << uint32(iter->first);
data->appendPackGUID(iter->second.counter); data->appendPackGUID(iter->second.counter);
@@ -2352,7 +2352,7 @@ void AchievementMgr::BuildAllDataPacket(WorldPacket* data) const
bool AchievementMgr::HasAchieved(uint32 achievementId) const bool AchievementMgr::HasAchieved(uint32 achievementId) const
{ {
return m_completedAchievements.find(achievementId) != m_completedAchievements.end(); return _completedAchievements.find(achievementId) != _completedAchievements.end();
} }
bool AchievementMgr::CanUpdateCriteria(AchievementCriteriaEntry const* criteria, AchievementEntry const* achievement) bool AchievementMgr::CanUpdateCriteria(AchievementCriteriaEntry const* criteria, AchievementEntry const* achievement)
@@ -2402,10 +2402,10 @@ AchievementGlobalMgr* AchievementGlobalMgr::instance()
bool AchievementGlobalMgr::IsStatisticCriteria(AchievementCriteriaEntry const* achievementCriteria) const bool AchievementGlobalMgr::IsStatisticCriteria(AchievementCriteriaEntry const* achievementCriteria) const
{ {
return isStatisticAchievement(sAchievementStore.LookupEntry(achievementCriteria->referredAchievement)); return IsStatisticAchievement(sAchievementStore.LookupEntry(achievementCriteria->referredAchievement));
} }
bool AchievementGlobalMgr::isStatisticAchievement(AchievementEntry const* achievement) const bool AchievementGlobalMgr::IsStatisticAchievement(AchievementEntry const* achievement) const
{ {
if (!achievement) if (!achievement)
return false; return false;
@@ -2430,8 +2430,8 @@ bool AchievementGlobalMgr::isStatisticAchievement(AchievementEntry const* achiev
bool AchievementGlobalMgr::IsRealmCompleted(AchievementEntry const* achievement) const bool AchievementGlobalMgr::IsRealmCompleted(AchievementEntry const* achievement) const
{ {
auto itr = m_allCompletedAchievements.find(achievement->ID); auto itr = _allCompletedAchievements.find(achievement->ID);
if (itr == m_allCompletedAchievements.end()) if (itr == _allCompletedAchievements.end())
return false; return false;
if (itr->second == SystemTimePoint::min()) if (itr->second == SystemTimePoint::min())
@@ -2459,7 +2459,7 @@ void AchievementGlobalMgr::SetRealmCompleted(AchievementEntry const* achievement
if (IsRealmCompleted(achievement)) if (IsRealmCompleted(achievement))
return; return;
m_allCompletedAchievements[achievement->ID] = GameTime::GetSystemTime(); _allCompletedAchievements[achievement->ID] = GameTime::GetSystemTime();
} }
//========================================================== //==========================================================
@@ -2481,67 +2481,67 @@ void AchievementGlobalMgr::LoadAchievementCriteriaList()
if (!criteria) if (!criteria)
continue; continue;
m_AchievementCriteriasByType[criteria->requiredType].push_back(criteria); _achievementCriteriasByType[criteria->requiredType].push_back(criteria);
m_AchievementCriteriaListByAchievement[criteria->referredAchievement].push_back(criteria); _achievementCriteriaListByAchievement[criteria->referredAchievement].push_back(criteria);
if (criteria->additionalRequirements[0].additionalRequirement_type != ACHIEVEMENT_CRITERIA_CONDITION_NONE) if (criteria->additionalRequirements[0].additionalRequirement_type != ACHIEVEMENT_CRITERIA_CONDITION_NONE)
m_AchievementCriteriasByCondition[criteria->additionalRequirements[0].additionalRequirement_type][criteria->additionalRequirements[0].additionalRequirement_value].push_back(criteria); _achievementCriteriasByCondition[criteria->additionalRequirements[0].additionalRequirement_type][criteria->additionalRequirements[0].additionalRequirement_value].push_back(criteria);
if (criteria->additionalRequirements[1].additionalRequirement_type != ACHIEVEMENT_CRITERIA_CONDITION_NONE && if (criteria->additionalRequirements[1].additionalRequirement_type != ACHIEVEMENT_CRITERIA_CONDITION_NONE &&
criteria->additionalRequirements[1].additionalRequirement_type != criteria->additionalRequirements[0].additionalRequirement_type) criteria->additionalRequirements[1].additionalRequirement_type != criteria->additionalRequirements[0].additionalRequirement_type)
m_AchievementCriteriasByCondition[criteria->additionalRequirements[1].additionalRequirement_type][criteria->additionalRequirements[1].additionalRequirement_value].push_back(criteria); _achievementCriteriasByCondition[criteria->additionalRequirements[1].additionalRequirement_type][criteria->additionalRequirements[1].additionalRequirement_value].push_back(criteria);
switch (criteria->requiredType) switch (criteria->requiredType)
{ {
case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE: case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
m_SpecialList[criteria->requiredType][criteria->kill_creature.creatureID].push_back(criteria); _specialList[criteria->requiredType][criteria->kill_creature.creatureID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG: case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG:
m_SpecialList[criteria->requiredType][criteria->win_bg.bgMapID].push_back(criteria); _specialList[criteria->requiredType][criteria->win_bg.bgMapID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL: case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL:
m_SpecialList[criteria->requiredType][criteria->reach_skill_level.skillID].push_back(criteria); _specialList[criteria->requiredType][criteria->reach_skill_level.skillID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT: case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT:
m_SpecialList[criteria->requiredType][criteria->complete_achievement.linkedAchievement].push_back(criteria); _specialList[criteria->requiredType][criteria->complete_achievement.linkedAchievement].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE: case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
m_SpecialList[criteria->requiredType][criteria->complete_quests_in_zone.zoneID].push_back(criteria); _specialList[criteria->requiredType][criteria->complete_quests_in_zone.zoneID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND: case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND:
m_SpecialList[criteria->requiredType][criteria->complete_battleground.mapID].push_back(criteria); _specialList[criteria->requiredType][criteria->complete_battleground.mapID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE: case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE:
m_SpecialList[criteria->requiredType][criteria->killed_by_creature.creatureEntry].push_back(criteria); _specialList[criteria->requiredType][criteria->killed_by_creature.creatureEntry].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST: case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
m_SpecialList[criteria->requiredType][criteria->complete_quest.questID].push_back(criteria); _specialList[criteria->requiredType][criteria->complete_quest.questID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET: case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
m_SpecialList[criteria->requiredType][criteria->be_spell_target.spellID].push_back(criteria); _specialList[criteria->requiredType][criteria->be_spell_target.spellID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL: case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
m_SpecialList[criteria->requiredType][criteria->cast_spell.spellID].push_back(criteria); _specialList[criteria->requiredType][criteria->cast_spell.spellID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE: case ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE:
m_SpecialList[criteria->requiredType][criteria->bg_objective.objectiveId].push_back(criteria); _specialList[criteria->requiredType][criteria->bg_objective.objectiveId].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL_AT_AREA: case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL_AT_AREA:
m_SpecialList[criteria->requiredType][criteria->honorable_kill_at_area.areaID].push_back(criteria); _specialList[criteria->requiredType][criteria->honorable_kill_at_area.areaID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL: case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL:
m_SpecialList[criteria->requiredType][criteria->learn_spell.spellID].push_back(criteria); _specialList[criteria->requiredType][criteria->learn_spell.spellID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM: case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM:
m_SpecialList[criteria->requiredType][criteria->own_item.itemID].push_back(criteria); _specialList[criteria->requiredType][criteria->own_item.itemID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL: case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL:
m_SpecialList[criteria->requiredType][criteria->learn_skill_level.skillID].push_back(criteria); _specialList[criteria->requiredType][criteria->learn_skill_level.skillID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM: case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:
m_SpecialList[criteria->requiredType][criteria->use_item.itemID].push_back(criteria); _specialList[criteria->requiredType][criteria->use_item.itemID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM: case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM:
m_SpecialList[criteria->requiredType][criteria->own_item.itemID].push_back(criteria); _specialList[criteria->requiredType][criteria->own_item.itemID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA: case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA:
{ {
@@ -2557,53 +2557,53 @@ void AchievementGlobalMgr::LoadAchievementCriteriaList()
if (worldOverlayEntry->areatableID[j] == worldOverlayEntry->areatableID[i]) if (worldOverlayEntry->areatableID[j] == worldOverlayEntry->areatableID[i])
valid = false; valid = false;
if (valid) if (valid)
m_SpecialList[criteria->requiredType][worldOverlayEntry->areatableID[j]].push_back(criteria); _specialList[criteria->requiredType][worldOverlayEntry->areatableID[j]].push_back(criteria);
} }
} }
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION: case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
m_SpecialList[criteria->requiredType][criteria->gain_reputation.factionID].push_back(criteria); _specialList[criteria->requiredType][criteria->gain_reputation.factionID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM: case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM:
m_SpecialList[criteria->requiredType][criteria->equip_epic_item.itemSlot].push_back(criteria); _specialList[criteria->requiredType][criteria->equip_epic_item.itemSlot].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS: case ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS:
m_SpecialList[criteria->requiredType][criteria->hk_class.classID].push_back(criteria); _specialList[criteria->requiredType][criteria->hk_class.classID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_HK_RACE: case ACHIEVEMENT_CRITERIA_TYPE_HK_RACE:
m_SpecialList[criteria->requiredType][criteria->hk_race.raceID].push_back(criteria); _specialList[criteria->requiredType][criteria->hk_race.raceID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE: case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
m_SpecialList[criteria->requiredType][criteria->do_emote.emoteID].push_back(criteria); _specialList[criteria->requiredType][criteria->do_emote.emoteID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM: case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM:
m_SpecialList[criteria->requiredType][criteria->equip_item.itemID].push_back(criteria); _specialList[criteria->requiredType][criteria->equip_item.itemID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT: case ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT:
m_SpecialList[criteria->requiredType][criteria->use_gameobject.goEntry].push_back(criteria); _specialList[criteria->requiredType][criteria->use_gameobject.goEntry].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2: case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
m_SpecialList[criteria->requiredType][criteria->be_spell_target.spellID].push_back(criteria); _specialList[criteria->requiredType][criteria->be_spell_target.spellID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT: case ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT:
m_SpecialList[criteria->requiredType][criteria->fish_in_gameobject.goEntry].push_back(criteria); _specialList[criteria->requiredType][criteria->fish_in_gameobject.goEntry].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS: case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
m_SpecialList[criteria->requiredType][criteria->learn_skillline_spell.skillLine].push_back(criteria); _specialList[criteria->requiredType][criteria->learn_skillline_spell.skillLine].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE: case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:
m_SpecialList[criteria->requiredType][criteria->loot_type.lootType].push_back(criteria); _specialList[criteria->requiredType][criteria->loot_type.lootType].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2: case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
m_SpecialList[criteria->requiredType][criteria->cast_spell.spellID].push_back(criteria); _specialList[criteria->requiredType][criteria->cast_spell.spellID].push_back(criteria);
break; break;
case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE: case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE:
m_SpecialList[criteria->requiredType][criteria->learn_skill_line.skillLine].push_back(criteria); _specialList[criteria->requiredType][criteria->learn_skill_line.skillLine].push_back(criteria);
break; break;
} }
if (criteria->timeLimit) if (criteria->timeLimit)
m_AchievementCriteriasByTimedType[criteria->timedType].push_back(criteria); _achievementCriteriasByTimedType[criteria->timedType].push_back(criteria);
++loaded; ++loaded;
} }
@@ -2631,7 +2631,7 @@ void AchievementGlobalMgr::LoadAchievementReferenceList()
if (!achievement || !achievement->refAchievement) if (!achievement || !achievement->refAchievement)
continue; continue;
m_AchievementListByReferencedId[achievement->refAchievement].push_back(achievement); _achievementListByReferencedId[achievement->refAchievement].push_back(achievement);
++count; ++count;
} }
@@ -2643,7 +2643,7 @@ void AchievementGlobalMgr::LoadAchievementCriteriaData()
{ {
uint32 oldMSTime = getMSTime(); uint32 oldMSTime = getMSTime();
m_criteriaDataMap.clear(); // need for reload case _criteriaDataMap.clear(); // need for reload case
QueryResult result = WorldDatabase.Query("SELECT criteria_id, type, value1, value2, ScriptName FROM achievement_criteria_data"); QueryResult result = WorldDatabase.Query("SELECT criteria_id, type, value1, value2, ScriptName FROM achievement_criteria_data");
@@ -2686,7 +2686,7 @@ void AchievementGlobalMgr::LoadAchievementCriteriaData()
continue; continue;
// this will allocate empty data set storage // this will allocate empty data set storage
AchievementCriteriaDataSet& dataSet = m_criteriaDataMap[criteria_id]; AchievementCriteriaDataSet& dataSet = _criteriaDataMap[criteria_id];
dataSet.SetCriteriaId(criteria_id); dataSet.SetCriteriaId(criteria_id);
// add real data only for not NONE data types // add real data only for not NONE data types
@@ -2786,7 +2786,7 @@ void AchievementGlobalMgr::LoadCompletedAchievements()
for (uint32 i = 0; i < sAchievementStore.GetNumRows(); ++i) for (uint32 i = 0; i < sAchievementStore.GetNumRows(); ++i)
if (AchievementEntry const* achievement = sAchievementStore.LookupEntry(i)) if (AchievementEntry const* achievement = sAchievementStore.LookupEntry(i))
if (achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_REACH | ACHIEVEMENT_FLAG_REALM_FIRST_KILL)) if (achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_REACH | ACHIEVEMENT_FLAG_REALM_FIRST_KILL))
m_allCompletedAchievements[achievement->ID] = SystemTimePoint::min(); _allCompletedAchievements[achievement->ID] = SystemTimePoint::min();
if (!result) if (!result)
{ {
@@ -2814,10 +2814,10 @@ void AchievementGlobalMgr::LoadCompletedAchievements()
continue; continue;
} }
else if (achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_REACH | ACHIEVEMENT_FLAG_REALM_FIRST_KILL)) else if (achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_REACH | ACHIEVEMENT_FLAG_REALM_FIRST_KILL))
m_allCompletedAchievements[achievementId] = SystemTimePoint::max(); _allCompletedAchievements[achievementId] = SystemTimePoint::max();
} while (result->NextRow()); } while (result->NextRow());
LOG_INFO("server.loading", ">> Loaded {} completed achievements in {} ms", (unsigned long)m_allCompletedAchievements.size(), GetMSTimeDiffToNow(oldMSTime)); LOG_INFO("server.loading", ">> Loaded {} completed achievements in {} ms", (unsigned long)_allCompletedAchievements.size(), GetMSTimeDiffToNow(oldMSTime));
LOG_INFO("server.loading", " "); LOG_INFO("server.loading", " ");
} }
@@ -2825,7 +2825,7 @@ void AchievementGlobalMgr::LoadRewards()
{ {
uint32 oldMSTime = getMSTime(); uint32 oldMSTime = getMSTime();
m_achievementRewards.clear(); // need for reload case _achievementRewards.clear(); // need for reload case
// 0 1 2 3 4 5 6 7 // 0 1 2 3 4 5 6 7
QueryResult result = WorldDatabase.Query("SELECT ID, TitleA, TitleH, ItemID, Sender, Subject, Body, MailTemplateID FROM achievement_reward"); QueryResult result = WorldDatabase.Query("SELECT ID, TitleA, TitleH, ItemID, Sender, Subject, Body, MailTemplateID FROM achievement_reward");
@@ -2934,7 +2934,7 @@ void AchievementGlobalMgr::LoadRewards()
} }
} }
m_achievementRewards[entry] = reward; _achievementRewards[entry] = reward;
++count; ++count;
} while (result->NextRow()); } while (result->NextRow());
@@ -2946,7 +2946,7 @@ void AchievementGlobalMgr::LoadRewardLocales()
{ {
uint32 oldMSTime = getMSTime(); uint32 oldMSTime = getMSTime();
m_achievementRewardLocales.clear(); // need for reload case _achievementRewardLocales.clear(); // need for reload case
// 0 1 2 3 // 0 1 2 3
QueryResult result = WorldDatabase.Query("SELECT ID, Locale, Subject, Text FROM achievement_reward_locale"); QueryResult result = WorldDatabase.Query("SELECT ID, Locale, Subject, Text FROM achievement_reward_locale");
@@ -2963,7 +2963,7 @@ void AchievementGlobalMgr::LoadRewardLocales()
Field* fields = result->Fetch(); Field* fields = result->Fetch();
uint32 ID = fields[0].Get<uint32>(); uint32 ID = fields[0].Get<uint32>();
if (m_achievementRewards.find(ID) == m_achievementRewards.end()) if (_achievementRewards.find(ID) == _achievementRewards.end())
{ {
LOG_ERROR("sql.sql", "Table `achievement_reward_locale` (Entry: {}) has locale strings for non-existing achievement reward.", ID); LOG_ERROR("sql.sql", "Table `achievement_reward_locale` (Entry: {}) has locale strings for non-existing achievement reward.", ID);
continue; continue;
@@ -2973,12 +2973,12 @@ void AchievementGlobalMgr::LoadRewardLocales()
if (locale == LOCALE_enUS) if (locale == LOCALE_enUS)
continue; continue;
AchievementRewardLocale& data = m_achievementRewardLocales[ID]; AchievementRewardLocale& data = _achievementRewardLocales[ID];
ObjectMgr::AddLocaleString(fields[2].Get<std::string>(), locale, data.Subject); ObjectMgr::AddLocaleString(fields[2].Get<std::string>(), locale, data.Subject);
ObjectMgr::AddLocaleString(fields[3].Get<std::string>(), locale, data.Text); ObjectMgr::AddLocaleString(fields[3].Get<std::string>(), locale, data.Text);
} while (result->NextRow()); } while (result->NextRow());
LOG_INFO("server.loading", ">> Loaded {} Achievement Reward Locale Strings in {} ms", (unsigned long)m_achievementRewardLocales.size(), GetMSTimeDiffToNow(oldMSTime)); LOG_INFO("server.loading", ">> Loaded {} Achievement Reward Locale Strings in {} ms", (unsigned long)_achievementRewardLocales.size(), GetMSTimeDiffToNow(oldMSTime));
LOG_INFO("server.loading", " "); LOG_INFO("server.loading", " ");
} }

72
src/server/game/Achievements/AchievementMgr.h
View File

@@ -233,12 +233,12 @@ struct AchievementCriteriaDataSet
{ {
AchievementCriteriaDataSet() = default; AchievementCriteriaDataSet() = default;
typedef std::vector<AchievementCriteriaData> Storage; typedef std::vector<AchievementCriteriaData> Storage;
void Add(AchievementCriteriaData const& data) { storage.push_back(data); } void Add(AchievementCriteriaData const& data) { _storage.push_back(data); }
bool Meets(Player const* source, Unit const* target, uint32 miscvalue = 0) const; bool Meets(Player const* source, Unit const* target, uint32 miscvalue = 0) const;
void SetCriteriaId(uint32 id) {criteria_id = id;} void SetCriteriaId(uint32 id) {_criteria_id = id;}
private: private:
uint32 criteria_id{0}; uint32 _criteria_id{0};
Storage storage; Storage _storage;
}; };
typedef std::map<uint32, AchievementCriteriaDataSet> AchievementCriteriaDataMap; typedef std::map<uint32, AchievementCriteriaDataSet> AchievementCriteriaDataMap;
@@ -293,7 +293,7 @@ public:
void SendAllAchievementData() const; void SendAllAchievementData() const;
void SendRespondInspectAchievements(Player* player) const; void SendRespondInspectAchievements(Player* player) const;
[[nodiscard]] bool HasAchieved(uint32 achievementId) const; [[nodiscard]] bool HasAchieved(uint32 achievementId) const;
[[nodiscard]] Player* GetPlayer() const { return m_player; } [[nodiscard]] Player* GetPlayer() const { return _player; }
void UpdateTimedAchievements(uint32 timeDiff); void UpdateTimedAchievements(uint32 timeDiff);
void StartTimedAchievement(AchievementCriteriaTimedTypes type, uint32 entry, uint32 timeLost = 0); void StartTimedAchievement(AchievementCriteriaTimedTypes type, uint32 entry, uint32 timeLost = 0);
void RemoveTimedAchievement(AchievementCriteriaTimedTypes type, uint32 entry); // used for quest and scripted timed achievements void RemoveTimedAchievement(AchievementCriteriaTimedTypes type, uint32 entry); // used for quest and scripted timed achievements
@@ -311,11 +311,11 @@ private:
bool CanUpdateCriteria(AchievementCriteriaEntry const* criteria, AchievementEntry const* achievement); bool CanUpdateCriteria(AchievementCriteriaEntry const* criteria, AchievementEntry const* achievement);
void BuildAllDataPacket(WorldPacket* data) const; void BuildAllDataPacket(WorldPacket* data) const;
Player* m_player; Player* _player;
CriteriaProgressMap m_criteriaProgress; CriteriaProgressMap _criteriaProgress;
CompletedAchievementMap m_completedAchievements; CompletedAchievementMap _completedAchievements;
typedef std::map<uint32, uint32> TimedAchievementMap; typedef std::map<uint32, uint32> TimedAchievementMap;
TimedAchievementMap m_timedAchievements; // Criteria id/time left in MS TimedAchievementMap _timedAchievements; // Criteria id/time left in MS
}; };
class AchievementGlobalMgr class AchievementGlobalMgr
@@ -327,60 +327,60 @@ public:
static AchievementGlobalMgr* instance(); static AchievementGlobalMgr* instance();
bool IsStatisticCriteria(AchievementCriteriaEntry const* achievementCriteria) const; bool IsStatisticCriteria(AchievementCriteriaEntry const* achievementCriteria) const;
bool isStatisticAchievement(AchievementEntry const* achievement) const; bool IsStatisticAchievement(AchievementEntry const* achievement) const;
[[nodiscard]] AchievementCriteriaEntryList const* GetAchievementCriteriaByType(AchievementCriteriaTypes type) const [[nodiscard]] AchievementCriteriaEntryList const* GetAchievementCriteriaByType(AchievementCriteriaTypes type) const
{ {
return &m_AchievementCriteriasByType[type]; return &_achievementCriteriasByType[type];
} }
AchievementCriteriaEntryList const* GetSpecialAchievementCriteriaByType(AchievementCriteriaTypes type, uint32 val) AchievementCriteriaEntryList const* GetSpecialAchievementCriteriaByType(AchievementCriteriaTypes type, uint32 val)
{ {
if (m_SpecialList[type].find(val) != m_SpecialList[type].end()) if (_specialList[type].find(val) != _specialList[type].end())
return &m_SpecialList[type][val]; return &_specialList[type][val];
return nullptr; return nullptr;
} }
AchievementCriteriaEntryList const* GetAchievementCriteriaByCondition(AchievementCriteriaCondition condition, uint32 val) AchievementCriteriaEntryList const* GetAchievementCriteriaByCondition(AchievementCriteriaCondition condition, uint32 val)
{ {
if (m_AchievementCriteriasByCondition[condition].find(val) != m_AchievementCriteriasByCondition[condition].end()) if (_achievementCriteriasByCondition[condition].find(val) != _achievementCriteriasByCondition[condition].end())
return &m_AchievementCriteriasByCondition[condition][val]; return &_achievementCriteriasByCondition[condition][val];
return nullptr; return nullptr;
} }
[[nodiscard]] AchievementCriteriaEntryList const& GetTimedAchievementCriteriaByType(AchievementCriteriaTimedTypes type) const [[nodiscard]] AchievementCriteriaEntryList const& GetTimedAchievementCriteriaByType(AchievementCriteriaTimedTypes type) const
{ {
return m_AchievementCriteriasByTimedType[type]; return _achievementCriteriasByTimedType[type];
} }
[[nodiscard]] AchievementCriteriaEntryList const* GetAchievementCriteriaByAchievement(uint32 id) const [[nodiscard]] AchievementCriteriaEntryList const* GetAchievementCriteriaByAchievement(uint32 id) const
{ {
AchievementCriteriaListByAchievement::const_iterator itr = m_AchievementCriteriaListByAchievement.find(id); AchievementCriteriaListByAchievement::const_iterator itr = _achievementCriteriaListByAchievement.find(id);
return itr != m_AchievementCriteriaListByAchievement.end() ? &itr->second : nullptr; return itr != _achievementCriteriaListByAchievement.end() ? &itr->second : nullptr;
} }
[[nodiscard]] AchievementEntryList const* GetAchievementByReferencedId(uint32 id) const [[nodiscard]] AchievementEntryList const* GetAchievementByReferencedId(uint32 id) const
{ {
AchievementListByReferencedId::const_iterator itr = m_AchievementListByReferencedId.find(id); AchievementListByReferencedId::const_iterator itr = _achievementListByReferencedId.find(id);
return itr != m_AchievementListByReferencedId.end() ? &itr->second : nullptr; return itr != _achievementListByReferencedId.end() ? &itr->second : nullptr;
} }
AchievementReward const* GetAchievementReward(AchievementEntry const* achievement) const AchievementReward const* GetAchievementReward(AchievementEntry const* achievement) const
{ {
AchievementRewards::const_iterator iter = m_achievementRewards.find(achievement->ID); AchievementRewards::const_iterator iter = _achievementRewards.find(achievement->ID);
return iter != m_achievementRewards.end() ? &iter->second : nullptr; return iter != _achievementRewards.end() ? &iter->second : nullptr;
} }
AchievementRewardLocale const* GetAchievementRewardLocale(AchievementEntry const* achievement) const AchievementRewardLocale const* GetAchievementRewardLocale(AchievementEntry const* achievement) const
{ {
AchievementRewardLocales::const_iterator iter = m_achievementRewardLocales.find(achievement->ID); AchievementRewardLocales::const_iterator iter = _achievementRewardLocales.find(achievement->ID);
return iter != m_achievementRewardLocales.end() ? &iter->second : nullptr; return iter != _achievementRewardLocales.end() ? &iter->second : nullptr;
} }
AchievementCriteriaDataSet const* GetCriteriaDataSet(AchievementCriteriaEntry const* achievementCriteria) const AchievementCriteriaDataSet const* GetCriteriaDataSet(AchievementCriteriaEntry const* achievementCriteria) const
{ {
AchievementCriteriaDataMap::const_iterator iter = m_criteriaDataMap.find(achievementCriteria->ID); AchievementCriteriaDataMap::const_iterator iter = _criteriaDataMap.find(achievementCriteria->ID);
return iter != m_criteriaDataMap.end() ? &iter->second : nullptr; return iter != _criteriaDataMap.end() ? &iter->second : nullptr;
} }
bool IsRealmCompleted(AchievementEntry const* achievement) const; bool IsRealmCompleted(AchievementEntry const* achievement) const;
@@ -396,25 +396,25 @@ public:
[[nodiscard]] AchievementEntry const* GetAchievement(uint32 achievementId) const; [[nodiscard]] AchievementEntry const* GetAchievement(uint32 achievementId) const;
private: private:
AchievementCriteriaDataMap m_criteriaDataMap; AchievementCriteriaDataMap _criteriaDataMap;
// store achievement criterias by type to speed up lookup // store achievement criterias by type to speed up lookup
AchievementCriteriaEntryList m_AchievementCriteriasByType[ACHIEVEMENT_CRITERIA_TYPE_TOTAL]; AchievementCriteriaEntryList _achievementCriteriasByType[ACHIEVEMENT_CRITERIA_TYPE_TOTAL];
AchievementCriteriaEntryList m_AchievementCriteriasByTimedType[ACHIEVEMENT_TIMED_TYPE_MAX]; AchievementCriteriaEntryList _achievementCriteriasByTimedType[ACHIEVEMENT_TIMED_TYPE_MAX];
// store achievement criterias by achievement to speed up lookup // store achievement criterias by achievement to speed up lookup
AchievementCriteriaListByAchievement m_AchievementCriteriaListByAchievement; AchievementCriteriaListByAchievement _achievementCriteriaListByAchievement;
// store achievements by referenced achievement id to speed up lookup // store achievements by referenced achievement id to speed up lookup
AchievementListByReferencedId m_AchievementListByReferencedId; AchievementListByReferencedId _achievementListByReferencedId;
typedef std::unordered_map<uint32 /*achievementId*/, SystemTimePoint /*completionTime*/> AllCompletedAchievements; typedef std::unordered_map<uint32 /*achievementId*/, SystemTimePoint /*completionTime*/> AllCompletedAchievements;
AllCompletedAchievements m_allCompletedAchievements; AllCompletedAchievements _allCompletedAchievements;
AchievementRewards m_achievementRewards; AchievementRewards _achievementRewards;
AchievementRewardLocales m_achievementRewardLocales; AchievementRewardLocales _achievementRewardLocales;
// pussywizard: // pussywizard:
std::map<uint32, AchievementCriteriaEntryList> m_SpecialList[ACHIEVEMENT_CRITERIA_TYPE_TOTAL]; std::map<uint32, AchievementCriteriaEntryList> _specialList[ACHIEVEMENT_CRITERIA_TYPE_TOTAL];
std::map<uint32, AchievementCriteriaEntryList> m_AchievementCriteriasByCondition[ACHIEVEMENT_CRITERIA_CONDITION_TOTAL]; std::map<uint32, AchievementCriteriaEntryList> _achievementCriteriasByCondition[ACHIEVEMENT_CRITERIA_CONDITION_TOTAL];
}; };
#define sAchievementMgr AchievementGlobalMgr::instance() #define sAchievementMgr AchievementGlobalMgr::instance()