?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
port over some changes from Trinity version including one possible memory leak fix
[AHbot.git] / src / game / AchievementMgr.cpp
blob8d18a53dcaadee5410963187138a8d8385ed8adc
1 /*
2 * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18
19 #include "AchievementMgr.h"
20 #include "Common.h"
21 #include "Player.h"
22 #include "WorldPacket.h"
23 #include "DBCEnums.h"
24 #include "GameEventMgr.h"
25 #include "ObjectMgr.h"
26 #include "Guild.h"
27 #include "Database/DatabaseEnv.h"
28 #include "World.h"
29 #include "SpellMgr.h"
30 #include "ArenaTeam.h"
31 #include "ProgressBar.h"
32 #include "GridNotifiersImpl.h"
33 #include "CellImpl.h"
34 #include "Language.h"
35
36 #include "Policies/SingletonImp.h"
37
38 INSTANTIATE_SINGLETON_1(AchievementGlobalMgr);
39
40 namespace MaNGOS
41 {
42 class AchievementChatBuilder
43 {
44 public:
45 AchievementChatBuilder(Player const& pl, ChatMsg msgtype, int32 textId, uint32 ach_id)
46 : i_player(pl), i_msgtype(msgtype), i_textId(textId), i_achievementId(ach_id) {}
47 void operator()(WorldPacket& data, int32 loc_idx)
48 {
49 char const* text = objmgr.GetMangosString(i_textId,loc_idx);
50
51 data << uint8(i_msgtype);
52 data << uint32(LANG_UNIVERSAL);
53 data << uint64(i_player.GetGUID());
54 data << uint32(5);
55 data << uint64(i_player.GetGUID());
56 data << uint32(strlen(text)+1);
57 data << text;
58 data << uint8(0);
59 data << uint32(i_achievementId);
60 }
61
62 private:
63 Player const& i_player;
64 ChatMsg i_msgtype;
65 int32 i_textId;
66 uint32 i_achievementId;
67 };
68 } // namespace MaNGOS
69
70
71 bool AchievementCriteriaData::IsValid(AchievementCriteriaEntry const* criteria)
72 {
73 if(dataType >= MAX_ACHIEVEMENT_CRITERIA_DATA_TYPE)
74 {
75 sLog.outErrorDb( "Table `achievement_criteria_data` for criteria (Entry: %u) have wrong data type (%u), ignore.", criteria->ID,dataType);
76 return false;
77 }
78
79 switch(criteria->requiredType)
80 {
81 case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
82 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:
83 case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
84 break;
85 default:
86 sLog.outErrorDb( "Table `achievement_criteria_data` have data for not supported criteria type (Entry: %u Type: %u), ignore.", criteria->ID, criteria->requiredType);
87 return false;
88 }
89
90 switch(dataType)
91 {
92 case ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE:
93 return true;
94 case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_CREATURE:
95 if(!creature.id || !objmgr.GetCreatureTemplate(creature.id))
96 {
97 sLog.outErrorDb( "Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_CREATURE (%u) have not existed creature id in value1 (%u), ignore.",
98 criteria->ID, criteria->requiredType,dataType,creature.id);
99 return false;
100 }
101 return true;
102 case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE:
103 if(!classRace.class_id && !classRace.race_id)
104 {
105 sLog.outErrorDb( "Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_PLAYER_CLASS_RACE (%u) must have not 0 in one from value fields, ignore.",
106 criteria->ID, criteria->requiredType,dataType);
107 return false;
108 }
109 if(classRace.class_id && ((1 << (classRace.class_id-1)) & CLASSMASK_ALL_PLAYABLE)==0)
110 {
111 sLog.outErrorDb( "Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_CREATURE (%u) have not existed class in value1 (%u), ignore.",
112 criteria->ID, criteria->requiredType,dataType,classRace.class_id);
113 return false;
114 }
115 if(classRace.race_id && ((1 << (classRace.race_id-1)) & RACEMASK_ALL_PLAYABLE)==0)
116 {
117 sLog.outErrorDb( "Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_CREATURE (%u) have not existed race in value2 (%u), ignore.",
118 criteria->ID, criteria->requiredType,dataType,classRace.race_id);
119 return false;
120 }
121 return true;
122 case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_LESS_HEALTH:
123 if(health.percent < 1 || health.percent > 100)
124 {
125 sLog.outErrorDb( "Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_PLAYER_LESS_HEALTH (%u) have wrong percent value in value1 (%u), ignore.",
126 criteria->ID, criteria->requiredType,dataType,health.percent);
127 return false;
128 }
129 return true;
130 case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD:
131 return true;
132 case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA:
133 case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA:
134 {
135 SpellEntry const* spellEntry = sSpellStore.LookupEntry(aura.spell_id);
136 if(!spellEntry)
137 {
138 sLog.outErrorDb( "Table `achievement_criteria_data` (Entry: %u Type: %u) for data type %s (%u) have wrong spell id in value1 (%u), ignore.",
139 criteria->ID, criteria->requiredType,(dataType==ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA?"ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA":"ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA"),dataType,aura.spell_id);
140 return false;
141 }
142 if(aura.effect_idx >= 3)
143 {
144 sLog.outErrorDb( "Table `achievement_criteria_data` (Entry: %u Type: %u) for data type %s (%u) have wrong spell effect index in value2 (%u), ignore.",
145 criteria->ID, criteria->requiredType,(dataType==ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA?"ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA":"ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA"),dataType,aura.effect_idx);
146 return false;
147 }
148 if(!spellEntry->EffectApplyAuraName[aura.effect_idx])
149 {
150 sLog.outErrorDb( "Table `achievement_criteria_data` (Entry: %u Type: %u) for data type %s (%u) have non-aura spell effect (ID: %u Effect: %u), ignore.",
151 criteria->ID, criteria->requiredType,(dataType==ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA?"ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA":"ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA"),dataType,aura.spell_id,aura.effect_idx);
152 return false;
153 }
154 return true;
155 }
156 case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA:
157 if(!GetAreaEntryByAreaID(area.id))
158 {
159 sLog.outErrorDb( "Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA (%u) have wrong area id in value1 (%u), ignore.",
160 criteria->ID, criteria->requiredType,dataType,area.id);
161 return false;
162 }
163 return true;
164 default:
165 sLog.outErrorDb( "Table `achievement_criteria_data` (Entry: %u Type: %u) have data for not supported data type (%u), ignore.", criteria->ID, criteria->requiredType,dataType);
166 return false;
167 }
168 return false;
169 }
170
171 bool AchievementCriteriaData::Meets(Player const* source, Unit const* target) const
172 {
173 switch(dataType)
174 {
175 case ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE:
176 return true;
177 case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_CREATURE:
178 if (!target || target->GetTypeId()!=TYPEID_UNIT)
179 return false;
180 if (target->GetEntry() != creature.id)
181 return false;
182 return true;
183 case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE:
184 if (!target || target->GetTypeId()!=TYPEID_PLAYER)
185 return false;
186 if(classRace.class_id && classRace.class_id != ((Player*)target)->getClass())
187 return false;
188 if(classRace.race_id && classRace.race_id != ((Player*)target)->getRace())
189 return false;
190 return true;
191 case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_LESS_HEALTH:
192 if (!target || target->GetTypeId()!=TYPEID_PLAYER)
193 return false;
194 return target->GetHealth()*100 <= health.percent*target->GetMaxHealth();
195 case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD:
196 return target && target->GetTypeId() == TYPEID_PLAYER && !target->isAlive() && ((Player*)target)->GetDeathTimer() != 0;
197 case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA:
198 return source->HasAura(aura.spell_id,aura.effect_idx);
199 case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA:
200 {
201 uint32 zone_id,area_id;
202 source->GetZoneAndAreaId(zone_id,area_id);
203 return area.id==zone_id || area.id==area_id;
204 }
205 case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA:
206 return target && target->HasAura(aura.spell_id,aura.effect_idx);
207 }
208
209 return false;
210 }
211
212 bool AchievementCriteriaDataSet::Meets(Player const* source, Unit const* target) const
213 {
214 for(Storage::const_iterator itr = storage.begin(); itr != storage.end(); ++itr)
215 if(!itr->Meets(source,target))
216 return false;
217
218 return true;
219 }
220
221 AchievementMgr::AchievementMgr(Player *player)
222 {
223 m_player = player;
224 }
225
226 AchievementMgr::~AchievementMgr()
227 {
228 }
229
230 void AchievementMgr::Reset()
231 {
232 for(CompletedAchievementMap::const_iterator iter = m_completedAchievements.begin(); iter!=m_completedAchievements.end(); ++iter)
233 {
234 WorldPacket data(SMSG_ACHIEVEMENT_DELETED,4);
235 data << uint32(iter->first);
236 m_player->SendDirectMessage(&data);
237 }
238
239 for(CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
240 {
241 WorldPacket data(SMSG_CRITERIA_DELETED,4);
242 data << uint32(iter->first);
243 m_player->SendDirectMessage(&data);
244 }
245
246 m_completedAchievements.clear();
247 m_criteriaProgress.clear();
248 DeleteFromDB(m_player->GetGUIDLow());
249
250 // re-fill data
251 CheckAllAchievementCriteria();
252 }
253
254 void AchievementMgr::ResetAchievementCriteria(AchievementCriteriaTypes type, uint32 miscvalue1, uint32 miscvalue2)
255 {
256 if((sLog.getLogFilter() & LOG_FILTER_ACHIEVEMENT_UPDATES)==0)
257 sLog.outDetail("AchievementMgr::ResetAchievementCriteria(%u, %u, %u)", type, miscvalue1, miscvalue2);
258
259 if (!sWorld.getConfig(CONFIG_GM_ALLOW_ACHIEVEMENT_GAINS) && m_player->GetSession()->GetSecurity() > SEC_PLAYER)
260 return;
261
262 AchievementCriteriaEntryList const& achievementCriteriaList = achievementmgr.GetAchievementCriteriaByType(type);
263 for(AchievementCriteriaEntryList::const_iterator i = achievementCriteriaList.begin(); i!=achievementCriteriaList.end(); ++i)
264 {
265 AchievementCriteriaEntry const *achievementCriteria = (*i);
266
267 AchievementEntry const *achievement = sAchievementStore.LookupEntry(achievementCriteria->referredAchievement);
268 if (!achievement)
269 continue;
270
271 // don't update already completed criteria
272 if (IsCompletedCriteria(achievementCriteria,achievement))
273 continue;
274
275 switch (type)
276 {
277 case ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE: // have total statistic also not expected to be reset
278 case ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE: // have total statistic also not expected to be reset
279 if (achievementCriteria->healing_done.flag == miscvalue1 &&
280 achievementCriteria->healing_done.mapid == miscvalue2)
281 SetCriteriaProgress(achievementCriteria, 0, PROGRESS_SET);
282 break;
283 default: // reset all cases
284 break;
285 }
286 }
287 }
288
289 void AchievementMgr::DeleteFromDB(uint32 lowguid)
290 {
291 CharacterDatabase.BeginTransaction ();
292 CharacterDatabase.PExecute("DELETE FROM character_achievement WHERE guid = %u",lowguid);
293 CharacterDatabase.PExecute("DELETE FROM character_achievement_progress WHERE guid = %u",lowguid);
294 CharacterDatabase.CommitTransaction ();
295 }
296
297 void AchievementMgr::SaveToDB()
298 {
299 if(!m_completedAchievements.empty())
300 {
301 bool need_execute = false;
302 std::ostringstream ssdel;
303 std::ostringstream ssins;
304 for(CompletedAchievementMap::iterator iter = m_completedAchievements.begin(); iter!=m_completedAchievements.end(); ++iter)
305 {
306 if(!iter->second.changed)
307 continue;
308
309 /// first new/changed record prefix
310 if(!need_execute)
311 {
312 ssdel << "DELETE FROM character_achievement WHERE guid = " << GetPlayer()->GetGUIDLow() << " AND achievement IN (";
313 ssins << "INSERT INTO character_achievement (guid, achievement, date) VALUES ";
314 need_execute = true;
315 }
316 /// next new/changed record prefix
317 else
318 {
319 ssdel << ", ";
320 ssins << ", ";
321 }
322
323 // new/changed record data
324 ssdel << iter->first;
325 ssins << "("<<GetPlayer()->GetGUIDLow() << ", " << iter->first << ", " << uint64(iter->second.date) << ")";
326
327 /// mark as saved in db
328 iter->second.changed = false;
329 }
330
331 if(need_execute)
332 ssdel << ")";
333
334 if(need_execute)
335 {
336 CharacterDatabase.Execute( ssdel.str().c_str() );
337 CharacterDatabase.Execute( ssins.str().c_str() );
338 }
339 }
340
341 if(!m_criteriaProgress.empty())
342 {
343 /// prepare deleting and insert
344 bool need_execute_del = false;
345 bool need_execute_ins = false;
346 std::ostringstream ssdel;
347 std::ostringstream ssins;
348 for(CriteriaProgressMap::iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
349 {
350 if(!iter->second.changed)
351 continue;
352
353 // deleted data (including 0 progress state)
354 {
355 /// first new/changed record prefix (for any counter value)
356 if(!need_execute_del)
357 {
358 ssdel << "DELETE FROM character_achievement_progress WHERE guid = " << GetPlayer()->GetGUIDLow() << " AND criteria IN (";
359 need_execute_del = true;
360 }
361 /// next new/changed record prefix
362 else
363 ssdel << ", ";
364
365 // new/changed record data
366 ssdel << iter->first;
367 }
368
369 // store data only for real progress
370 if(iter->second.counter != 0)
371 {
372 /// first new/changed record prefix
373 if(!need_execute_ins)
374 {
375 ssins << "INSERT INTO character_achievement_progress (guid, criteria, counter, date) VALUES ";
376 need_execute_ins = true;
377 }
378 /// next new/changed record prefix
379 else
380 ssins << ", ";
381
382 // new/changed record data
383 ssins << "(" << GetPlayer()->GetGUIDLow() << ", " << iter->first << ", " << iter->second.counter << ", " << iter->second.date << ")";
384 }
385
386 /// mark as updated in db
387 iter->second.changed = false;
388 }
389
390 if(need_execute_del) // DELETE ... IN (.... _)_
391 ssdel << ")";
392
393 if(need_execute_del || need_execute_ins)
394 {
395 if(need_execute_del)
396 CharacterDatabase.Execute( ssdel.str().c_str() );
397 if(need_execute_ins)
398 CharacterDatabase.Execute( ssins.str().c_str() );
399 }
400 }
401 }
402
403 void AchievementMgr::LoadFromDB(QueryResult *achievementResult, QueryResult *criteriaResult)
404 {
405 if(achievementResult)
406 {
407 do
408 {
409 Field *fields = achievementResult->Fetch();
410
411 uint32 achievement_id = fields[0].GetUInt32();
412
413 // don't must happen: cleanup at server startup in achievementmgr.LoadCompletedAchievements()
414 if(!sAchievementStore.LookupEntry(achievement_id))
415 continue;
416
417 CompletedAchievementData& ca = m_completedAchievements[achievement_id];
418 ca.date = time_t(fields[1].GetUInt64());
419 ca.changed = false;
420 } while(achievementResult->NextRow());
421 delete achievementResult;
422 }
423
424 if(criteriaResult)
425 {
426 do
427 {
428 Field *fields = criteriaResult->Fetch();
429
430 uint32 id = fields[0].GetUInt32();
431 uint32 counter = fields[1].GetUInt32();
432 time_t date = time_t(fields[2].GetUInt64());
433
434 AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(id);
435 if (!criteria)
436 {
437 // we will remove not existed criteria for all characters
438 sLog.outError("Not existed achievement creataria %u data removed from table `character_achievement_progress`.",id);
439 CharacterDatabase.PExecute("DELETE FROM character_achievement_progress WHERE criteria = %u",id);
440 continue;
441 }
442
443 if (criteria->timeLimit && time_t(date + criteria->timeLimit) < time(NULL))
444 continue;
445
446 CriteriaProgress& progress = m_criteriaProgress[id];
447 progress.counter = counter;
448 progress.date = date;
449 progress.changed = false;
450 } while(criteriaResult->NextRow());
451 delete criteriaResult;
452 }
453
454 }
455
456 void AchievementMgr::SendAchievementEarned(AchievementEntry const* achievement)
457 {
458 if(GetPlayer()->GetSession()->PlayerLoading())
459 return;
460
461 #ifdef MANGOS_DEBUG
462 if((sLog.getLogFilter() & LOG_FILTER_ACHIEVEMENT_UPDATES)==0)
463 sLog.outDebug("AchievementMgr::SendAchievementEarned(%u)", achievement->ID);
464 #endif
465
466 if(Guild* guild = objmgr.GetGuildById(GetPlayer()->GetGuildId()))
467 {
468 MaNGOS::AchievementChatBuilder say_builder(*GetPlayer(), CHAT_MSG_GUILD_ACHIEVEMENT, LANG_ACHIEVEMENT_EARNED,achievement->ID);
469 MaNGOS::LocalizedPacketDo<MaNGOS::AchievementChatBuilder> say_do(say_builder);
470 guild->BroadcastWorker(say_do,GetPlayer());
471 }
472
473 if(achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_KILL|ACHIEVEMENT_FLAG_REALM_FIRST_REACH))
474 {
475 // broadcast realm first reached
476 WorldPacket data(SMSG_SERVER_FIRST_ACHIEVEMENT, strlen(GetPlayer()->GetName())+1+8+4+4);
477 data << GetPlayer()->GetName();
478 data << uint64(GetPlayer()->GetGUID());
479 data << uint32(achievement->ID);
480 data << uint32(0); // 1=link supplied string as player name, 0=display plain string
481 sWorld.SendGlobalMessage(&data);
482 }
483 else
484 {
485 CellPair p = MaNGOS::ComputeCellPair(GetPlayer()->GetPositionX(), GetPlayer()->GetPositionY());
486
487 Cell cell(p);
488 cell.data.Part.reserved = ALL_DISTRICT;
489 cell.SetNoCreate();
490
491 MaNGOS::AchievementChatBuilder say_builder(*GetPlayer(), CHAT_MSG_ACHIEVEMENT, LANG_ACHIEVEMENT_EARNED,achievement->ID);
492 MaNGOS::LocalizedPacketDo<MaNGOS::AchievementChatBuilder> say_do(say_builder);
493 MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::AchievementChatBuilder> > say_worker(GetPlayer(),sWorld.getConfig(CONFIG_LISTEN_RANGE_SAY),say_do);
494 TypeContainerVisitor<MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::AchievementChatBuilder> >, WorldTypeMapContainer > message(say_worker);
495 CellLock<GridReadGuard> cell_lock(cell, p);
496 cell_lock->Visit(cell_lock, message, *GetPlayer()->GetMap());
497 }
498
499 WorldPacket data(SMSG_ACHIEVEMENT_EARNED, 8+4+8);
500 data.append(GetPlayer()->GetPackGUID());
501 data << uint32(achievement->ID);
502 data << uint32(secsToTimeBitFields(time(NULL)));
503 data << uint32(0);
504 GetPlayer()->SendMessageToSetInRange(&data, sWorld.getConfig(CONFIG_LISTEN_RANGE_SAY), true);
505 }
506
507 void AchievementMgr::SendCriteriaUpdate(uint32 id, CriteriaProgress const* progress)
508 {
509 WorldPacket data(SMSG_CRITERIA_UPDATE, 8+4+8);
510 data << uint32(id);
511
512 // the counter is packed like a packed Guid
513 data.appendPackGUID(progress->counter);
514
515 data.append(GetPlayer()->GetPackGUID());
516 data << uint32(0);
517 data << uint32(secsToTimeBitFields(progress->date));
518 data << uint32(0); // timer 1
519 data << uint32(0); // timer 2
520 GetPlayer()->SendDirectMessage(&data);
521 }
522
523 /**
524 * called at player login. The player might have fulfilled some achievements when the achievement system wasn't working yet
525 */
526 void AchievementMgr::CheckAllAchievementCriteria()
527 {
528 // suppress sending packets
529 for(uint32 i=0; i<ACHIEVEMENT_CRITERIA_TYPE_TOTAL; ++i)
530 UpdateAchievementCriteria(AchievementCriteriaTypes(i));
531 }
532
533 static const uint32 achievIdByArenaSlot[MAX_ARENA_SLOT] = { 1057, 1107, 1108 };
534 static const uint32 achievIdForDangeon[][4] =
535 {
536 // ach_cr_id,is_dungeon,is_raid,is_heroic_dungeon
537 { 321, true, true, true },
538 { 916, false, true, false },
539 { 917, false, true, false },
540 { 918, true, false, false },
541 { 2219, false, false, true },
542 { 0, false, false, false }
543 };
544
545 /**
546 * this function will be called whenever the user might have done a criteria relevant action
547 */
548 void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, uint32 miscvalue1, uint32 miscvalue2, Unit *unit, uint32 time)
549 {
550 if((sLog.getLogFilter() & LOG_FILTER_ACHIEVEMENT_UPDATES)==0)
551 sLog.outDetail("AchievementMgr::UpdateAchievementCriteria(%u, %u, %u, %u)", type, miscvalue1, miscvalue2, time);
552
553 if (!sWorld.getConfig(CONFIG_GM_ALLOW_ACHIEVEMENT_GAINS) && m_player->GetSession()->GetSecurity() > SEC_PLAYER)
554 return;
555
556 AchievementCriteriaEntryList const& achievementCriteriaList = achievementmgr.GetAchievementCriteriaByType(type);
557 for(AchievementCriteriaEntryList::const_iterator i = achievementCriteriaList.begin(); i!=achievementCriteriaList.end(); ++i)
558 {
559 AchievementCriteriaEntry const *achievementCriteria = (*i);
560
561 if (achievementCriteria->groupFlag & ACHIEVEMENT_CRITERIA_GROUP_NOT_IN_GROUP && GetPlayer()->GetGroup())
562 continue;
563
564 AchievementEntry const *achievement = sAchievementStore.LookupEntry(achievementCriteria->referredAchievement);
565 if (!achievement)
566 continue;
567
568 if ((achievement->factionFlag == ACHIEVEMENT_FACTION_FLAG_HORDE && GetPlayer()->GetTeam() != HORDE) ||
569 (achievement->factionFlag == ACHIEVEMENT_FACTION_FLAG_ALLIANCE && GetPlayer()->GetTeam() != ALLIANCE))
570 continue;
571
572 // don't update already completed criteria
573 if (IsCompletedCriteria(achievementCriteria,achievement))
574 continue;
575
576 switch (type)
577 {
578 // std. case: increment at 1
579 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST:
580 case ACHIEVEMENT_CRITERIA_TYPE_NUMBER_OF_TALENT_RESETS:
581 case ACHIEVEMENT_CRITERIA_TYPE_WIN_DUEL:
582 case ACHIEVEMENT_CRITERIA_TYPE_LOSE_DUEL:
583 case ACHIEVEMENT_CRITERIA_TYPE_QUEST_ABANDONED:
584 case ACHIEVEMENT_CRITERIA_TYPE_FLIGHT_PATHS_TAKEN:
585 case ACHIEVEMENT_CRITERIA_TYPE_ACCEPTED_SUMMONINGS:
586 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
587 if(!miscvalue1)
588 continue;
589 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
590 break;
591 // std case: increment at miscvalue1
592 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_TALENTS:
593 case ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_QUEST_REWARD:
594 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_TRAVELLING:
595 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_AT_BARBER:
596 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_MAIL:
597 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_MONEY:
598 case ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED:
599 case ACHIEVEMENT_CRITERIA_TYPE_TOTAL_HEALING_RECEIVED:
600 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
601 if(!miscvalue1)
602 continue;
603 SetCriteriaProgress(achievementCriteria, miscvalue1, PROGRESS_ACCUMULATE);
604 break;
605 // std case: high value at miscvalue1
606 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID:
607 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_SOLD: /* FIXME: for online player only currently */
608 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_DEALT:
609 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_RECEIVED:
610 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEAL_CASTED:
611 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALING_RECEIVED:
612 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
613 if(!miscvalue1)
614 continue;
615 SetCriteriaProgress(achievementCriteria, miscvalue1, PROGRESS_HIGHEST);
616 break;
617
618 // specialized cases
619
620 case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
621 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
622 if(!miscvalue1)
623 continue;
624 if(achievementCriteria->kill_creature.creatureID != miscvalue1)
625 continue;
626
627 // LOT achievement->ID required special custom checks
628 switch(achievement->ID)
629 {
630 // Just heroic
631 case 489: case 490: case 491: case 492: case 493: case 494: case 495:
632 case 496: case 497: case 498: case 499: case 500: case 563: case 565:
633 case 567: case 569: case 573: case 575: case 577: case 623: case 625:
634 case 667: case 668: case 669: case 670: case 671: case 672: case 673:
635 case 674: case 675: case 676: case 677: case 678: case 679: case 680:
636 case 681: case 682: case 1367: case 1368: case 1378: case 1379:
637 case 1380: case 1381: case 1382: case 1383: case 1384: case 1385:
638 case 1386: case 1387: case 1388: case 1389: case 1390: case 1393:
639 case 1394: case 1400: case 1402: case 1504: case 1505: case 1506:
640 case 1507: case 1508: case 1509: case 1510: case 1511: case 1512:
641 case 1513: case 1514: case 1515: case 1721: case 1754: case 1756:
642 case 1768: case 1817: case 1865:
643 if(GetPlayer()->GetDifficulty()!=DIFFICULTY_HEROIC)
644 continue;
645 break;
646 // Heroic + other
647 case 579: case 1296: case 1297: case 1816: case 1834: case 1857: case 1859:
648 case 1860: case 1861: case 1862: case 1864: case 1866: case 1867: case 1868:
649 case 1870: case 1871: case 1872: case 1873: case 1875: case 1877: case 1919:
650 case 2036: case 2037: case 2038: case 2039: case 2040: case 2041: case 2042:
651 case 2043: case 2044: case 2045: case 2046: case 2048: case 2052: case 2053:
652 case 2054: case 2056: case 2057: case 2058: case 2139: case 2140: case 2147:
653 case 2149: case 2150: case 2151: case 2152: case 2154: case 2155: case 2156:
654 case 2157: case 2179: case 2181: case 2183: case 2185: case 2186:
655 if(GetPlayer()->GetDifficulty()!=DIFFICULTY_HEROIC)
656 continue;
657 // FIX ME: mark as fail always until implement
658 continue;
659 // Normal + other
660 case 578: case 624: case 1790: case 1856: case 1858: case 1869: case 1874:
661 case 1996: case 1997: case 2047: case 2049: case 2050: case 2051: case 2146:
662 case 2148: case 2153: case 2178: case 2180: case 2182: case 2184: case 2187:
663 if(GetPlayer()->GetDifficulty()!=DIFFICULTY_NORMAL)
664 continue;
665 // FIX ME: mark as fail always until implement
666 continue;
667 // Just Normal
668 default:
669 if(GetPlayer()->GetDifficulty()!=DIFFICULTY_NORMAL)
670 continue;
671 break;
672 };
673
674 SetCriteriaProgress(achievementCriteria, miscvalue2, PROGRESS_ACCUMULATE);
675 break;
676 case ACHIEVEMENT_CRITERIA_TYPE_REACH_LEVEL:
677 SetCriteriaProgress(achievementCriteria, GetPlayer()->getLevel());
678 break;
679 case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL:
680 // update at loading or specific skill update
681 if(miscvalue1 && miscvalue1 != achievementCriteria->reach_skill_level.skillID)
682 continue;
683 if(uint32 skillvalue = GetPlayer()->GetBaseSkillValue(achievementCriteria->reach_skill_level.skillID))
684 SetCriteriaProgress(achievementCriteria, skillvalue);
685 break;
686 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL:
687 // update at loading or specific skill update
688 if(miscvalue1 && miscvalue1 != achievementCriteria->learn_skill_level.skillID)
689 continue;
690 if(uint32 maxSkillvalue = GetPlayer()->GetPureMaxSkillValue(achievementCriteria->learn_skill_level.skillID))
691 SetCriteriaProgress(achievementCriteria, maxSkillvalue);
692 break;
693 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT:
694 if(m_completedAchievements.find(achievementCriteria->complete_achievement.linkedAchievement) != m_completedAchievements.end())
695 SetCriteriaProgress(achievementCriteria, 1);
696 break;
697 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST_COUNT:
698 {
699 uint32 counter =0;
700 for(QuestStatusMap::const_iterator itr = GetPlayer()->getQuestStatusMap().begin(); itr!=GetPlayer()->getQuestStatusMap().end(); itr++)
701 if(itr->second.m_rewarded)
702 counter++;
703 SetCriteriaProgress(achievementCriteria, counter);
704 break;
705 }
706 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
707 {
708 // speedup for non-login case
709 if(miscvalue1 && miscvalue1 != achievementCriteria->complete_quests_in_zone.zoneID)
710 continue;
711
712 uint32 counter =0;
713 for(QuestStatusMap::const_iterator itr = GetPlayer()->getQuestStatusMap().begin(); itr!=GetPlayer()->getQuestStatusMap().end(); itr++)
714 {
715 Quest const* quest = objmgr.GetQuestTemplate(itr->first);
716 if(itr->second.m_rewarded && quest->GetZoneOrSort() >= 0 && uint32(quest->GetZoneOrSort()) == achievementCriteria->complete_quests_in_zone.zoneID)
717 counter++;
718 }
719 SetCriteriaProgress(achievementCriteria, counter);
720 break;
721 }
722 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND:
723 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
724 if(!miscvalue1)
725 continue;
726 if(GetPlayer()->GetMapId() != achievementCriteria->complete_battleground.mapID)
727 continue;
728 SetCriteriaProgress(achievementCriteria, miscvalue1, PROGRESS_ACCUMULATE);
729 break;
730 case ACHIEVEMENT_CRITERIA_TYPE_DEATH_AT_MAP:
731 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
732 if(!miscvalue1)
733 continue;
734 if(GetPlayer()->GetMapId() != achievementCriteria->death_at_map.mapID)
735 continue;
736 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
737 break;
738 case ACHIEVEMENT_CRITERIA_TYPE_DEATH:
739 {
740 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
741 if(!miscvalue1)
742 continue;
743 // skip wrong arena achievements, if not achievIdByArenaSlot then normal total death counter
744 bool notfit = false;
745 for(int j = 0; j < MAX_ARENA_SLOT; ++j)
746 {
747 if(achievIdByArenaSlot[j] == achievement->ID)
748 {
749 BattleGround* bg = GetPlayer()->GetBattleGround();
750 if(!bg || !bg->isArena() || ArenaTeam::GetSlotByType(bg->GetArenaType()) != j)
751 notfit = true;
752
753 break;
754 }
755 }
756 if(notfit)
757 continue;
758
759 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
760 break;
761 }
762 case ACHIEVEMENT_CRITERIA_TYPE_DEATH_IN_DUNGEON:
763 {
764 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
765 if(!miscvalue1)
766 continue;
767
768 Map const* map = GetPlayer()->GetMap();
769 if(!map->IsDungeon())
770 continue;
771
772 // search case
773 bool found = false;
774 for(int j = 0; achievIdForDangeon[j][0]; ++j)
775 {
776 if(achievIdForDangeon[j][0] == achievement->ID)
777 {
778 if(map->IsRaid())
779 {
780 // if raid accepted (ignore difficulty)
781 if(!achievIdForDangeon[j][2])
782 break; // for
783 }
784 else if(GetPlayer()->GetDifficulty()==DIFFICULTY_NORMAL)
785 {
786 // dungeon in normal mode accepted
787 if(!achievIdForDangeon[j][1])
788 break; // for
789 }
790 else
791 {
792 // dungeon in heroic mode accepted
793 if(!achievIdForDangeon[j][3])
794 break; // for
795 }
796
797 found = true;
798 break; // for
799 }
800 }
801 if(!found)
802 continue;
803
804 //FIXME: work only for instances where max==min for players
805 if(((InstanceMap*)map)->GetMaxPlayers() != achievementCriteria->death_in_dungeon.manLimit)
806 continue;
807 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
808 break;
809
810 }
811 case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE:
812 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
813 if(!miscvalue1)
814 continue;
815 if(miscvalue1 != achievementCriteria->killed_by_creature.creatureEntry)
816 continue;
817 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
818 break;
819 case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_PLAYER:
820 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
821 if(!miscvalue1)
822 continue;
823
824 // if team check required: must kill by opposition faction
825 if(achievement->ID==318 && miscvalue2==GetPlayer()->GetTeam())
826 continue;
827
828 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
829 break;
830 case ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING:
831 {
832 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
833 if(!miscvalue1)
834 continue;
835 if(achievement->ID == 1260)
836 {
837 if(Player::GetDrunkenstateByValue(GetPlayer()->GetDrunkValue()) != DRUNKEN_SMASHED)
838 continue;
839 if(!IsHolidayActive(HOLIDAY_BREWFEST))
840 continue;
841 }
842 // miscvalue1 is the ingame fallheight*100 as stored in dbc
843 SetCriteriaProgress(achievementCriteria, miscvalue1);
844 break;
845 }
846 case ACHIEVEMENT_CRITERIA_TYPE_DEATHS_FROM:
847 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
848 if(!miscvalue1)
849 continue;
850 if(miscvalue2 != achievementCriteria->death_from.type)
851 continue;
852 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
853 break;
854 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
855 // if miscvalues != 0, it contains the questID.
856 if (miscvalue1)
857 {
858 if (miscvalue1 == achievementCriteria->complete_quest.questID)
859 SetCriteriaProgress(achievementCriteria, 1);
860 }
861 else
862 {
863 // login case.
864 if(GetPlayer()->GetQuestRewardStatus(achievementCriteria->complete_quest.questID))
865 SetCriteriaProgress(achievementCriteria, 1);
866 }
867 break;
868 case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
869 case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
870 if (!miscvalue1 || miscvalue1 != achievementCriteria->be_spell_target.spellID)
871 continue;
872 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
873 break;
874 case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
875 if (!miscvalue1 || miscvalue1 != achievementCriteria->cast_spell.spellID)
876 continue;
877 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
878 break;
879 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL:
880 if(miscvalue1 && miscvalue1!=achievementCriteria->learn_spell.spellID)
881 continue;
882
883 if(GetPlayer()->HasSpell(achievementCriteria->learn_spell.spellID))
884 SetCriteriaProgress(achievementCriteria, 1);
885 break;
886 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:
887 {
888 // miscvalue1=loot_type (note: 0 = LOOT_CORSPE and then it ignored)
889 // miscvalue2=count of item loot
890 if (!miscvalue1 || !miscvalue2)
891 continue;
892 if (miscvalue1 != achievementCriteria->loot_type.lootType)
893 continue;
894
895 // zone specific
896 if(achievementCriteria->loot_type.lootTypeCount==1)
897 {
898 // those requirements couldn't be found in the dbc
899 AchievementCriteriaDataSet const* data = achievementmgr.GetCriteriaDataSet(achievementCriteria);
900 if(!data)
901 continue;
902
903 if(!data->Meets(GetPlayer(),unit))
904 continue;
905 }
906
907 SetCriteriaProgress(achievementCriteria, miscvalue2, PROGRESS_ACCUMULATE);
908 break;
909 }
910 case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM:
911 // speedup for non-login case
912 if(miscvalue1 && achievementCriteria->own_item.itemID != miscvalue1)
913 continue;
914 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetItemCount(achievementCriteria->own_item.itemID, true));
915 break;
916 case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:
917 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
918 if(!miscvalue1)
919 continue;
920 if(achievementCriteria->use_item.itemID != miscvalue1)
921 continue;
922 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
923 break;
924 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM:
925 // You _have_ to loot that item, just owning it when logging in does _not_ count!
926 if(!miscvalue1)
927 continue;
928 if(miscvalue1 != achievementCriteria->own_item.itemID)
929 continue;
930 SetCriteriaProgress(achievementCriteria, miscvalue2, PROGRESS_ACCUMULATE);
931 break;
932 case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA:
933 {
934 WorldMapOverlayEntry const* worldOverlayEntry = sWorldMapOverlayStore.LookupEntry(achievementCriteria->explore_area.areaReference);
935 if(!worldOverlayEntry)
936 break;
937
938 bool matchFound = false;
939 for (int j = 0; j < MAX_WORLD_MAP_OVERLAY_AREA_IDX; ++j)
940 {
941 uint32 area_id = worldOverlayEntry->areatableID[j];
942 if(!area_id) // array have 0 only in empty tail
943 break;
944
945 int32 exploreFlag = GetAreaFlagByAreaID(area_id);
946 if(exploreFlag < 0)
947 continue;
948
949 uint32 playerIndexOffset = uint32(exploreFlag) / 32;
950 uint32 mask = 1<< (uint32(exploreFlag) % 32);
951
952 if(GetPlayer()->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + playerIndexOffset) & mask)
953 {
954 matchFound = true;
955 break;
956 }
957 }
958
959 if(matchFound)
960 SetCriteriaProgress(achievementCriteria, 1);
961 break;
962 }
963 case ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT:
964 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetByteValue(PLAYER_BYTES_2, 2)+1);
965 break;
966 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
967 {
968 // skip faction check only at loading
969 if (miscvalue1 && miscvalue1 != achievementCriteria->gain_reputation.factionID)
970 continue;
971
972 int32 reputation = GetPlayer()->GetReputationMgr().GetReputation(achievementCriteria->gain_reputation.factionID);
973 if (reputation > 0)
974 SetCriteriaProgress(achievementCriteria, reputation);
975 break;
976 }
977 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION:
978 {
979 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetReputationMgr().GetExaltedFactionCount());
980 break;
981 }
982 case ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP:
983 {
984 // skip for login case
985 if(!miscvalue1)
986 continue;
987 SetCriteriaProgress(achievementCriteria, 1);
988 break;
989 }
990 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT:
991 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT:
992 {
993 // miscvalue1 = itemid
994 // miscvalue2 = diced value
995 if(!miscvalue1)
996 continue;
997 if(miscvalue2 != achievementCriteria->roll_greed_on_loot.rollValue)
998 continue;
999 ItemPrototype const *pProto = objmgr.GetItemPrototype( miscvalue1 );
1000
1001 uint32 requiredItemLevel = 0;
1002 if (achievementCriteria->ID == 2412 || achievementCriteria->ID == 2358)
1003 requiredItemLevel = 185;
1004
1005 if(!pProto || pProto->ItemLevel <requiredItemLevel)
1006 continue;
1007 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
1008 break;
1009 }
1010 case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
1011 {
1012 // miscvalue1 = emote
1013 if(!miscvalue1)
1014 continue;
1015 if(miscvalue1 != achievementCriteria->do_emote.emoteID)
1016 continue;
1017 if(achievementCriteria->do_emote.count)
1018 {
1019 // those requirements couldn't be found in the dbc
1020 AchievementCriteriaDataSet const* data = achievementmgr.GetCriteriaDataSet(achievementCriteria);
1021 if(!data)
1022 continue;
1023
1024 if(!data->Meets(GetPlayer(),unit))
1025 continue;
1026 }
1027
1028 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
1029 break;
1030 }
1031 case ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE:
1032 case ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE:
1033 {
1034 if (!miscvalue1)
1035 continue;
1036
1037 if (achievementCriteria->healing_done.flag == ACHIEVEMENT_CRITERIA_CONDITION_MAP)
1038 {
1039 if(GetPlayer()->GetMapId() != achievementCriteria->healing_done.mapid)
1040 continue;
1041
1042 // map specific case (BG in fact) expected player targeted damage/heal
1043 if(!unit || unit->GetTypeId()!=TYPEID_PLAYER)
1044 continue;
1045 }
1046
1047 SetCriteriaProgress(achievementCriteria, miscvalue1, PROGRESS_ACCUMULATE);
1048 break;
1049 }
1050 case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM:
1051 // miscvalue1 = item_id
1052 if(!miscvalue1)
1053 continue;
1054 if(miscvalue1 != achievementCriteria->equip_item.itemID)
1055 continue;
1056
1057 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
1058 break;
1059 case ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT:
1060 // miscvalue1 = go entry
1061 if(!miscvalue1)
1062 continue;
1063 if(miscvalue1 != achievementCriteria->use_gameobject.goEntry)
1064 continue;
1065
1066 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
1067 break;
1068 case ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT:
1069 if (!miscvalue1)
1070 continue;
1071 if (miscvalue1 != achievementCriteria->fish_in_gameobject.goEntry)
1072 continue;
1073
1074 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
1075 break;
1076 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
1077 {
1078 if(miscvalue1 && miscvalue1 != achievementCriteria->learn_skillline_spell.skillLine)
1079 continue;
1080
1081 uint32 spellCount = 0;
1082 for (PlayerSpellMap::const_iterator spellIter = GetPlayer()->GetSpellMap().begin();
1083 spellIter != GetPlayer()->GetSpellMap().end();
1084 ++spellIter)
1085 {
1086 for(SkillLineAbilityMap::const_iterator skillIter = spellmgr.GetBeginSkillLineAbilityMap(spellIter->first);
1087 skillIter != spellmgr.GetEndSkillLineAbilityMap(spellIter->first);
1088 ++skillIter)
1089 {
1090 if(skillIter->second->skillId == achievementCriteria->learn_skillline_spell.skillLine)
1091 spellCount++;
1092 }
1093 }
1094 SetCriteriaProgress(achievementCriteria, spellCount);
1095 break;
1096 }
1097 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REVERED_REPUTATION:
1098 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetReputationMgr().GetReveredFactionCount());
1099 break;
1100 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_HONORED_REPUTATION:
1101 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetReputationMgr().GetHonoredFactionCount());
1102 break;
1103 case ACHIEVEMENT_CRITERIA_TYPE_KNOWN_FACTIONS:
1104 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetReputationMgr().GetVisibleFactionCount());
1105 break;
1106 case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
1107 {
1108 if (!miscvalue1)
1109 continue;
1110
1111 if (!miscvalue1 || miscvalue1 != achievementCriteria->cast_spell.spellID)
1112 continue;
1113
1114 // those requirements couldn't be found in the dbc
1115 AchievementCriteriaDataSet const* data = achievementmgr.GetCriteriaDataSet(achievementCriteria);
1116 if(!data)
1117 continue;
1118
1119 if(!data->Meets(GetPlayer(),unit))
1120 continue;
1121
1122 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
1123 break;
1124 }
1125 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE:
1126 {
1127 if(miscvalue1 && miscvalue1 != achievementCriteria->learn_skill_line.skillLine)
1128 continue;
1129
1130 uint32 spellCount = 0;
1131 for (PlayerSpellMap::const_iterator spellIter = GetPlayer()->GetSpellMap().begin();
1132 spellIter != GetPlayer()->GetSpellMap().end();
1133 ++spellIter)
1134 {
1135 for(SkillLineAbilityMap::const_iterator skillIter = spellmgr.GetBeginSkillLineAbilityMap(spellIter->first);
1136 skillIter != spellmgr.GetEndSkillLineAbilityMap(spellIter->first);
1137 ++skillIter)
1138 {
1139 if(skillIter->second->skillId == achievementCriteria->learn_skill_line.skillLine)
1140 spellCount++;
1141 }
1142 }
1143 SetCriteriaProgress(achievementCriteria, spellCount);
1144 break;
1145 }
1146 case ACHIEVEMENT_CRITERIA_TYPE_EARN_HONORABLE_KILL:
1147 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORBALE_KILLS));
1148 break;
1149 case ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS:
1150 if (!miscvalue1 || miscvalue1 != achievementCriteria->hk_class.classID)
1151 continue;
1152
1153 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
1154 break;
1155 case ACHIEVEMENT_CRITERIA_TYPE_HK_RACE:
1156 if (!miscvalue1 || miscvalue1 != achievementCriteria->hk_race.raceID)
1157 continue;
1158
1159 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
1160 break;
1161 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_GOLD_VALUE_OWNED:
1162 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetMoney(), PROGRESS_HIGHEST);
1163 break;
1164 // std case: not exist in DBC, not triggered in code as result
1165 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALTH:
1166 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_SPELLPOWER:
1167 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_ARMOR:
1168 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_POWER:
1169 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_STAT:
1170 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_RATING:
1171 break;
1172 // FIXME: not triggered in code as result, need to implement
1173 case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG:
1174 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST_DAILY:
1175 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_RAID:
1176 case ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE:
1177 case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL_AT_AREA:
1178 case ACHIEVEMENT_CRITERIA_TYPE_WIN_ARENA:
1179 case ACHIEVEMENT_CRITERIA_TYPE_PLAY_ARENA:
1180 case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL:
1181 case ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA:
1182 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_TEAM_RATING:
1183 case ACHIEVEMENT_CRITERIA_TYPE_REACH_TEAM_RATING:
1184 case ACHIEVEMENT_CRITERIA_TYPE_OWN_RANK:
1185 case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM:
1186 case ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS:
1187 case ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_VENDORS:
1188 case ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL:
1189 case ACHIEVEMENT_CRITERIA_TYPE_EARNED_PVP_TITLE:
1190 case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE_TYPE:
1191 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_EARNED_BY_AUCTIONS:
1192 case ACHIEVEMENT_CRITERIA_TYPE_CREATE_AUCTION:
1193 case ACHIEVEMENT_CRITERIA_TYPE_WON_AUCTIONS:
1194 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_EPIC_ITEM:
1195 case ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM:
1196 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED:
1197 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED:
1198 case ACHIEVEMENT_CRITERIA_TYPE_TOTAL:
1199 break; // Not implemented yet :(
1200 }
1201 if(IsCompletedCriteria(achievementCriteria,achievement))
1202 CompletedCriteriaFor(achievement);
1203
1204 // check again the completeness for SUMM and REQ COUNT achievements,
1205 // as they don't depend on the completed criteria but on the sum of the progress of each individual criteria
1206 if (achievement->flags & ACHIEVEMENT_FLAG_SUMM)
1207 {
1208 if (IsCompletedAchievement(achievement))
1209 CompletedAchievement(achievement);
1210 }
1211
1212 if(AchievementEntryList const* achRefList = achievementmgr.GetAchievementByReferencedId(achievement->ID))
1213 {
1214 for(AchievementEntryList::const_iterator itr = achRefList->begin(); itr != achRefList->end(); ++itr)
1215 if(IsCompletedAchievement(*itr))
1216 CompletedAchievement(*itr);
1217 }
1218 }
1219 }
1220
1221 static const uint32 achievIdByClass[MAX_CLASSES] = { 0, 459, 465 , 462, 458, 464, 461, 467, 460, 463, 0, 466 };
1222 static const uint32 achievIdByRace[MAX_RACES] = { 0, 1408, 1410, 1407, 1409, 1413, 1411, 1404, 1412, 0, 1405, 1406 };
1223
1224 bool AchievementMgr::IsCompletedCriteria(AchievementCriteriaEntry const* achievementCriteria, AchievementEntry const* achievement)
1225 {
1226 // counter can never complete
1227 if(achievement->flags & ACHIEVEMENT_FLAG_COUNTER)
1228 return false;
1229
1230 if(achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_REACH | ACHIEVEMENT_FLAG_REALM_FIRST_KILL))
1231 {
1232 // someone on this realm has already completed that achievement
1233 if(achievementmgr.IsRealmCompleted(achievement))
1234 return false;
1235 }
1236
1237 CriteriaProgressMap::const_iterator itr = m_criteriaProgress.find(achievementCriteria->ID);
1238 if(itr == m_criteriaProgress.end())
1239 return false;
1240
1241 CriteriaProgress const* progress = &itr->second;
1242
1243 switch(achievementCriteria->requiredType)
1244 {
1245 case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
1246 return progress->counter >= achievementCriteria->kill_creature.creatureCount;
1247 case ACHIEVEMENT_CRITERIA_TYPE_REACH_LEVEL:
1248 {
1249 // skip wrong class achievements
1250 for(int i = 1; i < MAX_CLASSES; ++i)
1251 if(achievIdByClass[i] == achievement->ID && i != GetPlayer()->getClass())
1252 return false;
1253
1254 // skip wrong race achievements
1255 for(int i = 1; i < MAX_RACES; ++i)
1256 if(achievIdByRace[i] == achievement->ID && i != GetPlayer()->getRace())
1257 return false;
1258
1259 // appropriate class/race or not class/race specific
1260 return progress->counter >= achievementCriteria->reach_level.level;
1261 }
1262 case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL:
1263 return progress->counter >= achievementCriteria->reach_skill_level.skillLevel;
1264 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT:
1265 return progress->counter >= 1;
1266 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST_COUNT:
1267 return progress->counter >= achievementCriteria->complete_quest_count.totalQuestCount;
1268 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
1269 return progress->counter >= achievementCriteria->complete_quests_in_zone.questCount;
1270 case ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE:
1271 case ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE:
1272 return progress->counter >= achievementCriteria->healing_done.count;
1273 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST:
1274 return progress->counter >= achievementCriteria->complete_daily_quest.questCount;
1275 case ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING:
1276 return progress->counter >= achievementCriteria->fall_without_dying.fallHeight;
1277 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
1278 return progress->counter >= 1;
1279 case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
1280 case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
1281 return progress->counter >= achievementCriteria->be_spell_target.spellCount;
1282 case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
1283 case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
1284 return progress->counter >= achievementCriteria->cast_spell.castCount;
1285 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL:
1286 return progress->counter >= 1;
1287 case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM:
1288 return progress->counter >= achievementCriteria->own_item.itemCount;
1289 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL:
1290 return progress->counter >= (achievementCriteria->learn_skill_level.skillLevel * 75);
1291 case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:
1292 return progress->counter >= achievementCriteria->use_item.itemCount;
1293 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM:
1294 return progress->counter >= achievementCriteria->loot_item.itemCount;
1295 case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA:
1296 return progress->counter >= 1;
1297 case ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT:
1298 return progress->counter >= achievementCriteria->buy_bank_slot.numberOfSlots;
1299 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
1300 return progress->counter >= achievementCriteria->gain_reputation.reputationAmount;
1301 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION:
1302 return progress->counter >= achievementCriteria->gain_exalted_reputation.numberOfExaltedFactions;
1303 case ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP:
1304 return progress->counter >= achievementCriteria->visit_barber.numberOfVisits;
1305 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT:
1306 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT:
1307 return progress->counter >= achievementCriteria->roll_greed_on_loot.count;
1308 case ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS:
1309 return progress->counter >= achievementCriteria->hk_class.count;
1310 case ACHIEVEMENT_CRITERIA_TYPE_HK_RACE:
1311 return progress->counter >= achievementCriteria->hk_race.count;
1312 case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
1313 return progress->counter >= achievementCriteria->do_emote.count;
1314 case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM:
1315 return progress->counter >= achievementCriteria->equip_item.count;
1316 case ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_QUEST_REWARD:
1317 return progress->counter >= achievementCriteria->quest_reward_money.goldInCopper;
1318 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_MONEY:
1319 return progress->counter >= achievementCriteria->loot_money.goldInCopper;
1320 case ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT:
1321 return progress->counter >= achievementCriteria->use_gameobject.useCount;
1322 case ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT:
1323 return progress->counter >= achievementCriteria->fish_in_gameobject.lootCount;
1324 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
1325 return progress->counter >= achievementCriteria->learn_skillline_spell.spellCount;
1326 case ACHIEVEMENT_CRITERIA_TYPE_WIN_DUEL:
1327 return progress->counter >= achievementCriteria->win_duel.duelCount;
1328 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:
1329 return progress->counter >= achievementCriteria->loot_type.lootTypeCount;
1330 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE:
1331 return progress->counter >= achievementCriteria->learn_skill_line.spellCount;
1332 case ACHIEVEMENT_CRITERIA_TYPE_EARN_HONORABLE_KILL:
1333 return progress->counter >= achievementCriteria->honorable_kill.killCount;
1334
1335 // handle all statistic-only criteria here
1336 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND:
1337 case ACHIEVEMENT_CRITERIA_TYPE_DEATH_AT_MAP:
1338 case ACHIEVEMENT_CRITERIA_TYPE_DEATH:
1339 case ACHIEVEMENT_CRITERIA_TYPE_DEATH_IN_DUNGEON:
1340 case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE:
1341 case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_PLAYER:
1342 case ACHIEVEMENT_CRITERIA_TYPE_DEATHS_FROM:
1343 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_TALENTS:
1344 case ACHIEVEMENT_CRITERIA_TYPE_NUMBER_OF_TALENT_RESETS:
1345 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_AT_BARBER:
1346 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_MAIL:
1347 case ACHIEVEMENT_CRITERIA_TYPE_LOSE_DUEL:
1348 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID:
1349 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_SOLD:
1350 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_GOLD_VALUE_OWNED:
1351 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REVERED_REPUTATION:
1352 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_HONORED_REPUTATION:
1353 case ACHIEVEMENT_CRITERIA_TYPE_KNOWN_FACTIONS:
1354 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALTH:
1355 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_SPELLPOWER:
1356 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_ARMOR:
1357 case ACHIEVEMENT_CRITERIA_TYPE_QUEST_ABANDONED:
1358 case ACHIEVEMENT_CRITERIA_TYPE_FLIGHT_PATHS_TAKEN:
1359 case ACHIEVEMENT_CRITERIA_TYPE_ACCEPTED_SUMMONINGS:
1360 return false;
1361 }
1362 return false;
1363 }
1364
1365 void AchievementMgr::CompletedCriteriaFor(AchievementEntry const* achievement)
1366 {
1367 // counter can never complete
1368 if(achievement->flags & ACHIEVEMENT_FLAG_COUNTER)
1369 return;
1370
1371 // already completed and stored
1372 if (m_completedAchievements.find(achievement->ID)!=m_completedAchievements.end())
1373 return;
1374
1375 if (IsCompletedAchievement(achievement))
1376 CompletedAchievement(achievement);
1377 }
1378
1379 bool AchievementMgr::IsCompletedAchievement(AchievementEntry const* entry)
1380 {
1381 // counter can never complete
1382 if(entry->flags & ACHIEVEMENT_FLAG_COUNTER)
1383 return false;
1384
1385 // for achievement with referenced achievement criterias get from referenced and counter from self
1386 uint32 achievmentForTestId = entry->refAchievement ? entry->refAchievement : entry->ID;
1387 uint32 achievmentForTestCount = entry->count;
1388
1389 AchievementCriteriaEntryList const* cList = achievementmgr.GetAchievementCriteriaByAchievement(achievmentForTestId);
1390 if(!cList)
1391 return false;
1392 uint32 count = 0;
1393
1394 // For SUMM achievements, we have to count the progress of each criteria of the achievement.
1395 // Oddly, the target count is NOT countained in the achievement, but in each individual criteria
1396 if (entry->flags & ACHIEVEMENT_FLAG_SUMM)
1397 {
1398 for(AchievementCriteriaEntryList::const_iterator itr = cList->begin(); itr != cList->end(); ++itr)
1399 {
1400 AchievementCriteriaEntry const* criteria = *itr;
1401
1402 CriteriaProgressMap::const_iterator itrProgress = m_criteriaProgress.find(criteria->ID);
1403 if(itrProgress == m_criteriaProgress.end())
1404 continue;
1405
1406 CriteriaProgress const* progress = &itrProgress->second;
1407 count += progress->counter;
1408
1409 // for counters, field4 contains the main count requirement
1410 if (count >= criteria->raw.count)
1411 return true;
1412 }
1413 return false;
1414 }
1415
1416 // Default case - need complete all or
1417 bool completed_all = true;
1418 for(AchievementCriteriaEntryList::const_iterator itr = cList->begin(); itr != cList->end(); ++itr)
1419 {
1420 AchievementCriteriaEntry const* criteria = *itr;
1421
1422 bool completed = IsCompletedCriteria(criteria,entry);
1423
1424 // found an uncompleted criteria, but DONT return false yet - there might be a completed criteria with ACHIEVEMENT_CRITERIA_COMPLETE_FLAG_ALL
1425 if(completed)
1426 ++count;
1427 else
1428 completed_all = false;
1429
1430 // completed as have req. count of completed criterias
1431 if(achievmentForTestCount > 0 && achievmentForTestCount <= count)
1432 return true;
1433 }
1434
1435 // all criterias completed requirement
1436 if(completed_all && achievmentForTestCount==0)
1437 return true;
1438
1439 return false;
1440 }
1441
1442 void AchievementMgr::SetCriteriaProgress(AchievementCriteriaEntry const* entry, uint32 changeValue, ProgressType ptype)
1443 {
1444 if((sLog.getLogFilter() & LOG_FILTER_ACHIEVEMENT_UPDATES)==0)
1445 sLog.outDetail("AchievementMgr::SetCriteriaProgress(%u, %u) for (GUID:%u)", entry->ID, changeValue, m_player->GetGUIDLow());
1446
1447 CriteriaProgress *progress = NULL;
1448
1449 CriteriaProgressMap::iterator iter = m_criteriaProgress.find(entry->ID);
1450
1451 if(iter == m_criteriaProgress.end())
1452 {
1453 // not create record for 0 counter
1454 if(changeValue == 0)
1455 return;
1456
1457 progress = &m_criteriaProgress[entry->ID];
1458 progress->counter = changeValue;
1459 progress->date = time(NULL);
1460 }
1461 else
1462 {
1463 progress = &iter->second;
1464
1465 uint32 newValue = 0;
1466 switch(ptype)
1467 {
1468 case PROGRESS_SET:
1469 newValue = changeValue;
1470 break;
1471 case PROGRESS_ACCUMULATE:
1472 {
1473 // avoid overflow
1474 uint32 max_value = std::numeric_limits<uint32>::max();
1475 newValue = max_value - progress->counter > changeValue ? progress->counter + changeValue : max_value;
1476 break;
1477 }
1478 case PROGRESS_HIGHEST:
1479 newValue = progress->counter < changeValue ? changeValue : progress->counter;
1480 break;
1481 }
1482
1483 // not update (not mark as changed) if counter will have same value
1484 if(progress->counter == newValue)
1485 return;
1486
1487 progress->counter = newValue;
1488 }
1489
1490 progress->changed = true;
1491
1492 if(entry->timeLimit)
1493 {
1494 time_t now = time(NULL);
1495 if(time_t(progress->date + entry->timeLimit) < now)
1496 progress->counter = 1;
1497
1498 // also it seems illogical, the timeframe will be extended at every criteria update
1499 progress->date = now;
1500 }
1501 SendCriteriaUpdate(entry->ID,progress);
1502 }
1503
1504 void AchievementMgr::CompletedAchievement(AchievementEntry const* achievement)
1505 {
1506 sLog.outDetail("AchievementMgr::CompletedAchievement(%u)", achievement->ID);
1507 if(achievement->flags & ACHIEVEMENT_FLAG_COUNTER || m_completedAchievements.find(achievement->ID)!=m_completedAchievements.end())
1508 return;
1509
1510 SendAchievementEarned(achievement);
1511 CompletedAchievementData& ca = m_completedAchievements[achievement->ID];
1512 ca.date = time(NULL);
1513 ca.changed = true;
1514
1515 // don't insert for ACHIEVEMENT_FLAG_REALM_FIRST_KILL since otherwise only the first group member would reach that achievement
1516 // TODO: where do set this instead?
1517 if(!(achievement->flags & ACHIEVEMENT_FLAG_REALM_FIRST_KILL))
1518 achievementmgr.SetRealmCompleted(achievement);
1519
1520 UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT);
1521
1522 // reward items and titles if any
1523 AchievementReward const* reward = achievementmgr.GetAchievementReward(achievement);
1524
1525 // no rewards
1526 if(!reward)
1527 return;
1528
1529 // titles
1530 if(uint32 titleId = reward->titleId[GetPlayer()->GetTeam() == HORDE ? 0 : 1])
1531 {
1532 if(CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(titleId))
1533 GetPlayer()->SetTitle(titleEntry);
1534 }
1535
1536 // mail
1537 if(reward->sender)
1538 {
1539 Item* item = reward->itemId ? Item::CreateItem(reward->itemId,1,GetPlayer ()) : NULL;
1540
1541 MailItemsInfo mi;
1542 if(item)
1543 {
1544 // save new item before send
1545 item->SaveToDB(); // save for prevent lost at next mail load, if send fail then item will deleted
1546
1547 // item
1548 mi.AddItem(item->GetGUIDLow(), item->GetEntry(), item);
1549 }
1550
1551 int loc_idx = GetPlayer()->GetSession()->GetSessionDbLocaleIndex();
1552
1553 // subject and text
1554 std::string subject = reward->subject;
1555 std::string text = reward->text;
1556 if ( loc_idx >= 0 )
1557 {
1558 if(AchievementRewardLocale const* loc = achievementmgr.GetAchievementRewardLocale(achievement))
1559 {
1560 if (loc->subject.size() > size_t(loc_idx) && !loc->subject[loc_idx].empty())
1561 subject = loc->subject[loc_idx];
1562 if (loc->text.size() > size_t(loc_idx) && !loc->text[loc_idx].empty())
1563 text = loc->text[loc_idx];
1564 }
1565 }
1566
1567 uint32 itemTextId = objmgr.CreateItemText( text );
1568
1569 WorldSession::SendMailTo(GetPlayer(), MAIL_CREATURE, MAIL_STATIONERY_NORMAL, reward->sender, GetPlayer()->GetGUIDLow(), subject, itemTextId , &mi, 0, 0, MAIL_CHECK_MASK_NONE);
1570 }
1571 }
1572
1573 void AchievementMgr::SendAllAchievementData()
1574 {
1575 // since we don't know the exact size of the packed GUIDs this is just an approximation
1576 WorldPacket data(SMSG_ALL_ACHIEVEMENT_DATA, 4*2+m_completedAchievements.size()*4*2+m_completedAchievements.size()*7*4);
1577 BuildAllDataPacket(&data);
1578 GetPlayer()->GetSession()->SendPacket(&data);
1579 }
1580
1581 void AchievementMgr::SendRespondInspectAchievements(Player* player)
1582 {
1583 // since we don't know the exact size of the packed GUIDs this is just an approximation
1584 WorldPacket data(SMSG_RESPOND_INSPECT_ACHIEVEMENTS, 4+4*2+m_completedAchievements.size()*4*2+m_completedAchievements.size()*7*4);
1585 data.append(GetPlayer()->GetPackGUID());
1586 BuildAllDataPacket(&data);
1587 player->GetSession()->SendPacket(&data);
1588 }
1589
1590 /**
1591 * used by both SMSG_ALL_ACHIEVEMENT_DATA and SMSG_RESPOND_INSPECT_ACHIEVEMENT
1592 */
1593 void AchievementMgr::BuildAllDataPacket(WorldPacket *data)
1594 {
1595 for(CompletedAchievementMap::const_iterator iter = m_completedAchievements.begin(); iter!=m_completedAchievements.end(); ++iter)
1596 {
1597 *data << uint32(iter->first);
1598 *data << uint32(secsToTimeBitFields(iter->second.date));
1599 }
1600 *data << int32(-1);
1601
1602 for(CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
1603 {
1604 *data << uint32(iter->first);
1605 data->appendPackGUID(iter->second.counter);
1606 data->append(GetPlayer()->GetPackGUID());
1607 *data << uint32(0);
1608 *data << uint32(secsToTimeBitFields(iter->second.date));
1609 *data << uint32(0);
1610 *data << uint32(0);
1611 }
1612
1613 *data << int32(-1);
1614 }
1615
1616 //==========================================================
1617 AchievementCriteriaEntryList const& AchievementGlobalMgr::GetAchievementCriteriaByType(AchievementCriteriaTypes type)
1618 {
1619 return m_AchievementCriteriasByType[type];
1620 }
1621
1622 void AchievementGlobalMgr::LoadAchievementCriteriaList()
1623 {
1624 if(sAchievementCriteriaStore.GetNumRows()==0)
1625 {
1626 barGoLink bar(1);
1627 bar.step();
1628
1629 sLog.outString();
1630 sLog.outErrorDb(">> Loaded 0 achievement criteria.");
1631 return;
1632 }
1633
1634 barGoLink bar( sAchievementCriteriaStore.GetNumRows() );
1635 for (uint32 entryId = 0; entryId < sAchievementCriteriaStore.GetNumRows(); ++entryId)
1636 {
1637 bar.step();
1638
1639 AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(entryId);
1640 if(!criteria)
1641 continue;
1642
1643 m_AchievementCriteriasByType[criteria->requiredType].push_back(criteria);
1644 m_AchievementCriteriaListByAchievement[criteria->referredAchievement].push_back(criteria);
1645 }
1646
1647 sLog.outString();
1648 sLog.outString(">> Loaded %lu achievement criteria.",(unsigned long)m_AchievementCriteriasByType->size());
1649 }
1650
1651 void AchievementGlobalMgr::LoadAchievementReferenceList()
1652 {
1653 if(sAchievementStore.GetNumRows()==0)
1654 {
1655 barGoLink bar(1);
1656 bar.step();
1657
1658 sLog.outString();
1659 sLog.outErrorDb(">> Loaded 0 achievement references.");
1660 return;
1661 }
1662
1663 uint32 count = 0;
1664 barGoLink bar( sAchievementStore.GetNumRows() );
1665 for (uint32 entryId = 0; entryId < sAchievementStore.GetNumRows(); ++entryId)
1666 {
1667 bar.step();
1668
1669 AchievementEntry const* achievement = sAchievementStore.LookupEntry(entryId);
1670 if(!achievement || !achievement->refAchievement)
1671 continue;
1672
1673 m_AchievementListByReferencedId[achievement->refAchievement].push_back(achievement);
1674 ++count;
1675 }
1676
1677 sLog.outString();
1678 sLog.outString(">> Loaded %u achievement references.",count);
1679 }
1680
1681 void AchievementGlobalMgr::LoadAchievementCriteriaData()
1682 {
1683 m_criteriaDataMap.clear(); // need for reload case
1684
1685 QueryResult *result = WorldDatabase.Query("SELECT criteria_id, type, value1, value2 FROM achievement_criteria_data");
1686
1687 if(!result)
1688 {
1689 barGoLink bar(1);
1690 bar.step();
1691
1692 sLog.outString();
1693 sLog.outString(">> Loaded 0 additional achievement criteria data. DB table `achievement_criteria_data` is empty.");
1694 return;
1695 }
1696
1697 uint32 count = 0;
1698 barGoLink bar(result->GetRowCount());
1699 do
1700 {
1701 bar.step();
1702 Field *fields = result->Fetch();
1703 uint32 criteria_id = fields[0].GetUInt32();
1704
1705 AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(criteria_id);
1706
1707 if (!criteria)
1708 {
1709 sLog.outErrorDb( "Table `achievement_criteria_data` have data for not existed criteria (Entry: %u), ignore.", criteria_id);
1710 continue;
1711 }
1712
1713 AchievementCriteriaData data(fields[1].GetUInt32(),fields[2].GetUInt32(),fields[3].GetUInt32());
1714
1715 if(!data.IsValid(criteria))
1716 continue;
1717
1718 // this will allocate empty data set storage
1719 AchievementCriteriaDataSet& dataSet = m_criteriaDataMap[criteria_id];
1720
1721 // add real data only for not NONE data types
1722 if(data.dataType!=ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE)
1723 dataSet.Add(data);
1724
1725 // counting data by and data types
1726 ++count;
1727 } while(result->NextRow());
1728
1729 delete result;
1730
1731 // post loading checks
1732 for (uint32 entryId = 0; entryId < sAchievementCriteriaStore.GetNumRows(); ++entryId)
1733 {
1734 AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(entryId);
1735 if(!criteria)
1736 continue;
1737
1738 switch(criteria->requiredType)
1739 {
1740 case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE: // need skip generic cases
1741 if(criteria->do_emote.count==0)
1742 continue;
1743 break;
1744 case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2: // any cases
1745 break;
1746 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE: // need skip generic cases
1747 if(criteria->loot_type.lootTypeCount!=1)
1748 continue;
1749 break;
1750 default: // type not use DB data, ignore
1751 continue;
1752 }
1753
1754 if(!GetCriteriaDataSet(criteria))
1755 sLog.outErrorDb( "Table `achievement_criteria_data` not have expected data for for criteria (Entry: %u Type: %u).", criteria->ID, criteria->requiredType);
1756 }
1757
1758 sLog.outString();
1759 sLog.outString(">> Loaded %u additional achievement criteria data.",count);
1760 }
1761
1762 void AchievementGlobalMgr::LoadCompletedAchievements()
1763 {
1764 QueryResult *result = CharacterDatabase.Query("SELECT achievement FROM character_achievement GROUP BY achievement");
1765
1766 if(!result)
1767 {
1768 barGoLink bar(1);
1769 bar.step();
1770
1771 sLog.outString();
1772 sLog.outString(">> Loaded 0 realm completed achievements . DB table `character_achievement` is empty.");
1773 return;
1774 }
1775
1776 barGoLink bar(result->GetRowCount());
1777 do
1778 {
1779 bar.step();
1780 Field *fields = result->Fetch();
1781
1782 uint32 achievement_id = fields[0].GetUInt32();
1783 if(!sAchievementStore.LookupEntry(achievement_id))
1784 {
1785 // we will remove not existed achievement for all characters
1786 sLog.outError("Not existed achievement %u data removed from table `character_achievement`.",achievement_id);
1787 CharacterDatabase.PExecute("DELETE FROM character_achievement WHERE achievement = %u",achievement_id);
1788 continue;
1789 }
1790
1791 m_allCompletedAchievements.insert(achievement_id);
1792 } while(result->NextRow());
1793
1794 delete result;
1795
1796 sLog.outString();
1797 sLog.outString(">> Loaded %lu realm completed achievements.",(unsigned long)m_allCompletedAchievements.size());
1798 }
1799
1800 void AchievementGlobalMgr::LoadRewards()
1801 {
1802 m_achievementRewards.clear(); // need for reload case
1803
1804 // 0 1 2 3 4 5 6
1805 QueryResult *result = WorldDatabase.Query("SELECT entry, title_A, title_H, item, sender, subject, text FROM achievement_reward");
1806
1807 if(!result)
1808 {
1809 barGoLink bar(1);
1810
1811 bar.step();
1812
1813 sLog.outString();
1814 sLog.outErrorDb(">> Loaded 0 achievement rewards. DB table `achievement_reward` is empty.");
1815 return;
1816 }
1817
1818 uint32 count = 0;
1819 barGoLink bar(result->GetRowCount());
1820
1821 do
1822 {
1823 bar.step();
1824
1825 Field *fields = result->Fetch();
1826 uint32 entry = fields[0].GetUInt32();
1827 if (!sAchievementStore.LookupEntry(entry))
1828 {
1829 sLog.outErrorDb( "Table `achievement_reward` has wrong achievement (Entry: %u), ignore", entry);
1830 continue;
1831 }
1832
1833 AchievementReward reward;
1834 reward.titleId[0] = fields[1].GetUInt32();
1835 reward.titleId[1] = fields[2].GetUInt32();
1836 reward.itemId = fields[3].GetUInt32();
1837 reward.sender = fields[4].GetUInt32();
1838 reward.subject = fields[5].GetCppString();
1839 reward.text = fields[6].GetCppString();
1840
1841 if ((reward.titleId[0]==0)!=(reward.titleId[1]==0))
1842 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) has title (A: %u H: %u) only for one from teams.", entry, reward.titleId[0], reward.titleId[1]);
1843
1844 // must be title or mail at least
1845 if (!reward.titleId[0] && !reward.titleId[1] && !reward.sender)
1846 {
1847 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) not have title or item reward data, ignore.", entry);
1848 continue;
1849 }
1850
1851 if (reward.titleId[0])
1852 {
1853 CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(reward.titleId[0]);
1854 if (!titleEntry)
1855 {
1856 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) has invalid title id (%u) in `title_A`, set to 0", entry, reward.titleId[0]);
1857 reward.titleId[0] = 0;
1858 }
1859 }
1860
1861 if (reward.titleId[1])
1862 {
1863 CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(reward.titleId[1]);
1864 if (!titleEntry)
1865 {
1866 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) has invalid title id (%u) in `title_A`, set to 0", entry, reward.titleId[1]);
1867 reward.titleId[1] = 0;
1868 }
1869 }
1870
1871 //check mail data before item for report including wrong item case
1872 if (reward.sender)
1873 {
1874 if (!objmgr.GetCreatureTemplate(reward.sender))
1875 {
1876 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) has invalid creature entry %u as sender, mail reward skipped.", entry, reward.sender);
1877 reward.sender = 0;
1878 }
1879 }
1880 else
1881 {
1882 if (reward.itemId)
1883 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) not have sender data but have item reward, item will not rewarded", entry);
1884
1885 if (!reward.subject.empty())
1886 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) not have sender data but have mail subject.", entry);
1887
1888 if (!reward.text.empty())
1889 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) not have sender data but have mail text.", entry);
1890 }
1891
1892 if (reward.itemId)
1893 {
1894 if (!objmgr.GetItemPrototype(reward.itemId))
1895 {
1896 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) has invalid item id %u, reward mail will be without item.", entry, reward.itemId);
1897 reward.itemId = 0;
1898 }
1899 }
1900
1901 m_achievementRewards[entry] = reward;
1902 ++count;
1903
1904 } while (result->NextRow());
1905
1906 delete result;
1907
1908 sLog.outString();
1909 sLog.outString( ">> Loaded %u achievement rewards", count );
1910 }
1911
1912 void AchievementGlobalMgr::LoadRewardLocales()
1913 {
1914 m_achievementRewardLocales.clear(); // need for reload case
1915
1916 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");
1917
1918 if(!result)
1919 {
1920 barGoLink bar(1);
1921
1922 bar.step();
1923
1924 sLog.outString();
1925 sLog.outString(">> Loaded 0 achievement reward locale strings. DB table `locales_achievement_reward` is empty.");
1926 return;
1927 }
1928
1929 barGoLink bar(result->GetRowCount());
1930
1931 do
1932 {
1933 Field *fields = result->Fetch();
1934 bar.step();
1935
1936 uint32 entry = fields[0].GetUInt32();
1937
1938 if(m_achievementRewards.find(entry)==m_achievementRewards.end())
1939 {
1940 sLog.outErrorDb( "Table `locales_achievement_reward` (Entry: %u) has locale strings for not existed achievement reward .", entry);
1941 continue;
1942 }
1943
1944 AchievementRewardLocale& data = m_achievementRewardLocales[entry];
1945
1946 for(int i = 1; i < MAX_LOCALE; ++i)
1947 {
1948 std::string str = fields[1+2*(i-1)].GetCppString();
1949 if(!str.empty())
1950 {
1951 int idx = objmgr.GetOrNewIndexForLocale(LocaleConstant(i));
1952 if(idx >= 0)
1953 {
1954 if(data.subject.size() <= size_t(idx))
1955 data.subject.resize(idx+1);
1956
1957 data.subject[idx] = str;
1958 }
1959 }
1960 str = fields[1+2*(i-1)+1].GetCppString();
1961 if(!str.empty())
1962 {
1963 int idx = objmgr.GetOrNewIndexForLocale(LocaleConstant(i));
1964 if(idx >= 0)
1965 {
1966 if(data.text.size() <= size_t(idx))
1967 data.text.resize(idx+1);
1968
1969 data.text[idx] = str;
1970 }
1971 }
1972 }
1973 } while (result->NextRow());
1974
1975 delete result;
1976
1977 sLog.outString();
1978 sLog.outString( ">> Loaded %lu achievement reward locale strings", (unsigned long)m_achievementRewardLocales.size() );
1979 }