?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[7732] Fixed compile warnings.
[getmangos.git] / src / game / AchievementMgr.cpp
blob363e8cbe750dfe91099fda7750ea8cc6c6e08486
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::const_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::const_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::const_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::const_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 < MAX_WORLD_MAP_OVERLAY_AREA_IDX; ++j)
894 {
895 uint32 area_id = worldOverlayEntry->areatableID[j];
896 if(!area_id) // array have 0 only in empty tail
897 break;
898
899 int32 exploreFlag = GetAreaFlagByAreaID(area_id);
900 if(exploreFlag < 0)
901 continue;
902
903 uint32 playerIndexOffset = uint32(exploreFlag) / 32;
904 uint32 mask = 1<< (uint32(exploreFlag) % 32);
905
906 if(GetPlayer()->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + playerIndexOffset) & mask)
907 {
908 matchFound = true;
909 break;
910 }
911 }
912
913 if(matchFound)
914 SetCriteriaProgress(achievementCriteria, 1);
915 break;
916 }
917 case ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT:
918 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetByteValue(PLAYER_BYTES_2, 2)+1);
919 break;
920 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
921 {
922 // skip faction check only at loading
923 if (miscvalue1 && miscvalue1 != achievementCriteria->gain_reputation.factionID)
924 continue;
925
926 int32 reputation = GetPlayer()->GetReputationMgr().GetReputation(achievementCriteria->gain_reputation.factionID);
927 if (reputation > 0)
928 SetCriteriaProgress(achievementCriteria, reputation);
929 break;
930 }
931 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION:
932 {
933 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetReputationMgr().GetExaltedFactionCount());
934 break;
935 }
936 case ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP:
937 {
938 // skip for login case
939 if(!miscvalue1)
940 continue;
941 SetCriteriaProgress(achievementCriteria, 1);
942 break;
943 }
944 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT:
945 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT:
946 {
947 // miscvalue1 = itemid
948 // miscvalue2 = diced value
949 if(!miscvalue1)
950 continue;
951 if(miscvalue2 != achievementCriteria->roll_greed_on_loot.rollValue)
952 continue;
953 ItemPrototype const *pProto = objmgr.GetItemPrototype( miscvalue1 );
954
955 uint32 requiredItemLevel = 0;
956 if (achievementCriteria->ID == 2412 || achievementCriteria->ID == 2358)
957 requiredItemLevel = 185;
958
959 if(!pProto || pProto->ItemLevel <requiredItemLevel)
960 continue;
961 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
962 break;
963 }
964 case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
965 {
966 // miscvalue1 = emote
967 if(!miscvalue1)
968 continue;
969 if(miscvalue1 != achievementCriteria->do_emote.emoteID)
970 continue;
971 if(achievementCriteria->do_emote.count)
972 {
973 // those requirements couldn't be found in the dbc
974 AchievementCriteriaDataSet const* data = achievementmgr.GetCriteriaDataSet(achievementCriteria);
975 if(!data)
976 continue;
977
978 if(!data->Meets(GetPlayer(),unit))
979 continue;
980 }
981
982 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
983 break;
984 }
985 case ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE:
986 case ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE:
987 {
988 if (!miscvalue1)
989 continue;
990
991 if (achievementCriteria->healing_done.flag == ACHIEVEMENT_CRITERIA_CONDITION_MAP)
992 {
993 if(GetPlayer()->GetMapId() != achievementCriteria->healing_done.mapid)
994 continue;
995
996 // map specific case (BG in fact) expected player targeted damage/heal
997 if(!unit || unit->GetTypeId()!=TYPEID_PLAYER)
998 continue;
999 }
1000
1001 SetCriteriaProgress(achievementCriteria, miscvalue1, PROGRESS_ACCUMULATE);
1002 break;
1003 }
1004 case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM:
1005 // miscvalue1 = item_id
1006 if(!miscvalue1)
1007 continue;
1008 if(miscvalue1 != achievementCriteria->equip_item.itemID)
1009 continue;
1010
1011 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
1012 break;
1013 case ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT:
1014 // miscvalue1 = go entry
1015 if(!miscvalue1)
1016 continue;
1017 if(miscvalue1 != achievementCriteria->use_gameobject.goEntry)
1018 continue;
1019
1020 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
1021 break;
1022 case ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT:
1023 if (!miscvalue1)
1024 continue;
1025 if (miscvalue1 != achievementCriteria->fish_in_gameobject.goEntry)
1026 continue;
1027
1028 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
1029 break;
1030 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
1031 {
1032 if(miscvalue1 && miscvalue1 != achievementCriteria->learn_skillline_spell.skillLine)
1033 continue;
1034
1035 uint32 spellCount = 0;
1036 for (PlayerSpellMap::const_iterator spellIter = GetPlayer()->GetSpellMap().begin();
1037 spellIter != GetPlayer()->GetSpellMap().end();
1038 ++spellIter)
1039 {
1040 for(SkillLineAbilityMap::const_iterator skillIter = spellmgr.GetBeginSkillLineAbilityMap(spellIter->first);
1041 skillIter != spellmgr.GetEndSkillLineAbilityMap(spellIter->first);
1042 ++skillIter)
1043 {
1044 if(skillIter->second->skillId == achievementCriteria->learn_skillline_spell.skillLine)
1045 spellCount++;
1046 }
1047 }
1048 SetCriteriaProgress(achievementCriteria, spellCount);
1049 break;
1050 }
1051 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REVERED_REPUTATION:
1052 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetReputationMgr().GetReveredFactionCount());
1053 break;
1054 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_HONORED_REPUTATION:
1055 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetReputationMgr().GetHonoredFactionCount());
1056 break;
1057 case ACHIEVEMENT_CRITERIA_TYPE_KNOWN_FACTIONS:
1058 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetReputationMgr().GetVisibleFactionCount());
1059 break;
1060 case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
1061 {
1062 if (!miscvalue1)
1063 continue;
1064
1065 if (!miscvalue1 || miscvalue1 != achievementCriteria->cast_spell.spellID)
1066 continue;
1067
1068 // those requirements couldn't be found in the dbc
1069 AchievementCriteriaDataSet const* data = achievementmgr.GetCriteriaDataSet(achievementCriteria);
1070 if(!data)
1071 continue;
1072
1073 if(!data->Meets(GetPlayer(),unit))
1074 continue;
1075
1076 SetCriteriaProgress(achievementCriteria, 1, PROGRESS_ACCUMULATE);
1077 break;
1078 }
1079 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE:
1080 {
1081 if(miscvalue1 && miscvalue1 != achievementCriteria->learn_skill_line.skillLine)
1082 continue;
1083
1084 uint32 spellCount = 0;
1085 for (PlayerSpellMap::const_iterator spellIter = GetPlayer()->GetSpellMap().begin();
1086 spellIter != GetPlayer()->GetSpellMap().end();
1087 ++spellIter)
1088 {
1089 for(SkillLineAbilityMap::const_iterator skillIter = spellmgr.GetBeginSkillLineAbilityMap(spellIter->first);
1090 skillIter != spellmgr.GetEndSkillLineAbilityMap(spellIter->first);
1091 ++skillIter)
1092 {
1093 if(skillIter->second->skillId == achievementCriteria->learn_skill_line.skillLine)
1094 spellCount++;
1095 }
1096 }
1097 SetCriteriaProgress(achievementCriteria, spellCount);
1098 break;
1099 }
1100 case ACHIEVEMENT_CRITERIA_TYPE_EARN_HONORABLE_KILL:
1101 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORBALE_KILLS));
1102 break;
1103 // std case: not exist in DBC, not triggered in code as result
1104 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALTH:
1105 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_SPELLPOWER:
1106 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_ARMOR:
1107 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_POWER:
1108 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_STAT:
1109 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_RATING:
1110 break;
1111 // FIXME: not triggered in code as result, need to implement
1112 case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG:
1113 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST_DAILY:
1114 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_RAID:
1115 case ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE:
1116 case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL_AT_AREA:
1117 case ACHIEVEMENT_CRITERIA_TYPE_WIN_ARENA:
1118 case ACHIEVEMENT_CRITERIA_TYPE_PLAY_ARENA:
1119 case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL:
1120 case ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA:
1121 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_TEAM_RATING:
1122 case ACHIEVEMENT_CRITERIA_TYPE_REACH_TEAM_RATING:
1123 case ACHIEVEMENT_CRITERIA_TYPE_OWN_RANK:
1124 case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM:
1125 case ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS:
1126 case ACHIEVEMENT_CRITERIA_TYPE_HK_RACE:
1127 case ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS:
1128 case ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_VENDORS:
1129 case ACHIEVEMENT_CRITERIA_TYPE_NUMBER_OF_TALENT_RESETS:
1130 case ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL:
1131 case ACHIEVEMENT_CRITERIA_TYPE_EARNED_PVP_TITLE:
1132 case ACHIEVEMENT_CRITERIA_TYPE_WIN_DUEL:
1133 case ACHIEVEMENT_CRITERIA_TYPE_LOSE_DUEL:
1134 case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE_TYPE:
1135 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_EARNED_BY_AUCTIONS:
1136 case ACHIEVEMENT_CRITERIA_TYPE_CREATE_AUCTION:
1137 case ACHIEVEMENT_CRITERIA_TYPE_WON_AUCTIONS:
1138 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_GOLD_VALUE_OWNED:
1139 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_EPIC_ITEM:
1140 case ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM:
1141 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED:
1142 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED:
1143 case ACHIEVEMENT_CRITERIA_TYPE_QUEST_ABANDONED:
1144 case ACHIEVEMENT_CRITERIA_TYPE_FLIGHT_PATHS_TAKEN:
1145 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:
1146 case ACHIEVEMENT_CRITERIA_TYPE_ACCEPTED_SUMMONINGS:
1147 case ACHIEVEMENT_CRITERIA_TYPE_TOTAL:
1148 break; // Not implemented yet :(
1149 }
1150 if(IsCompletedCriteria(achievementCriteria,achievement))
1151 CompletedCriteriaFor(achievement);
1152
1153 // check again the completeness for SUMM and REQ COUNT achievements,
1154 // as they don't depend on the completed criteria but on the sum of the progress of each individual criteria
1155 if (achievement->flags & ACHIEVEMENT_FLAG_SUMM)
1156 {
1157 if (IsCompletedAchievement(achievement))
1158 CompletedAchievement(achievement);
1159 }
1160
1161 if(AchievementEntryList const* achRefList = achievementmgr.GetAchievementByReferencedId(achievement->ID))
1162 {
1163 for(AchievementEntryList::const_iterator itr = achRefList->begin(); itr != achRefList->end(); ++itr)
1164 if(IsCompletedAchievement(*itr))
1165 CompletedAchievement(*itr);
1166 }
1167 }
1168 }
1169
1170 static const uint32 achievIdByClass[MAX_CLASSES] = { 0, 459, 465 , 462, 458, 464, 461, 467, 460, 463, 0, 466 };
1171 static const uint32 achievIdByRace[MAX_RACES] = { 0, 1408, 1410, 1407, 1409, 1413, 1411, 1404, 1412, 0, 1405, 1406 };
1172
1173 bool AchievementMgr::IsCompletedCriteria(AchievementCriteriaEntry const* achievementCriteria, AchievementEntry const* achievement)
1174 {
1175 // counter can never complete
1176 if(achievement->flags & ACHIEVEMENT_FLAG_COUNTER)
1177 return false;
1178
1179 if(achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_REACH | ACHIEVEMENT_FLAG_REALM_FIRST_KILL))
1180 {
1181 // someone on this realm has already completed that achievement
1182 if(achievementmgr.IsRealmCompleted(achievement))
1183 return false;
1184 }
1185
1186 CriteriaProgressMap::const_iterator itr = m_criteriaProgress.find(achievementCriteria->ID);
1187 if(itr == m_criteriaProgress.end())
1188 return false;
1189
1190 CriteriaProgress const* progress = &itr->second;
1191
1192 switch(achievementCriteria->requiredType)
1193 {
1194 case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
1195 return progress->counter >= achievementCriteria->kill_creature.creatureCount;
1196 case ACHIEVEMENT_CRITERIA_TYPE_REACH_LEVEL:
1197 {
1198 // skip wrong class achievements
1199 for(int i = 1; i < MAX_CLASSES; ++i)
1200 if(achievIdByClass[i] == achievement->ID && i != GetPlayer()->getClass())
1201 return false;
1202
1203 // skip wrong race achievements
1204 for(int i = 1; i < MAX_RACES; ++i)
1205 if(achievIdByRace[i] == achievement->ID && i != GetPlayer()->getRace())
1206 return false;
1207
1208 // appropriate class/race or not class/race specific
1209 return progress->counter >= achievementCriteria->reach_level.level;
1210 }
1211 case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL:
1212 return progress->counter >= achievementCriteria->reach_skill_level.skillLevel;
1213 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL:
1214 return progress->counter >= (achievementCriteria->learn_skill_level.skillLevel * 75);
1215 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT:
1216 return progress->counter >= 1;
1217 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST_COUNT:
1218 return progress->counter >= achievementCriteria->complete_quest_count.totalQuestCount;
1219 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
1220 return progress->counter >= achievementCriteria->complete_quests_in_zone.questCount;
1221 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST:
1222 return progress->counter >= achievementCriteria->complete_daily_quest.questCount;
1223 case ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING:
1224 return progress->counter >= achievementCriteria->fall_without_dying.fallHeight;
1225 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
1226 return progress->counter >= 1;
1227 case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
1228 case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
1229 return progress->counter >= achievementCriteria->be_spell_target.spellCount;
1230 case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
1231 case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
1232 return progress->counter >= achievementCriteria->cast_spell.castCount;
1233 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL:
1234 return progress->counter >= 1;
1235 case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM:
1236 return progress->counter >= achievementCriteria->own_item.itemCount;
1237 case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:
1238 return progress->counter >= achievementCriteria->use_item.itemCount;
1239 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM:
1240 return progress->counter >= achievementCriteria->loot_item.itemCount;
1241 case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA:
1242 return progress->counter >= 1;
1243 case ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT:
1244 return progress->counter >= achievementCriteria->buy_bank_slot.numberOfSlots;
1245 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
1246 return progress->counter >= achievementCriteria->gain_reputation.reputationAmount;
1247 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION:
1248 return progress->counter >= achievementCriteria->gain_exalted_reputation.numberOfExaltedFactions;
1249 case ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP:
1250 return progress->counter >= achievementCriteria->visit_barber.numberOfVisits;
1251 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT:
1252 case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT:
1253 return progress->counter >= achievementCriteria->roll_greed_on_loot.count;
1254 case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
1255 return progress->counter >= achievementCriteria->do_emote.count;
1256 case ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE:
1257 case ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE:
1258 return progress->counter >= achievementCriteria->healing_done.count;
1259 case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM:
1260 return progress->counter >= achievementCriteria->equip_item.count;
1261 case ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_QUEST_REWARD:
1262 return progress->counter >= achievementCriteria->quest_reward_money.goldInCopper;
1263 case ACHIEVEMENT_CRITERIA_TYPE_LOOT_MONEY:
1264 return progress->counter >= achievementCriteria->loot_money.goldInCopper;
1265 case ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT:
1266 return progress->counter >= achievementCriteria->use_gameobject.useCount;
1267 case ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT:
1268 return progress->counter >= achievementCriteria->fish_in_gameobject.lootCount;
1269 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
1270 return progress->counter >= achievementCriteria->learn_skillline_spell.spellCount;
1271 case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE:
1272 return progress->counter >= achievementCriteria->learn_skill_line.spellCount;
1273 case ACHIEVEMENT_CRITERIA_TYPE_EARN_HONORABLE_KILL:
1274 return progress->counter >= achievementCriteria->honorable_kill.killCount;
1275
1276 // handle all statistic-only criteria here
1277 case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND:
1278 case ACHIEVEMENT_CRITERIA_TYPE_DEATH_AT_MAP:
1279 case ACHIEVEMENT_CRITERIA_TYPE_DEATH:
1280 case ACHIEVEMENT_CRITERIA_TYPE_DEATH_IN_DUNGEON:
1281 case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE:
1282 case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_PLAYER:
1283 case ACHIEVEMENT_CRITERIA_TYPE_DEATHS_FROM:
1284 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_TALENTS:
1285 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_AT_BARBER:
1286 case ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_MAIL:
1287 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID:
1288 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_SOLD:
1289 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REVERED_REPUTATION:
1290 case ACHIEVEMENT_CRITERIA_TYPE_GAIN_HONORED_REPUTATION:
1291 case ACHIEVEMENT_CRITERIA_TYPE_KNOWN_FACTIONS:
1292 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALTH:
1293 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_SPELLPOWER:
1294 case ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_ARMOR:
1295 return false;
1296 }
1297 return false;
1298 }
1299
1300 void AchievementMgr::CompletedCriteriaFor(AchievementEntry const* achievement)
1301 {
1302 // counter can never complete
1303 if(achievement->flags & ACHIEVEMENT_FLAG_COUNTER)
1304 return;
1305
1306 // already completed and stored
1307 if (m_completedAchievements.find(achievement->ID)!=m_completedAchievements.end())
1308 return;
1309
1310 if (IsCompletedAchievement(achievement))
1311 CompletedAchievement(achievement);
1312 }
1313
1314 bool AchievementMgr::IsCompletedAchievement(AchievementEntry const* entry)
1315 {
1316 // counter can never complete
1317 if(entry->flags & ACHIEVEMENT_FLAG_COUNTER)
1318 return false;
1319
1320 // for achievement with referenced achievement criterias get from referenced and counter from self
1321 uint32 achievmentForTestId = entry->refAchievement ? entry->refAchievement : entry->ID;
1322 uint32 achievmentForTestCount = entry->count;
1323
1324 AchievementCriteriaEntryList const* cList = achievementmgr.GetAchievementCriteriaByAchievement(achievmentForTestId);
1325 if(!cList)
1326 return false;
1327 uint32 count = 0;
1328
1329 // For SUMM achievements, we have to count the progress of each criteria of the achievement.
1330 // Oddly, the target count is NOT countained in the achievement, but in each individual criteria
1331 if (entry->flags & ACHIEVEMENT_FLAG_SUMM)
1332 {
1333 for(AchievementCriteriaEntryList::const_iterator itr = cList->begin(); itr != cList->end(); ++itr)
1334 {
1335 AchievementCriteriaEntry const* criteria = *itr;
1336
1337 CriteriaProgressMap::const_iterator itrProgress = m_criteriaProgress.find(criteria->ID);
1338 if(itrProgress == m_criteriaProgress.end())
1339 continue;
1340
1341 CriteriaProgress const* progress = &itrProgress->second;
1342 count += progress->counter;
1343
1344 // for counters, field4 contains the main count requirement
1345 if (count >= criteria->raw.count)
1346 return true;
1347 }
1348 return false;
1349 }
1350
1351 // Default case - need complete all or
1352 bool completed_all = true;
1353 for(AchievementCriteriaEntryList::const_iterator itr = cList->begin(); itr != cList->end(); ++itr)
1354 {
1355 AchievementCriteriaEntry const* criteria = *itr;
1356
1357 bool completed = IsCompletedCriteria(criteria,entry);
1358
1359 // found an uncompleted criteria, but DONT return false yet - there might be a completed criteria with ACHIEVEMENT_CRITERIA_COMPLETE_FLAG_ALL
1360 if(completed)
1361 ++count;
1362 else
1363 completed_all = false;
1364
1365 // completed as have req. count of completed criterias
1366 if(achievmentForTestCount > 0 && achievmentForTestCount <= count)
1367 return true;
1368 }
1369
1370 // all criterias completed requirement
1371 if(completed_all && achievmentForTestCount==0)
1372 return true;
1373
1374 return false;
1375 }
1376
1377 void AchievementMgr::SetCriteriaProgress(AchievementCriteriaEntry const* entry, uint32 changeValue, ProgressType ptype)
1378 {
1379 if((sLog.getLogFilter() & LOG_FILTER_ACHIEVEMENT_UPDATES)==0)
1380 sLog.outDetail("AchievementMgr::SetCriteriaProgress(%u, %u) for (GUID:%u)", entry->ID, changeValue, m_player->GetGUIDLow());
1381
1382 CriteriaProgress *progress = NULL;
1383
1384 CriteriaProgressMap::iterator iter = m_criteriaProgress.find(entry->ID);
1385
1386 if(iter == m_criteriaProgress.end())
1387 {
1388 // not create record for 0 counter
1389 if(changeValue == 0)
1390 return;
1391
1392 progress = &m_criteriaProgress[entry->ID];
1393 progress->counter = changeValue;
1394 progress->date = time(NULL);
1395 }
1396 else
1397 {
1398 progress = &iter->second;
1399
1400 uint32 newValue = 0;
1401 switch(ptype)
1402 {
1403 case PROGRESS_SET:
1404 newValue = changeValue;
1405 break;
1406 case PROGRESS_ACCUMULATE:
1407 {
1408 // avoid overflow
1409 uint32 max_value = std::numeric_limits<uint32>::max();
1410 newValue = max_value - progress->counter > changeValue ? progress->counter + changeValue : max_value;
1411 break;
1412 }
1413 case PROGRESS_HIGHEST:
1414 newValue = progress->counter < changeValue ? changeValue : progress->counter;
1415 break;
1416 }
1417
1418 // not update (not mark as changed) if counter will have same value
1419 if(progress->counter == newValue)
1420 return;
1421
1422 progress->counter = newValue;
1423 }
1424
1425 progress->changed = true;
1426
1427 if(entry->timeLimit)
1428 {
1429 time_t now = time(NULL);
1430 if(time_t(progress->date + entry->timeLimit) < now)
1431 progress->counter = 1;
1432
1433 // also it seems illogical, the timeframe will be extended at every criteria update
1434 progress->date = now;
1435 }
1436 SendCriteriaUpdate(entry->ID,progress);
1437 }
1438
1439 void AchievementMgr::CompletedAchievement(AchievementEntry const* achievement)
1440 {
1441 sLog.outDetail("AchievementMgr::CompletedAchievement(%u)", achievement->ID);
1442 if(achievement->flags & ACHIEVEMENT_FLAG_COUNTER || m_completedAchievements.find(achievement->ID)!=m_completedAchievements.end())
1443 return;
1444
1445 SendAchievementEarned(achievement);
1446 CompletedAchievementData& ca = m_completedAchievements[achievement->ID];
1447 ca.date = time(NULL);
1448 ca.changed = true;
1449
1450 // don't insert for ACHIEVEMENT_FLAG_REALM_FIRST_KILL since otherwise only the first group member would reach that achievement
1451 // TODO: where do set this instead?
1452 if(!(achievement->flags & ACHIEVEMENT_FLAG_REALM_FIRST_KILL))
1453 achievementmgr.SetRealmCompleted(achievement);
1454
1455 UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT);
1456
1457 // reward items and titles if any
1458 AchievementReward const* reward = achievementmgr.GetAchievementReward(achievement);
1459
1460 // no rewards
1461 if(!reward)
1462 return;
1463
1464 // titles
1465 if(uint32 titleId = reward->titleId[GetPlayer()->GetTeam() == HORDE?0:1])
1466 {
1467 if(CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(titleId))
1468 GetPlayer()->SetTitle(titleEntry);
1469 }
1470
1471 // mail
1472 if(reward->sender)
1473 {
1474 Item* item = reward->itemId ? Item::CreateItem(reward->itemId,1,GetPlayer ()) : NULL;
1475
1476 MailItemsInfo mi;
1477 if(item)
1478 {
1479 // save new item before send
1480 item->SaveToDB(); // save for prevent lost at next mail load, if send fail then item will deleted
1481
1482 // item
1483 mi.AddItem(item->GetGUIDLow(), item->GetEntry(), item);
1484 }
1485
1486 int loc_idx = GetPlayer()->GetSession()->GetSessionDbLocaleIndex();
1487
1488 // subject and text
1489 std::string subject = reward->subject;
1490 std::string text = reward->text;
1491 if ( loc_idx >= 0 )
1492 {
1493 if(AchievementRewardLocale const* loc = achievementmgr.GetAchievementRewardLocale(achievement))
1494 {
1495 if (loc->subject.size() > size_t(loc_idx) && !loc->subject[loc_idx].empty())
1496 subject = loc->subject[loc_idx];
1497 if (loc->text.size() > size_t(loc_idx) && !loc->text[loc_idx].empty())
1498 text = loc->text[loc_idx];
1499 }
1500 }
1501
1502 uint32 itemTextId = objmgr.CreateItemText( text );
1503
1504 WorldSession::SendMailTo(GetPlayer(), MAIL_CREATURE, MAIL_STATIONERY_NORMAL, reward->sender, GetPlayer()->GetGUIDLow(), subject, itemTextId , &mi, 0, 0, MAIL_CHECK_MASK_NONE);
1505 }
1506 }
1507
1508 void AchievementMgr::SendAllAchievementData()
1509 {
1510 // since we don't know the exact size of the packed GUIDs this is just an approximation
1511 WorldPacket data(SMSG_ALL_ACHIEVEMENT_DATA, 4*2+m_completedAchievements.size()*4*2+m_completedAchievements.size()*7*4);
1512 BuildAllDataPacket(&data);
1513 GetPlayer()->GetSession()->SendPacket(&data);
1514 }
1515
1516 void AchievementMgr::SendRespondInspectAchievements(Player* player)
1517 {
1518 // since we don't know the exact size of the packed GUIDs this is just an approximation
1519 WorldPacket data(SMSG_RESPOND_INSPECT_ACHIEVEMENTS, 4+4*2+m_completedAchievements.size()*4*2+m_completedAchievements.size()*7*4);
1520 data.append(GetPlayer()->GetPackGUID());
1521 BuildAllDataPacket(&data);
1522 player->GetSession()->SendPacket(&data);
1523 }
1524
1525 /**
1526 * used by both SMSG_ALL_ACHIEVEMENT_DATA and SMSG_RESPOND_INSPECT_ACHIEVEMENT
1527 */
1528 void AchievementMgr::BuildAllDataPacket(WorldPacket *data)
1529 {
1530 for(CompletedAchievementMap::const_iterator iter = m_completedAchievements.begin(); iter!=m_completedAchievements.end(); ++iter)
1531 {
1532 *data << uint32(iter->first);
1533 *data << uint32(secsToTimeBitFields(iter->second.date));
1534 }
1535 *data << int32(-1);
1536
1537 for(CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
1538 {
1539 *data << uint32(iter->first);
1540 data->appendPackGUID(iter->second.counter);
1541 data->append(GetPlayer()->GetPackGUID());
1542 *data << uint32(0);
1543 *data << uint32(secsToTimeBitFields(iter->second.date));
1544 *data << uint32(0);
1545 *data << uint32(0);
1546 }
1547
1548 *data << int32(-1);
1549 }
1550
1551 //==========================================================
1552 AchievementCriteriaEntryList const& AchievementGlobalMgr::GetAchievementCriteriaByType(AchievementCriteriaTypes type)
1553 {
1554 return m_AchievementCriteriasByType[type];
1555 }
1556
1557 void AchievementGlobalMgr::LoadAchievementCriteriaList()
1558 {
1559 if(sAchievementCriteriaStore.GetNumRows()==0)
1560 {
1561 barGoLink bar(1);
1562 bar.step();
1563
1564 sLog.outString();
1565 sLog.outErrorDb(">> Loaded 0 achievement criteria.");
1566 return;
1567 }
1568
1569 barGoLink bar( sAchievementCriteriaStore.GetNumRows() );
1570 for (uint32 entryId = 0; entryId < sAchievementCriteriaStore.GetNumRows(); ++entryId)
1571 {
1572 bar.step();
1573
1574 AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(entryId);
1575 if(!criteria)
1576 continue;
1577
1578 m_AchievementCriteriasByType[criteria->requiredType].push_back(criteria);
1579 m_AchievementCriteriaListByAchievement[criteria->referredAchievement].push_back(criteria);
1580 }
1581
1582 sLog.outString();
1583 sLog.outString(">> Loaded %lu achievement criteria.",(unsigned long)m_AchievementCriteriasByType->size());
1584 }
1585
1586 void AchievementGlobalMgr::LoadAchievementReferenceList()
1587 {
1588 if(sAchievementStore.GetNumRows()==0)
1589 {
1590 barGoLink bar(1);
1591 bar.step();
1592
1593 sLog.outString();
1594 sLog.outErrorDb(">> Loaded 0 achievement references.");
1595 return;
1596 }
1597
1598 uint32 count = 0;
1599 barGoLink bar( sAchievementStore.GetNumRows() );
1600 for (uint32 entryId = 0; entryId < sAchievementStore.GetNumRows(); ++entryId)
1601 {
1602 bar.step();
1603
1604 AchievementEntry const* achievement = sAchievementStore.LookupEntry(entryId);
1605 if(!achievement || !achievement->refAchievement)
1606 continue;
1607
1608 m_AchievementListByReferencedId[achievement->refAchievement].push_back(achievement);
1609 ++count;
1610 }
1611
1612 sLog.outString();
1613 sLog.outString(">> Loaded %u achievement references.",count);
1614 }
1615
1616 void AchievementGlobalMgr::LoadAchievementCriteriaData()
1617 {
1618 m_criteriaDataMap.clear(); // need for reload case
1619
1620 QueryResult *result = WorldDatabase.Query("SELECT criteria_id, type, value1, value2 FROM achievement_criteria_data");
1621
1622 if(!result)
1623 {
1624 barGoLink bar(1);
1625 bar.step();
1626
1627 sLog.outString();
1628 sLog.outString(">> Loaded 0 additional achievement criteria data. DB table `achievement_criteria_data` is empty.");
1629 return;
1630 }
1631
1632 uint32 count = 0;
1633 barGoLink bar(result->GetRowCount());
1634 do
1635 {
1636 bar.step();
1637 Field *fields = result->Fetch();
1638 uint32 criteria_id = fields[0].GetUInt32();
1639
1640 AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(criteria_id);
1641
1642 if (!criteria)
1643 {
1644 sLog.outErrorDb( "Table `achievement_criteria_data` have data for not existed criteria (Entry: %u), ignore.", criteria_id);
1645 continue;
1646 }
1647
1648 AchievementCriteriaData data(fields[1].GetUInt32(),fields[2].GetUInt32(),fields[3].GetUInt32());
1649
1650 if(!data.IsValid(criteria))
1651 continue;
1652
1653 // this will allocate empty data set storage
1654 AchievementCriteriaDataSet& dataSet = m_criteriaDataMap[criteria_id];
1655
1656 // add real data only for not NONE data types
1657 if(data.dataType!=ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE)
1658 dataSet.Add(data);
1659
1660 // counting data by and data types
1661 ++count;
1662 } while(result->NextRow());
1663
1664 delete result;
1665
1666 // post loading checks
1667 for (uint32 entryId = 0; entryId < sAchievementCriteriaStore.GetNumRows(); ++entryId)
1668 {
1669 AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(entryId);
1670 if(!criteria)
1671 continue;
1672
1673 switch(criteria->requiredType)
1674 {
1675 case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
1676 if(!GetCriteriaDataSet(criteria))
1677 sLog.outErrorDb( "Table `achievement_criteria_data` not have expected data for for criteria (Entry: %u Type: %u).", criteria->ID, criteria->requiredType);
1678 break;
1679 case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE: // need skip generic cases
1680 if(criteria->do_emote.count && !GetCriteriaDataSet(criteria))
1681 sLog.outErrorDb( "Table `achievement_criteria_data` not have expected data for for criteria (Entry: %u Type: %u).", criteria->ID, criteria->requiredType);
1682 break;
1683 default: // unexpected case processed in IsValid check
1684 break;
1685 }
1686
1687 }
1688
1689 sLog.outString();
1690 sLog.outString(">> Loaded %u additional achievement criteria data.",count);
1691 }
1692
1693 void AchievementGlobalMgr::LoadCompletedAchievements()
1694 {
1695 QueryResult *result = CharacterDatabase.Query("SELECT achievement FROM character_achievement GROUP BY achievement");
1696
1697 if(!result)
1698 {
1699 barGoLink bar(1);
1700 bar.step();
1701
1702 sLog.outString();
1703 sLog.outString(">> Loaded 0 realm completed achievements . DB table `character_achievement` is empty.");
1704 return;
1705 }
1706
1707 barGoLink bar(result->GetRowCount());
1708 do
1709 {
1710 bar.step();
1711 Field *fields = result->Fetch();
1712 m_allCompletedAchievements.insert(fields[0].GetUInt32());
1713 } while(result->NextRow());
1714
1715 delete result;
1716
1717 sLog.outString();
1718 sLog.outString(">> Loaded %lu realm completed achievements.",(unsigned long)m_allCompletedAchievements.size());
1719 }
1720
1721 void AchievementGlobalMgr::LoadRewards()
1722 {
1723 m_achievementRewards.clear(); // need for reload case
1724
1725 // 0 1 2 3 4 5 6
1726 QueryResult *result = WorldDatabase.Query("SELECT entry, title_A, title_H, item, sender, subject, text FROM achievement_reward");
1727
1728 if(!result)
1729 {
1730 barGoLink bar(1);
1731
1732 bar.step();
1733
1734 sLog.outString();
1735 sLog.outErrorDb(">> Loaded 0 achievement rewards. DB table `achievement_reward` is empty.");
1736 return;
1737 }
1738
1739 uint32 count = 0;
1740 barGoLink bar(result->GetRowCount());
1741
1742 do
1743 {
1744 bar.step();
1745
1746 Field *fields = result->Fetch();
1747 uint32 entry = fields[0].GetUInt32();
1748 if (!sAchievementStore.LookupEntry(entry))
1749 {
1750 sLog.outErrorDb( "Table `achievement_reward` has wrong achievement (Entry: %u), ignore", entry);
1751 continue;
1752 }
1753
1754 AchievementReward reward;
1755 reward.titleId[0] = fields[1].GetUInt32();
1756 reward.titleId[1] = fields[2].GetUInt32();
1757 reward.itemId = fields[3].GetUInt32();
1758 reward.sender = fields[4].GetUInt32();
1759 reward.subject = fields[5].GetCppString();
1760 reward.text = fields[6].GetCppString();
1761
1762 if ((reward.titleId[0]==0)!=(reward.titleId[1]==0))
1763 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]);
1764
1765 // must be title or mail at least
1766 if (!reward.titleId[0] && !reward.titleId[1] && !reward.sender)
1767 {
1768 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) not have title or item reward data, ignore.", entry);
1769 continue;
1770 }
1771
1772 if (reward.titleId[0])
1773 {
1774 CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(reward.titleId[0]);
1775 if (!titleEntry)
1776 {
1777 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) has invalid title id (%u) in `title_A`, set to 0", entry, reward.titleId[0]);
1778 reward.titleId[0] = 0;
1779 }
1780 }
1781
1782 if (reward.titleId[1])
1783 {
1784 CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(reward.titleId[1]);
1785 if (!titleEntry)
1786 {
1787 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) has invalid title id (%u) in `title_A`, set to 0", entry, reward.titleId[1]);
1788 reward.titleId[1] = 0;
1789 }
1790 }
1791
1792 //check mail data before item for report including wrong item case
1793 if (reward.sender)
1794 {
1795 if (!objmgr.GetCreatureTemplate(reward.sender))
1796 {
1797 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) has invalid creature entry %u as sender, mail reward skipped.", entry, reward.sender);
1798 reward.sender = 0;
1799 }
1800 }
1801 else
1802 {
1803 if (reward.itemId)
1804 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) not have sender data but have item reward, item will not rewarded", entry);
1805
1806 if (!reward.subject.empty())
1807 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) not have sender data but have mail subject.", entry);
1808
1809 if (!reward.text.empty())
1810 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) not have sender data but have mail text.", entry);
1811 }
1812
1813 if (reward.itemId)
1814 {
1815 if (!objmgr.GetItemPrototype(reward.itemId))
1816 {
1817 sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) has invalid item id %u, reward mail will be without item.", entry, reward.itemId);
1818 reward.itemId = 0;
1819 }
1820 }
1821
1822 m_achievementRewards[entry] = reward;
1823 ++count;
1824
1825 } while (result->NextRow());
1826
1827 delete result;
1828
1829 sLog.outString();
1830 sLog.outString( ">> Loaded %u achievement rewards", count );
1831 }
1832
1833 void AchievementGlobalMgr::LoadRewardLocales()
1834 {
1835 m_achievementRewardLocales.clear(); // need for reload case
1836
1837 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");
1838
1839 if(!result)
1840 {
1841 barGoLink bar(1);
1842
1843 bar.step();
1844
1845 sLog.outString();
1846 sLog.outString(">> Loaded 0 achievement reward locale strings. DB table `locales_achievement_reward` is empty.");
1847 return;
1848 }
1849
1850 barGoLink bar(result->GetRowCount());
1851
1852 do
1853 {
1854 Field *fields = result->Fetch();
1855 bar.step();
1856
1857 uint32 entry = fields[0].GetUInt32();
1858
1859 if(m_achievementRewards.find(entry)==m_achievementRewards.end())
1860 {
1861 sLog.outErrorDb( "Table `locales_achievement_reward` (Entry: %u) has locale strings for not existed achievement reward .", entry);
1862 continue;
1863 }
1864
1865 AchievementRewardLocale& data = m_achievementRewardLocales[entry];
1866
1867 for(int i = 1; i < MAX_LOCALE; ++i)
1868 {
1869 std::string str = fields[1+2*(i-1)].GetCppString();
1870 if(!str.empty())
1871 {
1872 int idx = objmgr.GetOrNewIndexForLocale(LocaleConstant(i));
1873 if(idx >= 0)
1874 {
1875 if(data.subject.size() <= size_t(idx))
1876 data.subject.resize(idx+1);
1877
1878 data.subject[idx] = str;
1879 }
1880 }
1881 str = fields[1+2*(i-1)+1].GetCppString();
1882 if(!str.empty())
1883 {
1884 int idx = objmgr.GetOrNewIndexForLocale(LocaleConstant(i));
1885 if(idx >= 0)
1886 {
1887 if(data.text.size() <= size_t(idx))
1888 data.text.resize(idx+1);
1889
1890 data.text[idx] = str;
1891 }
1892 }
1893 }
1894 } while (result->NextRow());
1895
1896 delete result;
1897
1898 sLog.outString();
1899 sLog.outString( ">> Loaded %lu achievement reward locale strings", (unsigned long)m_achievementRewardLocales.size() );
1900 }
MaNGOS is a free, Open Source implementation of a game server compatible with the original World of Warcraft client.