src/game/AchievementMgr.cpp

   1 /*
   2  * Copyright (C) 2005-2008 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 "Database/DBCEnums.h"
  24 #include "ObjectMgr.h"
  25 #include "Guild.h"
  26 #include "Database/DatabaseEnv.h"
  27 #include "GameEvent.h"
  28 #include "World.h"
  29 #include "SpellMgr.h"
  30
  31 const CriteriaCastSpellRequirement AchievementMgr::criteriaCastSpellRequirements[CRITERIA_CAST_SPELL_REQ_COUNT] =
  32     {
  33         {5272, 3057, 0, 0},
  34         {5273, 2784, 0, 0},
  35         {5752, 9099, 0, 0},
  36         {5753, 8403, 0, 0},
  37         {5772, 0, 0, RACE_GNOME},
  38         {5774, 0, 0, RACE_BLOODELF},
  39         {5775, 0, 0, RACE_DRAENEI},
  40         {5776, 0, 0, RACE_DWARF},
  41         {5777, 0, 0, RACE_HUMAN},
  42         {5778, 0, 0, RACE_NIGHTELF},
  43         {5779, 0, 0, RACE_ORC},
  44         {5780, 0, 0, RACE_TAUREN},
  45         {5781, 0, 0, RACE_TROLL},
  46         {5782, 0, 0, RACE_UNDEAD_PLAYER},
  47         {6225, 5661, 0, 0},
  48         {6226, 26044, 0, 0},
  49         {6228, 739, 0, 0},
  50         {6229, 927, 0, 0},
  51         {6230, 1444, 0, 0},
  52         {6231, 8140, 0, 0},
  53         {6232, 5489, 0, 0},
  54         {6233,12336, 0, 0},
  55         {6234, 1351, 0, 0},
  56         {6235, 5484, 0, 0},
  57         {6236, 1182, 0, 0},
  58         {6237, 0, CLASS_DEATH_KNIGHT, RACE_ORC},
  59         {6238, 0, CLASS_WARRIOR, RACE_HUMAN},
  60         {6239, 0, CLASS_SHAMAN, RACE_TAUREN},
  61         {6240, 0, CLASS_DRUID, RACE_NIGHTELF},
  62         {6241, 0, CLASS_ROGUE, RACE_UNDEAD_PLAYER},
  63         {6242, 0, CLASS_HUNTER, RACE_TROLL},
  64         {6243, 0, CLASS_MAGE, RACE_GNOME},
  65         {6244, 0, CLASS_PALADIN, RACE_DWARF},
  66         {6245, 0, CLASS_WARLOCK, RACE_BLOODELF},
  67         {6246, 0, CLASS_PRIEST, RACE_DRAENEI},
  68         {6312, 0, CLASS_WARLOCK, RACE_GNOME},
  69         {6313, 0, CLASS_DEATH_KNIGHT, RACE_HUMAN},
  70         {6314, 0, CLASS_PRIEST, RACE_NIGHTELF},
  71         {6315, 0, CLASS_SHAMAN, RACE_ORC},
  72         {6316, 0, CLASS_DRUID, RACE_TAUREN},
  73         {6317, 0, CLASS_ROGUE, RACE_TROLL},
  74         {6318, 0, CLASS_WARRIOR, RACE_UNDEAD_PLAYER},
  75         {6319, 0, CLASS_MAGE, RACE_BLOODELF},
  76         {6320, 0, CLASS_PALADIN, RACE_DRAENEI},
  77         {6321, 0, CLASS_HUNTER, RACE_DWARF},
  78         {6662, 31261, 0, 0}
  79         };
  80
  81 const AchievementReward AchievementMgr::achievementRewards[ACHIEVEMENT_REWARD_COUNT] =
  82     {
  83         // achievementId, horde titleid, alliance titleid, itemid
  84         {45, 0, 0, 43348},
  85         {46, 78, 78, 0},
  86         {230, 72, 72, 0},
  87         {456, 139, 139, 0},
  88         {614, 0, 0, 44223},
  89         {619, 0, 0, 44224},
  90         {714, 47, 47, 0},
  91         {762, 130, 130, 0},
  92         {870, 127, 126, 0},
  93         {871, 144, 144, 0},
  94         {876, 0, 0, 43349},
  95         {907, 48, 48, 0},
  96         {913, 74, 74, 0},
  97         {942, 79, 79, 0},
  98         {943, 79, 79, 0},
  99         {945, 131, 131, 0},
 100         {948, 130, 130, 0},
 101         {953, 132, 132, 0},
 102         {978, 81, 81, 0},
 103         {1015, 77, 77, 0},
 104         {1021, 0, 0, 40643},
 105         {1038, 75, 75, 0},
 106         {1039, 76, 76, 0},
 107         {1163, 128, 128, 0},
 108         {1174, 82, 82, 0},
 109         {1175, 72, 72, 0},
 110         {1250, 0, 0, 40653},
 111         {1400, 120, 120, 0},
 112         {1402, 122, 122, 0},
 113         {1516, 83, 83, 0},
 114         {1563, 84, 84, 0},
 115         {1656, 124, 124, 0},
 116         {1657, 124, 124, 0},
 117         {1658, 129, 129, 0},
 118         {1681, 125, 125, 43300},
 119         {1682, 125, 125, 43300},
 120         {1683, 133, 133, 0},
 121         {1684, 133, 133, 0},
 122         {1691, 134, 134, 0},
 123         {1692, 134, 134, 0},
 124         {1693, 135, 135, 0},
 125         {1707, 135, 135, 0},
 126         {1784, 84, 84, 0},
 127         {1793, 137, 137, 0},
 128         {1956, 0, 0, 43824},
 129         {2051, 140, 140, 0},
 130         {2054, 121, 121, 0},
 131         {2096, 0, 0, 44430},
 132         {2136, 0, 0, 0},// <- TODO: find item for spell 59961
 133         {2137, 0, 0, 0},// <- TODO: find item for spell 60021
 134         {2138, 0, 0, 0},// <- TODO: find item for spell 59976
 135         {2143, 0, 0, 44178},
 136         {2144, 0, 0, 0},// <- TODO: find item for spell 60024
 137         {2145, 0, 0, 0},// <- TODO: find item for spell 60024
 138         {2186, 141, 141, 0},
 139         {2187, 142, 142, 0},
 140         {2188, 143, 143, 0}
 141     };
 142
 143 AchievementMgr::AchievementMgr(Player *player)
 144 {
 145     m_player = player;
 146 }
 147
 148 AchievementMgr::~AchievementMgr()
 149 {
 150     for(CriteriaProgressMap::iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
 151         delete iter->second;
 152     m_criteriaProgress.clear();
 153 }
 154
 155 void AchievementMgr::SaveToDB()
 156 {
 157     if(!m_completedAchievements.empty())
 158     {
 159         CharacterDatabase.PExecute("DELETE FROM character_achievement WHERE guid = %u", GetPlayer()->GetGUIDLow());
 160
 161         std::ostringstream ss;
 162         ss << "INSERT INTO character_achievement (guid, achievement, date) VALUES ";
 163         for(CompletedAchievementMap::iterator iter = m_completedAchievements.begin(); iter!=m_completedAchievements.end(); iter++)
 164         {
 165             if(iter != m_completedAchievements.begin())
 166                 ss << ", ";
 167             ss << "("<<GetPlayer()->GetGUIDLow() << ", " << iter->first << ", " << iter->second << ")";
 168         }
 169         CharacterDatabase.Execute( ss.str().c_str() );
 170     }
 171
 172     if(!m_criteriaProgress.empty())
 173     {
 174         CharacterDatabase.PExecute("DELETE FROM character_achievement_progress WHERE guid = %u", GetPlayer()->GetGUIDLow());
 175
 176         std::ostringstream ss;
 177         ss << "INSERT INTO character_achievement_progress (guid, criteria, counter, date) VALUES ";
 178         for(CriteriaProgressMap::iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
 179         {
 180             if(iter != m_criteriaProgress.begin())
 181                 ss << ", ";
 182             ss << "(" << GetPlayer()->GetGUIDLow() << ", " << iter->first << ", " << iter->second->counter << ", " << iter->second->date << ")";
 183         }
 184         CharacterDatabase.Execute( ss.str().c_str() );
 185     }
 186 }
 187
 188 void AchievementMgr::LoadFromDB(QueryResult *achievementResult, QueryResult *criteriaResult)
 189 {
 190     if(achievementResult)
 191     {
 192         do
 193         {
 194             Field *fields = achievementResult->Fetch();
 195             m_completedAchievements[fields[0].GetUInt32()] = fields[1].GetUInt32();
 196         } while(achievementResult->NextRow());
 197         delete achievementResult;
 198     }
 199
 200     if(criteriaResult)
 201     {
 202         do
 203         {
 204             Field *fields = criteriaResult->Fetch();
 205             CriteriaProgress *progress = new CriteriaProgress(fields[0].GetUInt32(), fields[1].GetUInt32(), fields[2].GetUInt64());
 206
 207             AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(progress->id);
 208             if(!criteria ||
 209                     criteria->timeLimit && progress->date + criteria->timeLimit < time(NULL))
 210             {
 211                 delete progress;
 212                 continue;
 213             }
 214             m_criteriaProgress[progress->id] = progress;
 215         } while(criteriaResult->NextRow());
 216         delete criteriaResult;
 217     }
 218
 219 }
 220
 221 void AchievementMgr::SendAchievementEarned(AchievementEntry const* achievement)
 222 {
 223     sLog.outString("AchievementMgr::SendAchievementEarned(%u)", achievement->ID);
 224
 225     const char *msg = "|Hplayer:$N|h[$N]|h has earned the achievement $a!";
 226     if(Guild* guild = objmgr.GetGuildById(GetPlayer()->GetGuildId()))
 227     {
 228         WorldPacket data(SMSG_MESSAGECHAT, 200);
 229         data << uint8(CHAT_MSG_ACHIEVEMENT);
 230         data << uint8(CHAT_MSG_GUILD_ACHIEVEMENT);
 231         data << uint32(LANG_UNIVERSAL);
 232         data << uint64(GetPlayer()->GetGUID());
 233         data << uint32(5);
 234         data << uint64(GetPlayer()->GetGUID());
 235         data << uint32(strlen(msg)+1);
 236         data << msg;
 237         data << uint8(0);
 238         data << uint32(achievement->ID);
 239         guild->BroadcastPacket(&data);
 240     }
 241     if(achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_KILL|ACHIEVEMENT_FLAG_REALM_FIRST_REACH))
 242     {
 243         // broadcast realm first reached
 244         WorldPacket data(SMSG_SERVER_FIRST_ACHIEVEMENT, strlen(GetPlayer()->GetName())+1+8+4+4);
 245         data << GetPlayer()->GetName();
 246         data << uint64(GetPlayer()->GetGUID());
 247         data << uint32(achievement->ID);
 248         data << uint32(0);  // 1=link supplied string as player name, 0=display plain string
 249         sWorld.SendGlobalMessage(&data);
 250     }
 251     else
 252     {
 253         WorldPacket data(SMSG_MESSAGECHAT, 200);
 254         data << uint8(CHAT_MSG_ACHIEVEMENT);
 255         data << uint32(LANG_UNIVERSAL);
 256         data << uint64(GetPlayer()->GetGUID());
 257         data << uint32(5);
 258         data << uint64(GetPlayer()->GetGUID());
 259         data << uint32(strlen(msg)+1);
 260         data << msg;
 261         data << uint8(0);
 262         data << uint32(achievement->ID);
 263         GetPlayer()->SendMessageToSet(&data, true);
 264
 265     }
 266     WorldPacket data(SMSG_ACHIEVEMENT_EARNED, 8+4+8);
 267     data.append(GetPlayer()->GetPackGUID());
 268     data << uint32(achievement->ID);
 269     data << uint32(secsToTimeBitFields(time(NULL)));
 270     data << uint32(0);
 271     GetPlayer()->SendMessageToSet(&data, true);
 272 }
 273
 274 void AchievementMgr::SendCriteriaUpdate(CriteriaProgress *progress)
 275 {
 276     WorldPacket data(SMSG_CRITERIA_UPDATE, 8+4+8);
 277     data << uint32(progress->id);
 278
 279     // the counter is packed like a packed Guid
 280     data.appendPackGUID(progress->counter);
 281
 282     data.append(GetPlayer()->GetPackGUID());
 283     data << uint32(0);
 284     data << uint32(secsToTimeBitFields(progress->date));
 285     data << uint32(0);  // timer 1
 286     data << uint32(0);  // timer 2
 287     GetPlayer()->SendMessageToSet(&data, true);
 288 }
 289
 290 /**
 291  * called at player login. The player might have fulfilled some achievements when the achievement system wasn't working yet
 292  */
 293 void AchievementMgr::CheckAllAchievementCriteria()
 294 {
 295     // suppress sending packets
 296     for(uint32 i=0; i<ACHIEVEMENT_CRITERIA_TYPE_TOTAL; i++)
 297         UpdateAchievementCriteria(AchievementCriteriaTypes(i));
 298 }
 299
 300 /**
 301  * this function will be called whenever the user might have done a criteria relevant action
 302  */
 303 void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, uint32 miscvalue1, uint32 miscvalue2, Unit *unit, uint32 time)
 304 {
 305     sLog.outString("AchievementMgr::UpdateAchievementCriteria(%u, %u, %u, %u)", type, miscvalue1, miscvalue2, time);
 306     AchievementCriteriaEntryList const& achievementCriteriaList = objmgr.GetAchievementCriteriaByType(type);
 307     for(AchievementCriteriaEntryList::const_iterator i = achievementCriteriaList.begin(); i!=achievementCriteriaList.end(); ++i)
 308     {
 309         AchievementCriteriaEntry const *achievementCriteria = (*i);
 310
 311         // don't update already completed criteria
 312         if(IsCompletedCriteria(achievementCriteria))
 313             continue;
 314
 315         if(achievementCriteria->groupFlag & ACHIEVEMENT_CRITERIA_GROUP_NOT_IN_GROUP && GetPlayer()->GetGroup())
 316             continue;
 317
 318         AchievementEntry const *achievement = sAchievementStore.LookupEntry(achievementCriteria->referredAchievement);
 319         if(!achievement)
 320             continue;
 321
 322         if(achievement->factionFlag == ACHIEVEMENT_FACTION_FLAG_HORDE && GetPlayer()->GetTeam() != HORDE ||
 323             achievement->factionFlag == ACHIEVEMENT_FACTION_FLAG_ALLIANCE && GetPlayer()->GetTeam() != ALLIANCE)
 324             continue;
 325
 326         switch (type)
 327         {
 328             case ACHIEVEMENT_CRITERIA_TYPE_REACH_LEVEL:
 329                 SetCriteriaProgress(achievementCriteria, GetPlayer()->getLevel());
 330                 break;
 331             case ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT:
 332                 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetByteValue(PLAYER_BYTES_2, 2)+1);
 333                 break;
 334             case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
 335                 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
 336                 if(!miscvalue1)
 337                     continue;
 338                 if(achievementCriteria->kill_creature.creatureID != miscvalue1)
 339                     continue;
 340                 SetCriteriaProgress(achievementCriteria, miscvalue2, true);
 341                 break;
 342             case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL:
 343                 if(uint32 skillvalue = GetPlayer()->GetBaseSkillValue(achievementCriteria->reach_skill_level.skillID))
 344                     SetCriteriaProgress(achievementCriteria, skillvalue);
 345                 break;
 346             case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST_COUNT:
 347             {
 348                 uint32 counter =0;
 349                 for(QuestStatusMap::iterator itr = GetPlayer()->getQuestStatusMap().begin(); itr!=GetPlayer()->getQuestStatusMap().end(); itr++)
 350                     if(itr->second.m_rewarded)
 351                         counter++;
 352                 SetCriteriaProgress(achievementCriteria, counter);
 353                 break;
 354             }
 355             case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
 356             {
 357                 uint32 counter =0;
 358                 for(QuestStatusMap::iterator itr = GetPlayer()->getQuestStatusMap().begin(); itr!=GetPlayer()->getQuestStatusMap().end(); itr++)
 359                 {
 360                     Quest const* quest = objmgr.GetQuestTemplate(itr->first);
 361                     if(itr->second.m_rewarded && quest->GetZoneOrSort() == achievementCriteria->complete_quests_in_zone.zoneID)
 362                         counter++;
 363                 }
 364                 SetCriteriaProgress(achievementCriteria, counter);
 365                 break;
 366             }
 367             case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST:
 368                 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
 369                 if(!miscvalue1)
 370                     continue;
 371                 SetCriteriaProgress(achievementCriteria, miscvalue1, true);
 372                 break;
 373             case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND:
 374                 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
 375                 if(!miscvalue1)
 376                     continue;
 377                 if(GetPlayer()->GetMapId() != achievementCriteria->complete_battleground.mapID)
 378                     continue;
 379                 SetCriteriaProgress(achievementCriteria, miscvalue1, true);
 380                 break;
 381             case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL:
 382                 if(GetPlayer()->HasSpell(achievementCriteria->learn_spell.spellID))
 383                     SetCriteriaProgress(achievementCriteria, 1);
 384                 break;
 385             case ACHIEVEMENT_CRITERIA_TYPE_DEATH_AT_MAP:
 386                 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
 387                 if(!miscvalue1)
 388                     continue;
 389                 if(GetPlayer()->GetMapId() != achievementCriteria->death_at_map.mapID)
 390                     continue;
 391                 SetCriteriaProgress(achievementCriteria, 1, true);
 392                 break;
 393             case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE:
 394                 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
 395                 if(!miscvalue1)
 396                     continue;
 397                 if(miscvalue1 != achievementCriteria->killed_by_creature.creatureEntry)
 398                     continue;
 399                 SetCriteriaProgress(achievementCriteria, 1, true);
 400                 break;
 401             case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_PLAYER:
 402                 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
 403                 if(!miscvalue1)
 404                     continue;
 405                 SetCriteriaProgress(achievementCriteria, 1, true);
 406                 break;
 407             case ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING:
 408             {
 409                 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
 410                 if(!miscvalue1)
 411                     continue;
 412                 if(achievement->ID == 1260)
 413                 {
 414                     if(Player::GetDrunkenstateByValue(GetPlayer()->GetDrunkValue()) != DRUNKEN_SMASHED)
 415                         continue;
 416                     // TODO: hardcoding eventid is bad, it can differ from DB to DB - maye implement something using HolidayNames.dbc?
 417                     if(!gameeventmgr.IsActiveEvent(26))
 418                         continue;
 419                 }
 420                 // miscvalue1 is the ingame fallheight*100 as stored in dbc
 421                 SetCriteriaProgress(achievementCriteria, miscvalue1);
 422                 break;
 423             }
 424             case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
 425                 if(GetPlayer()->GetQuestRewardStatus(achievementCriteria->complete_quest.questID))
 426                     SetCriteriaProgress(achievementCriteria, 1);
 427                 break;
 428             case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:
 429                 // AchievementMgr::UpdateAchievementCriteria might also be called on login - skip in this case
 430                 if(!miscvalue1)
 431                     continue;
 432                 if(achievementCriteria->use_item.itemID != miscvalue1)
 433                     continue;
 434                 SetCriteriaProgress(achievementCriteria, 1, true);
 435                 break;
 436             case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM:
 437                 // speedup for non-login case
 438                 if(miscvalue1 && achievementCriteria->own_item.itemID!=miscvalue1)
 439                     continue;
 440                 SetCriteriaProgress(achievementCriteria, GetPlayer()->GetItemCount(achievementCriteria->own_item.itemID, true));
 441                 break;
 442             case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM:
 443                 // You _have_ to loot that item, just owning it when logging in does _not_ count!
 444                 if(!miscvalue1)
 445                     continue;
 446                 if(miscvalue1 != achievementCriteria->own_item.itemID)
 447                     continue;
 448                 SetCriteriaProgress(achievementCriteria, miscvalue2, true);
 449                 break;
 450             case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
 451             case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
 452                 if (!miscvalue1 || miscvalue1 != achievementCriteria->be_spell_target.spellID)
 453                     continue;
 454                 SetCriteriaProgress(achievementCriteria, 1, true);
 455                 break;
 456             case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
 457                 if (!miscvalue1 || miscvalue1 != achievementCriteria->cast_spell.spellID)
 458                     continue;
 459                 SetCriteriaProgress(achievementCriteria, 1, true);
 460                 break;
 461             case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
 462             {
 463                 if (!miscvalue1 || miscvalue1 != achievementCriteria->cast_spell.spellID)
 464                     continue;
 465                 // those requirements couldn't be found in the dbc
 466
 467                 const CriteriaCastSpellRequirement *requirement = NULL;
 468                 for (uint32 i=0; i<CRITERIA_CAST_SPELL_REQ_COUNT; i++)
 469                 {
 470                     if (criteriaCastSpellRequirements[i].achievementCriteriaId == achievementCriteria->ID)
 471                     {
 472                         requirement = &criteriaCastSpellRequirements[i];
 473                         break;
 474                     }
 475                 }
 476
 477                 if (requirement)
 478                 {
 479                     if (!unit)
 480                         continue;
 481
 482                     if (requirement->creatureEntry && unit->GetEntry() != requirement->creatureEntry)
 483                         continue;
 484
 485                     if (requirement->playerRace && (unit->GetTypeId() != TYPEID_PLAYER || unit->getRace()!=requirement->playerRace))
 486                         continue;
 487
 488                     if (requirement->playerClass && (unit->GetTypeId() != TYPEID_PLAYER || unit->getClass()!=requirement->playerClass))
 489                         continue;
 490                 }
 491                 SetCriteriaProgress(achievementCriteria, 1, true);
 492                 break;
 493             }
 494             case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
 495             {
 496                 uint32 spellCount = 0;
 497                 for (PlayerSpellMap::const_iterator spellIter = GetPlayer()->GetSpellMap().begin();
 498                         spellIter != GetPlayer()->GetSpellMap().end();
 499                         spellIter++)
 500                 {
 501                     for(SkillLineAbilityMap::const_iterator skillIter = spellmgr.GetBeginSkillLineAbilityMap(spellIter->first);
 502                             skillIter != spellmgr.GetEndSkillLineAbilityMap(spellIter->first);
 503                             skillIter++)
 504                     {
 505                         if(skillIter->second->skillId == achievementCriteria->learn_skilline_spell.skillLine)
 506                             spellCount++;
 507                     }
 508                 }
 509                 SetCriteriaProgress(achievementCriteria, spellCount);
 510                 break;
 511             }
 512             case ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP:
 513             {
 514                 // skip for login case
 515                 if(!miscvalue1)
 516                     continue;
 517                 SetCriteriaProgress(achievementCriteria, 1);
 518                 break;
 519             }
 520             case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
 521             {
 522                 int32 reputation = GetPlayer()->GetReputation(achievementCriteria->gain_reputation.factionID);
 523                 if (reputation > 0)
 524                     SetCriteriaProgress(achievementCriteria, reputation);
 525                 break;
 526             }
 527             case ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION:
 528             {
 529                 uint32 counter = 0;
 530                 const FactionStateList factionStateList = GetPlayer()->GetFactionStateList();
 531                 for (FactionStateList::const_iterator iter = factionStateList.begin(); iter!= factionStateList.end(); iter++)
 532                 {
 533                     if(GetPlayer()->ReputationToRank(iter->second.Standing) >= REP_EXALTED)
 534                         ++counter;
 535                 }
 536                 SetCriteriaProgress(achievementCriteria, counter);
 537                 break;
 538             }
 539             case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA:
 540             {
 541                 WorldMapOverlayEntry const* worldOverlayEntry = sWorldMapOverlayStore.LookupEntry(achievementCriteria->explore_area.areaReference);
 542                 if(!worldOverlayEntry)
 543                     break;
 544
 545                 int32 exploreFlag = GetAreaFlagByAreaID(worldOverlayEntry->areatableID);
 546                 if(exploreFlag < 0)
 547                     break;
 548
 549                 uint32 playerIndexOffset = uint32(exploreFlag) / 32;
 550                 uint32 mask = 1<< (uint32(exploreFlag) % 32);
 551
 552                 if(GetPlayer()->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + playerIndexOffset) & mask)
 553                     SetCriteriaProgress(achievementCriteria, 1);
 554                 break;
 555             }
 556
 557         }
 558         if(IsCompletedCriteria(achievementCriteria))
 559             CompletedCriteria(achievementCriteria);
 560     }
 561 }
 562
 563 bool AchievementMgr::IsCompletedCriteria(AchievementCriteriaEntry const* achievementCriteria)
 564 {
 565     AchievementEntry const* achievement = sAchievementStore.LookupEntry(achievementCriteria->referredAchievement);
 566     if(!achievement)
 567         return false;
 568
 569     // counter can never complete
 570     if(achievement->flags & ACHIEVEMENT_FLAG_COUNTER)
 571         return false;
 572
 573     if(achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_REACH | ACHIEVEMENT_FLAG_REALM_FIRST_KILL))
 574     {
 575         // someone on this realm has already completed that achievement
 576         if(objmgr.allCompletedAchievements.find(achievement->ID)!=objmgr.allCompletedAchievements.end())
 577             return false;
 578     }
 579
 580     CriteriaProgressMap::iterator itr = m_criteriaProgress.find(achievementCriteria->ID);
 581     if(itr == m_criteriaProgress.end())
 582         return false;
 583
 584     CriteriaProgress *progress = itr->second;
 585
 586     switch(achievementCriteria->requiredType)
 587     {
 588         case ACHIEVEMENT_CRITERIA_TYPE_REACH_LEVEL:
 589             if(achievement->ID == 467 && GetPlayer()->getClass() != CLASS_SHAMAN ||
 590                     achievement->ID == 466 && GetPlayer()->getClass() != CLASS_DRUID ||
 591                     achievement->ID == 465 && GetPlayer()->getClass() != CLASS_PALADIN ||
 592                     achievement->ID == 464 && GetPlayer()->getClass() != CLASS_PRIEST ||
 593                     achievement->ID == 463 && GetPlayer()->getClass() != CLASS_WARLOCK ||
 594                     achievement->ID == 462 && GetPlayer()->getClass() != CLASS_HUNTER ||
 595                     achievement->ID == 461 && GetPlayer()->getClass() != CLASS_DEATH_KNIGHT ||
 596                     achievement->ID == 460 && GetPlayer()->getClass() != CLASS_MAGE ||
 597                     achievement->ID == 459 && GetPlayer()->getClass() != CLASS_WARRIOR ||
 598                     achievement->ID == 458 && GetPlayer()->getClass() != CLASS_ROGUE ||
 599
 600                     achievement->ID == 1404 && GetPlayer()->getRace() != RACE_GNOME ||
 601                     achievement->ID == 1405 && GetPlayer()->getRace() != RACE_BLOODELF ||
 602                     achievement->ID == 1406 && GetPlayer()->getRace() != RACE_DRAENEI ||
 603                     achievement->ID == 1407 && GetPlayer()->getRace() != RACE_DWARF ||
 604                     achievement->ID == 1408 && GetPlayer()->getRace() != RACE_HUMAN ||
 605                     achievement->ID == 1409 && GetPlayer()->getRace() != RACE_NIGHTELF ||
 606                     achievement->ID == 1410 && GetPlayer()->getRace() != RACE_ORC ||
 607                     achievement->ID == 1411 && GetPlayer()->getRace() != RACE_TAUREN ||
 608                     achievement->ID == 1412 && GetPlayer()->getRace() != RACE_TROLL ||
 609                     achievement->ID == 1413 && GetPlayer()->getRace() != RACE_UNDEAD_PLAYER )
 610                 return false;
 611             return progress->counter >= achievementCriteria->reach_level.level;
 612         case ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT:
 613             return progress->counter >= achievementCriteria->buy_bank_slot.numberOfSlots;
 614         case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
 615             return progress->counter >= achievementCriteria->kill_creature.creatureCount;
 616         case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT:
 617             return m_completedAchievements.find(achievementCriteria->complete_achievement.linkedAchievement) != m_completedAchievements.end();
 618         case ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL:
 619             return progress->counter >= achievementCriteria->reach_skill_level.skillLevel;
 620         case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
 621             return progress->counter >= achievementCriteria->complete_quests_in_zone.questCount;
 622         case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST:
 623             return progress->counter >= achievementCriteria->complete_daily_quest.questCount;
 624         case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL:
 625             return progress->counter >= 1;
 626         case ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING:
 627             return progress->counter >= achievementCriteria->fall_without_dying.fallHeight;
 628         case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:
 629             return progress->counter >= 1;
 630         case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:
 631             return progress->counter >= achievementCriteria->use_item.itemCount;
 632         case ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM:
 633             return progress->counter >= achievementCriteria->own_item.itemCount;
 634         case ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM:
 635             return progress->counter >= achievementCriteria->loot_item.itemCount;
 636         case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
 637         case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
 638             return progress->counter >= achievementCriteria->be_spell_target.spellCount;
 639         case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
 640         case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
 641             return progress->counter >= achievementCriteria->cast_spell.castCount;
 642         case ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
 643             return progress->counter >= achievementCriteria->learn_skilline_spell.spellCount;
 644         case ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP:
 645             return progress->counter >= achievementCriteria->visit_barber.numberOfVisits;
 646         case ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION:
 647             return progress->counter >= achievementCriteria->gain_reputation.reputationAmount;
 648         case ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION:
 649             return progress->counter >= achievementCriteria->gain_exalted_reputation.numberOfExaltedFactions;
 650         case ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA:
 651             return progress->counter >= 1;
 652
 653         // handle all statistic-only criteria here
 654         case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND:
 655         case ACHIEVEMENT_CRITERIA_TYPE_DEATH_AT_MAP:
 656         case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE:
 657         case ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_PLAYER:
 658             return false;
 659     }
 660     return false;
 661 }
 662
 663 void AchievementMgr::CompletedCriteria(AchievementCriteriaEntry const* criteria)
 664 {
 665     AchievementEntry const* achievement = sAchievementStore.LookupEntry(criteria->referredAchievement);
 666     if(!achievement)
 667         return;
 668     // counter can never complete
 669     if(achievement->flags & ACHIEVEMENT_FLAG_COUNTER)
 670         return;
 671
 672     if(criteria->completionFlag & ACHIEVEMENT_CRITERIA_COMPLETE_FLAG_ALL || GetAchievementCompletionState(achievement)==ACHIEVEMENT_COMPLETED_COMPLETED_NOT_STORED)
 673     {
 674         CompletedAchievement(achievement);
 675     }
 676 }
 677
 678 // TODO: achievement 705 requires 4 criteria to be fulfilled
 679 AchievementCompletionState AchievementMgr::GetAchievementCompletionState(AchievementEntry const* entry)
 680 {
 681     if(m_completedAchievements.find(entry->ID)!=m_completedAchievements.end())
 682         return ACHIEVEMENT_COMPLETED_COMPLETED_STORED;
 683
 684     bool foundOutstanding = false;
 685     for (uint32 entryId = 0; entryId<sAchievementCriteriaStore.GetNumRows(); entryId++)
 686     {
 687          AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(entryId);
 688          if(!criteria || criteria->referredAchievement!= entry->ID)
 689              continue;
 690
 691          if(IsCompletedCriteria(criteria) && criteria->completionFlag & ACHIEVEMENT_CRITERIA_COMPLETE_FLAG_ALL)
 692              return ACHIEVEMENT_COMPLETED_COMPLETED_NOT_STORED;
 693
 694          // found an umcompleted criteria, but DONT return false yet - there might be a completed criteria with ACHIEVEMENT_CRITERIA_COMPLETE_FLAG_ALL
 695          if(!IsCompletedCriteria(criteria))
 696              foundOutstanding = true;
 697     }
 698     if(foundOutstanding)
 699         return ACHIEVEMENT_COMPLETED_NONE;
 700     else
 701         return ACHIEVEMENT_COMPLETED_COMPLETED_NOT_STORED;
 702 }
 703
 704 void AchievementMgr::SetCriteriaProgress(AchievementCriteriaEntry const* entry, uint32 newValue, bool relative)
 705 {
 706     sLog.outString("AchievementMgr::SetCriteriaProgress(%u, %u)", entry->ID, newValue);
 707     CriteriaProgress *progress = NULL;
 708
 709     if(m_criteriaProgress.find(entry->ID) == m_criteriaProgress.end())
 710     {
 711         progress = new CriteriaProgress(entry->ID, newValue);
 712         m_criteriaProgress[entry->ID]=progress;
 713     }
 714     else
 715     {
 716         progress = m_criteriaProgress[entry->ID];
 717         if(relative)
 718             newValue += progress->counter;
 719         if(progress->counter == newValue)
 720             return;
 721         progress->counter = newValue;
 722     }
 723     if(entry->timeLimit)
 724     {
 725         time_t now = time(NULL);
 726         if(progress->date + entry->timeLimit < now)
 727         {
 728             progress->counter = 1;
 729         }
 730         // also it seems illogical, the timeframe will be extended at every criteria update
 731         progress->date = now;
 732     }
 733     SendCriteriaUpdate(progress);
 734 }
 735
 736 void AchievementMgr::CompletedAchievement(AchievementEntry const* achievement)
 737 {
 738     sLog.outString("AchievementMgr::CompletedAchievement(%u)", achievement->ID);
 739     if(achievement->flags & ACHIEVEMENT_FLAG_COUNTER || m_completedAchievements.find(achievement->ID)!=m_completedAchievements.end())
 740         return;
 741
 742     SendAchievementEarned(achievement);
 743     m_completedAchievements[achievement->ID] = time(NULL);
 744
 745     // don't insert for ACHIEVEMENT_FLAG_REALM_FIRST_KILL since otherwise only the first group member would reach that achievement
 746     // TODO: where do set this instead?
 747     if(!(achievement->flags & ACHIEVEMENT_FLAG_REALM_FIRST_KILL))
 748         objmgr.allCompletedAchievements.insert(achievement->ID);
 749
 750     UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT);
 751
 752     // reward items and titles
 753     AchievementReward const* reward = NULL;
 754     for (uint32 i=0; i<ACHIEVEMENT_REWARD_COUNT; i++)
 755     {
 756         if (achievementRewards[i].achievementId == achievement->ID)
 757         {
 758             reward = &achievementRewards[i];
 759             break;
 760         }
 761     }
 762
 763     if (reward)
 764     {
 765         sLog.outString("achiev %u, title= %u, %u", reward->achievementId, reward->titleId[0], reward->titleId[1]);
 766         uint32 titleId = reward->titleId[GetPlayer()->GetTeam() == HORDE?0:1];
 767         if(CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(titleId))
 768             GetPlayer()->SetTitle(titleEntry);
 769
 770         if (reward->itemId)
 771         {
 772             ItemPrototype const *pProto = objmgr.GetItemPrototype( reward->itemId );
 773
 774             if(!pProto)
 775             {
 776                 GetPlayer()->SendEquipError( EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
 777                 return;
 778             }
 779
 780             ItemPosCountVec dest;
 781             uint32 no_space = 0;
 782             uint8 msg = GetPlayer()->CanStoreNewItem( NULL_BAG, NULL_SLOT, dest, reward->itemId, 1, &no_space );
 783
 784             if( msg != EQUIP_ERR_OK )
 785             {
 786                 GetPlayer()->SendEquipError( msg, NULL, NULL );
 787                 return;
 788             }
 789             Item* pItem = GetPlayer()->StoreNewItem( dest, reward->itemId, true);
 790
 791             if(!pItem)
 792             {
 793                 GetPlayer()->SendEquipError( EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
 794                 return;
 795             }
 796         }
 797     }
 798 }
 799
 800 void AchievementMgr::SendAllAchievementData()
 801 {
 802     // since we don't know the exact size of the packed GUIDs this is just an approximation
 803     WorldPacket data(SMSG_ALL_ACHIEVEMENT_DATA, 4*2+m_completedAchievements.size()*4*2+m_completedAchievements.size()*7*4);
 804     BuildAllDataPacket(&data);
 805     GetPlayer()->GetSession()->SendPacket(&data);
 806 }
 807
 808 void AchievementMgr::SendRespondInspectAchievements(Player* player)
 809 {
 810     // since we don't know the exact size of the packed GUIDs this is just an approximation
 811     WorldPacket data(SMSG_RESPOND_INSPECT_ACHIEVEMENTS, 4+4*2+m_completedAchievements.size()*4*2+m_completedAchievements.size()*7*4);
 812     data.append(GetPlayer()->GetPackGUID());
 813     BuildAllDataPacket(&data);
 814     player->GetSession()->SendPacket(&data);
 815 }
 816
 817 /**
 818  * used by both SMSG_ALL_ACHIEVEMENT_DATA  and SMSG_RESPOND_INSPECT_ACHIEVEMENT
 819  */
 820 void AchievementMgr::BuildAllDataPacket(WorldPacket *data)
 821 {
 822     for(CompletedAchievementMap::iterator iter = m_completedAchievements.begin(); iter!=m_completedAchievements.end(); ++iter)
 823     {
 824         *data << uint32(iter->first);
 825         *data << uint32(secsToTimeBitFields(iter->second));
 826     }
 827     *data << int32(-1);
 828
 829     for(CriteriaProgressMap::iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
 830     {
 831         *data << uint32(iter->second->id);
 832         data->appendPackGUID(iter->second->counter);
 833         data->append(GetPlayer()->GetPackGUID());
 834         *data << uint32(0);
 835         *data << uint32(secsToTimeBitFields(iter->second->date));
 836         *data << uint32(0);
 837         *data << uint32(0);
 838     }
 839
 840     *data << int32(-1);
 841 }