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