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