src/game/ObjectMgr.cpp

   1 /*
   2  * Copyright (C) 2005-2010 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 "Common.h"
  20 #include "Database/DatabaseEnv.h"
  21 #include "Database/SQLStorage.h"
  22 #include "Database/SQLStorageImpl.h"
  23 #include "Policies/SingletonImp.h"
  24
  25 #include "Log.h"
  26 #include "MapManager.h"
  27 #include "ObjectMgr.h"
  28 #include "ObjectDefines.h"
  29 #include "SpellMgr.h"
  30 #include "UpdateMask.h"
  31 #include "World.h"
  32 #include "Group.h"
  33 #include "Guild.h"
  34 #include "ArenaTeam.h"
  35 #include "Transports.h"
  36 #include "ProgressBar.h"
  37 #include "Language.h"
  38 #include "GameEventMgr.h"
  39 #include "Spell.h"
  40 #include "Chat.h"
  41 #include "AccountMgr.h"
  42 #include "InstanceSaveMgr.h"
  43 #include "SpellAuras.h"
  44 #include "Util.h"
  45 #include "WaypointManager.h"
  46 #include "GossipDef.h"
  47
  48 INSTANTIATE_SINGLETON_1(ObjectMgr);
  49
  50 ScriptMapMap sQuestEndScripts;
  51 ScriptMapMap sQuestStartScripts;
  52 ScriptMapMap sSpellScripts;
  53 ScriptMapMap sGameObjectScripts;
  54 ScriptMapMap sEventScripts;
  55 ScriptMapMap sGossipScripts;
  56
  57 bool normalizePlayerName(std::string& name)
  58 {
  59     if(name.empty())
  60         return false;
  61
  62     wchar_t wstr_buf[MAX_INTERNAL_PLAYER_NAME+1];
  63     size_t wstr_len = MAX_INTERNAL_PLAYER_NAME;
  64
  65     if(!Utf8toWStr(name,&wstr_buf[0],wstr_len))
  66         return false;
  67
  68     wstr_buf[0] = wcharToUpper(wstr_buf[0]);
  69     for(size_t i = 1; i < wstr_len; ++i)
  70         wstr_buf[i] = wcharToLower(wstr_buf[i]);
  71
  72     if(!WStrToUtf8(wstr_buf,wstr_len,name))
  73         return false;
  74
  75     return true;
  76 }
  77
  78 LanguageDesc lang_description[LANGUAGES_COUNT] =
  79 {
  80     { LANG_ADDON,           0, 0                       },
  81     { LANG_UNIVERSAL,       0, 0                       },
  82     { LANG_ORCISH,        669, SKILL_LANG_ORCISH       },
  83     { LANG_DARNASSIAN,    671, SKILL_LANG_DARNASSIAN   },
  84     { LANG_TAURAHE,       670, SKILL_LANG_TAURAHE      },
  85     { LANG_DWARVISH,      672, SKILL_LANG_DWARVEN      },
  86     { LANG_COMMON,        668, SKILL_LANG_COMMON       },
  87     { LANG_DEMONIC,       815, SKILL_LANG_DEMON_TONGUE },
  88     { LANG_TITAN,         816, SKILL_LANG_TITAN        },
  89     { LANG_THALASSIAN,    813, SKILL_LANG_THALASSIAN   },
  90     { LANG_DRACONIC,      814, SKILL_LANG_DRACONIC     },
  91     { LANG_KALIMAG,       817, SKILL_LANG_OLD_TONGUE   },
  92     { LANG_GNOMISH,      7340, SKILL_LANG_GNOMISH      },
  93     { LANG_TROLL,        7341, SKILL_LANG_TROLL        },
  94     { LANG_GUTTERSPEAK, 17737, SKILL_LANG_GUTTERSPEAK  },
  95     { LANG_DRAENEI,     29932, SKILL_LANG_DRAENEI      },
  96     { LANG_ZOMBIE,          0, 0                       },
  97     { LANG_GNOMISH_BINARY,  0, 0                       },
  98     { LANG_GOBLIN_BINARY,   0, 0                       }
  99 };
 100
 101 LanguageDesc const* GetLanguageDescByID(uint32 lang)
 102 {
 103     for(int i = 0; i < LANGUAGES_COUNT; ++i)
 104     {
 105         if(uint32(lang_description[i].lang_id) == lang)
 106             return &lang_description[i];
 107     }
 108
 109     return NULL;
 110 }
 111
 112 bool SpellClickInfo::IsFitToRequirements(Player const* player) const
 113 {
 114     if(questStart)
 115     {
 116         // not in expected required quest state
 117         if (!player || ((!questStartCanActive || !player->IsActiveQuest(questStart)) && !player->GetQuestRewardStatus(questStart)))
 118             return false;
 119     }
 120
 121     if(questEnd)
 122     {
 123         // not in expected forbidden quest state
 124         if(!player || player->GetQuestRewardStatus(questEnd))
 125             return false;
 126     }
 127
 128     return true;
 129 }
 130
 131 ObjectMgr::ObjectMgr()
 132 {
 133     m_hiCharGuid        = 1;
 134     m_hiCreatureGuid    = 1;
 135     m_hiItemGuid        = 1;
 136     m_hiGoGuid          = 1;
 137     m_hiCorpseGuid      = 1;
 138     m_hiPetNumber       = 1;
 139     m_ItemTextId        = 1;
 140     m_mailid            = 1;
 141     m_equipmentSetGuid  = 1;
 142     m_guildId           = 1;
 143     m_arenaTeamId       = 1;
 144     m_auctionid         = 1;
 145
 146     // Only zero condition left, others will be added while loading DB tables
 147     mConditions.resize(1);
 148 }
 149
 150 ObjectMgr::~ObjectMgr()
 151 {
 152     for( QuestMap::iterator i = mQuestTemplates.begin( ); i != mQuestTemplates.end( ); ++i )
 153         delete i->second;
 154
 155     for(PetLevelInfoMap::iterator i = petInfo.begin( ); i != petInfo.end( ); ++i )
 156         delete[] i->second;
 157
 158     // free only if loaded
 159     for (int class_ = 0; class_ < MAX_CLASSES; ++class_)
 160         delete[] playerClassInfo[class_].levelInfo;
 161
 162     for (int race = 0; race < MAX_RACES; ++race)
 163         for (int class_ = 0; class_ < MAX_CLASSES; ++class_)
 164             delete[] playerInfo[race][class_].levelInfo;
 165
 166     // free group and guild objects
 167     for (GroupSet::iterator itr = mGroupSet.begin(); itr != mGroupSet.end(); ++itr)
 168         delete (*itr);
 169
 170     for (GuildMap::iterator itr = mGuildMap.begin(); itr != mGuildMap.end(); ++itr)
 171         delete itr->second;
 172
 173     for (ArenaTeamMap::iterator itr = mArenaTeamMap.begin(); itr != mArenaTeamMap.end(); ++itr)
 174         delete itr->second;
 175
 176     for (CacheVendorItemMap::iterator itr = m_mCacheVendorItemMap.begin(); itr != m_mCacheVendorItemMap.end(); ++itr)
 177         itr->second.Clear();
 178
 179     for (CacheTrainerSpellMap::iterator itr = m_mCacheTrainerSpellMap.begin(); itr != m_mCacheTrainerSpellMap.end(); ++itr)
 180         itr->second.Clear();
 181 }
 182
 183 Group * ObjectMgr::GetGroupByLeader(const uint64 &guid) const
 184 {
 185     for(GroupSet::const_iterator itr = mGroupSet.begin(); itr != mGroupSet.end(); ++itr)
 186         if ((*itr)->GetLeaderGUID() == guid)
 187             return *itr;
 188
 189     return NULL;
 190 }
 191
 192 Guild * ObjectMgr::GetGuildById(uint32 GuildId) const
 193 {
 194     GuildMap::const_iterator itr = mGuildMap.find(GuildId);
 195     if (itr != mGuildMap.end())
 196         return itr->second;
 197
 198     return NULL;
 199 }
 200
 201 Guild * ObjectMgr::GetGuildByName(const std::string& guildname) const
 202 {
 203     for(GuildMap::const_iterator itr = mGuildMap.begin(); itr != mGuildMap.end(); ++itr)
 204         if (itr->second->GetName() == guildname)
 205             return itr->second;
 206
 207     return NULL;
 208 }
 209
 210 std::string ObjectMgr::GetGuildNameById(uint32 GuildId) const
 211 {
 212     GuildMap::const_iterator itr = mGuildMap.find(GuildId);
 213     if (itr != mGuildMap.end())
 214         return itr->second->GetName();
 215
 216     return "";
 217 }
 218
 219 Guild* ObjectMgr::GetGuildByLeader(const uint64 &guid) const
 220 {
 221     for(GuildMap::const_iterator itr = mGuildMap.begin(); itr != mGuildMap.end(); ++itr)
 222         if (itr->second->GetLeader() == guid)
 223             return itr->second;
 224
 225     return NULL;
 226 }
 227
 228 void ObjectMgr::AddGuild(Guild* guild)
 229 {
 230     mGuildMap[guild->GetId()] = guild;
 231 }
 232
 233 void ObjectMgr::RemoveGuild(uint32 Id)
 234 {
 235     mGuildMap.erase(Id);
 236 }
 237
 238 ArenaTeam* ObjectMgr::GetArenaTeamById(uint32 arenateamid) const
 239 {
 240     ArenaTeamMap::const_iterator itr = mArenaTeamMap.find(arenateamid);
 241     if (itr != mArenaTeamMap.end())
 242         return itr->second;
 243
 244     return NULL;
 245 }
 246
 247 ArenaTeam* ObjectMgr::GetArenaTeamByName(const std::string& arenateamname) const
 248 {
 249     for(ArenaTeamMap::const_iterator itr = mArenaTeamMap.begin(); itr != mArenaTeamMap.end(); ++itr)
 250         if (itr->second->GetName() == arenateamname)
 251             return itr->second;
 252
 253     return NULL;
 254 }
 255
 256 ArenaTeam* ObjectMgr::GetArenaTeamByCaptain(uint64 const& guid) const
 257 {
 258     for(ArenaTeamMap::const_iterator itr = mArenaTeamMap.begin(); itr != mArenaTeamMap.end(); ++itr)
 259         if (itr->second->GetCaptain() == guid)
 260             return itr->second;
 261
 262     return NULL;
 263 }
 264
 265 void ObjectMgr::AddArenaTeam(ArenaTeam* arenaTeam)
 266 {
 267     mArenaTeamMap[arenaTeam->GetId()] = arenaTeam;
 268 }
 269
 270 void ObjectMgr::RemoveArenaTeam(uint32 Id)
 271 {
 272     mArenaTeamMap.erase(Id);
 273 }
 274
 275 CreatureInfo const* ObjectMgr::GetCreatureTemplate(uint32 id)
 276 {
 277     return sCreatureStorage.LookupEntry<CreatureInfo>(id);
 278 }
 279
 280 void ObjectMgr::LoadCreatureLocales()
 281 {
 282     mCreatureLocaleMap.clear();                              // need for reload case
 283
 284     QueryResult *result = WorldDatabase.Query("SELECT entry,name_loc1,subname_loc1,name_loc2,subname_loc2,name_loc3,subname_loc3,name_loc4,subname_loc4,name_loc5,subname_loc5,name_loc6,subname_loc6,name_loc7,subname_loc7,name_loc8,subname_loc8 FROM locales_creature");
 285
 286     if(!result)
 287     {
 288         barGoLink bar(1);
 289
 290         bar.step();
 291
 292         sLog.outString();
 293         sLog.outString(">> Loaded 0 creature locale strings. DB table `locales_creature` is empty.");
 294         return;
 295     }
 296
 297     barGoLink bar(result->GetRowCount());
 298
 299     do
 300     {
 301         Field *fields = result->Fetch();
 302         bar.step();
 303
 304         uint32 entry = fields[0].GetUInt32();
 305
 306         CreatureLocale& data = mCreatureLocaleMap[entry];
 307
 308         for(int i = 1; i < MAX_LOCALE; ++i)
 309         {
 310             std::string str = fields[1+2*(i-1)].GetCppString();
 311             if(!str.empty())
 312             {
 313                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
 314                 if(idx >= 0)
 315                 {
 316                     if(data.Name.size() <= idx)
 317                         data.Name.resize(idx+1);
 318
 319                     data.Name[idx] = str;
 320                 }
 321             }
 322             str = fields[1+2*(i-1)+1].GetCppString();
 323             if(!str.empty())
 324             {
 325                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
 326                 if(idx >= 0)
 327                 {
 328                     if(data.SubName.size() <= idx)
 329                         data.SubName.resize(idx+1);
 330
 331                     data.SubName[idx] = str;
 332                 }
 333             }
 334         }
 335     } while (result->NextRow());
 336
 337     delete result;
 338
 339     sLog.outString();
 340     sLog.outString( ">> Loaded %lu creature locale strings", (unsigned long)mCreatureLocaleMap.size() );
 341 }
 342
 343 void ObjectMgr::LoadGossipMenuItemsLocales()
 344 {
 345     mGossipMenuItemsLocaleMap.clear();                      // need for reload case
 346
 347     QueryResult *result = WorldDatabase.Query("SELECT menu_id,id,"
 348         "option_text_loc1,box_text_loc1,option_text_loc2,box_text_loc2,"
 349         "option_text_loc3,box_text_loc3,option_text_loc4,box_text_loc4,"
 350         "option_text_loc5,box_text_loc5,option_text_loc6,box_text_loc6,"
 351         "option_text_loc7,box_text_loc7,option_text_loc8,box_text_loc8 "
 352         "FROM locales_gossip_menu_option");
 353
 354     if(!result)
 355     {
 356         barGoLink bar(1);
 357
 358         bar.step();
 359
 360         sLog.outString();
 361         sLog.outString(">> Loaded 0 gossip_menu_option locale strings. DB table `locales_gossip_menu_option` is empty.");
 362         return;
 363     }
 364
 365     barGoLink bar(result->GetRowCount());
 366
 367     do
 368     {
 369         Field *fields = result->Fetch();
 370         bar.step();
 371
 372         uint16 menuId   = fields[0].GetUInt16();
 373         uint16 id       = fields[1].GetUInt16();
 374
 375         GossipMenuItemsLocale& data = mGossipMenuItemsLocaleMap[MAKE_PAIR32(menuId,id)];
 376
 377         for(int i = 1; i < MAX_LOCALE; ++i)
 378         {
 379             std::string str = fields[2+2*(i-1)].GetCppString();
 380             if(!str.empty())
 381             {
 382                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
 383                 if(idx >= 0)
 384                 {
 385                     if(data.OptionText.size() <= idx)
 386                         data.OptionText.resize(idx+1);
 387
 388                     data.OptionText[idx] = str;
 389                 }
 390             }
 391             str = fields[2+2*(i-1)+1].GetCppString();
 392             if(!str.empty())
 393             {
 394                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
 395                 if(idx >= 0)
 396                 {
 397                     if(data.BoxText.size() <= idx)
 398                         data.BoxText.resize(idx+1);
 399
 400                     data.BoxText[idx] = str;
 401                 }
 402             }
 403         }
 404     } while (result->NextRow());
 405
 406     delete result;
 407
 408     sLog.outString();
 409     sLog.outString( ">> Loaded %lu gossip_menu_option locale strings", (unsigned long)mGossipMenuItemsLocaleMap.size() );
 410 }
 411
 412 void ObjectMgr::LoadPointOfInterestLocales()
 413 {
 414     mPointOfInterestLocaleMap.clear();                              // need for reload case
 415
 416     QueryResult *result = WorldDatabase.Query("SELECT entry,icon_name_loc1,icon_name_loc2,icon_name_loc3,icon_name_loc4,icon_name_loc5,icon_name_loc6,icon_name_loc7,icon_name_loc8 FROM locales_points_of_interest");
 417
 418     if(!result)
 419     {
 420         barGoLink bar(1);
 421
 422         bar.step();
 423
 424         sLog.outString();
 425         sLog.outString(">> Loaded 0 points_of_interest locale strings. DB table `locales_points_of_interest` is empty.");
 426         return;
 427     }
 428
 429     barGoLink bar(result->GetRowCount());
 430
 431     do
 432     {
 433         Field *fields = result->Fetch();
 434         bar.step();
 435
 436         uint32 entry = fields[0].GetUInt32();
 437
 438         PointOfInterestLocale& data = mPointOfInterestLocaleMap[entry];
 439
 440         for(int i = 1; i < MAX_LOCALE; ++i)
 441         {
 442             std::string str = fields[i].GetCppString();
 443             if(str.empty())
 444                 continue;
 445
 446             int idx = GetOrNewIndexForLocale(LocaleConstant(i));
 447             if(idx >= 0)
 448             {
 449                 if(data.IconName.size() <= idx)
 450                     data.IconName.resize(idx+1);
 451
 452                 data.IconName[idx] = str;
 453             }
 454         }
 455     } while (result->NextRow());
 456
 457     delete result;
 458
 459     sLog.outString();
 460     sLog.outString( ">> Loaded %lu points_of_interest locale strings", (unsigned long)mPointOfInterestLocaleMap.size() );
 461 }
 462
 463 struct SQLCreatureLoader : public SQLStorageLoaderBase<SQLCreatureLoader>
 464 {
 465     template<class D>
 466     void convert_from_str(uint32 /*field_pos*/, char *src, D &dst)
 467     {
 468         dst = D(sObjectMgr.GetScriptId(src));
 469     }
 470 };
 471
 472 void ObjectMgr::LoadCreatureTemplates()
 473 {
 474     SQLCreatureLoader loader;
 475     loader.Load(sCreatureStorage);
 476
 477     sLog.outString( ">> Loaded %u creature definitions", sCreatureStorage.RecordCount );
 478     sLog.outString();
 479
 480     std::set<uint32> difficultyEntries[MAX_DIFFICULTY - 1]; // already loaded difficulty 1 value in creatures
 481     std::set<uint32> hasDifficultyEntries[MAX_DIFFICULTY - 1]; // already loaded creatures with difficulty 1  values
 482
 483     // check data correctness
 484     for(uint32 i = 1; i < sCreatureStorage.MaxEntry; ++i)
 485     {
 486         CreatureInfo const* cInfo = sCreatureStorage.LookupEntry<CreatureInfo>(i);
 487         if (!cInfo)
 488             continue;
 489
 490         bool ok = true;                                     // bool to allow continue outside this loop
 491         for (uint32 diff = 0; diff < MAX_DIFFICULTY - 1 && ok; ++diff)
 492         {
 493             if (!cInfo->DifficultyEntry[diff])
 494                 continue;
 495             ok = false;                                     // will be set to true at the end of this loop again
 496
 497             CreatureInfo const* difficultyInfo = GetCreatureTemplate(cInfo->DifficultyEntry[diff]);
 498             if (!difficultyInfo)
 499             {
 500                 sLog.outErrorDb("Creature (Entry: %u) have `difficulty_entry_%u`=%u but creature entry %u not exist.",
 501                     i, diff + 1, cInfo->DifficultyEntry[diff], cInfo->DifficultyEntry[diff]);
 502                 continue;
 503             }
 504
 505             if (difficultyEntries[diff].find(i) != difficultyEntries[diff].end())
 506             {
 507                 sLog.outErrorDb("Creature (Entry: %u) listed as difficulty %u but have value in `difficulty_entry_%u`.", i, diff + 1, diff + 1);
 508                 continue;
 509             }
 510
 511             bool ok2 = true;
 512             for (uint32 diff2 = 0; diff2 < MAX_DIFFICULTY - 1 && ok2; ++diff2)
 513             {
 514                 ok2 = false;
 515                 if (difficultyEntries[diff2].find(cInfo->DifficultyEntry[diff]) != difficultyEntries[diff2].end())
 516                 {
 517                     sLog.outErrorDb("Creature (Entry: %u) already listed as difficulty %u for another entry.", cInfo->DifficultyEntry[diff], diff2 + 1);
 518                     continue;
 519                 }
 520
 521                 if (hasDifficultyEntries[diff2].find(cInfo->DifficultyEntry[diff]) != hasDifficultyEntries[diff2].end())
 522                 {
 523                     sLog.outErrorDb("Creature (Entry: %u) have `difficulty_entry_%u`=%u but creature entry %u have difficulty %u entry also.",
 524                         i, diff + 1, cInfo->DifficultyEntry[diff], cInfo->DifficultyEntry[diff], diff2 + 1);
 525                     continue;
 526                 }
 527                 ok2 = true;
 528             }
 529             if (!ok2)
 530                 continue;
 531
 532             if (cInfo->unit_class != difficultyInfo->unit_class)
 533             {
 534                 sLog.outErrorDb("Creature (Entry: %u, class %u) has different `unit_class` in difficulty %u mode (Entry: %u, class %u).",
 535                     i, cInfo->unit_class, diff + 1, cInfo->DifficultyEntry[diff], difficultyInfo->unit_class);
 536                 continue;
 537             }
 538
 539             if (cInfo->npcflag != difficultyInfo->npcflag)
 540             {
 541                 sLog.outErrorDb("Creature (Entry: %u) has different `npcflag` in difficulty %u mode (Entry: %u).", i, diff + 1, cInfo->DifficultyEntry[diff]);
 542                 continue;
 543             }
 544
 545             if (cInfo->trainer_class != difficultyInfo->trainer_class)
 546             {
 547                 sLog.outErrorDb("Creature (Entry: %u) has different `trainer_class` in difficulty %u mode (Entry: %u).", i, diff + 1, cInfo->DifficultyEntry[diff]);
 548                 continue;
 549             }
 550
 551             if (cInfo->trainer_race != difficultyInfo->trainer_race)
 552             {
 553                 sLog.outErrorDb("Creature (Entry: %u) has different `trainer_race` in difficulty %u mode (Entry: %u).", i, diff + 1, cInfo->DifficultyEntry[diff]);
 554                 continue;
 555             }
 556
 557             if (cInfo->trainer_type != difficultyInfo->trainer_type)
 558             {
 559                 sLog.outErrorDb("Creature (Entry: %u) has different `trainer_type` in difficulty %u mode (Entry: %u).", i, diff + 1, cInfo->DifficultyEntry[diff]);
 560                 continue;
 561             }
 562
 563             if (cInfo->trainer_spell != difficultyInfo->trainer_spell)
 564             {
 565                 sLog.outErrorDb("Creature (Entry: %u) has different `trainer_spell` in difficulty %u mode (Entry: %u).", i, diff + 1, cInfo->DifficultyEntry[diff]);
 566                 continue;
 567             }
 568
 569             if (difficultyInfo->AIName && *difficultyInfo->AIName)
 570             {
 571                 sLog.outErrorDb("Difficulty %u mode creature (Entry: %u) has `AIName`, but in any case will used difficulty 0 mode creature (Entry: %u) AIName.",
 572                     diff, cInfo->DifficultyEntry[diff], i);
 573                 continue;
 574             }
 575
 576             if (difficultyInfo->ScriptID)
 577             {
 578                 sLog.outErrorDb("Difficulty %u mode creature (Entry: %u) has `ScriptName`, but in any case will used difficulty 0 mode creature (Entry: %u) ScriptName.",
 579                     diff, cInfo->DifficultyEntry[diff], i);
 580                 continue;
 581             }
 582
 583             hasDifficultyEntries[diff].insert(i);
 584             difficultyEntries[diff].insert(cInfo->DifficultyEntry[diff]);
 585             ok = true;
 586         }
 587         if (!ok)
 588             continue;
 589
 590         FactionTemplateEntry const* factionTemplate = sFactionTemplateStore.LookupEntry(cInfo->faction_A);
 591         if (!factionTemplate)
 592             sLog.outErrorDb("Creature (Entry: %u) has non-existing faction_A template (%u)", cInfo->Entry, cInfo->faction_A);
 593
 594         factionTemplate = sFactionTemplateStore.LookupEntry(cInfo->faction_H);
 595         if (!factionTemplate)
 596             sLog.outErrorDb("Creature (Entry: %u) has non-existing faction_H template (%u)", cInfo->Entry, cInfo->faction_H);
 597
 598         // used later for scale
 599         CreatureDisplayInfoEntry const* displayScaleEntry = NULL;
 600
 601         if (cInfo->DisplayID_A[0])
 602         {
 603             CreatureDisplayInfoEntry const* displayEntry = sCreatureDisplayInfoStore.LookupEntry(cInfo->DisplayID_A[0]);
 604             if(!displayEntry)
 605             {
 606                 sLog.outErrorDb("Creature (Entry: %u) has non-existing DisplayID_A id (%u), can crash client", cInfo->Entry, cInfo->DisplayID_A[0]);
 607                 const_cast<CreatureInfo*>(cInfo)->DisplayID_A[0] = 0;
 608             }
 609             else if(!displayScaleEntry)
 610                 displayScaleEntry = displayEntry;
 611
 612             CreatureModelInfo const* minfo = sCreatureModelStorage.LookupEntry<CreatureModelInfo>(cInfo->DisplayID_A[0]);
 613             if (!minfo)
 614                 sLog.outErrorDb("Creature (Entry: %u) not has model data for DisplayID_A (%u)", cInfo->Entry, cInfo->DisplayID_A[0]);
 615         }
 616
 617         if (cInfo->DisplayID_A[1])
 618         {
 619             CreatureDisplayInfoEntry const* displayEntry = sCreatureDisplayInfoStore.LookupEntry(cInfo->DisplayID_A[1]);
 620             if(!displayEntry)
 621             {
 622                 sLog.outErrorDb("Creature (Entry: %u) has non-existing DisplayID_A2 id (%u), can crash client", cInfo->Entry, cInfo->DisplayID_A[1]);
 623                 const_cast<CreatureInfo*>(cInfo)->DisplayID_A[1] = 0;
 624             }
 625             else if(!displayScaleEntry)
 626                 displayScaleEntry = displayEntry;
 627
 628             CreatureModelInfo const* minfo = sCreatureModelStorage.LookupEntry<CreatureModelInfo>(cInfo->DisplayID_A[1]);
 629             if (!minfo)
 630                 sLog.outErrorDb("Creature (Entry: %u) not has model data for DisplayID_A2 (%u)", cInfo->Entry, cInfo->DisplayID_A[1]);
 631         }
 632
 633         if (cInfo->DisplayID_H[0])
 634         {
 635             CreatureDisplayInfoEntry const* displayEntry = sCreatureDisplayInfoStore.LookupEntry(cInfo->DisplayID_H[0]);
 636             if(!displayEntry)
 637             {
 638                 sLog.outErrorDb("Creature (Entry: %u) has non-existing DisplayID_H id (%u), can crash client", cInfo->Entry, cInfo->DisplayID_H[0]);
 639                 const_cast<CreatureInfo*>(cInfo)->DisplayID_H[0] = 0;
 640             }
 641             else if(!displayScaleEntry)
 642                 displayScaleEntry = displayEntry;
 643
 644             CreatureModelInfo const* minfo = sCreatureModelStorage.LookupEntry<CreatureModelInfo>(cInfo->DisplayID_H[0]);
 645             if (!minfo)
 646                 sLog.outErrorDb("Creature (Entry: %u) not has model data for DisplayID_H (%u)", cInfo->Entry, cInfo->DisplayID_H[0]);
 647         }
 648
 649         if (cInfo->DisplayID_H[1])
 650         {
 651             CreatureDisplayInfoEntry const* displayEntry = sCreatureDisplayInfoStore.LookupEntry(cInfo->DisplayID_H[1]);
 652             if(!displayEntry)
 653             {
 654                 sLog.outErrorDb("Creature (Entry: %u) has non-existing DisplayID_H2 id (%u), can crash client", cInfo->Entry, cInfo->DisplayID_H[1]);
 655                 const_cast<CreatureInfo*>(cInfo)->DisplayID_H[1] = 0;
 656             }
 657             else if(!displayScaleEntry)
 658                 displayScaleEntry = displayEntry;
 659
 660             CreatureModelInfo const* minfo = sCreatureModelStorage.LookupEntry<CreatureModelInfo>(cInfo->DisplayID_H[1]);
 661             if (!minfo)
 662                 sLog.outErrorDb("Creature (Entry: %u) not has model data for DisplayID_H2 (%u)", cInfo->Entry, cInfo->DisplayID_H[1]);
 663         }
 664
 665         if (!displayScaleEntry)
 666             sLog.outErrorDb("Creature (Entry: %u) not has any existed display id in DisplayID_A/DisplayID_A2/DisplayID_H/DisplayID_H2", cInfo->Entry);
 667
 668         for(int k = 0; k < MAX_KILL_CREDIT; ++k)
 669         {
 670             if(cInfo->KillCredit[k])
 671             {
 672                 if(!GetCreatureTemplate(cInfo->KillCredit[k]))
 673                 {
 674                     sLog.outErrorDb("Creature (Entry: %u) has not existed creature entry in `KillCredit%d` (%u)",cInfo->Entry,k+1,cInfo->KillCredit[k]);
 675                     const_cast<CreatureInfo*>(cInfo)->KillCredit[k] = 0;
 676                 }
 677             }
 678         }
 679
 680         if (cInfo->unit_class && ((1 << (cInfo->unit_class-1)) & CLASSMASK_ALL_CREATURES) == 0)
 681             sLog.outErrorDb("Creature (Entry: %u) has invalid unit_class(%u) for creature_template", cInfo->Entry, cInfo->unit_class);
 682
 683         if(cInfo->dmgschool >= MAX_SPELL_SCHOOL)
 684         {
 685             sLog.outErrorDb("Creature (Entry: %u) has invalid spell school value (%u) in `dmgschool`",cInfo->Entry,cInfo->dmgschool);
 686             const_cast<CreatureInfo*>(cInfo)->dmgschool = SPELL_SCHOOL_NORMAL;
 687         }
 688
 689         if(cInfo->baseattacktime == 0)
 690             const_cast<CreatureInfo*>(cInfo)->baseattacktime  = BASE_ATTACK_TIME;
 691
 692         if(cInfo->rangeattacktime == 0)
 693             const_cast<CreatureInfo*>(cInfo)->rangeattacktime = BASE_ATTACK_TIME;
 694
 695         if(cInfo->npcflag & UNIT_NPC_FLAG_SPELLCLICK)
 696         {
 697             sLog.outErrorDb("Creature (Entry: %u) has dynamic flag UNIT_NPC_FLAG_SPELLCLICK (%u) set, it expect to be set by code base at `npc_spellclick_spells` content.",cInfo->Entry,UNIT_NPC_FLAG_SPELLCLICK);
 698             const_cast<CreatureInfo*>(cInfo)->npcflag &= ~UNIT_NPC_FLAG_SPELLCLICK;
 699         }
 700
 701         if((cInfo->npcflag & UNIT_NPC_FLAG_TRAINER) && cInfo->trainer_type >= MAX_TRAINER_TYPE)
 702             sLog.outErrorDb("Creature (Entry: %u) has wrong trainer type %u",cInfo->Entry,cInfo->trainer_type);
 703
 704         if(cInfo->type && !sCreatureTypeStore.LookupEntry(cInfo->type))
 705         {
 706             sLog.outErrorDb("Creature (Entry: %u) has invalid creature type (%u) in `type`",cInfo->Entry,cInfo->type);
 707             const_cast<CreatureInfo*>(cInfo)->type = CREATURE_TYPE_HUMANOID;
 708         }
 709
 710         // must exist or used hidden but used in data horse case
 711         if(cInfo->family && !sCreatureFamilyStore.LookupEntry(cInfo->family) && cInfo->family != CREATURE_FAMILY_HORSE_CUSTOM )
 712         {
 713             sLog.outErrorDb("Creature (Entry: %u) has invalid creature family (%u) in `family`",cInfo->Entry,cInfo->family);
 714             const_cast<CreatureInfo*>(cInfo)->family = 0;
 715         }
 716
 717         if(cInfo->InhabitType <= 0 || cInfo->InhabitType > INHABIT_ANYWHERE)
 718         {
 719             sLog.outErrorDb("Creature (Entry: %u) has wrong value (%u) in `InhabitType`, creature will not correctly walk/swim/fly",cInfo->Entry,cInfo->InhabitType);
 720             const_cast<CreatureInfo*>(cInfo)->InhabitType = INHABIT_ANYWHERE;
 721         }
 722
 723         if(cInfo->PetSpellDataId)
 724         {
 725             CreatureSpellDataEntry const* spellDataId = sCreatureSpellDataStore.LookupEntry(cInfo->PetSpellDataId);
 726             if(!spellDataId)
 727                 sLog.outErrorDb("Creature (Entry: %u) has non-existing PetSpellDataId (%u)", cInfo->Entry, cInfo->PetSpellDataId);
 728         }
 729
 730         for(int j = 0; j < CREATURE_MAX_SPELLS; ++j)
 731         {
 732             if(cInfo->spells[j] && !sSpellStore.LookupEntry(cInfo->spells[j]))
 733             {
 734                 sLog.outErrorDb("Creature (Entry: %u) has non-existing Spell%d (%u), set to 0", cInfo->Entry, j+1,cInfo->spells[j]);
 735                 const_cast<CreatureInfo*>(cInfo)->spells[j] = 0;
 736             }
 737         }
 738
 739         if(cInfo->MovementType >= MAX_DB_MOTION_TYPE)
 740         {
 741             sLog.outErrorDb("Creature (Entry: %u) has wrong movement generator type (%u), ignore and set to IDLE.",cInfo->Entry,cInfo->MovementType);
 742             const_cast<CreatureInfo*>(cInfo)->MovementType = IDLE_MOTION_TYPE;
 743         }
 744
 745         if(cInfo->equipmentId > 0)                          // 0 no equipment
 746         {
 747             if(!GetEquipmentInfo(cInfo->equipmentId))
 748             {
 749                 sLog.outErrorDb("Table `creature_template` have creature (Entry: %u) with equipment_id %u not found in table `creature_equip_template`, set to no equipment.", cInfo->Entry, cInfo->equipmentId);
 750                 const_cast<CreatureInfo*>(cInfo)->equipmentId = 0;
 751             }
 752         }
 753
 754         /// if not set custom creature scale then load scale from CreatureDisplayInfo.dbc
 755         if(cInfo->scale <= 0.0f)
 756         {
 757             if(displayScaleEntry)
 758                 const_cast<CreatureInfo*>(cInfo)->scale = displayScaleEntry->scale;
 759             else
 760                 const_cast<CreatureInfo*>(cInfo)->scale = 1.0f;
 761         }
 762     }
 763 }
 764
 765 void ObjectMgr::ConvertCreatureAddonAuras(CreatureDataAddon* addon, char const* table, char const* guidEntryStr)
 766 {
 767     // Now add the auras, format "spellid effectindex spellid effectindex..."
 768     char *p,*s;
 769     std::vector<int> val;
 770     s=p=(char*)reinterpret_cast<char const*>(addon->auras);
 771     if(p)
 772     {
 773         while (p[0]!=0)
 774         {
 775             ++p;
 776             if (p[0]==' ')
 777             {
 778                 val.push_back(atoi(s));
 779                 s=++p;
 780             }
 781         }
 782         if (p!=s)
 783             val.push_back(atoi(s));
 784
 785         // free char* loaded memory
 786         delete[] (char*)reinterpret_cast<char const*>(addon->auras);
 787
 788         // wrong list
 789         if (val.size()%2)
 790         {
 791             addon->auras = NULL;
 792             sLog.outErrorDb("Creature (%s: %u) has wrong `auras` data in `%s`.",guidEntryStr,addon->guidOrEntry,table);
 793             return;
 794         }
 795     }
 796
 797     // empty list
 798     if(val.empty())
 799     {
 800         addon->auras = NULL;
 801         return;
 802     }
 803
 804     // replace by new structures array
 805     const_cast<CreatureDataAddonAura*&>(addon->auras) = new CreatureDataAddonAura[val.size()/2+1];
 806
 807     uint32 i=0;
 808     for(uint32 j = 0; j < val.size()/2; ++j)
 809     {
 810         CreatureDataAddonAura& cAura = const_cast<CreatureDataAddonAura&>(addon->auras[i]);
 811         cAura.spell_id = (uint32)val[2*j+0];
 812         cAura.effect_idx  = (uint32)val[2*j+1];
 813         if ( cAura.effect_idx > 2 )
 814         {
 815             sLog.outErrorDb("Creature (%s: %u) has wrong effect %u for spell %u in `auras` field in `%s`.",guidEntryStr,addon->guidOrEntry,cAura.effect_idx,cAura.spell_id,table);
 816             continue;
 817         }
 818         SpellEntry const *AdditionalSpellInfo = sSpellStore.LookupEntry(cAura.spell_id);
 819         if (!AdditionalSpellInfo)
 820         {
 821             sLog.outErrorDb("Creature (%s: %u) has wrong spell %u defined in `auras` field in `%s`.",guidEntryStr,addon->guidOrEntry,cAura.spell_id,table);
 822             continue;
 823         }
 824
 825         if (!AdditionalSpellInfo->Effect[cAura.effect_idx] || !AdditionalSpellInfo->EffectApplyAuraName[cAura.effect_idx])
 826         {
 827             sLog.outErrorDb("Creature (%s: %u) has not aura effect %u of spell %u defined in `auras` field in `%s`.",guidEntryStr,addon->guidOrEntry,cAura.effect_idx,cAura.spell_id,table);
 828             continue;
 829         }
 830
 831         ++i;
 832     }
 833
 834     // fill terminator element (after last added)
 835     CreatureDataAddonAura& endAura = const_cast<CreatureDataAddonAura&>(addon->auras[i]);
 836     endAura.spell_id   = 0;
 837     endAura.effect_idx = 0;
 838 }
 839
 840 void ObjectMgr::LoadCreatureAddons(SQLStorage& creatureaddons, char const* entryName, char const* comment)
 841 {
 842     creatureaddons.Load();
 843
 844     sLog.outString(">> Loaded %u %s", creatureaddons.RecordCount, comment);
 845     sLog.outString();
 846
 847     // check data correctness and convert 'auras'
 848     for(uint32 i = 1; i < creatureaddons.MaxEntry; ++i)
 849     {
 850         CreatureDataAddon const* addon = creatureaddons.LookupEntry<CreatureDataAddon>(i);
 851         if(!addon)
 852             continue;
 853
 854         if (addon->mount)
 855         {
 856             if (!sCreatureDisplayInfoStore.LookupEntry(addon->mount))
 857             {
 858                 sLog.outErrorDb("Creature (%s %u) have invalid displayInfoId for mount (%u) defined in `%s`.", entryName, addon->guidOrEntry, addon->mount, creatureaddons.GetTableName());
 859                 const_cast<CreatureDataAddon*>(addon)->mount = 0;
 860             }
 861         }
 862
 863         if (!sEmotesStore.LookupEntry(addon->emote))
 864             sLog.outErrorDb("Creature (%s %u) have invalid emote (%u) defined in `%s`.", entryName, addon->guidOrEntry, addon->emote, creatureaddons.GetTableName());
 865
 866         if (addon->move_flags & (MONSTER_MOVE_UNK1|MONSTER_MOVE_UNK4))
 867         {
 868             sLog.outErrorDb("Creature (%s %u) movement flags mask defined in `%s` include forbidden  flags (" I32FMT ") that can crash client, cleanup at load.", entryName, addon->guidOrEntry, creatureaddons.GetTableName(), (MONSTER_MOVE_UNK1|MONSTER_MOVE_UNK4));
 869             const_cast<CreatureDataAddon*>(addon)->move_flags &= ~(MONSTER_MOVE_UNK1|MONSTER_MOVE_UNK4);
 870         }
 871
 872         ConvertCreatureAddonAuras(const_cast<CreatureDataAddon*>(addon), creatureaddons.GetTableName(), entryName);
 873     }
 874 }
 875
 876 void ObjectMgr::LoadCreatureAddons()
 877 {
 878     LoadCreatureAddons(sCreatureInfoAddonStorage,"Entry","creature template addons");
 879
 880     // check entry ids
 881     for(uint32 i = 1; i < sCreatureInfoAddonStorage.MaxEntry; ++i)
 882         if(CreatureDataAddon const* addon = sCreatureInfoAddonStorage.LookupEntry<CreatureDataAddon>(i))
 883             if(!sCreatureStorage.LookupEntry<CreatureInfo>(addon->guidOrEntry))
 884                 sLog.outErrorDb("Creature (Entry: %u) does not exist but has a record in `%s`",addon->guidOrEntry, sCreatureInfoAddonStorage.GetTableName());
 885
 886     LoadCreatureAddons(sCreatureDataAddonStorage,"GUID","creature addons");
 887
 888     // check entry ids
 889     for(uint32 i = 1; i < sCreatureDataAddonStorage.MaxEntry; ++i)
 890         if(CreatureDataAddon const* addon = sCreatureDataAddonStorage.LookupEntry<CreatureDataAddon>(i))
 891             if(mCreatureDataMap.find(addon->guidOrEntry)==mCreatureDataMap.end())
 892                 sLog.outErrorDb("Creature (GUID: %u) does not exist but has a record in `creature_addon`",addon->guidOrEntry);
 893 }
 894
 895 EquipmentInfo const* ObjectMgr::GetEquipmentInfo(uint32 entry)
 896 {
 897     return sEquipmentStorage.LookupEntry<EquipmentInfo>(entry);
 898 }
 899
 900 void ObjectMgr::LoadEquipmentTemplates()
 901 {
 902     sEquipmentStorage.Load();
 903
 904     for(uint32 i=0; i< sEquipmentStorage.MaxEntry; ++i)
 905     {
 906         EquipmentInfo const* eqInfo = sEquipmentStorage.LookupEntry<EquipmentInfo>(i);
 907
 908         if(!eqInfo)
 909             continue;
 910
 911         for(uint8 j=0; j<3; j++)
 912         {
 913             if(!eqInfo->equipentry[j])
 914                continue;
 915
 916             ItemEntry const *dbcitem = sItemStore.LookupEntry(eqInfo->equipentry[j]);
 917
 918             if(!dbcitem)
 919             {
 920                 sLog.outErrorDb("Unknown item (entry=%u) in creature_equip_template.equipentry%u for entry = %u, forced to 0.", eqInfo->equipentry[j], j+1, i);
 921                 const_cast<EquipmentInfo*>(eqInfo)->equipentry[j] = 0;
 922                 continue;
 923             }
 924
 925             if(dbcitem->InventoryType != INVTYPE_WEAPON &&
 926                     dbcitem->InventoryType != INVTYPE_SHIELD &&
 927                     dbcitem->InventoryType != INVTYPE_RANGED &&
 928                     dbcitem->InventoryType != INVTYPE_2HWEAPON &&
 929                     dbcitem->InventoryType != INVTYPE_WEAPONMAINHAND &&
 930                     dbcitem->InventoryType != INVTYPE_WEAPONOFFHAND &&
 931                     dbcitem->InventoryType != INVTYPE_HOLDABLE &&
 932                     dbcitem->InventoryType != INVTYPE_THROWN &&
 933                     dbcitem->InventoryType != INVTYPE_RANGEDRIGHT)
 934             {
 935                 sLog.outErrorDb("Item (entry=%u) in creature_equip_template.equipentry%u for entry = %u is not equipable in a hand, forced to 0.", eqInfo->equipentry[j], j+1, i);
 936                 const_cast<EquipmentInfo*>(eqInfo)->equipentry[j] = 0;
 937             }
 938         }
 939     }
 940     sLog.outString( ">> Loaded %u equipment template", sEquipmentStorage.RecordCount );
 941     sLog.outString();
 942 }
 943
 944 CreatureModelInfo const* ObjectMgr::GetCreatureModelInfo(uint32 modelid)
 945 {
 946     return sCreatureModelStorage.LookupEntry<CreatureModelInfo>(modelid);
 947 }
 948
 949 uint32 ObjectMgr::ChooseDisplayId(uint32 team, const CreatureInfo *cinfo, const CreatureData *data /*= NULL*/)
 950 {
 951     // Load creature model (display id)
 952     if (data && data->displayid)
 953         return data->displayid;
 954
 955     // use defaults from the template
 956     uint32 display_id;
 957
 958     // DisplayID_A is used if no team is given
 959     if (team == HORDE)
 960     {
 961         if(cinfo->DisplayID_H[0])
 962             display_id = cinfo->DisplayID_H[1] ? cinfo->DisplayID_H[urand(0,1)] : cinfo->DisplayID_H[0];
 963         else
 964             display_id = cinfo->DisplayID_H[1];
 965
 966         if(!display_id)
 967             display_id = cinfo->DisplayID_A[0] ? cinfo->DisplayID_A[0] : cinfo->DisplayID_A[1];
 968     }
 969     else
 970     {
 971         if(cinfo->DisplayID_A[0])
 972             display_id = cinfo->DisplayID_A[1] ? cinfo->DisplayID_A[urand(0,1)] : cinfo->DisplayID_A[0];
 973         else
 974             display_id = cinfo->DisplayID_A[1];
 975
 976         if(!display_id)
 977             display_id = cinfo->DisplayID_H[0] ? cinfo->DisplayID_H[0] : cinfo->DisplayID_H[1];
 978     }
 979
 980     return display_id;
 981 }
 982
 983 CreatureModelInfo const* ObjectMgr::GetCreatureModelRandomGender(uint32 display_id)
 984 {
 985     CreatureModelInfo const *minfo = GetCreatureModelInfo(display_id);
 986     if(!minfo)
 987         return NULL;
 988
 989     // If a model for another gender exists, 50% chance to use it
 990     if(minfo->modelid_other_gender != 0 && urand(0,1) == 0)
 991     {
 992         CreatureModelInfo const *minfo_tmp = GetCreatureModelInfo(minfo->modelid_other_gender);
 993         if(!minfo_tmp)
 994         {
 995             sLog.outErrorDb("Model (Entry: %u) has modelid_other_gender %u not found in table `creature_model_info`. ", minfo->modelid, minfo->modelid_other_gender);
 996             return minfo;                                   // not fatal, just use the previous one
 997         }
 998         else
 999             return minfo_tmp;
1000     }
1001     else
1002         return minfo;
1003 }
1004
1005 void ObjectMgr::LoadCreatureModelInfo()
1006 {
1007     sCreatureModelStorage.Load();
1008
1009     // post processing
1010     for(uint32 i = 1; i < sCreatureModelStorage.MaxEntry; ++i)
1011     {
1012         CreatureModelInfo const *minfo = sCreatureModelStorage.LookupEntry<CreatureModelInfo>(i);
1013         if (!minfo)
1014             continue;
1015
1016         if (!sCreatureDisplayInfoStore.LookupEntry(minfo->modelid))
1017             sLog.outErrorDb("Table `creature_model_info` has model for not existed display id (%u).", minfo->modelid);
1018
1019         if (minfo->gender > GENDER_NONE)
1020         {
1021             sLog.outErrorDb("Table `creature_model_info` has wrong gender (%u) for display id (%u).", uint32(minfo->gender), minfo->modelid);
1022             const_cast<CreatureModelInfo*>(minfo)->gender = GENDER_MALE;
1023         }
1024
1025         if (minfo->modelid_other_gender && !sCreatureDisplayInfoStore.LookupEntry(minfo->modelid_other_gender))
1026         {
1027             sLog.outErrorDb("Table `creature_model_info` has not existed alt.gender model (%u) for existed display id (%u).", minfo->modelid_other_gender, minfo->modelid);
1028             const_cast<CreatureModelInfo*>(minfo)->modelid_other_gender = 0;
1029         }
1030     }
1031
1032     sLog.outString( ">> Loaded %u creature model based info", sCreatureModelStorage.RecordCount );
1033     sLog.outString();
1034 }
1035
1036 void ObjectMgr::LoadCreatures()
1037 {
1038     uint32 count = 0;
1039     //                                                0              1   2    3
1040     QueryResult *result = WorldDatabase.Query("SELECT creature.guid, id, map, modelid,"
1041     //   4             5           6           7           8            9              10         11
1042         "equipment_id, position_x, position_y, position_z, orientation, spawntimesecs, spawndist, currentwaypoint,"
1043     //   12         13       14          15            16         17         18     19
1044         "curhealth, curmana, DeathState, MovementType, spawnMask, phaseMask, event, pool_entry "
1045         "FROM creature LEFT OUTER JOIN game_event_creature ON creature.guid = game_event_creature.guid "
1046         "LEFT OUTER JOIN pool_creature ON creature.guid = pool_creature.guid");
1047
1048     if(!result)
1049     {
1050         barGoLink bar(1);
1051
1052         bar.step();
1053
1054         sLog.outString();
1055         sLog.outErrorDb(">> Loaded 0 creature. DB table `creature` is empty.");
1056         return;
1057     }
1058
1059     // build single time for check creature data
1060     std::set<uint32> difficultyCreatures[MAX_DIFFICULTY - 1];
1061     for (uint32 i = 0; i < sCreatureStorage.MaxEntry; ++i)
1062         if (CreatureInfo const* cInfo = sCreatureStorage.LookupEntry<CreatureInfo>(i))
1063             for (uint32 diff = 0; diff < MAX_DIFFICULTY - 1; ++diff)
1064                 if (cInfo->DifficultyEntry[diff])
1065                     difficultyCreatures[diff].insert(cInfo->DifficultyEntry[diff]);
1066
1067     // build single time for check spawnmask
1068     std::map<uint32,uint32> spawnMasks;
1069     for(uint32 i = 0; i < sMapStore.GetNumRows(); ++i)
1070         if(sMapStore.LookupEntry(i))
1071             for(int k = 0; k < MAX_DIFFICULTY; ++k)
1072                 if (GetMapDifficultyData(i,Difficulty(k)))
1073                     spawnMasks[i] |= (1 << k);
1074
1075     barGoLink bar(result->GetRowCount());
1076
1077     do
1078     {
1079         Field *fields = result->Fetch();
1080         bar.step();
1081
1082         uint32 guid         = fields[ 0].GetUInt32();
1083         uint32 entry        = fields[ 1].GetUInt32();
1084
1085         CreatureInfo const* cInfo = GetCreatureTemplate(entry);
1086         if(!cInfo)
1087         {
1088             sLog.outErrorDb("Table `creature` has creature (GUID: %u) with non existing creature entry %u, skipped.", guid, entry);
1089             continue;
1090         }
1091
1092         CreatureData& data = mCreatureDataMap[guid];
1093
1094         data.id             = entry;
1095         data.mapid          = fields[ 2].GetUInt32();
1096         data.displayid      = fields[ 3].GetUInt32();
1097         data.equipmentId    = fields[ 4].GetUInt32();
1098         data.posX           = fields[ 5].GetFloat();
1099         data.posY           = fields[ 6].GetFloat();
1100         data.posZ           = fields[ 7].GetFloat();
1101         data.orientation    = fields[ 8].GetFloat();
1102         data.spawntimesecs  = fields[ 9].GetUInt32();
1103         data.spawndist      = fields[10].GetFloat();
1104         data.currentwaypoint= fields[11].GetUInt32();
1105         data.curhealth      = fields[12].GetUInt32();
1106         data.curmana        = fields[13].GetUInt32();
1107         data.is_dead        = fields[14].GetBool();
1108         data.movementType   = fields[15].GetUInt8();
1109         data.spawnMask      = fields[16].GetUInt8();
1110         data.phaseMask      = fields[17].GetUInt16();
1111         int16 gameEvent     = fields[18].GetInt16();
1112         int16 PoolId        = fields[19].GetInt16();
1113
1114         MapEntry const* mapEntry = sMapStore.LookupEntry(data.mapid);
1115         if(!mapEntry)
1116         {
1117             sLog.outErrorDb("Table `creature` have creature (GUID: %u) that spawned at not existed map (Id: %u), skipped.",guid, data.mapid );
1118             continue;
1119         }
1120
1121         if (data.spawnMask & ~spawnMasks[data.mapid])
1122             sLog.outErrorDb("Table `creature` have creature (GUID: %u) that have wrong spawn mask %u including not supported difficulty modes for map (Id: %u).",guid, data.spawnMask, data.mapid );
1123
1124         bool ok = true;
1125         for (uint32 diff = 0; diff < MAX_DIFFICULTY - 1 && ok; ++diff)
1126         {
1127             if (difficultyCreatures[diff].find(data.id) != difficultyCreatures[diff].end())
1128             {
1129                 sLog.outErrorDb("Table `creature` have creature (GUID: %u) that listed as difficulty %u template (entry: %u) in `creature_template`, skipped.",
1130                     guid, diff + 1, data.id );
1131                 ok = false;
1132             }
1133         }
1134         if (!ok)
1135             continue;
1136
1137         if(data.equipmentId > 0)                            // -1 no equipment, 0 use default
1138         {
1139             if(!GetEquipmentInfo(data.equipmentId))
1140             {
1141                 sLog.outErrorDb("Table `creature` have creature (Entry: %u) with equipment_id %u not found in table `creature_equip_template`, set to no equipment.", data.id, data.equipmentId);
1142                 data.equipmentId = -1;
1143             }
1144         }
1145
1146         if(cInfo->RegenHealth && data.curhealth < cInfo->minhealth)
1147         {
1148             sLog.outErrorDb("Table `creature` have creature (GUID: %u Entry: %u) with `creature_template`.`RegenHealth`=1 and low current health (%u), `creature_template`.`minhealth`=%u.",guid,data.id,data.curhealth, cInfo->minhealth );
1149             data.curhealth = cInfo->minhealth;
1150         }
1151
1152         if(cInfo->flags_extra & CREATURE_FLAG_EXTRA_INSTANCE_BIND)
1153         {
1154             if(!mapEntry || !mapEntry->IsDungeon())
1155                 sLog.outErrorDb("Table `creature` have creature (GUID: %u Entry: %u) with `creature_template`.`flags_extra` including CREATURE_FLAG_EXTRA_INSTANCE_BIND but creature are not in instance.",guid,data.id);
1156         }
1157
1158         if(data.curmana < cInfo->minmana)
1159         {
1160             sLog.outErrorDb("Table `creature` have creature (GUID: %u Entry: %u) with low current mana (%u), `creature_template`.`minmana`=%u.",guid,data.id,data.curmana, cInfo->minmana );
1161             data.curmana = cInfo->minmana;
1162         }
1163
1164         if(data.spawndist < 0.0f)
1165         {
1166             sLog.outErrorDb("Table `creature` have creature (GUID: %u Entry: %u) with `spawndist`< 0, set to 0.",guid,data.id );
1167             data.spawndist = 0.0f;
1168         }
1169         else if(data.movementType == RANDOM_MOTION_TYPE)
1170         {
1171             if(data.spawndist == 0.0f)
1172             {
1173                 sLog.outErrorDb("Table `creature` have creature (GUID: %u Entry: %u) with `MovementType`=1 (random movement) but with `spawndist`=0, replace by idle movement type (0).",guid,data.id );
1174                 data.movementType = IDLE_MOTION_TYPE;
1175             }
1176         }
1177         else if(data.movementType == IDLE_MOTION_TYPE)
1178         {
1179             if(data.spawndist != 0.0f)
1180             {
1181                 sLog.outErrorDb("Table `creature` have creature (GUID: %u Entry: %u) with `MovementType`=0 (idle) have `spawndist`<>0, set to 0.",guid,data.id );
1182                 data.spawndist = 0.0f;
1183             }
1184         }
1185
1186         if(data.phaseMask==0)
1187         {
1188             sLog.outErrorDb("Table `creature` have creature (GUID: %u Entry: %u) with `phaseMask`=0 (not visible for anyone), set to 1.",guid,data.id );
1189             data.phaseMask = 1;
1190         }
1191
1192         if (gameEvent==0 && PoolId==0)                      // if not this is to be managed by GameEvent System or Pool system
1193             AddCreatureToGrid(guid, &data);
1194
1195         ++count;
1196
1197     } while (result->NextRow());
1198
1199     delete result;
1200
1201     sLog.outString();
1202     sLog.outString( ">> Loaded %lu creatures", (unsigned long)mCreatureDataMap.size() );
1203 }
1204
1205 void ObjectMgr::AddCreatureToGrid(uint32 guid, CreatureData const* data)
1206 {
1207     uint8 mask = data->spawnMask;
1208     for(uint8 i = 0; mask != 0; i++, mask >>= 1)
1209     {
1210         if(mask & 1)
1211         {
1212             CellPair cell_pair = MaNGOS::ComputeCellPair(data->posX, data->posY);
1213             uint32 cell_id = (cell_pair.y_coord*TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
1214
1215             CellObjectGuids& cell_guids = mMapObjectGuids[MAKE_PAIR32(data->mapid,i)][cell_id];
1216             cell_guids.creatures.insert(guid);
1217         }
1218     }
1219 }
1220
1221 void ObjectMgr::RemoveCreatureFromGrid(uint32 guid, CreatureData const* data)
1222 {
1223     uint8 mask = data->spawnMask;
1224     for(uint8 i = 0; mask != 0; i++, mask >>= 1)
1225     {
1226         if(mask & 1)
1227         {
1228             CellPair cell_pair = MaNGOS::ComputeCellPair(data->posX, data->posY);
1229             uint32 cell_id = (cell_pair.y_coord*TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
1230
1231             CellObjectGuids& cell_guids = mMapObjectGuids[MAKE_PAIR32(data->mapid,i)][cell_id];
1232             cell_guids.creatures.erase(guid);
1233         }
1234     }
1235 }
1236
1237 void ObjectMgr::LoadGameobjects()
1238 {
1239     uint32 count = 0;
1240
1241     //                                                0                1   2    3           4           5           6
1242     QueryResult *result = WorldDatabase.Query("SELECT gameobject.guid, id, map, position_x, position_y, position_z, orientation,"
1243     //   7          8          9          10         11             12            13     14         15         16     17
1244         "rotation0, rotation1, rotation2, rotation3, spawntimesecs, animprogress, state, spawnMask, phaseMask, event, pool_entry "
1245         "FROM gameobject LEFT OUTER JOIN game_event_gameobject ON gameobject.guid = game_event_gameobject.guid "
1246         "LEFT OUTER JOIN pool_gameobject ON gameobject.guid = pool_gameobject.guid");
1247
1248     if(!result)
1249     {
1250         barGoLink bar(1);
1251
1252         bar.step();
1253
1254         sLog.outString();
1255         sLog.outErrorDb(">> Loaded 0 gameobjects. DB table `gameobject` is empty.");
1256         return;
1257     }
1258
1259     // build single time for check spawnmask
1260     std::map<uint32,uint32> spawnMasks;
1261     for(uint32 i = 0; i < sMapStore.GetNumRows(); ++i)
1262         if(sMapStore.LookupEntry(i))
1263             for(int k = 0; k < MAX_DIFFICULTY; ++k)
1264                 if (GetMapDifficultyData(i,Difficulty(k)))
1265                     spawnMasks[i] |= (1 << k);
1266
1267     barGoLink bar(result->GetRowCount());
1268
1269     do
1270     {
1271         Field *fields = result->Fetch();
1272         bar.step();
1273
1274         uint32 guid         = fields[ 0].GetUInt32();
1275         uint32 entry        = fields[ 1].GetUInt32();
1276
1277         GameObjectInfo const* gInfo = GetGameObjectInfo(entry);
1278         if (!gInfo)
1279         {
1280             sLog.outErrorDb("Table `gameobject` has gameobject (GUID: %u) with non existing gameobject entry %u, skipped.", guid, entry);
1281             continue;
1282         }
1283
1284         if(!gInfo->displayId)
1285         {
1286             switch(gInfo->type)
1287             {
1288                 // can be invisible always and then not req. display id in like case
1289                 case GAMEOBJECT_TYPE_TRAP:
1290                 case GAMEOBJECT_TYPE_SPELL_FOCUS:
1291                     break;
1292                 default:
1293                     sLog.outErrorDb("Gameobject (GUID: %u Entry %u GoType: %u) have displayId == 0 and then will always invisible in game.", guid, entry, gInfo->type);
1294                     break;
1295             }
1296         }
1297         else if (!sGameObjectDisplayInfoStore.LookupEntry(gInfo->displayId))
1298         {
1299             sLog.outErrorDb("Gameobject (GUID: %u Entry %u GoType: %u) have invalid displayId (%u), not loaded.", guid, entry, gInfo->type, gInfo->displayId);
1300             continue;
1301         }
1302
1303         GameObjectData& data = mGameObjectDataMap[guid];
1304
1305         data.id             = entry;
1306         data.mapid          = fields[ 2].GetUInt32();
1307         data.posX           = fields[ 3].GetFloat();
1308         data.posY           = fields[ 4].GetFloat();
1309         data.posZ           = fields[ 5].GetFloat();
1310         data.orientation    = fields[ 6].GetFloat();
1311         data.rotation0      = fields[ 7].GetFloat();
1312         data.rotation1      = fields[ 8].GetFloat();
1313         data.rotation2      = fields[ 9].GetFloat();
1314         data.rotation3      = fields[10].GetFloat();
1315         data.spawntimesecs  = fields[11].GetInt32();
1316
1317         MapEntry const* mapEntry = sMapStore.LookupEntry(data.mapid);
1318         if(!mapEntry)
1319         {
1320             sLog.outErrorDb("Table `gameobject` have gameobject (GUID: %u Entry: %u) that spawned at not existed map (Id: %u), skip", guid, data.id, data.mapid);
1321             continue;
1322         }
1323
1324         if (data.spawnMask & ~spawnMasks[data.mapid])
1325             sLog.outErrorDb("Table `gameobject` have gameobject (GUID: %u Entry: %u) that have wrong spawn mask %u including not supported difficulty modes for map (Id: %u), skip", guid, data.id, data.spawnMask, data.mapid);
1326
1327         if (data.spawntimesecs == 0 && gInfo->IsDespawnAtAction())
1328         {
1329             sLog.outErrorDb("Table `gameobject` have gameobject (GUID: %u Entry: %u) with `spawntimesecs` (0) value, but gameobejct marked as despawnable at action.", guid, data.id);
1330         }
1331
1332         data.animprogress   = fields[12].GetUInt32();
1333
1334         uint32 go_state     = fields[13].GetUInt32();
1335         if (go_state >= MAX_GO_STATE)
1336         {
1337             sLog.outErrorDb("Table `gameobject` have gameobject (GUID: %u Entry: %u) with invalid `state` (%u) value, skip", guid, data.id, go_state);
1338             continue;
1339         }
1340         data.go_state       = GOState(go_state);
1341
1342         data.spawnMask      = fields[14].GetUInt8();
1343         data.phaseMask      = fields[15].GetUInt16();
1344         int16 gameEvent     = fields[16].GetInt16();
1345         int16 PoolId        = fields[17].GetInt16();
1346
1347         if (data.rotation2 < -1.0f || data.rotation2 > 1.0f)
1348         {
1349             sLog.outErrorDb("Table `gameobject` have gameobject (GUID: %u Entry: %u) with invalid rotation2 (%f) value, skip", guid, data.id, data.rotation2);
1350             continue;
1351         }
1352
1353         if (data.rotation3 < -1.0f || data.rotation3 > 1.0f)
1354         {
1355             sLog.outErrorDb("Table `gameobject` have gameobject (GUID: %u Entry: %u) with invalid rotation3 (%f) value, skip", guid, data.id, data.rotation3);
1356             continue;
1357         }
1358
1359         if(!MapManager::IsValidMapCoord(data.mapid, data.posX, data.posY, data.posZ, data.orientation))
1360         {
1361             sLog.outErrorDb("Table `gameobject` have gameobject (GUID: %u Entry: %u) with invalid coordinates, skip", guid, data.id);
1362             continue;
1363         }
1364
1365         if(data.phaseMask == 0)
1366         {
1367             sLog.outErrorDb("Table `gameobject` have gameobject (GUID: %u Entry: %u) with `phaseMask`=0 (not visible for anyone), set to 1.", guid, data.id);
1368             data.phaseMask = 1;
1369         }
1370
1371         if (gameEvent == 0 && PoolId == 0)                  // if not this is to be managed by GameEvent System or Pool system
1372             AddGameobjectToGrid(guid, &data);
1373         ++count;
1374
1375     } while (result->NextRow());
1376
1377     delete result;
1378
1379     sLog.outString();
1380     sLog.outString( ">> Loaded %lu gameobjects", (unsigned long)mGameObjectDataMap.size());
1381 }
1382
1383 void ObjectMgr::AddGameobjectToGrid(uint32 guid, GameObjectData const* data)
1384 {
1385     uint8 mask = data->spawnMask;
1386     for(uint8 i = 0; mask != 0; i++, mask >>= 1)
1387     {
1388         if(mask & 1)
1389         {
1390             CellPair cell_pair = MaNGOS::ComputeCellPair(data->posX, data->posY);
1391             uint32 cell_id = (cell_pair.y_coord*TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
1392
1393             CellObjectGuids& cell_guids = mMapObjectGuids[MAKE_PAIR32(data->mapid,i)][cell_id];
1394             cell_guids.gameobjects.insert(guid);
1395         }
1396     }
1397 }
1398
1399 void ObjectMgr::RemoveGameobjectFromGrid(uint32 guid, GameObjectData const* data)
1400 {
1401     uint8 mask = data->spawnMask;
1402     for(uint8 i = 0; mask != 0; i++, mask >>= 1)
1403     {
1404         if(mask & 1)
1405         {
1406             CellPair cell_pair = MaNGOS::ComputeCellPair(data->posX, data->posY);
1407             uint32 cell_id = (cell_pair.y_coord*TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
1408
1409             CellObjectGuids& cell_guids = mMapObjectGuids[MAKE_PAIR32(data->mapid,i)][cell_id];
1410             cell_guids.gameobjects.erase(guid);
1411         }
1412     }
1413 }
1414
1415 void ObjectMgr::LoadCreatureRespawnTimes()
1416 {
1417     // remove outdated data
1418     WorldDatabase.DirectExecute("DELETE FROM creature_respawn WHERE respawntime <= UNIX_TIMESTAMP(NOW())");
1419
1420     uint32 count = 0;
1421
1422     QueryResult *result = WorldDatabase.Query("SELECT guid,respawntime,instance FROM creature_respawn");
1423
1424     if(!result)
1425     {
1426         barGoLink bar(1);
1427
1428         bar.step();
1429
1430         sLog.outString();
1431         sLog.outString(">> Loaded 0 creature respawn time.");
1432         return;
1433     }
1434
1435     barGoLink bar(result->GetRowCount());
1436
1437     do
1438     {
1439         Field *fields = result->Fetch();
1440         bar.step();
1441
1442         uint32 loguid       = fields[0].GetUInt32();
1443         uint64 respawn_time = fields[1].GetUInt64();
1444         uint32 instance     = fields[2].GetUInt32();
1445
1446         mCreatureRespawnTimes[MAKE_PAIR64(loguid,instance)] = time_t(respawn_time);
1447
1448         ++count;
1449     } while (result->NextRow());
1450
1451     delete result;
1452
1453     sLog.outString( ">> Loaded %lu creature respawn times", (unsigned long)mCreatureRespawnTimes.size() );
1454     sLog.outString();
1455 }
1456
1457 void ObjectMgr::LoadGameobjectRespawnTimes()
1458 {
1459     // remove outdated data
1460     WorldDatabase.DirectExecute("DELETE FROM gameobject_respawn WHERE respawntime <= UNIX_TIMESTAMP(NOW())");
1461
1462     uint32 count = 0;
1463
1464     QueryResult *result = WorldDatabase.Query("SELECT guid,respawntime,instance FROM gameobject_respawn");
1465
1466     if(!result)
1467     {
1468         barGoLink bar(1);
1469
1470         bar.step();
1471
1472         sLog.outString();
1473         sLog.outString(">> Loaded 0 gameobject respawn time.");
1474         return;
1475     }
1476
1477     barGoLink bar(result->GetRowCount());
1478
1479     do
1480     {
1481         Field *fields = result->Fetch();
1482         bar.step();
1483
1484         uint32 loguid       = fields[0].GetUInt32();
1485         uint64 respawn_time = fields[1].GetUInt64();
1486         uint32 instance     = fields[2].GetUInt32();
1487
1488         mGORespawnTimes[MAKE_PAIR64(loguid,instance)] = time_t(respawn_time);
1489
1490         ++count;
1491     } while (result->NextRow());
1492
1493     delete result;
1494
1495     sLog.outString( ">> Loaded %lu gameobject respawn times", (unsigned long)mGORespawnTimes.size() );
1496     sLog.outString();
1497 }
1498
1499 // name must be checked to correctness (if received) before call this function
1500 uint64 ObjectMgr::GetPlayerGUIDByName(std::string name) const
1501 {
1502     uint64 guid = 0;
1503
1504     CharacterDatabase.escape_string(name);
1505
1506     // Player name safe to sending to DB (checked at login) and this function using
1507     QueryResult *result = CharacterDatabase.PQuery("SELECT guid FROM characters WHERE name = '%s'", name.c_str());
1508     if(result)
1509     {
1510         guid = MAKE_NEW_GUID((*result)[0].GetUInt32(), 0, HIGHGUID_PLAYER);
1511
1512         delete result;
1513     }
1514
1515     return guid;
1516 }
1517
1518 bool ObjectMgr::GetPlayerNameByGUID(const uint64 &guid, std::string &name) const
1519 {
1520     // prevent DB access for online player
1521     if(Player* player = GetPlayer(guid))
1522     {
1523         name = player->GetName();
1524         return true;
1525     }
1526
1527     QueryResult *result = CharacterDatabase.PQuery("SELECT name FROM characters WHERE guid = '%u'", GUID_LOPART(guid));
1528
1529     if(result)
1530     {
1531         name = (*result)[0].GetCppString();
1532         delete result;
1533         return true;
1534     }
1535
1536     return false;
1537 }
1538
1539 uint32 ObjectMgr::GetPlayerTeamByGUID(const uint64 &guid) const
1540 {
1541     // prevent DB access for online player
1542     if(Player* player = GetPlayer(guid))
1543     {
1544         return Player::TeamForRace(player->getRace());
1545     }
1546
1547     QueryResult *result = CharacterDatabase.PQuery("SELECT race FROM characters WHERE guid = '%u'", GUID_LOPART(guid));
1548
1549     if(result)
1550     {
1551         uint8 race = (*result)[0].GetUInt8();
1552         delete result;
1553         return Player::TeamForRace(race);
1554     }
1555
1556     return 0;
1557 }
1558
1559 uint32 ObjectMgr::GetPlayerAccountIdByGUID(const uint64 &guid) const
1560 {
1561     // prevent DB access for online player
1562     if(Player* player = GetPlayer(guid))
1563     {
1564         return player->GetSession()->GetAccountId();
1565     }
1566
1567     QueryResult *result = CharacterDatabase.PQuery("SELECT account FROM characters WHERE guid = '%u'", GUID_LOPART(guid));
1568     if(result)
1569     {
1570         uint32 acc = (*result)[0].GetUInt32();
1571         delete result;
1572         return acc;
1573     }
1574
1575     return 0;
1576 }
1577
1578 uint32 ObjectMgr::GetPlayerAccountIdByPlayerName(const std::string& name) const
1579 {
1580     QueryResult *result = CharacterDatabase.PQuery("SELECT account FROM characters WHERE name = '%s'", name.c_str());
1581     if(result)
1582     {
1583         uint32 acc = (*result)[0].GetUInt32();
1584         delete result;
1585         return acc;
1586     }
1587
1588     return 0;
1589 }
1590
1591 void ObjectMgr::LoadItemLocales()
1592 {
1593     mItemLocaleMap.clear();                                 // need for reload case
1594
1595     QueryResult *result = WorldDatabase.Query("SELECT entry,name_loc1,description_loc1,name_loc2,description_loc2,name_loc3,description_loc3,name_loc4,description_loc4,name_loc5,description_loc5,name_loc6,description_loc6,name_loc7,description_loc7,name_loc8,description_loc8 FROM locales_item");
1596
1597     if(!result)
1598     {
1599         barGoLink bar(1);
1600
1601         bar.step();
1602
1603         sLog.outString();
1604         sLog.outString(">> Loaded 0 Item locale strings. DB table `locales_item` is empty.");
1605         return;
1606     }
1607
1608     barGoLink bar(result->GetRowCount());
1609
1610     do
1611     {
1612         Field *fields = result->Fetch();
1613         bar.step();
1614
1615         uint32 entry = fields[0].GetUInt32();
1616
1617         ItemLocale& data = mItemLocaleMap[entry];
1618
1619         for(int i = 1; i < MAX_LOCALE; ++i)
1620         {
1621             std::string str = fields[1+2*(i-1)].GetCppString();
1622             if(!str.empty())
1623             {
1624                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
1625                 if(idx >= 0)
1626                 {
1627                     if(data.Name.size() <= idx)
1628                         data.Name.resize(idx+1);
1629
1630                     data.Name[idx] = str;
1631                 }
1632             }
1633
1634             str = fields[1+2*(i-1)+1].GetCppString();
1635             if(!str.empty())
1636             {
1637                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
1638                 if(idx >= 0)
1639                 {
1640                     if(data.Description.size() <= idx)
1641                         data.Description.resize(idx+1);
1642
1643                     data.Description[idx] = str;
1644                 }
1645             }
1646         }
1647     } while (result->NextRow());
1648
1649     delete result;
1650
1651     sLog.outString();
1652     sLog.outString( ">> Loaded %lu Item locale strings", (unsigned long)mItemLocaleMap.size() );
1653 }
1654
1655 struct SQLItemLoader : public SQLStorageLoaderBase<SQLItemLoader>
1656 {
1657     template<class D>
1658     void convert_from_str(uint32 /*field_pos*/, char *src, D &dst)
1659     {
1660         dst = D(sObjectMgr.GetScriptId(src));
1661     }
1662 };
1663
1664 void ObjectMgr::LoadItemPrototypes()
1665 {
1666     SQLItemLoader loader;
1667     loader.Load(sItemStorage);
1668     sLog.outString( ">> Loaded %u item prototypes", sItemStorage.RecordCount );
1669     sLog.outString();
1670
1671     // check data correctness
1672     for(uint32 i = 1; i < sItemStorage.MaxEntry; ++i)
1673     {
1674         ItemPrototype const* proto = sItemStorage.LookupEntry<ItemPrototype >(i);
1675         ItemEntry const *dbcitem = sItemStore.LookupEntry(i);
1676         if(!proto)
1677         {
1678             /* to many errors, and possible not all items really used in game
1679             if (dbcitem)
1680                 sLog.outErrorDb("Item (Entry: %u) doesn't exists in DB, but must exist.",i);
1681             */
1682             continue;
1683         }
1684
1685         if(dbcitem)
1686         {
1687             if(proto->Class != dbcitem->Class)
1688             {
1689                 sLog.outErrorDb("Item (Entry: %u) not correct class %u, must be %u (still using DB value).",i,proto->Class,dbcitem->Class);
1690                 // It safe let use Class from DB
1691             }
1692             /* disabled: have some strange wrong cases for Subclass values.
1693                for enable also uncomment Subclass field in ItemEntry structure and in Itemfmt[]
1694             if(proto->SubClass != dbcitem->SubClass)
1695             {
1696                 sLog.outErrorDb("Item (Entry: %u) not correct (Class: %u, Sub: %u) pair, must be (Class: %u, Sub: %u) (still using DB value).",i,proto->Class,proto->SubClass,dbcitem->Class,dbcitem->SubClass);
1697                 // It safe let use Subclass from DB
1698             }
1699             */
1700
1701             if(proto->Unk0 != dbcitem->Unk0)
1702             {
1703                 sLog.outErrorDb("Item (Entry: %u) not correct %i Unk0, must be %i (still using DB value).",i,proto->Unk0,dbcitem->Unk0);
1704                 // It safe let use Unk0 from DB
1705             }
1706
1707             if(proto->Material != dbcitem->Material)
1708             {
1709                 sLog.outErrorDb("Item (Entry: %u) not correct %i material, must be %i (still using DB value).",i,proto->Material,dbcitem->Material);
1710                 // It safe let use Material from DB
1711             }
1712
1713             if(proto->InventoryType != dbcitem->InventoryType)
1714             {
1715                 sLog.outErrorDb("Item (Entry: %u) not correct %u inventory type, must be %u (still using DB value).",i,proto->InventoryType,dbcitem->InventoryType);
1716                 // It safe let use InventoryType from DB
1717             }
1718
1719             if(proto->DisplayInfoID != dbcitem->DisplayId)
1720             {
1721                 sLog.outErrorDb("Item (Entry: %u) not correct %u display id, must be %u (using it).",i,proto->DisplayInfoID,dbcitem->DisplayId);
1722                 const_cast<ItemPrototype*>(proto)->DisplayInfoID = dbcitem->DisplayId;
1723             }
1724             if(proto->Sheath != dbcitem->Sheath)
1725             {
1726                 sLog.outErrorDb("Item (Entry: %u) not correct %u sheath, must be %u  (using it).",i,proto->Sheath,dbcitem->Sheath);
1727                 const_cast<ItemPrototype*>(proto)->Sheath = dbcitem->Sheath;
1728             }
1729         }
1730         else
1731         {
1732             sLog.outErrorDb("Item (Entry: %u) not correct (not listed in list of existed items).",i);
1733         }
1734
1735         if(proto->Class >= MAX_ITEM_CLASS)
1736         {
1737             sLog.outErrorDb("Item (Entry: %u) has wrong Class value (%u)",i,proto->Class);
1738             const_cast<ItemPrototype*>(proto)->Class = ITEM_CLASS_MISC;
1739         }
1740
1741         if(proto->SubClass >= MaxItemSubclassValues[proto->Class])
1742         {
1743             sLog.outErrorDb("Item (Entry: %u) has wrong Subclass value (%u) for class %u",i,proto->SubClass,proto->Class);
1744             const_cast<ItemPrototype*>(proto)->SubClass = 0;// exist for all item classes
1745         }
1746
1747         if(proto->Quality >= MAX_ITEM_QUALITY)
1748         {
1749             sLog.outErrorDb("Item (Entry: %u) has wrong Quality value (%u)",i,proto->Quality);
1750             const_cast<ItemPrototype*>(proto)->Quality = ITEM_QUALITY_NORMAL;
1751         }
1752
1753         if(proto->BuyCount <= 0)
1754         {
1755             sLog.outErrorDb("Item (Entry: %u) has wrong BuyCount value (%u), set to default(1).",i,proto->BuyCount);
1756             const_cast<ItemPrototype*>(proto)->BuyCount = 1;
1757         }
1758
1759         if(proto->InventoryType >= MAX_INVTYPE)
1760         {
1761             sLog.outErrorDb("Item (Entry: %u) has wrong InventoryType value (%u)",i,proto->InventoryType);
1762             const_cast<ItemPrototype*>(proto)->InventoryType = INVTYPE_NON_EQUIP;
1763         }
1764
1765         if(proto->RequiredSkill >= MAX_SKILL_TYPE)
1766         {
1767             sLog.outErrorDb("Item (Entry: %u) has wrong RequiredSkill value (%u)",i,proto->RequiredSkill);
1768             const_cast<ItemPrototype*>(proto)->RequiredSkill = 0;
1769         }
1770
1771         {
1772             // can be used in equip slot, as page read use in inventory, or spell casting at use
1773             bool req = proto->InventoryType!=INVTYPE_NON_EQUIP || proto->PageText;
1774             if(!req)
1775             {
1776                 for (int j = 0; j < MAX_ITEM_PROTO_SPELLS; ++j)
1777                 {
1778                     if(proto->Spells[j].SpellId)
1779                     {
1780                         req = true;
1781                         break;
1782                     }
1783                 }
1784             }
1785
1786             if(req)
1787             {
1788                 if(!(proto->AllowableClass & CLASSMASK_ALL_PLAYABLE))
1789                     sLog.outErrorDb("Item (Entry: %u) not have in `AllowableClass` any playable classes (%u) and can't be equipped or use.",i,proto->AllowableClass);
1790
1791                 if(!(proto->AllowableRace & RACEMASK_ALL_PLAYABLE))
1792                     sLog.outErrorDb("Item (Entry: %u) not have in `AllowableRace` any playable races (%u) and can't be equipped or use.",i,proto->AllowableRace);
1793             }
1794         }
1795
1796         if(proto->RequiredSpell && !sSpellStore.LookupEntry(proto->RequiredSpell))
1797         {
1798             sLog.outErrorDb("Item (Entry: %u) have wrong (non-existed) spell in RequiredSpell (%u)",i,proto->RequiredSpell);
1799             const_cast<ItemPrototype*>(proto)->RequiredSpell = 0;
1800         }
1801
1802         if(proto->RequiredReputationRank >= MAX_REPUTATION_RANK)
1803             sLog.outErrorDb("Item (Entry: %u) has wrong reputation rank in RequiredReputationRank (%u), item can't be used.",i,proto->RequiredReputationRank);
1804
1805         if(proto->RequiredReputationFaction)
1806         {
1807             if(!sFactionStore.LookupEntry(proto->RequiredReputationFaction))
1808             {
1809                 sLog.outErrorDb("Item (Entry: %u) has wrong (not existing) faction in RequiredReputationFaction (%u)",i,proto->RequiredReputationFaction);
1810                 const_cast<ItemPrototype*>(proto)->RequiredReputationFaction = 0;
1811             }
1812
1813             if(proto->RequiredReputationRank == MIN_REPUTATION_RANK)
1814                 sLog.outErrorDb("Item (Entry: %u) has min. reputation rank in RequiredReputationRank (0) but RequiredReputationFaction > 0, faction setting is useless.",i);
1815         }
1816         else if(proto->RequiredReputationRank > MIN_REPUTATION_RANK)
1817             sLog.outErrorDb("Item (Entry: %u) has RequiredReputationFaction ==0 but RequiredReputationRank > 0, rank setting is useless.",i);
1818
1819         if(proto->MaxCount < -1)
1820         {
1821             sLog.outErrorDb("Item (Entry: %u) has too large negative in maxcount (%i), replace by value (-1) no storing limits.",i,proto->MaxCount);
1822             const_cast<ItemPrototype*>(proto)->MaxCount = -1;
1823         }
1824
1825         if(proto->Stackable == 0)
1826         {
1827             sLog.outErrorDb("Item (Entry: %u) has wrong value in stackable (%i), replace by default 1.",i,proto->Stackable);
1828             const_cast<ItemPrototype*>(proto)->Stackable = 1;
1829         }
1830         else if(proto->Stackable < -1)
1831         {
1832             sLog.outErrorDb("Item (Entry: %u) has too large negative in stackable (%i), replace by value (-1) no stacking limits.",i,proto->Stackable);
1833             const_cast<ItemPrototype*>(proto)->Stackable = -1;
1834         }
1835         else if(proto->Stackable > 1000)
1836         {
1837             sLog.outErrorDb("Item (Entry: %u) has too large value in stackable (%u), replace by hardcoded upper limit (1000).",i,proto->Stackable);
1838             const_cast<ItemPrototype*>(proto)->Stackable = 1000;
1839         }
1840
1841         if(proto->ContainerSlots > MAX_BAG_SIZE)
1842         {
1843             sLog.outErrorDb("Item (Entry: %u) has too large value in ContainerSlots (%u), replace by hardcoded limit (%u).",i,proto->ContainerSlots,MAX_BAG_SIZE);
1844             const_cast<ItemPrototype*>(proto)->ContainerSlots = MAX_BAG_SIZE;
1845         }
1846
1847         if(proto->StatsCount > MAX_ITEM_PROTO_STATS)
1848         {
1849             sLog.outErrorDb("Item (Entry: %u) has too large value in statscount (%u), replace by hardcoded limit (%u).",i,proto->StatsCount,MAX_ITEM_PROTO_STATS);
1850             const_cast<ItemPrototype*>(proto)->StatsCount = MAX_ITEM_PROTO_STATS;
1851         }
1852
1853         for (int j = 0; j < MAX_ITEM_PROTO_STATS; ++j)
1854         {
1855             // for ItemStatValue != 0
1856             if(proto->ItemStat[j].ItemStatValue && proto->ItemStat[j].ItemStatType >= MAX_ITEM_MOD)
1857             {
1858                 sLog.outErrorDb("Item (Entry: %u) has wrong stat_type%d (%u)",i,j+1,proto->ItemStat[j].ItemStatType);
1859                 const_cast<ItemPrototype*>(proto)->ItemStat[j].ItemStatType = 0;
1860             }
1861
1862             switch(proto->ItemStat[j].ItemStatType)
1863             {
1864                 case ITEM_MOD_SPELL_HEALING_DONE:
1865                 case ITEM_MOD_SPELL_DAMAGE_DONE:
1866                     sLog.outErrorDb("Item (Entry: %u) has deprecated stat_type%d (%u)",i,j+1,proto->ItemStat[j].ItemStatType);
1867                     break;
1868                 default:
1869                     break;
1870             }
1871         }
1872
1873         for (int j = 0; j < MAX_ITEM_PROTO_DAMAGES; ++j)
1874         {
1875             if(proto->Damage[j].DamageType >= MAX_SPELL_SCHOOL)
1876             {
1877                 sLog.outErrorDb("Item (Entry: %u) has wrong dmg_type%d (%u)",i,j+1,proto->Damage[j].DamageType);
1878                 const_cast<ItemPrototype*>(proto)->Damage[j].DamageType = 0;
1879             }
1880         }
1881
1882         // special format
1883         if((proto->Spells[0].SpellId == SPELL_ID_GENERIC_LEARN) || (proto->Spells[0].SpellId == SPELL_ID_GENERIC_LEARN_PET))
1884         {
1885             // spell_1
1886             if(proto->Spells[0].SpellTrigger != ITEM_SPELLTRIGGER_ON_USE)
1887             {
1888                 sLog.outErrorDb("Item (Entry: %u) has wrong item spell trigger value in spelltrigger_%d (%u) for special learning format",i,0+1,proto->Spells[0].SpellTrigger);
1889                 const_cast<ItemPrototype*>(proto)->Spells[0].SpellId = 0;
1890                 const_cast<ItemPrototype*>(proto)->Spells[0].SpellTrigger = ITEM_SPELLTRIGGER_ON_USE;
1891                 const_cast<ItemPrototype*>(proto)->Spells[1].SpellId = 0;
1892                 const_cast<ItemPrototype*>(proto)->Spells[1].SpellTrigger = ITEM_SPELLTRIGGER_ON_USE;
1893             }
1894
1895             // spell_2 have learning spell
1896             if(proto->Spells[1].SpellTrigger != ITEM_SPELLTRIGGER_LEARN_SPELL_ID)
1897             {
1898                 sLog.outErrorDb("Item (Entry: %u) has wrong item spell trigger value in spelltrigger_%d (%u) for special learning format.",i,1+1,proto->Spells[1].SpellTrigger);
1899                 const_cast<ItemPrototype*>(proto)->Spells[0].SpellId = 0;
1900                 const_cast<ItemPrototype*>(proto)->Spells[1].SpellId = 0;
1901                 const_cast<ItemPrototype*>(proto)->Spells[1].SpellTrigger = ITEM_SPELLTRIGGER_ON_USE;
1902             }
1903             else if(!proto->Spells[1].SpellId)
1904             {
1905                 sLog.outErrorDb("Item (Entry: %u) not has expected spell in spellid_%d in special learning format.",i,1+1);
1906                 const_cast<ItemPrototype*>(proto)->Spells[0].SpellId = 0;
1907                 const_cast<ItemPrototype*>(proto)->Spells[1].SpellTrigger = ITEM_SPELLTRIGGER_ON_USE;
1908             }
1909             else
1910             {
1911                 SpellEntry const* spellInfo = sSpellStore.LookupEntry(proto->Spells[1].SpellId);
1912                 if(!spellInfo)
1913                 {
1914                     sLog.outErrorDb("Item (Entry: %u) has wrong (not existing) spell in spellid_%d (%u)",i,1+1,proto->Spells[1].SpellId);
1915                     const_cast<ItemPrototype*>(proto)->Spells[0].SpellId = 0;
1916                     const_cast<ItemPrototype*>(proto)->Spells[1].SpellId = 0;
1917                     const_cast<ItemPrototype*>(proto)->Spells[1].SpellTrigger = ITEM_SPELLTRIGGER_ON_USE;
1918                 }
1919                 // allowed only in special format
1920                 else if((proto->Spells[1].SpellId==SPELL_ID_GENERIC_LEARN) || (proto->Spells[1].SpellId==SPELL_ID_GENERIC_LEARN_PET))
1921                 {
1922                     sLog.outErrorDb("Item (Entry: %u) has broken spell in spellid_%d (%u)",i,1+1,proto->Spells[1].SpellId);
1923                     const_cast<ItemPrototype*>(proto)->Spells[0].SpellId = 0;
1924                     const_cast<ItemPrototype*>(proto)->Spells[1].SpellId = 0;
1925                     const_cast<ItemPrototype*>(proto)->Spells[1].SpellTrigger = ITEM_SPELLTRIGGER_ON_USE;
1926                 }
1927             }
1928
1929             // spell_3*,spell_4*,spell_5* is empty
1930             for (int j = 2; j < MAX_ITEM_PROTO_SPELLS; ++j)
1931             {
1932                 if(proto->Spells[j].SpellTrigger != ITEM_SPELLTRIGGER_ON_USE)
1933                 {
1934                     sLog.outErrorDb("Item (Entry: %u) has wrong item spell trigger value in spelltrigger_%d (%u)",i,j+1,proto->Spells[j].SpellTrigger);
1935                     const_cast<ItemPrototype*>(proto)->Spells[j].SpellId = 0;
1936                     const_cast<ItemPrototype*>(proto)->Spells[j].SpellTrigger = ITEM_SPELLTRIGGER_ON_USE;
1937                 }
1938                 else if(proto->Spells[j].SpellId != 0)
1939                 {
1940                     sLog.outErrorDb("Item (Entry: %u) has wrong spell in spellid_%d (%u) for learning special format",i,j+1,proto->Spells[j].SpellId);
1941                     const_cast<ItemPrototype*>(proto)->Spells[j].SpellId = 0;
1942                 }
1943             }
1944         }
1945         // normal spell list
1946         else
1947         {
1948             for (int j = 0; j < MAX_ITEM_PROTO_SPELLS; ++j)
1949             {
1950                 if (proto->Spells[j].SpellTrigger >= MAX_ITEM_SPELLTRIGGER || proto->Spells[j].SpellTrigger == ITEM_SPELLTRIGGER_LEARN_SPELL_ID)
1951                 {
1952                     sLog.outErrorDb("Item (Entry: %u) has wrong item spell trigger value in spelltrigger_%d (%u)",i,j+1,proto->Spells[j].SpellTrigger);
1953                     const_cast<ItemPrototype*>(proto)->Spells[j].SpellId = 0;
1954                     const_cast<ItemPrototype*>(proto)->Spells[j].SpellTrigger = ITEM_SPELLTRIGGER_ON_USE;
1955                 }
1956                 // on hit can be sued only at weapon
1957                 else if (proto->Spells[j].SpellTrigger == ITEM_SPELLTRIGGER_CHANCE_ON_HIT)
1958                 {
1959                     if(proto->Class != ITEM_CLASS_WEAPON)
1960                         sLog.outErrorDb("Item (Entry: %u) isn't weapon (Class: %u) but has on hit spelltrigger_%d (%u), it will not triggered.",i,proto->Class,j+1,proto->Spells[j].SpellTrigger);
1961                 }
1962
1963                 if(proto->Spells[j].SpellId)
1964                 {
1965                     SpellEntry const* spellInfo = sSpellStore.LookupEntry(proto->Spells[j].SpellId);
1966                     if(!spellInfo)
1967                     {
1968                         sLog.outErrorDb("Item (Entry: %u) has wrong (not existing) spell in spellid_%d (%u)",i,j+1,proto->Spells[j].SpellId);
1969                         const_cast<ItemPrototype*>(proto)->Spells[j].SpellId = 0;
1970                     }
1971                     // allowed only in special format
1972                     else if((proto->Spells[j].SpellId==SPELL_ID_GENERIC_LEARN) || (proto->Spells[j].SpellId==SPELL_ID_GENERIC_LEARN_PET))
1973                     {
1974                         sLog.outErrorDb("Item (Entry: %u) has broken spell in spellid_%d (%u)",i,j+1,proto->Spells[j].SpellId);
1975                         const_cast<ItemPrototype*>(proto)->Spells[j].SpellId = 0;
1976                     }
1977                 }
1978             }
1979         }
1980
1981         if(proto->Bonding >= MAX_BIND_TYPE)
1982             sLog.outErrorDb("Item (Entry: %u) has wrong Bonding value (%u)",i,proto->Bonding);
1983
1984         if(proto->PageText && !sPageTextStore.LookupEntry<PageText>(proto->PageText))
1985             sLog.outErrorDb("Item (Entry: %u) has non existing first page (Id:%u)", i,proto->PageText);
1986
1987         if(proto->LockID && !sLockStore.LookupEntry(proto->LockID))
1988             sLog.outErrorDb("Item (Entry: %u) has wrong LockID (%u)",i,proto->LockID);
1989
1990         if(proto->Sheath >= MAX_SHEATHETYPE)
1991         {
1992             sLog.outErrorDb("Item (Entry: %u) has wrong Sheath (%u)",i,proto->Sheath);
1993             const_cast<ItemPrototype*>(proto)->Sheath = SHEATHETYPE_NONE;
1994         }
1995
1996         if(proto->RandomProperty && !sItemRandomPropertiesStore.LookupEntry(GetItemEnchantMod(proto->RandomProperty)))
1997         {
1998             sLog.outErrorDb("Item (Entry: %u) has unknown (wrong or not listed in `item_enchantment_template`) RandomProperty (%u)",i,proto->RandomProperty);
1999             const_cast<ItemPrototype*>(proto)->RandomProperty = 0;
2000         }
2001
2002         if(proto->RandomSuffix && !sItemRandomSuffixStore.LookupEntry(GetItemEnchantMod(proto->RandomSuffix)))
2003         {
2004             sLog.outErrorDb("Item (Entry: %u) has wrong RandomSuffix (%u)",i,proto->RandomSuffix);
2005             const_cast<ItemPrototype*>(proto)->RandomSuffix = 0;
2006         }
2007
2008         if(proto->ItemSet && !sItemSetStore.LookupEntry(proto->ItemSet))
2009         {
2010             sLog.outErrorDb("Item (Entry: %u) have wrong ItemSet (%u)",i,proto->ItemSet);
2011             const_cast<ItemPrototype*>(proto)->ItemSet = 0;
2012         }
2013
2014         if(proto->Area && !GetAreaEntryByAreaID(proto->Area))
2015             sLog.outErrorDb("Item (Entry: %u) has wrong Area (%u)",i,proto->Area);
2016
2017         if(proto->Map && !sMapStore.LookupEntry(proto->Map))
2018             sLog.outErrorDb("Item (Entry: %u) has wrong Map (%u)",i,proto->Map);
2019
2020         if(proto->BagFamily)
2021         {
2022             // check bits
2023             for(uint32 j = 0; j < sizeof(proto->BagFamily)*8; ++j)
2024             {
2025                 uint32 mask = 1 << j;
2026                 if((proto->BagFamily & mask)==0)
2027                     continue;
2028
2029                 ItemBagFamilyEntry const* bf = sItemBagFamilyStore.LookupEntry(j+1);
2030                 if(!bf)
2031                 {
2032                     sLog.outErrorDb("Item (Entry: %u) has bag family bit set not listed in ItemBagFamily.dbc, remove bit",i);
2033                     const_cast<ItemPrototype*>(proto)->BagFamily &= ~mask;
2034                     continue;
2035                 }
2036
2037                 if(BAG_FAMILY_MASK_CURRENCY_TOKENS & mask)
2038                 {
2039                     CurrencyTypesEntry const* ctEntry = sCurrencyTypesStore.LookupEntry(proto->ItemId);
2040                     if(!ctEntry)
2041                     {
2042                         sLog.outErrorDb("Item (Entry: %u) has currency bag family bit set in BagFamily but not listed in CurrencyTypes.dbc, remove bit",i);
2043                         const_cast<ItemPrototype*>(proto)->BagFamily &= ~mask;
2044                     }
2045                 }
2046             }
2047         }
2048
2049         if(proto->TotemCategory && !sTotemCategoryStore.LookupEntry(proto->TotemCategory))
2050             sLog.outErrorDb("Item (Entry: %u) has wrong TotemCategory (%u)",i,proto->TotemCategory);
2051
2052         for (int j = 0; j < MAX_ITEM_PROTO_SOCKETS; ++j)
2053         {
2054             if(proto->Socket[j].Color && (proto->Socket[j].Color & SOCKET_COLOR_ALL) != proto->Socket[j].Color)
2055             {
2056                 sLog.outErrorDb("Item (Entry: %u) has wrong socketColor_%d (%u)",i,j+1,proto->Socket[j].Color);
2057                 const_cast<ItemPrototype*>(proto)->Socket[j].Color = 0;
2058             }
2059         }
2060
2061         if(proto->GemProperties && !sGemPropertiesStore.LookupEntry(proto->GemProperties))
2062             sLog.outErrorDb("Item (Entry: %u) has wrong GemProperties (%u)",i,proto->GemProperties);
2063
2064         if(proto->FoodType >= MAX_PET_DIET)
2065         {
2066             sLog.outErrorDb("Item (Entry: %u) has wrong FoodType value (%u)",i,proto->FoodType);
2067             const_cast<ItemPrototype*>(proto)->FoodType = 0;
2068         }
2069
2070         if(proto->ItemLimitCategory && !sItemLimitCategoryStore.LookupEntry(proto->ItemLimitCategory))
2071         {
2072             sLog.outErrorDb("Item (Entry: %u) has wrong LimitCategory value (%u)",i,proto->ItemLimitCategory);
2073             const_cast<ItemPrototype*>(proto)->ItemLimitCategory = 0;
2074         }
2075
2076         if(proto->HolidayId && !sHolidaysStore.LookupEntry(proto->HolidayId))
2077         {
2078             sLog.outErrorDb("Item (Entry: %u) has wrong HolidayId value (%u)", i, proto->HolidayId);
2079             const_cast<ItemPrototype*>(proto)->HolidayId = 0;
2080         }
2081     }
2082
2083     // check some dbc referenced items (avoid duplicate reports)
2084     std::set<uint32> notFoundOutfit;
2085     for (uint32 i = 1; i < sCharStartOutfitStore.GetNumRows(); ++i)
2086     {
2087         CharStartOutfitEntry const* entry = sCharStartOutfitStore.LookupEntry(i);
2088         if (!entry)
2089             continue;
2090
2091         for(int j = 0; j < MAX_OUTFIT_ITEMS; ++j)
2092         {
2093             if(entry->ItemId[j] <= 0)
2094                 continue;
2095
2096             uint32 item_id = entry->ItemId[j];
2097
2098             if(!GetItemPrototype(item_id))
2099                 notFoundOutfit.insert(item_id);
2100         }
2101     }
2102
2103     for(std::set<uint32>::const_iterator itr = notFoundOutfit.begin(); itr != notFoundOutfit.end(); ++itr)
2104         sLog.outErrorDb("Item (Entry: %u) not exist in `item_template` but referenced in `CharStartOutfit.dbc`", *itr);
2105 }
2106
2107 void ObjectMgr::LoadItemRequiredTarget()
2108 {
2109     m_ItemRequiredTarget.clear();                           // needed for reload case
2110
2111     uint32 count = 0;
2112
2113     QueryResult *result = WorldDatabase.Query("SELECT entry,type,targetEntry FROM item_required_target");
2114
2115     if (!result)
2116     {
2117         barGoLink bar(1);
2118
2119         bar.step();
2120
2121         sLog.outString();
2122         sLog.outErrorDb(">> Loaded 0 ItemRequiredTarget. DB table `item_required_target` is empty.");
2123         return;
2124     }
2125
2126     barGoLink bar(result->GetRowCount());
2127
2128     do
2129     {
2130         Field *fields = result->Fetch();
2131         bar.step();
2132
2133         uint32 uiItemId      = fields[0].GetUInt32();
2134         uint32 uiType        = fields[1].GetUInt32();
2135         uint32 uiTargetEntry = fields[2].GetUInt32();
2136
2137         ItemPrototype const* pItemProto = sItemStorage.LookupEntry<ItemPrototype>(uiItemId);
2138
2139         if (!pItemProto)
2140         {
2141             sLog.outErrorDb("Table `item_required_target`: Entry %u listed for TargetEntry %u does not exist in `item_template`.",uiItemId,uiTargetEntry);
2142             continue;
2143         }
2144
2145         bool bIsItemSpellValid = false;
2146
2147         for(int i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
2148         {
2149             if (SpellEntry const* pSpellInfo = sSpellStore.LookupEntry(pItemProto->Spells[i].SpellId))
2150             {
2151                 if (pItemProto->Spells[i].SpellTrigger == ITEM_SPELLTRIGGER_ON_USE ||
2152                     pItemProto->Spells[i].SpellTrigger == ITEM_SPELLTRIGGER_ON_NO_DELAY_USE)
2153                 {
2154                     SpellScriptTargetBounds bounds = sSpellMgr.GetSpellScriptTargetBounds(pSpellInfo->Id);
2155                     if (bounds.first != bounds.second)
2156                         break;
2157
2158                     for (int j = 0; j < 3; ++j)
2159                     {
2160                         if (pSpellInfo->EffectImplicitTargetA[j] == TARGET_CHAIN_DAMAGE ||
2161                             pSpellInfo->EffectImplicitTargetB[j] == TARGET_CHAIN_DAMAGE ||
2162                             pSpellInfo->EffectImplicitTargetA[j] == TARGET_DUELVSPLAYER ||
2163                             pSpellInfo->EffectImplicitTargetB[j] == TARGET_DUELVSPLAYER)
2164                         {
2165                             bIsItemSpellValid = true;
2166                             break;
2167                         }
2168                     }
2169                     if (bIsItemSpellValid)
2170                         break;
2171                 }
2172             }
2173         }
2174
2175         if (!bIsItemSpellValid)
2176         {
2177             sLog.outErrorDb("Table `item_required_target`: Spell used by item %u does not have implicit target TARGET_CHAIN_DAMAGE(6), TARGET_DUELVSPLAYER(25), already listed in `spell_script_target` or doesn't have item spelltrigger.",uiItemId);
2178             continue;
2179         }
2180
2181         if (!uiType || uiType > MAX_ITEM_REQ_TARGET_TYPE)
2182         {
2183             sLog.outErrorDb("Table `item_required_target`: Type %u for TargetEntry %u is incorrect.",uiType,uiTargetEntry);
2184             continue;
2185         }
2186
2187         if (!uiTargetEntry)
2188         {
2189             sLog.outErrorDb("Table `item_required_target`: TargetEntry == 0 for Type (%u).",uiType);
2190             continue;
2191         }
2192
2193         if (!sCreatureStorage.LookupEntry<CreatureInfo>(uiTargetEntry))
2194         {
2195             sLog.outErrorDb("Table `item_required_target`: creature template entry %u does not exist.",uiTargetEntry);
2196             continue;
2197         }
2198
2199         m_ItemRequiredTarget.insert(ItemRequiredTargetMap::value_type(uiItemId,ItemRequiredTarget(ItemRequiredTargetType(uiType),uiTargetEntry)));
2200
2201         ++count;
2202     } while (result->NextRow());
2203
2204     delete result;
2205
2206     sLog.outString();
2207     sLog.outString(">> Loaded %u Item required targets", count);
2208 }
2209
2210 void ObjectMgr::LoadPetLevelInfo()
2211 {
2212     // Loading levels data
2213     {
2214         //                                                 0               1      2   3     4    5    6    7     8    9
2215         QueryResult *result  = WorldDatabase.Query("SELECT creature_entry, level, hp, mana, str, agi, sta, inte, spi, armor FROM pet_levelstats");
2216
2217         uint32 count = 0;
2218
2219         if (!result)
2220         {
2221             barGoLink bar( 1 );
2222             bar.step();
2223
2224             sLog.outString();
2225             sLog.outString(">> Loaded %u level pet stats definitions", count);
2226             sLog.outErrorDb("Error loading `pet_levelstats` table or empty table.");
2227             return;
2228         }
2229
2230         barGoLink bar( result->GetRowCount() );
2231
2232         do
2233         {
2234             Field* fields = result->Fetch();
2235
2236             uint32 creature_id = fields[0].GetUInt32();
2237             if(!sCreatureStorage.LookupEntry<CreatureInfo>(creature_id))
2238             {
2239                 sLog.outErrorDb("Wrong creature id %u in `pet_levelstats` table, ignoring.",creature_id);
2240                 continue;
2241             }
2242
2243             uint32 current_level = fields[1].GetUInt32();
2244             if(current_level > sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL))
2245             {
2246                 if(current_level > STRONG_MAX_LEVEL)        // hardcoded level maximum
2247                     sLog.outErrorDb("Wrong (> %u) level %u in `pet_levelstats` table, ignoring.",STRONG_MAX_LEVEL,current_level);
2248                 else
2249                 {
2250                     sLog.outDetail("Unused (> MaxPlayerLevel in mangosd.conf) level %u in `pet_levelstats` table, ignoring.",current_level);
2251                     ++count;                                // make result loading percent "expected" correct in case disabled detail mode for example.
2252                 }
2253                 continue;
2254             }
2255             else if(current_level < 1)
2256             {
2257                 sLog.outErrorDb("Wrong (<1) level %u in `pet_levelstats` table, ignoring.",current_level);
2258                 continue;
2259             }
2260
2261             PetLevelInfo*& pInfoMapEntry = petInfo[creature_id];
2262
2263             if(pInfoMapEntry==NULL)
2264                 pInfoMapEntry =  new PetLevelInfo[sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL)];
2265
2266             // data for level 1 stored in [0] array element, ...
2267             PetLevelInfo* pLevelInfo = &pInfoMapEntry[current_level-1];
2268
2269             pLevelInfo->health = fields[2].GetUInt16();
2270             pLevelInfo->mana   = fields[3].GetUInt16();
2271             pLevelInfo->armor  = fields[9].GetUInt16();
2272
2273             for (int i = 0; i < MAX_STATS; i++)
2274             {
2275                 pLevelInfo->stats[i] = fields[i+4].GetUInt16();
2276             }
2277
2278             bar.step();
2279             ++count;
2280         }
2281         while (result->NextRow());
2282
2283         delete result;
2284
2285         sLog.outString();
2286         sLog.outString( ">> Loaded %u level pet stats definitions", count );
2287     }
2288
2289     // Fill gaps and check integrity
2290     for (PetLevelInfoMap::iterator itr = petInfo.begin(); itr != petInfo.end(); ++itr)
2291     {
2292         PetLevelInfo* pInfo = itr->second;
2293
2294         // fatal error if no level 1 data
2295         if(!pInfo || pInfo[0].health == 0 )
2296         {
2297             sLog.outErrorDb("Creature %u does not have pet stats data for Level 1!",itr->first);
2298             exit(1);
2299         }
2300
2301         // fill level gaps
2302         for (uint32 level = 1; level < sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL); ++level)
2303         {
2304             if(pInfo[level].health == 0)
2305             {
2306                 sLog.outErrorDb("Creature %u has no data for Level %i pet stats data, using data of Level %i.",itr->first,level+1, level);
2307                 pInfo[level] = pInfo[level-1];
2308             }
2309         }
2310     }
2311 }
2312
2313 PetLevelInfo const* ObjectMgr::GetPetLevelInfo(uint32 creature_id, uint32 level) const
2314 {
2315     if(level > sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL))
2316         level = sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL);
2317
2318     PetLevelInfoMap::const_iterator itr = petInfo.find(creature_id);
2319     if(itr == petInfo.end())
2320         return NULL;
2321
2322     return &itr->second[level-1];                           // data for level 1 stored in [0] array element, ...
2323 }
2324
2325 void ObjectMgr::LoadPlayerInfo()
2326 {
2327     // Load playercreate
2328     {
2329         //                                                0     1      2    3     4           5           6
2330         QueryResult *result = WorldDatabase.Query("SELECT race, class, map, zone, position_x, position_y, position_z FROM playercreateinfo");
2331
2332         uint32 count = 0;
2333
2334         if (!result)
2335         {
2336             barGoLink bar( 1 );
2337
2338             sLog.outString();
2339             sLog.outString( ">> Loaded %u player create definitions", count );
2340             sLog.outErrorDb( "Error loading `playercreateinfo` table or empty table.");
2341             exit(1);
2342         }
2343
2344         barGoLink bar( result->GetRowCount() );
2345
2346         do
2347         {
2348             Field* fields = result->Fetch();
2349
2350             uint32 current_race = fields[0].GetUInt32();
2351             uint32 current_class = fields[1].GetUInt32();
2352             uint32 mapId     = fields[2].GetUInt32();
2353             uint32 zoneId    = fields[3].GetUInt32();
2354             float  positionX = fields[4].GetFloat();
2355             float  positionY = fields[5].GetFloat();
2356             float  positionZ = fields[6].GetFloat();
2357
2358             if(current_race >= MAX_RACES)
2359             {
2360                 sLog.outErrorDb("Wrong race %u in `playercreateinfo` table, ignoring.",current_race);
2361                 continue;
2362             }
2363
2364             ChrRacesEntry const* rEntry = sChrRacesStore.LookupEntry(current_race);
2365             if(!rEntry)
2366             {
2367                 sLog.outErrorDb("Wrong race %u in `playercreateinfo` table, ignoring.",current_race);
2368                 continue;
2369             }
2370
2371             if(current_class >= MAX_CLASSES)
2372             {
2373                 sLog.outErrorDb("Wrong class %u in `playercreateinfo` table, ignoring.",current_class);
2374                 continue;
2375             }
2376
2377             if(!sChrClassesStore.LookupEntry(current_class))
2378             {
2379                 sLog.outErrorDb("Wrong class %u in `playercreateinfo` table, ignoring.",current_class);
2380                 continue;
2381             }
2382
2383             // accept DB data only for valid position (and non instanceable)
2384             if( !MapManager::IsValidMapCoord(mapId,positionX,positionY,positionZ) )
2385             {
2386                 sLog.outErrorDb("Wrong home position for class %u race %u pair in `playercreateinfo` table, ignoring.",current_class,current_race);
2387                 continue;
2388             }
2389
2390             if( sMapStore.LookupEntry(mapId)->Instanceable() )
2391             {
2392                 sLog.outErrorDb("Home position in instanceable map for class %u race %u pair in `playercreateinfo` table, ignoring.",current_class,current_race);
2393                 continue;
2394             }
2395
2396             PlayerInfo* pInfo = &playerInfo[current_race][current_class];
2397
2398             pInfo->mapId     = mapId;
2399             pInfo->zoneId    = zoneId;
2400             pInfo->positionX = positionX;
2401             pInfo->positionY = positionY;
2402             pInfo->positionZ = positionZ;
2403
2404             pInfo->displayId_m = rEntry->model_m;
2405             pInfo->displayId_f = rEntry->model_f;
2406
2407             bar.step();
2408             ++count;
2409         }
2410         while (result->NextRow());
2411
2412         delete result;
2413
2414         sLog.outString();
2415         sLog.outString( ">> Loaded %u player create definitions", count );
2416     }
2417
2418     // Load playercreate items
2419     {
2420         //                                                0     1      2       3
2421         QueryResult *result = WorldDatabase.Query("SELECT race, class, itemid, amount FROM playercreateinfo_item");
2422
2423         uint32 count = 0;
2424
2425         if (!result)
2426         {
2427             barGoLink bar( 1 );
2428
2429             bar.step();
2430
2431             sLog.outString();
2432             sLog.outString( ">> Loaded %u custom player create items", count );
2433         }
2434         else
2435         {
2436             barGoLink bar( result->GetRowCount() );
2437
2438             do
2439             {
2440                 Field* fields = result->Fetch();
2441
2442                 uint32 current_race = fields[0].GetUInt32();
2443                 if(current_race >= MAX_RACES)
2444                 {
2445                     sLog.outErrorDb("Wrong race %u in `playercreateinfo_item` table, ignoring.",current_race);
2446                     continue;
2447                 }
2448
2449                 uint32 current_class = fields[1].GetUInt32();
2450                 if(current_class >= MAX_CLASSES)
2451                 {
2452                     sLog.outErrorDb("Wrong class %u in `playercreateinfo_item` table, ignoring.",current_class);
2453                     continue;
2454                 }
2455
2456                 PlayerInfo* pInfo = &playerInfo[current_race][current_class];
2457
2458                 uint32 item_id = fields[2].GetUInt32();
2459
2460                 if(!GetItemPrototype(item_id))
2461                 {
2462                     sLog.outErrorDb("Item id %u (race %u class %u) in `playercreateinfo_item` table but not listed in `item_template`, ignoring.",item_id,current_race,current_class);
2463                     continue;
2464                 }
2465
2466                 uint32 amount  = fields[3].GetUInt32();
2467
2468                 if(!amount)
2469                 {
2470                     sLog.outErrorDb("Item id %u (class %u race %u) have amount==0 in `playercreateinfo_item` table, ignoring.",item_id,current_race,current_class);
2471                     continue;
2472                 }
2473
2474                 pInfo->item.push_back(PlayerCreateInfoItem( item_id, amount));
2475
2476                 bar.step();
2477                 ++count;
2478             }
2479             while(result->NextRow());
2480
2481             delete result;
2482
2483             sLog.outString();
2484             sLog.outString( ">> Loaded %u custom player create items", count );
2485         }
2486     }
2487
2488     // Load playercreate spells
2489     {
2490         //                                                0     1      2
2491         QueryResult *result = WorldDatabase.Query("SELECT race, class, Spell FROM playercreateinfo_spell");
2492
2493         uint32 count = 0;
2494
2495         if (!result)
2496         {
2497             barGoLink bar( 1 );
2498
2499             sLog.outString();
2500             sLog.outString( ">> Loaded %u player create spells", count );
2501             sLog.outErrorDb( "Error loading `playercreateinfo_spell` table or empty table.");
2502         }
2503         else
2504         {
2505             barGoLink bar( result->GetRowCount() );
2506
2507             do
2508             {
2509                 Field* fields = result->Fetch();
2510
2511                 uint32 current_race = fields[0].GetUInt32();
2512                 if(current_race >= MAX_RACES)
2513                 {
2514                     sLog.outErrorDb("Wrong race %u in `playercreateinfo_spell` table, ignoring.",current_race);
2515                     continue;
2516                 }
2517
2518                 uint32 current_class = fields[1].GetUInt32();
2519                 if(current_class >= MAX_CLASSES)
2520                 {
2521                     sLog.outErrorDb("Wrong class %u in `playercreateinfo_spell` table, ignoring.",current_class);
2522                     continue;
2523                 }
2524
2525                 uint32 spell_id = fields[2].GetUInt32();
2526                 if (!sSpellStore.LookupEntry(spell_id))
2527                 {
2528                     sLog.outErrorDb("Non existing spell %u in `playercreateinfo_spell` table, ignoring.", spell_id);
2529                     continue;
2530                 }
2531
2532                 PlayerInfo* pInfo = &playerInfo[current_race][current_class];
2533                 pInfo->spell.push_back(spell_id);
2534
2535                 bar.step();
2536                 ++count;
2537             }
2538             while( result->NextRow() );
2539
2540             delete result;
2541
2542             sLog.outString();
2543             sLog.outString( ">> Loaded %u player create spells", count );
2544         }
2545     }
2546
2547     // Load playercreate actions
2548     {
2549         //                                                0     1      2       3       4
2550         QueryResult *result = WorldDatabase.Query("SELECT race, class, button, action, type FROM playercreateinfo_action");
2551
2552         uint32 count = 0;
2553
2554         if (!result)
2555         {
2556             barGoLink bar( 1 );
2557
2558             sLog.outString();
2559             sLog.outString( ">> Loaded %u player create actions", count );
2560             sLog.outErrorDb( "Error loading `playercreateinfo_action` table or empty table.");
2561         }
2562         else
2563         {
2564             barGoLink bar( result->GetRowCount() );
2565
2566             do
2567             {
2568                 Field* fields = result->Fetch();
2569
2570                 uint32 current_race = fields[0].GetUInt32();
2571                 if(current_race >= MAX_RACES)
2572                 {
2573                     sLog.outErrorDb("Wrong race %u in `playercreateinfo_action` table, ignoring.",current_race);
2574                     continue;
2575                 }
2576
2577                 uint32 current_class = fields[1].GetUInt32();
2578                 if(current_class >= MAX_CLASSES)
2579                 {
2580                     sLog.outErrorDb("Wrong class %u in `playercreateinfo_action` table, ignoring.",current_class);
2581                     continue;
2582                 }
2583
2584                 uint8 action_button  = fields[2].GetUInt8();
2585                 uint32 action = fields[3].GetUInt32();
2586                 uint8 action_type = fields[4].GetUInt8();
2587
2588                 if (!Player::IsActionButtonDataValid(action_button,action,action_type,NULL))
2589                     continue;
2590
2591                 PlayerInfo* pInfo = &playerInfo[current_race][current_class];
2592                 pInfo->action.push_back(PlayerCreateInfoAction(action_button,action,action_type));
2593
2594                 bar.step();
2595                 ++count;
2596             }
2597             while( result->NextRow() );
2598
2599             delete result;
2600
2601             sLog.outString();
2602             sLog.outString( ">> Loaded %u player create actions", count );
2603         }
2604     }
2605
2606     // Loading levels data (class only dependent)
2607     {
2608         //                                                 0      1      2       3
2609         QueryResult *result  = WorldDatabase.Query("SELECT class, level, basehp, basemana FROM player_classlevelstats");
2610
2611         uint32 count = 0;
2612
2613         if (!result)
2614         {
2615             barGoLink bar( 1 );
2616
2617             sLog.outString();
2618             sLog.outString( ">> Loaded %u level health/mana definitions", count );
2619             sLog.outErrorDb( "Error loading `player_classlevelstats` table or empty table.");
2620             exit(1);
2621         }
2622
2623         barGoLink bar( result->GetRowCount() );
2624
2625         do
2626         {
2627             Field* fields = result->Fetch();
2628
2629             uint32 current_class = fields[0].GetUInt32();
2630             if(current_class >= MAX_CLASSES)
2631             {
2632                 sLog.outErrorDb("Wrong class %u in `player_classlevelstats` table, ignoring.",current_class);
2633                 continue;
2634             }
2635
2636             uint32 current_level = fields[1].GetUInt32();
2637             if(current_level == 0)
2638             {
2639                 sLog.outErrorDb("Wrong level %u in `player_classlevelstats` table, ignoring.",current_level);
2640                 continue;
2641             }
2642             else if(current_level > sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL))
2643             {
2644                 if(current_level > STRONG_MAX_LEVEL)        // hardcoded level maximum
2645                     sLog.outErrorDb("Wrong (> %u) level %u in `player_classlevelstats` table, ignoring.",STRONG_MAX_LEVEL,current_level);
2646                 else
2647                 {
2648                     sLog.outDetail("Unused (> MaxPlayerLevel in mangosd.conf) level %u in `player_classlevelstats` table, ignoring.",current_level);
2649                     ++count;                                // make result loading percent "expected" correct in case disabled detail mode for example.
2650                 }
2651                 continue;
2652             }
2653
2654             PlayerClassInfo* pClassInfo = &playerClassInfo[current_class];
2655
2656             if(!pClassInfo->levelInfo)
2657                 pClassInfo->levelInfo = new PlayerClassLevelInfo[sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL)];
2658
2659             PlayerClassLevelInfo* pClassLevelInfo = &pClassInfo->levelInfo[current_level-1];
2660
2661             pClassLevelInfo->basehealth = fields[2].GetUInt16();
2662             pClassLevelInfo->basemana   = fields[3].GetUInt16();
2663
2664             bar.step();
2665             ++count;
2666         }
2667         while (result->NextRow());
2668
2669         delete result;
2670
2671         sLog.outString();
2672         sLog.outString( ">> Loaded %u level health/mana definitions", count );
2673     }
2674
2675     // Fill gaps and check integrity
2676     for (int class_ = 0; class_ < MAX_CLASSES; ++class_)
2677     {
2678         // skip non existed classes
2679         if(!sChrClassesStore.LookupEntry(class_))
2680             continue;
2681
2682         PlayerClassInfo* pClassInfo = &playerClassInfo[class_];
2683
2684         // fatal error if no level 1 data
2685         if(!pClassInfo->levelInfo || pClassInfo->levelInfo[0].basehealth == 0 )
2686         {
2687             sLog.outErrorDb("Class %i Level 1 does not have health/mana data!",class_);
2688             exit(1);
2689         }
2690
2691         // fill level gaps
2692         for (uint32 level = 1; level < sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL); ++level)
2693         {
2694             if(pClassInfo->levelInfo[level].basehealth == 0)
2695             {
2696                 sLog.outErrorDb("Class %i Level %i does not have health/mana data. Using stats data of level %i.",class_,level+1, level);
2697                 pClassInfo->levelInfo[level] = pClassInfo->levelInfo[level-1];
2698             }
2699         }
2700     }
2701
2702     // Loading levels data (class/race dependent)
2703     {
2704         //                                                 0     1      2      3    4    5    6    7
2705         QueryResult *result  = WorldDatabase.Query("SELECT race, class, level, str, agi, sta, inte, spi FROM player_levelstats");
2706
2707         uint32 count = 0;
2708
2709         if (!result)
2710         {
2711             barGoLink bar( 1 );
2712
2713             sLog.outString();
2714             sLog.outString( ">> Loaded %u level stats definitions", count );
2715             sLog.outErrorDb( "Error loading `player_levelstats` table or empty table.");
2716             exit(1);
2717         }
2718
2719         barGoLink bar( result->GetRowCount() );
2720
2721         do
2722         {
2723             Field* fields = result->Fetch();
2724
2725             uint32 current_race = fields[0].GetUInt32();
2726             if(current_race >= MAX_RACES)
2727             {
2728                 sLog.outErrorDb("Wrong race %u in `player_levelstats` table, ignoring.",current_race);
2729                 continue;
2730             }
2731
2732             uint32 current_class = fields[1].GetUInt32();
2733             if(current_class >= MAX_CLASSES)
2734             {
2735                 sLog.outErrorDb("Wrong class %u in `player_levelstats` table, ignoring.",current_class);
2736                 continue;
2737             }
2738
2739             uint32 current_level = fields[2].GetUInt32();
2740             if(current_level > sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL))
2741             {
2742                 if(current_level > STRONG_MAX_LEVEL)        // hardcoded level maximum
2743                     sLog.outErrorDb("Wrong (> %u) level %u in `player_levelstats` table, ignoring.",STRONG_MAX_LEVEL,current_level);
2744                 else
2745                 {
2746                     sLog.outDetail("Unused (> MaxPlayerLevel in mangosd.conf) level %u in `player_levelstats` table, ignoring.",current_level);
2747                     ++count;                                // make result loading percent "expected" correct in case disabled detail mode for example.
2748                 }
2749                 continue;
2750             }
2751
2752             PlayerInfo* pInfo = &playerInfo[current_race][current_class];
2753
2754             if(!pInfo->levelInfo)
2755                 pInfo->levelInfo = new PlayerLevelInfo[sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL)];
2756
2757             PlayerLevelInfo* pLevelInfo = &pInfo->levelInfo[current_level-1];
2758
2759             for (int i = 0; i < MAX_STATS; i++)
2760             {
2761                 pLevelInfo->stats[i] = fields[i+3].GetUInt8();
2762             }
2763
2764             bar.step();
2765             ++count;
2766         }
2767         while (result->NextRow());
2768
2769         delete result;
2770
2771         sLog.outString();
2772         sLog.outString( ">> Loaded %u level stats definitions", count );
2773     }
2774
2775     // Fill gaps and check integrity
2776     for (int race = 0; race < MAX_RACES; ++race)
2777     {
2778         // skip non existed races
2779         if(!sChrRacesStore.LookupEntry(race))
2780             continue;
2781
2782         for (int class_ = 0; class_ < MAX_CLASSES; ++class_)
2783         {
2784             // skip non existed classes
2785             if(!sChrClassesStore.LookupEntry(class_))
2786                 continue;
2787
2788             PlayerInfo* pInfo = &playerInfo[race][class_];
2789
2790             // skip non loaded combinations
2791             if(!pInfo->displayId_m || !pInfo->displayId_f)
2792                 continue;
2793
2794             // skip expansion races if not playing with expansion
2795             if (sWorld.getConfig(CONFIG_EXPANSION) < 1 && (race == RACE_BLOODELF || race == RACE_DRAENEI))
2796                 continue;
2797
2798             // skip expansion classes if not playing with expansion
2799             if (sWorld.getConfig(CONFIG_EXPANSION) < 2 && class_ == CLASS_DEATH_KNIGHT)
2800                 continue;
2801
2802             // fatal error if no level 1 data
2803             if(!pInfo->levelInfo || pInfo->levelInfo[0].stats[0] == 0 )
2804             {
2805                 sLog.outErrorDb("Race %i Class %i Level 1 does not have stats data!",race,class_);
2806                 exit(1);
2807             }
2808
2809             // fill level gaps
2810             for (uint32 level = 1; level < sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL); ++level)
2811             {
2812                 if(pInfo->levelInfo[level].stats[0] == 0)
2813                 {
2814                     sLog.outErrorDb("Race %i Class %i Level %i does not have stats data. Using stats data of level %i.",race,class_,level+1, level);
2815                     pInfo->levelInfo[level] = pInfo->levelInfo[level-1];
2816                 }
2817             }
2818         }
2819     }
2820
2821     // Loading xp per level data
2822     {
2823         mPlayerXPperLevel.resize(sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL));
2824         for (uint32 level = 0; level < sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL); ++level)
2825             mPlayerXPperLevel[level] = 0;
2826
2827         //                                                 0    1
2828         QueryResult *result  = WorldDatabase.Query("SELECT lvl, xp_for_next_level FROM player_xp_for_level");
2829
2830         uint32 count = 0;
2831
2832         if (!result)
2833         {
2834             barGoLink bar( 1 );
2835
2836             sLog.outString();
2837             sLog.outString( ">> Loaded %u xp for level definitions", count );
2838             sLog.outErrorDb( "Error loading `player_xp_for_level` table or empty table.");
2839             exit(1);
2840         }
2841
2842         barGoLink bar( result->GetRowCount() );
2843
2844         do
2845         {
2846             Field* fields = result->Fetch();
2847
2848             uint32 current_level = fields[0].GetUInt32();
2849             uint32 current_xp    = fields[1].GetUInt32();
2850
2851             if(current_level >= sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL))
2852             {
2853                 if(current_level > STRONG_MAX_LEVEL)        // hardcoded level maximum
2854                     sLog.outErrorDb("Wrong (> %u) level %u in `player_xp_for_level` table, ignoring.", STRONG_MAX_LEVEL,current_level);
2855                 else
2856                 {
2857                     sLog.outDetail("Unused (> MaxPlayerLevel in mangosd.conf) level %u in `player_xp_for_levels` table, ignoring.",current_level);
2858                     ++count;                                // make result loading percent "expected" correct in case disabled detail mode for example.
2859                 }
2860                 continue;
2861             }
2862             //PlayerXPperLevel
2863             mPlayerXPperLevel[current_level] = current_xp;
2864             bar.step();
2865             ++count;
2866         }
2867         while (result->NextRow());
2868
2869         delete result;
2870
2871         sLog.outString();
2872         sLog.outString( ">> Loaded %u xp for level definitions", count );
2873     }
2874
2875     // fill level gaps
2876     for (uint32 level = 1; level < sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL); ++level)
2877     {
2878         if( mPlayerXPperLevel[level] == 0)
2879         {
2880             sLog.outErrorDb("Level %i does not have XP for level data. Using data of level [%i] + 100.",level+1, level);
2881             mPlayerXPperLevel[level] = mPlayerXPperLevel[level-1]+100;
2882         }
2883     }
2884 }
2885
2886 void ObjectMgr::GetPlayerClassLevelInfo(uint32 class_, uint32 level, PlayerClassLevelInfo* info) const
2887 {
2888     if(level < 1 || class_ >= MAX_CLASSES)
2889         return;
2890
2891     PlayerClassInfo const* pInfo = &playerClassInfo[class_];
2892
2893     if(level > sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL))
2894         level = sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL);
2895
2896     *info = pInfo->levelInfo[level-1];
2897 }
2898
2899 void ObjectMgr::GetPlayerLevelInfo(uint32 race, uint32 class_, uint32 level, PlayerLevelInfo* info) const
2900 {
2901     if(level < 1 || race   >= MAX_RACES || class_ >= MAX_CLASSES)
2902         return;
2903
2904     PlayerInfo const* pInfo = &playerInfo[race][class_];
2905     if(pInfo->displayId_m==0 || pInfo->displayId_f==0)
2906         return;
2907
2908     if(level <= sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL))
2909         *info = pInfo->levelInfo[level-1];
2910     else
2911         BuildPlayerLevelInfo(race,class_,level,info);
2912 }
2913
2914 void ObjectMgr::BuildPlayerLevelInfo(uint8 race, uint8 _class, uint8 level, PlayerLevelInfo* info) const
2915 {
2916     // base data (last known level)
2917     *info = playerInfo[race][_class].levelInfo[sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL)-1];
2918
2919     for(int lvl = sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL)-1; lvl < level; ++lvl)
2920     {
2921         switch(_class)
2922         {
2923             case CLASS_WARRIOR:
2924                 info->stats[STAT_STRENGTH]  += (lvl > 23 ? 2: (lvl > 1  ? 1: 0));
2925                 info->stats[STAT_STAMINA]   += (lvl > 23 ? 2: (lvl > 1  ? 1: 0));
2926                 info->stats[STAT_AGILITY]   += (lvl > 36 ? 1: (lvl > 6 && (lvl%2) ? 1: 0));
2927                 info->stats[STAT_INTELLECT] += (lvl > 9 && !(lvl%2) ? 1: 0);
2928                 info->stats[STAT_SPIRIT]    += (lvl > 9 && !(lvl%2) ? 1: 0);
2929                 break;
2930             case CLASS_PALADIN:
2931                 info->stats[STAT_STRENGTH]  += (lvl > 3  ? 1: 0);
2932                 info->stats[STAT_STAMINA]   += (lvl > 33 ? 2: (lvl > 1 ? 1: 0));
2933                 info->stats[STAT_AGILITY]   += (lvl > 38 ? 1: (lvl > 7 && !(lvl%2) ? 1: 0));
2934                 info->stats[STAT_INTELLECT] += (lvl > 6 && (lvl%2) ? 1: 0);
2935                 info->stats[STAT_SPIRIT]    += (lvl > 7 ? 1: 0);
2936                 break;
2937             case CLASS_HUNTER:
2938                 info->stats[STAT_STRENGTH]  += (lvl > 4  ? 1: 0);
2939                 info->stats[STAT_STAMINA]   += (lvl > 4  ? 1: 0);
2940                 info->stats[STAT_AGILITY]   += (lvl > 33 ? 2: (lvl > 1 ? 1: 0));
2941                 info->stats[STAT_INTELLECT] += (lvl > 8 && (lvl%2) ? 1: 0);
2942                 info->stats[STAT_SPIRIT]    += (lvl > 38 ? 1: (lvl > 9 && !(lvl%2) ? 1: 0));
2943                 break;
2944             case CLASS_ROGUE:
2945                 info->stats[STAT_STRENGTH]  += (lvl > 5  ? 1: 0);
2946                 info->stats[STAT_STAMINA]   += (lvl > 4  ? 1: 0);
2947                 info->stats[STAT_AGILITY]   += (lvl > 16 ? 2: (lvl > 1 ? 1: 0));
2948                 info->stats[STAT_INTELLECT] += (lvl > 8 && !(lvl%2) ? 1: 0);
2949                 info->stats[STAT_SPIRIT]    += (lvl > 38 ? 1: (lvl > 9 && !(lvl%2) ? 1: 0));
2950                 break;
2951             case CLASS_PRIEST:
2952                 info->stats[STAT_STRENGTH]  += (lvl > 9 && !(lvl%2) ? 1: 0);
2953                 info->stats[STAT_STAMINA]   += (lvl > 5  ? 1: 0);
2954                 info->stats[STAT_AGILITY]   += (lvl > 38 ? 1: (lvl > 8 && (lvl%2) ? 1: 0));
2955                 info->stats[STAT_INTELLECT] += (lvl > 22 ? 2: (lvl > 1 ? 1: 0));
2956                 info->stats[STAT_SPIRIT]    += (lvl > 3  ? 1: 0);
2957                 break;
2958             case CLASS_SHAMAN:
2959                 info->stats[STAT_STRENGTH]  += (lvl > 34 ? 1: (lvl > 6 && (lvl%2) ? 1: 0));
2960                 info->stats[STAT_STAMINA]   += (lvl > 4 ? 1: 0);
2961                 info->stats[STAT_AGILITY]   += (lvl > 7 && !(lvl%2) ? 1: 0);
2962                 info->stats[STAT_INTELLECT] += (lvl > 5 ? 1: 0);
2963                 info->stats[STAT_SPIRIT]    += (lvl > 4 ? 1: 0);
2964                 break;
2965             case CLASS_MAGE:
2966                 info->stats[STAT_STRENGTH]  += (lvl > 9 && !(lvl%2) ? 1: 0);
2967                 info->stats[STAT_STAMINA]   += (lvl > 5  ? 1: 0);
2968                 info->stats[STAT_AGILITY]   += (lvl > 9 && !(lvl%2) ? 1: 0);
2969                 info->stats[STAT_INTELLECT] += (lvl > 24 ? 2: (lvl > 1 ? 1: 0));
2970                 info->stats[STAT_SPIRIT]    += (lvl > 33 ? 2: (lvl > 2 ? 1: 0));
2971                 break;
2972             case CLASS_WARLOCK:
2973                 info->stats[STAT_STRENGTH]  += (lvl > 9 && !(lvl%2) ? 1: 0);
2974                 info->stats[STAT_STAMINA]   += (lvl > 38 ? 2: (lvl > 3 ? 1: 0));
2975                 info->stats[STAT_AGILITY]   += (lvl > 9 && !(lvl%2) ? 1: 0);
2976                 info->stats[STAT_INTELLECT] += (lvl > 33 ? 2: (lvl > 2 ? 1: 0));
2977                 info->stats[STAT_SPIRIT]    += (lvl > 38 ? 2: (lvl > 3 ? 1: 0));
2978                 break;
2979             case CLASS_DRUID:
2980                 info->stats[STAT_STRENGTH]  += (lvl > 38 ? 2: (lvl > 6 && (lvl%2) ? 1: 0));
2981                 info->stats[STAT_STAMINA]   += (lvl > 32 ? 2: (lvl > 4 ? 1: 0));
2982                 info->stats[STAT_AGILITY]   += (lvl > 38 ? 2: (lvl > 8 && (lvl%2) ? 1: 0));
2983                 info->stats[STAT_INTELLECT] += (lvl > 38 ? 3: (lvl > 4 ? 1: 0));
2984                 info->stats[STAT_SPIRIT]    += (lvl > 38 ? 3: (lvl > 5 ? 1: 0));
2985         }
2986     }
2987 }
2988
2989 void ObjectMgr::LoadGuilds()
2990 {
2991     Guild *newGuild;
2992     uint32 count = 0;
2993
2994     //                                                    0             1          2          3           4           5           6
2995     QueryResult *result = CharacterDatabase.Query("SELECT guild.guildid,guild.name,leaderguid,EmblemStyle,EmblemColor,BorderStyle,BorderColor,"
2996     //   7               8    9    10         11        12
2997         "BackgroundColor,info,motd,createdate,BankMoney,(SELECT COUNT(guild_bank_tab.guildid) FROM guild_bank_tab WHERE guild_bank_tab.guildid = guild.guildid) "
2998         "FROM guild ORDER BY guildid ASC");
2999
3000     if( !result )
3001     {
3002
3003         barGoLink bar( 1 );
3004
3005         bar.step();
3006
3007         sLog.outString();
3008         sLog.outString( ">> Loaded %u guild definitions", count );
3009         return;
3010     }
3011
3012     // load guild ranks
3013     //                                                                0       1   2     3      4
3014     QueryResult *guildRanksResult   = CharacterDatabase.Query("SELECT guildid,rid,rname,rights,BankMoneyPerDay FROM guild_rank ORDER BY guildid ASC, rid ASC");
3015
3016     // load guild members
3017     //                                                                0       1                 2    3     4       5                  6
3018     QueryResult *guildMembersResult = CharacterDatabase.Query("SELECT guildid,guild_member.guid,rank,pnote,offnote,BankResetTimeMoney,BankRemMoney,"
3019     //   7                 8                9                 10               11                12
3020         "BankResetTimeTab0,BankRemSlotsTab0,BankResetTimeTab1,BankRemSlotsTab1,BankResetTimeTab2,BankRemSlotsTab2,"
3021     //   13                14               15                16               17                18
3022         "BankResetTimeTab3,BankRemSlotsTab3,BankResetTimeTab4,BankRemSlotsTab4,BankResetTimeTab5,BankRemSlotsTab5,"
3023     //   19               20                21                22               23
3024         "characters.name, characters.level, characters.class, characters.zone, characters.logout_time "
3025         "FROM guild_member LEFT JOIN characters ON characters.guid = guild_member.guid ORDER BY guildid ASC");
3026
3027     // load guild bank tab rights
3028     //                                                                      0       1     2   3       4
3029     QueryResult *guildBankTabRightsResult = CharacterDatabase.Query("SELECT guildid,TabId,rid,gbright,SlotPerDay FROM guild_bank_right ORDER BY guildid ASC, TabId ASC");
3030
3031     barGoLink bar( result->GetRowCount() );
3032
3033     do
3034     {
3035         //Field *fields = result->Fetch();
3036
3037         bar.step();
3038         ++count;
3039
3040         newGuild = new Guild;
3041         if (!newGuild->LoadGuildFromDB(result) ||
3042             !newGuild->LoadRanksFromDB(guildRanksResult) ||
3043             !newGuild->LoadMembersFromDB(guildMembersResult) ||
3044             !newGuild->LoadBankRightsFromDB(guildBankTabRightsResult) ||
3045             !newGuild->CheckGuildStructure()
3046             )
3047         {
3048             newGuild->Disband();
3049             delete newGuild;
3050             continue;
3051         }
3052         newGuild->LoadGuildEventLogFromDB();
3053         newGuild->LoadGuildBankEventLogFromDB();
3054         newGuild->LoadGuildBankFromDB();
3055         AddGuild(newGuild);
3056     } while( result->NextRow() );
3057
3058     delete result;
3059     delete guildRanksResult;
3060     delete guildMembersResult;
3061     delete guildBankTabRightsResult;
3062
3063     //delete unused LogGuid records in guild_eventlog and guild_bank_eventlog table
3064     //you can comment these lines if you don't plan to change CONFIG_GUILD_EVENT_LOG_COUNT and CONFIG_GUILD_BANK_EVENT_LOG_COUNT
3065     CharacterDatabase.PQuery("DELETE FROM guild_eventlog WHERE LogGuid > '%u'", sWorld.getConfig(CONFIG_GUILD_EVENT_LOG_COUNT));
3066     CharacterDatabase.PQuery("DELETE FROM guild_bank_eventlog WHERE LogGuid > '%u'", sWorld.getConfig(CONFIG_GUILD_BANK_EVENT_LOG_COUNT));
3067
3068     sLog.outString();
3069     sLog.outString( ">> Loaded %u guild definitions", count );
3070 }
3071
3072 void ObjectMgr::LoadArenaTeams()
3073 {
3074     uint32 count = 0;
3075
3076     //                                                     0                      1    2           3    4               5
3077     QueryResult *result = CharacterDatabase.Query( "SELECT arena_team.arenateamid,name,captainguid,type,BackgroundColor,EmblemStyle,"
3078     //   6           7           8            9      10    11   12     13    14
3079         "EmblemColor,BorderStyle,BorderColor, rating,games,wins,played,wins2,rank "
3080         "FROM arena_team LEFT JOIN arena_team_stats ON arena_team.arenateamid = arena_team_stats.arenateamid ORDER BY arena_team.arenateamid ASC" );
3081
3082     if( !result )
3083     {
3084
3085         barGoLink bar( 1 );
3086
3087         bar.step();
3088
3089         sLog.outString();
3090         sLog.outString( ">> Loaded %u arenateam definitions", count );
3091         return;
3092     }
3093
3094     // load arena_team members
3095     QueryResult *arenaTeamMembersResult = CharacterDatabase.Query(
3096     //          0           1           2           3         4             5           6               7    8
3097         "SELECT arenateamid,member.guid,played_week,wons_week,played_season,wons_season,personal_rating,name,class "
3098         "FROM arena_team_member member LEFT JOIN characters chars on member.guid = chars.guid ORDER BY member.arenateamid ASC");
3099
3100     barGoLink bar( result->GetRowCount() );
3101
3102     do
3103     {
3104         Field *fields = result->Fetch();
3105
3106         bar.step();
3107         ++count;
3108
3109         ArenaTeam *newArenaTeam = new ArenaTeam;
3110         if (!newArenaTeam->LoadArenaTeamFromDB(result) ||
3111             !newArenaTeam->LoadMembersFromDB(arenaTeamMembersResult))
3112         {
3113             newArenaTeam->Disband(NULL);
3114             delete newArenaTeam;
3115             continue;
3116         }
3117         AddArenaTeam(newArenaTeam);
3118     }while( result->NextRow() );
3119
3120     delete result;
3121     delete arenaTeamMembersResult;
3122
3123     sLog.outString();
3124     sLog.outString( ">> Loaded %u arenateam definitions", count );
3125 }
3126
3127 void ObjectMgr::LoadGroups()
3128 {
3129     // -- loading groups --
3130     Group *group = NULL;
3131     uint64 leaderGuid = 0;
3132     uint32 count = 0;
3133     //                                                     0         1              2           3           4              5      6      7      8      9      10     11     12     13      14         15              16
3134     QueryResult *result = CharacterDatabase.Query("SELECT mainTank, mainAssistant, lootMethod, looterGuid, lootThreshold, icon1, icon2, icon3, icon4, icon5, icon6, icon7, icon8, isRaid, difficulty, raiddifficulty, leaderGuid FROM groups");
3135
3136     if( !result )
3137     {
3138         barGoLink bar( 1 );
3139
3140         bar.step();
3141
3142         sLog.outString();
3143         sLog.outString( ">> Loaded %u group definitions", count );
3144         return;
3145     }
3146
3147     barGoLink bar( result->GetRowCount() );
3148
3149     do
3150     {
3151         bar.step();
3152         Field *fields = result->Fetch();
3153         ++count;
3154         leaderGuid = MAKE_NEW_GUID(fields[16].GetUInt32(),0,HIGHGUID_PLAYER);
3155
3156         group = new Group;
3157         if(!group->LoadGroupFromDB(leaderGuid, result, false))
3158         {
3159             group->Disband();
3160             delete group;
3161             continue;
3162         }
3163         AddGroup(group);
3164     }while( result->NextRow() );
3165
3166     delete result;
3167
3168     sLog.outString();
3169     sLog.outString( ">> Loaded %u group definitions", count );
3170
3171     // -- loading members --
3172     count = 0;
3173     group = NULL;
3174     leaderGuid = 0;
3175     //                                        0           1          2         3
3176     result = CharacterDatabase.Query("SELECT memberGuid, assistant, subgroup, leaderGuid FROM group_member ORDER BY leaderGuid");
3177     if(!result)
3178     {
3179         barGoLink bar2( 1 );
3180         bar2.step();
3181     }
3182     else
3183     {
3184         barGoLink bar2( result->GetRowCount() );
3185         do
3186         {
3187             bar2.step();
3188             Field *fields = result->Fetch();
3189             count++;
3190             leaderGuid = MAKE_NEW_GUID(fields[3].GetUInt32(), 0, HIGHGUID_PLAYER);
3191             if(!group || group->GetLeaderGUID() != leaderGuid)
3192             {
3193                 group = GetGroupByLeader(leaderGuid);
3194                 if(!group)
3195                 {
3196                     sLog.outErrorDb("Incorrect entry in group_member table : no group with leader %d for member %d!", fields[3].GetUInt32(), fields[0].GetUInt32());
3197                     CharacterDatabase.PExecute("DELETE FROM group_member WHERE memberGuid = '%d'", fields[0].GetUInt32());
3198                     continue;
3199                 }
3200             }
3201
3202             if(!group->LoadMemberFromDB(fields[0].GetUInt32(), fields[2].GetUInt8(), fields[1].GetBool()))
3203             {
3204                 sLog.outErrorDb("Incorrect entry in group_member table : member %d cannot be added to player %d's group!", fields[0].GetUInt32(), fields[3].GetUInt32());
3205                 CharacterDatabase.PExecute("DELETE FROM group_member WHERE memberGuid = '%d'", fields[0].GetUInt32());
3206             }
3207         }while( result->NextRow() );
3208         delete result;
3209     }
3210
3211     // clean groups
3212     // TODO: maybe delete from the DB before loading in this case
3213     for(GroupSet::iterator itr = mGroupSet.begin(); itr != mGroupSet.end();)
3214     {
3215         if((*itr)->GetMembersCount() < 2)
3216         {
3217             (*itr)->Disband();
3218             delete *itr;
3219             mGroupSet.erase(itr++);
3220         }
3221         else
3222             ++itr;
3223     }
3224
3225     // -- loading instances --
3226     count = 0;
3227     group = NULL;
3228     leaderGuid = 0;
3229     result = CharacterDatabase.Query(
3230         //      0           1    2         3          4           5
3231         "SELECT leaderGuid, map, instance, permanent, difficulty, resettime, "
3232         // 6
3233         "(SELECT COUNT(*) FROM character_instance WHERE guid = leaderGuid AND instance = group_instance.instance AND permanent = 1 LIMIT 1) "
3234         "FROM group_instance LEFT JOIN instance ON instance = id ORDER BY leaderGuid"
3235     );
3236
3237     if(!result)
3238     {
3239         barGoLink bar2( 1 );
3240         bar2.step();
3241     }
3242     else
3243     {
3244         barGoLink bar2( result->GetRowCount() );
3245         do
3246         {
3247             bar2.step();
3248             Field *fields = result->Fetch();
3249             count++;
3250             leaderGuid = MAKE_NEW_GUID(fields[0].GetUInt32(), 0, HIGHGUID_PLAYER);
3251             if(!group || group->GetLeaderGUID() != leaderGuid)
3252             {
3253                 group = GetGroupByLeader(leaderGuid);
3254                 if(!group)
3255                 {
3256                     sLog.outErrorDb("Incorrect entry in group_instance table : no group with leader %d", fields[0].GetUInt32());
3257                     continue;
3258                 }
3259             }
3260
3261             MapEntry const* mapEntry = sMapStore.LookupEntry(fields[1].GetUInt32());
3262             if(!mapEntry || !mapEntry->IsDungeon())
3263             {
3264                 sLog.outErrorDb("Incorrect entry in group_instance table : no dungeon map %d", fields[1].GetUInt32());
3265                 continue;
3266             }
3267
3268             uint32 diff = fields[4].GetUInt8();
3269             if(diff >= (mapEntry->IsRaid() ? MAX_RAID_DIFFICULTY : MAX_DUNGEON_DIFFICULTY))
3270             {
3271                 sLog.outErrorDb("Wrong dungeon difficulty use in group_instance table: %d", diff + 1);
3272                 diff = 0;                                   // default for both difficaly types
3273             }
3274
3275             InstanceSave *save = sInstanceSaveMgr.AddInstanceSave(mapEntry->MapID, fields[2].GetUInt32(), Difficulty(diff), (time_t)fields[5].GetUInt64(), (fields[6].GetUInt32() == 0), true);
3276             group->BindToInstance(save, fields[3].GetBool(), true);
3277         }while( result->NextRow() );
3278         delete result;
3279     }
3280
3281     sLog.outString();
3282     sLog.outString( ">> Loaded %u group-instance binds total", count );
3283
3284     sLog.outString();
3285     sLog.outString( ">> Loaded %u group members total", count );
3286 }
3287
3288 void ObjectMgr::LoadQuests()
3289 {
3290     // For reload case
3291     for(QuestMap::const_iterator itr=mQuestTemplates.begin(); itr != mQuestTemplates.end(); ++itr)
3292         delete itr->second;
3293     mQuestTemplates.clear();
3294
3295     mExclusiveQuestGroups.clear();
3296
3297     //                                                0      1       2           3             4         5           6     7              8
3298     QueryResult *result = WorldDatabase.Query("SELECT entry, Method, ZoneOrSort, SkillOrClass, MinLevel, QuestLevel, Type, RequiredRaces, RequiredSkillValue,"
3299     //   9                    10                 11                     12                   13                     14                   15                16
3300         "RepObjectiveFaction, RepObjectiveValue, RequiredMinRepFaction, RequiredMinRepValue, RequiredMaxRepFaction, RequiredMaxRepValue, SuggestedPlayers, LimitTime,"
3301     //   17          18            19           20            21            22           23           24              25                26         27            28
3302         "QuestFlags, SpecialFlags, CharTitleId, PlayersSlain, BonusTalents, PrevQuestId, NextQuestId, ExclusiveGroup, NextQuestInChain, SrcItemId, SrcItemCount, SrcSpell,"
3303     //   29     30       31          32               33                34       35              36              37              38
3304         "Title, Details, Objectives, OfferRewardText, RequestItemsText, EndText, ObjectiveText1, ObjectiveText2, ObjectiveText3, ObjectiveText4,"
3305     //   39          40          41          42          43          44          45             46             47             48             49             50
3306         "ReqItemId1, ReqItemId2, ReqItemId3, ReqItemId4, ReqItemId5, ReqItemId6, ReqItemCount1, ReqItemCount2, ReqItemCount3, ReqItemCount4, ReqItemCount5, ReqItemCount6,"
3307     //   51            52            53            54            55               56               57               58
3308         "ReqSourceId1, ReqSourceId2, ReqSourceId3, ReqSourceId4, ReqSourceCount1, ReqSourceCount2, ReqSourceCount3, ReqSourceCount4,"
3309     //   59                  60                  61                  62                  63                     64                     65                     66
3310         "ReqCreatureOrGOId1, ReqCreatureOrGOId2, ReqCreatureOrGOId3, ReqCreatureOrGOId4, ReqCreatureOrGOCount1, ReqCreatureOrGOCount2, ReqCreatureOrGOCount3, ReqCreatureOrGOCount4,"
3311     //   67             68             69             70
3312         "ReqSpellCast1, ReqSpellCast2, ReqSpellCast3, ReqSpellCast4,"
3313     //   71                72                73                74                75                76
3314         "RewChoiceItemId1, RewChoiceItemId2, RewChoiceItemId3, RewChoiceItemId4, RewChoiceItemId5, RewChoiceItemId6,"
3315     //   77                   78                   79                   80                   81                   82
3316         "RewChoiceItemCount1, RewChoiceItemCount2, RewChoiceItemCount3, RewChoiceItemCount4, RewChoiceItemCount5, RewChoiceItemCount6,"
3317     //   83          84          85          86          87             88             89             90
3318         "RewItemId1, RewItemId2, RewItemId3, RewItemId4, RewItemCount1, RewItemCount2, RewItemCount3, RewItemCount4,"
3319     //   91              92              93              94              95              96            97            98            99            100
3320         "RewRepFaction1, RewRepFaction2, RewRepFaction3, RewRepFaction4, RewRepFaction5, RewRepValue1, RewRepValue2, RewRepValue3, RewRepValue4, RewRepValue5,"
3321     //   101                102            103               104       105           106                107               108         109     110     111
3322         "RewHonorableKills, RewOrReqMoney, RewMoneyMaxLevel, RewSpell, RewSpellCast, RewMailTemplateId, RewMailDelaySecs, PointMapId, PointX, PointY, PointOpt,"
3323     //   112            113            114            115            116                 117                 118                 119
3324         "DetailsEmote1, DetailsEmote2, DetailsEmote3, DetailsEmote4, DetailsEmoteDelay1, DetailsEmoteDelay2, DetailsEmoteDelay3, DetailsEmoteDelay4,"
3325     //   120              121            122                123                124                125
3326         "IncompleteEmote, CompleteEmote, OfferRewardEmote1, OfferRewardEmote2, OfferRewardEmote3, OfferRewardEmote4,"
3327     //   126                     127                     128                     129
3328         "OfferRewardEmoteDelay1, OfferRewardEmoteDelay2, OfferRewardEmoteDelay3, OfferRewardEmoteDelay4,"
3329     //   130          131
3330         "StartScript, CompleteScript"
3331         " FROM quest_template");
3332     if(result == NULL)
3333     {
3334         barGoLink bar( 1 );
3335         bar.step();
3336
3337         sLog.outString();
3338         sLog.outString( ">> Loaded 0 quests definitions" );
3339         sLog.outErrorDb("`quest_template` table is empty!");
3340         return;
3341     }
3342
3343     // create multimap previous quest for each existed quest
3344     // some quests can have many previous maps set by NextQuestId in previous quest
3345     // for example set of race quests can lead to single not race specific quest
3346     barGoLink bar( result->GetRowCount() );
3347     do
3348     {
3349         bar.step();
3350         Field *fields = result->Fetch();
3351
3352         Quest * newQuest = new Quest(fields);
3353         mQuestTemplates[newQuest->GetQuestId()] = newQuest;
3354     } while( result->NextRow() );
3355
3356     delete result;
3357
3358     // Post processing
3359
3360     std::map<uint32,uint32> usedMailTemplates;
3361
3362     for (QuestMap::iterator iter = mQuestTemplates.begin(); iter != mQuestTemplates.end(); ++iter)
3363     {
3364         Quest * qinfo = iter->second;
3365
3366         // additional quest integrity checks (GO, creature_template and item_template must be loaded already)
3367
3368         if( qinfo->GetQuestMethod() >= 3 )
3369         {
3370             sLog.outErrorDb("Quest %u has `Method` = %u, expected values are 0, 1 or 2.",qinfo->GetQuestId(),qinfo->GetQuestMethod());
3371         }
3372
3373         if (qinfo->QuestFlags & ~QUEST_MANGOS_FLAGS_DB_ALLOWED)
3374         {
3375             sLog.outErrorDb("Quest %u has `SpecialFlags` = %u > max allowed value. Correct `SpecialFlags` to value <= %u",
3376                 qinfo->GetQuestId(),qinfo->QuestFlags  >> 24,QUEST_MANGOS_FLAGS_DB_ALLOWED >> 24);
3377             qinfo->QuestFlags &= QUEST_MANGOS_FLAGS_DB_ALLOWED;
3378         }
3379
3380         if(qinfo->QuestFlags & QUEST_FLAGS_DAILY)
3381         {
3382             if(!(qinfo->QuestFlags & QUEST_MANGOS_FLAGS_REPEATABLE))
3383             {
3384                 sLog.outErrorDb("Daily Quest %u not marked as repeatable in `SpecialFlags`, added.",qinfo->GetQuestId());
3385                 qinfo->QuestFlags |= QUEST_MANGOS_FLAGS_REPEATABLE;
3386             }
3387         }
3388
3389         if(qinfo->QuestFlags & QUEST_FLAGS_AUTO_REWARDED)
3390         {
3391             // at auto-reward can be rewarded only RewChoiceItemId[0]
3392             for(int j = 1; j < QUEST_REWARD_CHOICES_COUNT; ++j )
3393             {
3394                 if(uint32 id = qinfo->RewChoiceItemId[j])
3395                 {
3396                     sLog.outErrorDb("Quest %u has `RewChoiceItemId%d` = %u but item from `RewChoiceItemId%d` can't be rewarded with quest flag QUEST_FLAGS_AUTO_REWARDED.",
3397                         qinfo->GetQuestId(),j+1,id,j+1);
3398                     // no changes, quest ignore this data
3399                 }
3400             }
3401         }
3402
3403         // client quest log visual (area case)
3404         if( qinfo->ZoneOrSort > 0 )
3405         {
3406             if(!GetAreaEntryByAreaID(qinfo->ZoneOrSort))
3407             {
3408                 sLog.outErrorDb("Quest %u has `ZoneOrSort` = %u (zone case) but zone with this id does not exist.",
3409                     qinfo->GetQuestId(),qinfo->ZoneOrSort);
3410                 // no changes, quest not dependent from this value but can have problems at client
3411             }
3412         }
3413         // client quest log visual (sort case)
3414         if( qinfo->ZoneOrSort < 0 )
3415         {
3416             QuestSortEntry const* qSort = sQuestSortStore.LookupEntry(-int32(qinfo->ZoneOrSort));
3417             if( !qSort )
3418             {
3419                 sLog.outErrorDb("Quest %u has `ZoneOrSort` = %i (sort case) but quest sort with this id does not exist.",
3420                     qinfo->GetQuestId(),qinfo->ZoneOrSort);
3421                 // no changes, quest not dependent from this value but can have problems at client (note some may be 0, we must allow this so no check)
3422             }
3423             //check SkillOrClass value (class case).
3424             if( ClassByQuestSort(-int32(qinfo->ZoneOrSort)) )
3425             {
3426                 // SkillOrClass should not have class case when class case already set in ZoneOrSort.
3427                 if(qinfo->SkillOrClass < 0)
3428                 {
3429                     sLog.outErrorDb("Quest %u has `ZoneOrSort` = %i (class sort case) and `SkillOrClass` = %i (class case), redundant.",
3430                         qinfo->GetQuestId(),qinfo->ZoneOrSort,qinfo->SkillOrClass);
3431                 }
3432             }
3433             //check for proper SkillOrClass value (skill case)
3434             if(int32 skill_id =  SkillByQuestSort(-int32(qinfo->ZoneOrSort)))
3435             {
3436                 // skill is positive value in SkillOrClass
3437                 if(qinfo->SkillOrClass != skill_id )
3438                 {
3439                     sLog.outErrorDb("Quest %u has `ZoneOrSort` = %i (skill sort case) but `SkillOrClass` does not have a corresponding value (%i).",
3440                         qinfo->GetQuestId(),qinfo->ZoneOrSort,skill_id);
3441                     //override, and force proper value here?
3442                 }
3443             }
3444         }
3445
3446         // SkillOrClass (class case)
3447         if( qinfo->SkillOrClass < 0 )
3448         {
3449             if( !sChrClassesStore.LookupEntry(-int32(qinfo->SkillOrClass)) )
3450             {
3451                 sLog.outErrorDb("Quest %u has `SkillOrClass` = %i (class case) but class (%i) does not exist",
3452                     qinfo->GetQuestId(),qinfo->SkillOrClass,-qinfo->SkillOrClass);
3453             }
3454         }
3455         // SkillOrClass (skill case)
3456         if( qinfo->SkillOrClass > 0 )
3457         {
3458             if( !sSkillLineStore.LookupEntry(qinfo->SkillOrClass) )
3459             {
3460                 sLog.outErrorDb("Quest %u has `SkillOrClass` = %u (skill case) but skill (%i) does not exist",
3461                     qinfo->GetQuestId(),qinfo->SkillOrClass,qinfo->SkillOrClass);
3462             }
3463         }
3464
3465         if( qinfo->RequiredSkillValue )
3466         {
3467             if( qinfo->RequiredSkillValue > sWorld.GetConfigMaxSkillValue() )
3468             {
3469                 sLog.outErrorDb("Quest %u has `RequiredSkillValue` = %u but max possible skill is %u, quest can't be done.",
3470                     qinfo->GetQuestId(),qinfo->RequiredSkillValue,sWorld.GetConfigMaxSkillValue());
3471                 // no changes, quest can't be done for this requirement
3472             }
3473
3474             if( qinfo->SkillOrClass <= 0 )
3475             {
3476                 sLog.outErrorDb("Quest %u has `RequiredSkillValue` = %u but `SkillOrClass` = %i (class case), value ignored.",
3477                     qinfo->GetQuestId(),qinfo->RequiredSkillValue,qinfo->SkillOrClass);
3478                 // no changes, quest can't be done for this requirement (fail at wrong skill id)
3479             }
3480         }
3481         // else Skill quests can have 0 skill level, this is ok
3482
3483         if(qinfo->RepObjectiveFaction && !sFactionStore.LookupEntry(qinfo->RepObjectiveFaction))
3484         {
3485             sLog.outErrorDb("Quest %u has `RepObjectiveFaction` = %u but faction template %u does not exist, quest can't be done.",
3486                 qinfo->GetQuestId(),qinfo->RepObjectiveFaction,qinfo->RepObjectiveFaction);
3487             // no changes, quest can't be done for this requirement
3488         }
3489
3490         if(qinfo->RequiredMinRepFaction && !sFactionStore.LookupEntry(qinfo->RequiredMinRepFaction))
3491         {
3492             sLog.outErrorDb("Quest %u has `RequiredMinRepFaction` = %u but faction template %u does not exist, quest can't be done.",
3493                 qinfo->GetQuestId(),qinfo->RequiredMinRepFaction,qinfo->RequiredMinRepFaction);
3494             // no changes, quest can't be done for this requirement
3495         }
3496
3497         if(qinfo->RequiredMaxRepFaction && !sFactionStore.LookupEntry(qinfo->RequiredMaxRepFaction))
3498         {
3499             sLog.outErrorDb("Quest %u has `RequiredMaxRepFaction` = %u but faction template %u does not exist, quest can't be done.",
3500                 qinfo->GetQuestId(),qinfo->RequiredMaxRepFaction,qinfo->RequiredMaxRepFaction);
3501             // no changes, quest can't be done for this requirement
3502         }
3503
3504         if(qinfo->RequiredMinRepValue && qinfo->RequiredMinRepValue > ReputationMgr::Reputation_Cap)
3505         {
3506             sLog.outErrorDb("Quest %u has `RequiredMinRepValue` = %d but max reputation is %u, quest can't be done.",
3507                 qinfo->GetQuestId(),qinfo->RequiredMinRepValue,ReputationMgr::Reputation_Cap);
3508             // no changes, quest can't be done for this requirement
3509         }
3510
3511         if(qinfo->RequiredMinRepValue && qinfo->RequiredMaxRepValue && qinfo->RequiredMaxRepValue <= qinfo->RequiredMinRepValue)
3512         {
3513             sLog.outErrorDb("Quest %u has `RequiredMaxRepValue` = %d and `RequiredMinRepValue` = %d, quest can't be done.",
3514                 qinfo->GetQuestId(),qinfo->RequiredMaxRepValue,qinfo->RequiredMinRepValue);
3515             // no changes, quest can't be done for this requirement
3516         }
3517
3518         if(!qinfo->RepObjectiveFaction && qinfo->RepObjectiveValue > 0 )
3519         {
3520             sLog.outErrorDb("Quest %u has `RepObjectiveValue` = %d but `RepObjectiveFaction` is 0, value has no effect",
3521                 qinfo->GetQuestId(),qinfo->RepObjectiveValue);
3522             // warning
3523         }
3524
3525         if(!qinfo->RequiredMinRepFaction && qinfo->RequiredMinRepValue > 0 )
3526         {
3527             sLog.outErrorDb("Quest %u has `RequiredMinRepValue` = %d but `RequiredMinRepFaction` is 0, value has no effect",
3528                 qinfo->GetQuestId(),qinfo->RequiredMinRepValue);
3529             // warning
3530         }
3531
3532         if(!qinfo->RequiredMaxRepFaction && qinfo->RequiredMaxRepValue > 0 )
3533         {
3534             sLog.outErrorDb("Quest %u has `RequiredMaxRepValue` = %d but `RequiredMaxRepFaction` is 0, value has no effect",
3535                 qinfo->GetQuestId(),qinfo->RequiredMaxRepValue);
3536             // warning
3537         }
3538
3539         if(qinfo->CharTitleId && !sCharTitlesStore.LookupEntry(qinfo->CharTitleId))
3540         {
3541             sLog.outErrorDb("Quest %u has `CharTitleId` = %u but CharTitle Id %u does not exist, quest can't be rewarded with title.",
3542                 qinfo->GetQuestId(),qinfo->GetCharTitleId(),qinfo->GetCharTitleId());
3543             qinfo->CharTitleId = 0;
3544             // quest can't reward this title
3545         }
3546
3547         if(qinfo->SrcItemId)
3548         {
3549             if(!sItemStorage.LookupEntry<ItemPrototype>(qinfo->SrcItemId))
3550             {
3551                 sLog.outErrorDb("Quest %u has `SrcItemId` = %u but item with entry %u does not exist, quest can't be done.",
3552                     qinfo->GetQuestId(),qinfo->SrcItemId,qinfo->SrcItemId);
3553                 qinfo->SrcItemId = 0;                       // quest can't be done for this requirement
3554             }
3555             else if(qinfo->SrcItemCount==0)
3556             {
3557                 sLog.outErrorDb("Quest %u has `SrcItemId` = %u but `SrcItemCount` = 0, set to 1 but need fix in DB.",
3558                     qinfo->GetQuestId(),qinfo->SrcItemId);
3559                 qinfo->SrcItemCount = 1;                    // update to 1 for allow quest work for backward compatibility with DB
3560             }
3561         }
3562         else if(qinfo->SrcItemCount>0)
3563         {
3564             sLog.outErrorDb("Quest %u has `SrcItemId` = 0 but `SrcItemCount` = %u, useless value.",
3565                 qinfo->GetQuestId(),qinfo->SrcItemCount);
3566             qinfo->SrcItemCount=0;                          // no quest work changes in fact
3567         }
3568
3569         if(qinfo->SrcSpell)
3570         {
3571             SpellEntry const* spellInfo = sSpellStore.LookupEntry(qinfo->SrcSpell);
3572             if(!spellInfo)
3573             {
3574                 sLog.outErrorDb("Quest %u has `SrcSpell` = %u but spell %u doesn't exist, quest can't be done.",
3575                     qinfo->GetQuestId(),qinfo->SrcSpell,qinfo->SrcSpell);
3576                 qinfo->SrcSpell = 0;                        // quest can't be done for this requirement
3577             }
3578             else if(!SpellMgr::IsSpellValid(spellInfo))
3579             {
3580                 sLog.outErrorDb("Quest %u has `SrcSpell` = %u but spell %u is broken, quest can't be done.",
3581                     qinfo->GetQuestId(),qinfo->SrcSpell,qinfo->SrcSpell);
3582                 qinfo->SrcSpell = 0;                        // quest can't be done for this requirement
3583             }
3584         }
3585
3586         for(int j = 0; j < QUEST_ITEM_OBJECTIVES_COUNT; ++j )
3587         {
3588             uint32 id = qinfo->ReqItemId[j];
3589             if(id)
3590             {
3591                 if(qinfo->ReqItemCount[j] == 0)
3592                 {
3593                     sLog.outErrorDb("Quest %u has `ReqItemId%d` = %u but `ReqItemCount%d` = 0, quest can't be done.",
3594                         qinfo->GetQuestId(), j+1, id, j+1);
3595                     // no changes, quest can't be done for this requirement
3596                 }
3597
3598                 qinfo->SetFlag(QUEST_MANGOS_FLAGS_DELIVER);
3599
3600                 if(!sItemStorage.LookupEntry<ItemPrototype>(id))
3601                 {
3602                     sLog.outErrorDb("Quest %u has `ReqItemId%d` = %u but item with entry %u does not exist, quest can't be done.",
3603                         qinfo->GetQuestId(), j+1, id, id);
3604                     qinfo->ReqItemCount[j] = 0;             // prevent incorrect work of quest
3605                 }
3606             }
3607             else if(qinfo->ReqItemCount[j] > 0)
3608             {
3609                 sLog.outErrorDb("Quest %u has `ReqItemId%d` = 0 but `ReqItemCount%d` = %u, quest can't be done.",
3610                     qinfo->GetQuestId(), j+1, j+1, qinfo->ReqItemCount[j]);
3611                 qinfo->ReqItemCount[j] = 0;                 // prevent incorrect work of quest
3612             }
3613         }
3614
3615         for(int j = 0; j < QUEST_SOURCE_ITEM_IDS_COUNT; ++j )
3616         {
3617             uint32 id = qinfo->ReqSourceId[j];
3618             if(id)
3619             {
3620                 if(!sItemStorage.LookupEntry<ItemPrototype>(id))
3621                 {
3622                     sLog.outErrorDb("Quest %u has `ReqSourceId%d` = %u but item with entry %u does not exist, quest can't be done.",
3623                         qinfo->GetQuestId(),j+1,id,id);
3624                     // no changes, quest can't be done for this requirement
3625                 }
3626             }
3627             else
3628             {
3629                 if(qinfo->ReqSourceCount[j]>0)
3630                 {
3631                     sLog.outErrorDb("Quest %u has `ReqSourceId%d` = 0 but `ReqSourceCount%d` = %u.",
3632                         qinfo->GetQuestId(),j+1,j+1,qinfo->ReqSourceCount[j]);
3633                     // no changes, quest ignore this data
3634                 }
3635             }
3636         }
3637
3638         for(int j = 0; j < QUEST_OBJECTIVES_COUNT; ++j )
3639         {
3640             uint32 id = qinfo->ReqSpell[j];
3641             if(id)
3642             {
3643                 SpellEntry const* spellInfo = sSpellStore.LookupEntry(id);
3644                 if(!spellInfo)
3645                 {
3646                     sLog.outErrorDb("Quest %u has `ReqSpellCast%d` = %u but spell %u does not exist, quest can't be done.",
3647                         qinfo->GetQuestId(),j+1,id,id);
3648                     continue;
3649                 }
3650
3651                 if(!qinfo->ReqCreatureOrGOId[j])
3652                 {
3653                     bool found = false;
3654                     for(int k = 0; k < 3; ++k)
3655                     {
3656                         if ((spellInfo->Effect[k] == SPELL_EFFECT_QUEST_COMPLETE && uint32(spellInfo->EffectMiscValue[k]) == qinfo->QuestId) ||
3657                             spellInfo->Effect[k] == SPELL_EFFECT_SEND_EVENT)
3658                         {
3659                             found = true;
3660                             break;
3661                         }
3662                     }
3663
3664                     if(found)
3665                     {
3666                         if(!qinfo->HasFlag(QUEST_MANGOS_FLAGS_EXPLORATION_OR_EVENT))
3667                         {
3668                             sLog.outErrorDb("Spell (id: %u) have SPELL_EFFECT_QUEST_COMPLETE or SPELL_EFFECT_SEND_EVENT for quest %u and ReqCreatureOrGOId%d = 0, but quest not have flag QUEST_MANGOS_FLAGS_EXPLORATION_OR_EVENT. Quest flags or ReqCreatureOrGOId%d must be fixed, quest modified to enable objective.",spellInfo->Id,qinfo->QuestId,j+1,j+1);
3669
3670                             // this will prevent quest completing without objective
3671                             const_cast<Quest*>(qinfo)->SetFlag(QUEST_MANGOS_FLAGS_EXPLORATION_OR_EVENT);
3672                         }
3673                     }
3674                     else
3675                     {
3676                         sLog.outErrorDb("Quest %u has `ReqSpellCast%d` = %u and ReqCreatureOrGOId%d = 0 but spell %u does not have SPELL_EFFECT_QUEST_COMPLETE or SPELL_EFFECT_SEND_EVENT effect for this quest, quest can't be done.",
3677                             qinfo->GetQuestId(),j+1,id,j+1,id);
3678                         // no changes, quest can't be done for this requirement
3679                     }
3680                 }
3681             }
3682         }
3683
3684         for(int j = 0; j < QUEST_OBJECTIVES_COUNT; ++j )
3685         {
3686             int32 id = qinfo->ReqCreatureOrGOId[j];
3687             if(id < 0 && !sGOStorage.LookupEntry<GameObjectInfo>(-id))
3688             {
3689                 sLog.outErrorDb("Quest %u has `ReqCreatureOrGOId%d` = %i but gameobject %u does not exist, quest can't be done.",
3690                     qinfo->GetQuestId(),j+1,id,uint32(-id));
3691                 qinfo->ReqCreatureOrGOId[j] = 0;            // quest can't be done for this requirement
3692             }
3693
3694             if(id > 0 && !sCreatureStorage.LookupEntry<CreatureInfo>(id))
3695             {
3696                 sLog.outErrorDb("Quest %u has `ReqCreatureOrGOId%d` = %i but creature with entry %u does not exist, quest can't be done.",
3697                     qinfo->GetQuestId(),j+1,id,uint32(id));
3698                 qinfo->ReqCreatureOrGOId[j] = 0;            // quest can't be done for this requirement
3699             }
3700
3701             if(id)
3702             {
3703                 // In fact SpeakTo and Kill are quite same: either you can speak to mob:SpeakTo or you can't:Kill/Cast
3704
3705                 qinfo->SetFlag(QUEST_MANGOS_FLAGS_KILL_OR_CAST | QUEST_MANGOS_FLAGS_SPEAKTO);
3706
3707                 if(!qinfo->ReqCreatureOrGOCount[j])
3708                 {
3709                     sLog.outErrorDb("Quest %u has `ReqCreatureOrGOId%d` = %u but `ReqCreatureOrGOCount%d` = 0, quest can't be done.",
3710                         qinfo->GetQuestId(),j+1,id,j+1);
3711                     // no changes, quest can be incorrectly done, but we already report this
3712                 }
3713             }
3714             else if(qinfo->ReqCreatureOrGOCount[j]>0)
3715             {
3716                 sLog.outErrorDb("Quest %u has `ReqCreatureOrGOId%d` = 0 but `ReqCreatureOrGOCount%d` = %u.",
3717                     qinfo->GetQuestId(),j+1,j+1,qinfo->ReqCreatureOrGOCount[j]);
3718                 // no changes, quest ignore this data
3719             }
3720         }
3721
3722         for(int j = 0; j < QUEST_REWARD_CHOICES_COUNT; ++j )
3723         {
3724             uint32 id = qinfo->RewChoiceItemId[j];
3725             if(id)
3726             {
3727                 if(!sItemStorage.LookupEntry<ItemPrototype>(id))
3728                 {
3729                     sLog.outErrorDb("Quest %u has `RewChoiceItemId%d` = %u but item with entry %u does not exist, quest will not reward this item.",
3730                         qinfo->GetQuestId(),j+1,id,id);
3731                     qinfo->RewChoiceItemId[j] = 0;          // no changes, quest will not reward this
3732                 }
3733
3734                 if(!qinfo->RewChoiceItemCount[j])
3735                 {
3736                     sLog.outErrorDb("Quest %u has `RewChoiceItemId%d` = %u but `RewChoiceItemCount%d` = 0, quest can't be done.",
3737                         qinfo->GetQuestId(),j+1,id,j+1);
3738                     // no changes, quest can't be done
3739                 }
3740             }
3741             else if(qinfo->RewChoiceItemCount[j]>0)
3742             {
3743                 sLog.outErrorDb("Quest %u has `RewChoiceItemId%d` = 0 but `RewChoiceItemCount%d` = %u.",
3744                     qinfo->GetQuestId(),j+1,j+1,qinfo->RewChoiceItemCount[j]);
3745                 // no changes, quest ignore this data
3746             }
3747         }
3748
3749         for(int j = 0; j < QUEST_REWARDS_COUNT; ++j )
3750         {
3751             uint32 id = qinfo->RewItemId[j];
3752             if(id)
3753             {
3754                 if(!sItemStorage.LookupEntry<ItemPrototype>(id))
3755                 {
3756                     sLog.outErrorDb("Quest %u has `RewItemId%d` = %u but item with entry %u does not exist, quest will not reward this item.",
3757                         qinfo->GetQuestId(),j+1,id,id);
3758                     qinfo->RewItemId[j] = 0;                // no changes, quest will not reward this item
3759                 }
3760
3761                 if(!qinfo->RewItemCount[j])
3762                 {
3763                     sLog.outErrorDb("Quest %u has `RewItemId%d` = %u but `RewItemCount%d` = 0, quest will not reward this item.",
3764                         qinfo->GetQuestId(),j+1,id,j+1);
3765                     // no changes
3766                 }
3767             }
3768             else if(qinfo->RewItemCount[j]>0)
3769             {
3770                 sLog.outErrorDb("Quest %u has `RewItemId%d` = 0 but `RewItemCount%d` = %u.",
3771                     qinfo->GetQuestId(),j+1,j+1,qinfo->RewItemCount[j]);
3772                 // no changes, quest ignore this data
3773             }
3774         }
3775
3776         for(int j = 0; j < QUEST_REPUTATIONS_COUNT; ++j)
3777         {
3778             if(qinfo->RewRepFaction[j])
3779             {
3780                 if(!qinfo->RewRepValue[j])
3781                 {
3782                     sLog.outErrorDb("Quest %u has `RewRepFaction%d` = %u but `RewRepValue%d` = 0, quest will not reward this reputation.",
3783                         qinfo->GetQuestId(),j+1,qinfo->RewRepValue[j],j+1);
3784                     // no changes
3785                 }
3786
3787                 if(!sFactionStore.LookupEntry(qinfo->RewRepFaction[j]))
3788                 {
3789                     sLog.outErrorDb("Quest %u has `RewRepFaction%d` = %u but raw faction (faction.dbc) %u does not exist, quest will not reward reputation for this faction.",
3790                         qinfo->GetQuestId(),j+1,qinfo->RewRepFaction[j] ,qinfo->RewRepFaction[j] );
3791                     qinfo->RewRepFaction[j] = 0;            // quest will not reward this
3792                 }
3793             }
3794             else if(qinfo->RewRepValue[j]!=0)
3795             {
3796                 sLog.outErrorDb("Quest %u has `RewRepFaction%d` = 0 but `RewRepValue%d` = %u.",
3797                     qinfo->GetQuestId(),j+1,j+1,qinfo->RewRepValue[j]);
3798                 // no changes, quest ignore this data
3799             }
3800         }
3801
3802         if(qinfo->RewSpell)
3803         {
3804             SpellEntry const* spellInfo = sSpellStore.LookupEntry(qinfo->RewSpell);
3805
3806             if(!spellInfo)
3807             {
3808                 sLog.outErrorDb("Quest %u has `RewSpell` = %u but spell %u does not exist, spell removed as display reward.",
3809                     qinfo->GetQuestId(),qinfo->RewSpell,qinfo->RewSpell);
3810                 qinfo->RewSpell = 0;                        // no spell reward will display for this quest
3811             }
3812             else if(!SpellMgr::IsSpellValid(spellInfo))
3813             {
3814                 sLog.outErrorDb("Quest %u has `RewSpell` = %u but spell %u is broken, quest will not have a spell reward.",
3815                     qinfo->GetQuestId(),qinfo->RewSpell,qinfo->RewSpell);
3816                 qinfo->RewSpell = 0;                        // no spell reward will display for this quest
3817             }
3818             else if(GetTalentSpellCost(qinfo->RewSpell))
3819             {
3820                 sLog.outErrorDb("Quest %u has `RewSpell` = %u but spell %u is talent, quest will not have a spell reward.",
3821                     qinfo->GetQuestId(),qinfo->RewSpell,qinfo->RewSpell);
3822                 qinfo->RewSpell = 0;                        // no spell reward will display for this quest
3823             }
3824         }
3825
3826         if(qinfo->RewSpellCast)
3827         {
3828             SpellEntry const* spellInfo = sSpellStore.LookupEntry(qinfo->RewSpellCast);
3829
3830             if(!spellInfo)
3831             {
3832                 sLog.outErrorDb("Quest %u has `RewSpellCast` = %u but spell %u does not exist, quest will not have a spell reward.",
3833                     qinfo->GetQuestId(),qinfo->RewSpellCast,qinfo->RewSpellCast);
3834                 qinfo->RewSpellCast = 0;                    // no spell will be casted on player
3835             }
3836             else if(!SpellMgr::IsSpellValid(spellInfo))
3837             {
3838                 sLog.outErrorDb("Quest %u has `RewSpellCast` = %u but spell %u is broken, quest will not have a spell reward.",
3839                     qinfo->GetQuestId(),qinfo->RewSpellCast,qinfo->RewSpellCast);
3840                 qinfo->RewSpellCast = 0;                    // no spell will be casted on player
3841             }
3842             else if(GetTalentSpellCost(qinfo->RewSpellCast))
3843             {
3844                 sLog.outErrorDb("Quest %u has `RewSpell` = %u but spell %u is talent, quest will not have a spell reward.",
3845                     qinfo->GetQuestId(),qinfo->RewSpellCast,qinfo->RewSpellCast);
3846                 qinfo->RewSpellCast = 0;                    // no spell will be casted on player
3847             }
3848         }
3849
3850         if (qinfo->RewMailTemplateId)
3851         {
3852             if (!sMailTemplateStore.LookupEntry(qinfo->RewMailTemplateId))
3853             {
3854                 sLog.outErrorDb("Quest %u has `RewMailTemplateId` = %u but mail template  %u does not exist, quest will not have a mail reward.",
3855                     qinfo->GetQuestId(),qinfo->RewMailTemplateId,qinfo->RewMailTemplateId);
3856                 qinfo->RewMailTemplateId = 0;               // no mail will send to player
3857                 qinfo->RewMailDelaySecs = 0;                // no mail will send to player
3858             }
3859             else if (usedMailTemplates.find(qinfo->RewMailTemplateId) != usedMailTemplates.end())
3860             {
3861                 std::map<uint32,uint32>::const_iterator used_mt_itr = usedMailTemplates.find(qinfo->RewMailTemplateId);
3862                 sLog.outErrorDb("Quest %u has `RewMailTemplateId` = %u but mail template  %u already used for quest %u, quest will not have a mail reward.",
3863                     qinfo->GetQuestId(),qinfo->RewMailTemplateId,qinfo->RewMailTemplateId,used_mt_itr->second);
3864                 qinfo->RewMailTemplateId = 0;               // no mail will send to player
3865                 qinfo->RewMailDelaySecs = 0;                // no mail will send to player
3866             }
3867             else
3868                 usedMailTemplates[qinfo->RewMailTemplateId] = qinfo->GetQuestId();
3869         }
3870
3871         if (qinfo->NextQuestInChain)
3872         {
3873             QuestMap::iterator qNextItr = mQuestTemplates.find(qinfo->NextQuestInChain);
3874             if (qNextItr == mQuestTemplates.end())
3875             {
3876                 sLog.outErrorDb("Quest %u has `NextQuestInChain` = %u but quest %u does not exist, quest chain will not work.",
3877                     qinfo->GetQuestId(),qinfo->NextQuestInChain ,qinfo->NextQuestInChain );
3878                 qinfo->NextQuestInChain = 0;
3879             }
3880             else
3881                 qNextItr->second->prevChainQuests.push_back(qinfo->GetQuestId());
3882         }
3883
3884         // fill additional data stores
3885         if (qinfo->PrevQuestId)
3886         {
3887             if (mQuestTemplates.find(abs(qinfo->GetPrevQuestId())) == mQuestTemplates.end())
3888             {
3889                 sLog.outErrorDb("Quest %d has PrevQuestId %i, but no such quest", qinfo->GetQuestId(), qinfo->GetPrevQuestId());
3890             }
3891             else
3892             {
3893                 qinfo->prevQuests.push_back(qinfo->PrevQuestId);
3894             }
3895         }
3896
3897         if(qinfo->NextQuestId)
3898         {
3899             QuestMap::iterator qNextItr = mQuestTemplates.find(abs(qinfo->GetNextQuestId()));
3900             if (qNextItr == mQuestTemplates.end())
3901             {
3902                 sLog.outErrorDb("Quest %d has NextQuestId %i, but no such quest", qinfo->GetQuestId(), qinfo->GetNextQuestId());
3903             }
3904             else
3905             {
3906                 int32 signedQuestId = qinfo->NextQuestId < 0 ? -int32(qinfo->GetQuestId()) : int32(qinfo->GetQuestId());
3907                 qNextItr->second->prevQuests.push_back(signedQuestId);
3908             }
3909         }
3910
3911         if(qinfo->ExclusiveGroup)
3912             mExclusiveQuestGroups.insert(std::pair<int32, uint32>(qinfo->ExclusiveGroup, qinfo->GetQuestId()));
3913         if(qinfo->LimitTime)
3914             qinfo->SetFlag(QUEST_MANGOS_FLAGS_TIMED);
3915     }
3916
3917     // check QUEST_MANGOS_FLAGS_EXPLORATION_OR_EVENT for spell with SPELL_EFFECT_QUEST_COMPLETE
3918     for (uint32 i = 0; i < sSpellStore.GetNumRows(); ++i)
3919     {
3920         SpellEntry const *spellInfo = sSpellStore.LookupEntry(i);
3921         if(!spellInfo)
3922             continue;
3923
3924         for(int j = 0; j < 3; ++j)
3925         {
3926             if(spellInfo->Effect[j] != SPELL_EFFECT_QUEST_COMPLETE)
3927                 continue;
3928
3929             uint32 quest_id = spellInfo->EffectMiscValue[j];
3930
3931             Quest const* quest = GetQuestTemplate(quest_id);
3932
3933             // some quest referenced in spells not exist (outdated spells)
3934             if(!quest)
3935                 continue;
3936
3937             if(!quest->HasFlag(QUEST_MANGOS_FLAGS_EXPLORATION_OR_EVENT))
3938             {
3939                 sLog.outErrorDb("Spell (id: %u) have SPELL_EFFECT_QUEST_COMPLETE for quest %u , but quest not have flag QUEST_MANGOS_FLAGS_EXPLORATION_OR_EVENT. Quest flags must be fixed, quest modified to enable objective.",spellInfo->Id,quest_id);
3940
3941                 // this will prevent quest completing without objective
3942                 const_cast<Quest*>(quest)->SetFlag(QUEST_MANGOS_FLAGS_EXPLORATION_OR_EVENT);
3943             }
3944         }
3945     }
3946
3947     sLog.outString();
3948     sLog.outString( ">> Loaded %lu quests definitions", (unsigned long)mQuestTemplates.size() );
3949 }
3950
3951 void ObjectMgr::LoadQuestLocales()
3952 {
3953     mQuestLocaleMap.clear();                                // need for reload case
3954
3955     QueryResult *result = WorldDatabase.Query("SELECT entry,"
3956         "Title_loc1,Details_loc1,Objectives_loc1,OfferRewardText_loc1,RequestItemsText_loc1,EndText_loc1,ObjectiveText1_loc1,ObjectiveText2_loc1,ObjectiveText3_loc1,ObjectiveText4_loc1,"
3957         "Title_loc2,Details_loc2,Objectives_loc2,OfferRewardText_loc2,RequestItemsText_loc2,EndText_loc2,ObjectiveText1_loc2,ObjectiveText2_loc2,ObjectiveText3_loc2,ObjectiveText4_loc2,"
3958         "Title_loc3,Details_loc3,Objectives_loc3,OfferRewardText_loc3,RequestItemsText_loc3,EndText_loc3,ObjectiveText1_loc3,ObjectiveText2_loc3,ObjectiveText3_loc3,ObjectiveText4_loc3,"
3959         "Title_loc4,Details_loc4,Objectives_loc4,OfferRewardText_loc4,RequestItemsText_loc4,EndText_loc4,ObjectiveText1_loc4,ObjectiveText2_loc4,ObjectiveText3_loc4,ObjectiveText4_loc4,"
3960         "Title_loc5,Details_loc5,Objectives_loc5,OfferRewardText_loc5,RequestItemsText_loc5,EndText_loc5,ObjectiveText1_loc5,ObjectiveText2_loc5,ObjectiveText3_loc5,ObjectiveText4_loc5,"
3961         "Title_loc6,Details_loc6,Objectives_loc6,OfferRewardText_loc6,RequestItemsText_loc6,EndText_loc6,ObjectiveText1_loc6,ObjectiveText2_loc6,ObjectiveText3_loc6,ObjectiveText4_loc6,"
3962         "Title_loc7,Details_loc7,Objectives_loc7,OfferRewardText_loc7,RequestItemsText_loc7,EndText_loc7,ObjectiveText1_loc7,ObjectiveText2_loc7,ObjectiveText3_loc7,ObjectiveText4_loc7,"
3963         "Title_loc8,Details_loc8,Objectives_loc8,OfferRewardText_loc8,RequestItemsText_loc8,EndText_loc8,ObjectiveText1_loc8,ObjectiveText2_loc8,ObjectiveText3_loc8,ObjectiveText4_loc8"
3964         " FROM locales_quest"
3965         );
3966
3967     if(!result)
3968     {
3969         barGoLink bar(1);
3970
3971         bar.step();
3972
3973         sLog.outString();
3974         sLog.outString(">> Loaded 0 Quest locale strings. DB table `locales_quest` is empty.");
3975         return;
3976     }
3977
3978     barGoLink bar(result->GetRowCount());
3979
3980     do
3981     {
3982         Field *fields = result->Fetch();
3983         bar.step();
3984
3985         uint32 entry = fields[0].GetUInt32();
3986
3987         QuestLocale& data = mQuestLocaleMap[entry];
3988
3989         for(int i = 1; i < MAX_LOCALE; ++i)
3990         {
3991             std::string str = fields[1+10*(i-1)].GetCppString();
3992             if(!str.empty())
3993             {
3994                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
3995                 if(idx >= 0)
3996                 {
3997                     if(data.Title.size() <= idx)
3998                         data.Title.resize(idx+1);
3999
4000                     data.Title[idx] = str;
4001                 }
4002             }
4003             str = fields[1+10*(i-1)+1].GetCppString();
4004             if(!str.empty())
4005             {
4006                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
4007                 if(idx >= 0)
4008                 {
4009                     if(data.Details.size() <= idx)
4010                         data.Details.resize(idx+1);
4011
4012                     data.Details[idx] = str;
4013                 }
4014             }
4015             str = fields[1+10*(i-1)+2].GetCppString();
4016             if(!str.empty())
4017             {
4018                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
4019                 if(idx >= 0)
4020                 {
4021                     if(data.Objectives.size() <= idx)
4022                         data.Objectives.resize(idx+1);
4023
4024                     data.Objectives[idx] = str;
4025                 }
4026             }
4027             str = fields[1+10*(i-1)+3].GetCppString();
4028             if(!str.empty())
4029             {
4030                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
4031                 if(idx >= 0)
4032                 {
4033                     if(data.OfferRewardText.size() <= idx)
4034                         data.OfferRewardText.resize(idx+1);
4035
4036                     data.OfferRewardText[idx] = str;
4037                 }
4038             }
4039             str = fields[1+10*(i-1)+4].GetCppString();
4040             if(!str.empty())
4041             {
4042                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
4043                 if(idx >= 0)
4044                 {
4045                     if(data.RequestItemsText.size() <= idx)
4046                         data.RequestItemsText.resize(idx+1);
4047
4048                     data.RequestItemsText[idx] = str;
4049                 }
4050             }
4051             str = fields[1+10*(i-1)+5].GetCppString();
4052             if(!str.empty())
4053             {
4054                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
4055                 if(idx >= 0)
4056                 {
4057                     if(data.EndText.size() <= idx)
4058                         data.EndText.resize(idx+1);
4059
4060                     data.EndText[idx] = str;
4061                 }
4062             }
4063             for(int k = 0; k < 4; ++k)
4064             {
4065                 str = fields[1+10*(i-1)+6+k].GetCppString();
4066                 if(!str.empty())
4067                 {
4068                     int idx = GetOrNewIndexForLocale(LocaleConstant(i));
4069                     if(idx >= 0)
4070                     {
4071                         if(data.ObjectiveText[k].size() <= idx)
4072                             data.ObjectiveText[k].resize(idx+1);
4073
4074                         data.ObjectiveText[k][idx] = str;
4075                     }
4076                 }
4077             }
4078         }
4079     } while (result->NextRow());
4080
4081     delete result;
4082
4083     sLog.outString();
4084     sLog.outString( ">> Loaded %lu Quest locale strings", (unsigned long)mQuestLocaleMap.size() );
4085 }
4086
4087 void ObjectMgr::LoadScripts(ScriptMapMap& scripts, char const* tablename)
4088 {
4089     if(sWorld.IsScriptScheduled())                          // function don't must be called in time scripts use.
4090         return;
4091
4092     sLog.outString( "%s :", tablename);
4093
4094     scripts.clear();                                        // need for reload support
4095
4096     QueryResult *result = WorldDatabase.PQuery( "SELECT id,delay,command,datalong,datalong2,dataint, x, y, z, o FROM %s", tablename );
4097
4098     uint32 count = 0;
4099
4100     if( !result )
4101     {
4102         barGoLink bar( 1 );
4103         bar.step();
4104
4105         sLog.outString();
4106         sLog.outString( ">> Loaded %u script definitions", count );
4107         return;
4108     }
4109
4110     barGoLink bar( result->GetRowCount() );
4111
4112     do
4113     {
4114         bar.step();
4115
4116         Field *fields = result->Fetch();
4117         ScriptInfo tmp;
4118         tmp.id        = fields[0].GetUInt32();
4119         tmp.delay     = fields[1].GetUInt32();
4120         tmp.command   = fields[2].GetUInt32();
4121         tmp.datalong  = fields[3].GetUInt32();
4122         tmp.datalong2 = fields[4].GetUInt32();
4123         tmp.dataint   = fields[5].GetInt32();
4124         tmp.x         = fields[6].GetFloat();
4125         tmp.y         = fields[7].GetFloat();
4126         tmp.z         = fields[8].GetFloat();
4127         tmp.o         = fields[9].GetFloat();
4128
4129         // generic command args check
4130         switch(tmp.command)
4131         {
4132             case SCRIPT_COMMAND_TALK:
4133             {
4134                 if(tmp.datalong > 3)
4135                 {
4136                     sLog.outErrorDb("Table `%s` has invalid talk type (datalong = %u) in SCRIPT_COMMAND_TALK for script id %u",tablename,tmp.datalong,tmp.id);
4137                     continue;
4138                 }
4139                 if(tmp.dataint==0)
4140                 {
4141                     sLog.outErrorDb("Table `%s` has invalid talk text id (dataint = %i) in SCRIPT_COMMAND_TALK for script id %u",tablename,tmp.dataint,tmp.id);
4142                     continue;
4143                 }
4144                 if(tmp.dataint < MIN_DB_SCRIPT_STRING_ID || tmp.dataint >= MAX_DB_SCRIPT_STRING_ID)
4145                 {
4146                     sLog.outErrorDb("Table `%s` has out of range text id (dataint = %i expected %u-%u) in SCRIPT_COMMAND_TALK for script id %u",tablename,tmp.dataint,MIN_DB_SCRIPT_STRING_ID,MAX_DB_SCRIPT_STRING_ID,tmp.id);
4147                     continue;
4148                 }
4149
4150                 // if(!GetMangosStringLocale(tmp.dataint)) will checked after db_script_string loading
4151                 break;
4152             }
4153
4154             case SCRIPT_COMMAND_EMOTE:
4155             {
4156                 if(!sEmotesStore.LookupEntry(tmp.datalong))
4157                 {
4158                     sLog.outErrorDb("Table `%s` has invalid emote id (datalong = %u) in SCRIPT_COMMAND_EMOTE for script id %u",tablename,tmp.datalong,tmp.id);
4159                     continue;
4160                 }
4161                 break;
4162             }
4163
4164             case SCRIPT_COMMAND_TELEPORT_TO:
4165             {
4166                 if(!sMapStore.LookupEntry(tmp.datalong))
4167                 {
4168                     sLog.outErrorDb("Table `%s` has invalid map (Id: %u) in SCRIPT_COMMAND_TELEPORT_TO for script id %u",tablename,tmp.datalong,tmp.id);
4169                     continue;
4170                 }
4171
4172                 if(!MaNGOS::IsValidMapCoord(tmp.x,tmp.y,tmp.z,tmp.o))
4173                 {
4174                     sLog.outErrorDb("Table `%s` has invalid coordinates (X: %f Y: %f) in SCRIPT_COMMAND_TELEPORT_TO for script id %u",tablename,tmp.x,tmp.y,tmp.id);
4175                     continue;
4176                 }
4177                 break;
4178             }
4179
4180             case SCRIPT_COMMAND_KILL_CREDIT:
4181             {
4182                 if (!GetCreatureTemplate(tmp.datalong))
4183                 {
4184                     sLog.outErrorDb("Table `%s` has invalid creature (Entry: %u) in SCRIPT_COMMAND_KILL_CREDIT for script id %u",tablename,tmp.datalong,tmp.id);
4185                     continue;
4186                 }
4187                 break;
4188             }
4189
4190             case SCRIPT_COMMAND_TEMP_SUMMON_CREATURE:
4191             {
4192                 if(!MaNGOS::IsValidMapCoord(tmp.x,tmp.y,tmp.z,tmp.o))
4193                 {
4194                     sLog.outErrorDb("Table `%s` has invalid coordinates (X: %f Y: %f) in SCRIPT_COMMAND_TEMP_SUMMON_CREATURE for script id %u",tablename,tmp.x,tmp.y,tmp.id);
4195                     continue;
4196                 }
4197
4198                 if(!GetCreatureTemplate(tmp.datalong))
4199                 {
4200                     sLog.outErrorDb("Table `%s` has invalid creature (Entry: %u) in SCRIPT_COMMAND_TEMP_SUMMON_CREATURE for script id %u",tablename,tmp.datalong,tmp.id);
4201                     continue;
4202                 }
4203                 break;
4204             }
4205
4206             case SCRIPT_COMMAND_RESPAWN_GAMEOBJECT:
4207             {
4208                 GameObjectData const* data = GetGOData(tmp.datalong);
4209                 if(!data)
4210                 {
4211                     sLog.outErrorDb("Table `%s` has invalid gameobject (GUID: %u) in SCRIPT_COMMAND_RESPAWN_GAMEOBJECT for script id %u",tablename,tmp.datalong,tmp.id);
4212                     continue;
4213                 }
4214
4215                 GameObjectInfo const* info = GetGameObjectInfo(data->id);
4216                 if(!info)
4217                 {
4218                     sLog.outErrorDb("Table `%s` has gameobject with invalid entry (GUID: %u Entry: %u) in SCRIPT_COMMAND_RESPAWN_GAMEOBJECT for script id %u",tablename,tmp.datalong,data->id,tmp.id);
4219                     continue;
4220                 }
4221
4222                 if( info->type==GAMEOBJECT_TYPE_FISHINGNODE ||
4223                     info->type==GAMEOBJECT_TYPE_FISHINGHOLE ||
4224                     info->type==GAMEOBJECT_TYPE_DOOR        ||
4225                     info->type==GAMEOBJECT_TYPE_BUTTON      ||
4226                     info->type==GAMEOBJECT_TYPE_TRAP )
4227                 {
4228                     sLog.outErrorDb("Table `%s` have gameobject type (%u) unsupported by command SCRIPT_COMMAND_RESPAWN_GAMEOBJECT for script id %u",tablename,info->id,tmp.id);
4229                     continue;
4230                 }
4231                 break;
4232             }
4233             case SCRIPT_COMMAND_OPEN_DOOR:
4234             case SCRIPT_COMMAND_CLOSE_DOOR:
4235             {
4236                 GameObjectData const* data = GetGOData(tmp.datalong);
4237                 if(!data)
4238                 {
4239                     sLog.outErrorDb("Table `%s` has invalid gameobject (GUID: %u) in %s for script id %u",tablename,tmp.datalong,(tmp.command==SCRIPT_COMMAND_OPEN_DOOR ? "SCRIPT_COMMAND_OPEN_DOOR" : "SCRIPT_COMMAND_CLOSE_DOOR"),tmp.id);
4240                     continue;
4241                 }
4242
4243                 GameObjectInfo const* info = GetGameObjectInfo(data->id);
4244                 if(!info)
4245                 {
4246                     sLog.outErrorDb("Table `%s` has gameobject with invalid entry (GUID: %u Entry: %u) in %s for script id %u",tablename,tmp.datalong,data->id,(tmp.command==SCRIPT_COMMAND_OPEN_DOOR ? "SCRIPT_COMMAND_OPEN_DOOR" : "SCRIPT_COMMAND_CLOSE_DOOR"),tmp.id);
4247                     continue;
4248                 }
4249
4250                 if( info->type!=GAMEOBJECT_TYPE_DOOR)
4251                 {
4252                     sLog.outErrorDb("Table `%s` has gameobject type (%u) non supported by command %s for script id %u",tablename,info->id,(tmp.command==SCRIPT_COMMAND_OPEN_DOOR ? "SCRIPT_COMMAND_OPEN_DOOR" : "SCRIPT_COMMAND_CLOSE_DOOR"),tmp.id);
4253                     continue;
4254                 }
4255
4256                 break;
4257             }
4258             case SCRIPT_COMMAND_QUEST_EXPLORED:
4259             {
4260                 Quest const* quest = GetQuestTemplate(tmp.datalong);
4261                 if(!quest)
4262                 {
4263                     sLog.outErrorDb("Table `%s` has invalid quest (ID: %u) in SCRIPT_COMMAND_QUEST_EXPLORED in `datalong` for script id %u",tablename,tmp.datalong,tmp.id);
4264                     continue;
4265                 }
4266
4267                 if(!quest->HasFlag(QUEST_MANGOS_FLAGS_EXPLORATION_OR_EVENT))
4268                 {
4269                     sLog.outErrorDb("Table `%s` has quest (ID: %u) in SCRIPT_COMMAND_QUEST_EXPLORED in `datalong` for script id %u, but quest not have flag QUEST_MANGOS_FLAGS_EXPLORATION_OR_EVENT in quest flags. Script command or quest flags wrong. Quest modified to require objective.",tablename,tmp.datalong,tmp.id);
4270
4271                     // this will prevent quest completing without objective
4272                     const_cast<Quest*>(quest)->SetFlag(QUEST_MANGOS_FLAGS_EXPLORATION_OR_EVENT);
4273
4274                     // continue; - quest objective requirement set and command can be allowed
4275                 }
4276
4277                 if(float(tmp.datalong2) > DEFAULT_VISIBILITY_DISTANCE)
4278                 {
4279                     sLog.outErrorDb("Table `%s` has too large distance (%u) for exploring objective complete in `datalong2` in SCRIPT_COMMAND_QUEST_EXPLORED in `datalong` for script id %u",
4280                         tablename,tmp.datalong2,tmp.id);
4281                     continue;
4282                 }
4283
4284                 if(tmp.datalong2 && float(tmp.datalong2) > DEFAULT_VISIBILITY_DISTANCE)
4285                 {
4286                     sLog.outErrorDb("Table `%s` has too large distance (%u) for exploring objective complete in `datalong2` in SCRIPT_COMMAND_QUEST_EXPLORED in `datalong` for script id %u, max distance is %f or 0 for disable distance check",
4287                         tablename,tmp.datalong2,tmp.id,DEFAULT_VISIBILITY_DISTANCE);
4288                     continue;
4289                 }
4290
4291                 if(tmp.datalong2 && float(tmp.datalong2) < INTERACTION_DISTANCE)
4292                 {
4293                     sLog.outErrorDb("Table `%s` has too small distance (%u) for exploring objective complete in `datalong2` in SCRIPT_COMMAND_QUEST_EXPLORED in `datalong` for script id %u, min distance is %f or 0 for disable distance check",
4294                         tablename,tmp.datalong2,tmp.id,INTERACTION_DISTANCE);
4295                     continue;
4296                 }
4297
4298                 break;
4299             }
4300
4301             case SCRIPT_COMMAND_REMOVE_AURA:
4302             {
4303                 if(!sSpellStore.LookupEntry(tmp.datalong))
4304                 {
4305                     sLog.outErrorDb("Table `%s` using non-existent spell (id: %u) in SCRIPT_COMMAND_REMOVE_AURA or SCRIPT_COMMAND_CAST_SPELL for script id %u",
4306                         tablename,tmp.datalong,tmp.id);
4307                     continue;
4308                 }
4309                 if(tmp.datalong2 & ~0x1)                    // 1 bits (0,1)
4310                 {
4311                     sLog.outErrorDb("Table `%s` using unknown flags in datalong2 (%u)i n SCRIPT_COMMAND_CAST_SPELL for script id %u",
4312                         tablename,tmp.datalong2,tmp.id);
4313                     continue;
4314                 }
4315                 break;
4316             }
4317             case SCRIPT_COMMAND_CAST_SPELL:
4318             {
4319                 if(!sSpellStore.LookupEntry(tmp.datalong))
4320                 {
4321                     sLog.outErrorDb("Table `%s` using non-existent spell (id: %u) in SCRIPT_COMMAND_REMOVE_AURA or SCRIPT_COMMAND_CAST_SPELL for script id %u",
4322                         tablename,tmp.datalong,tmp.id);
4323                     continue;
4324                 }
4325                 if(tmp.datalong2 & ~0x3)                    // 2 bits
4326                 {
4327                     sLog.outErrorDb("Table `%s` using unknown flags in datalong2 (%u)i n SCRIPT_COMMAND_CAST_SPELL for script id %u",
4328                         tablename,tmp.datalong2,tmp.id);
4329                     continue;
4330                 }
4331                 break;
4332             }
4333         }
4334
4335         if (scripts.find(tmp.id) == scripts.end())
4336         {
4337             ScriptMap emptyMap;
4338             scripts[tmp.id] = emptyMap;
4339         }
4340         scripts[tmp.id].insert(std::pair<uint32, ScriptInfo>(tmp.delay, tmp));
4341
4342         ++count;
4343     } while( result->NextRow() );
4344
4345     delete result;
4346
4347     sLog.outString();
4348     sLog.outString( ">> Loaded %u script definitions", count );
4349 }
4350
4351 void ObjectMgr::LoadGameObjectScripts()
4352 {
4353     LoadScripts(sGameObjectScripts,    "gameobject_scripts");
4354
4355     // check ids
4356     for(ScriptMapMap::const_iterator itr = sGameObjectScripts.begin(); itr != sGameObjectScripts.end(); ++itr)
4357     {
4358         if(!GetGOData(itr->first))
4359             sLog.outErrorDb("Table `gameobject_scripts` has not existing gameobject (GUID: %u) as script id",itr->first);
4360     }
4361 }
4362
4363 void ObjectMgr::LoadQuestEndScripts()
4364 {
4365     LoadScripts(sQuestEndScripts,  "quest_end_scripts");
4366
4367     // check ids
4368     for(ScriptMapMap::const_iterator itr = sQuestEndScripts.begin(); itr != sQuestEndScripts.end(); ++itr)
4369     {
4370         if(!GetQuestTemplate(itr->first))
4371             sLog.outErrorDb("Table `quest_end_scripts` has not existing quest (Id: %u) as script id",itr->first);
4372     }
4373 }
4374
4375 void ObjectMgr::LoadQuestStartScripts()
4376 {
4377     LoadScripts(sQuestStartScripts,"quest_start_scripts");
4378
4379     // check ids
4380     for(ScriptMapMap::const_iterator itr = sQuestStartScripts.begin(); itr != sQuestStartScripts.end(); ++itr)
4381     {
4382         if(!GetQuestTemplate(itr->first))
4383             sLog.outErrorDb("Table `quest_start_scripts` has not existing quest (Id: %u) as script id",itr->first);
4384     }
4385 }
4386
4387 void ObjectMgr::LoadSpellScripts()
4388 {
4389     LoadScripts(sSpellScripts, "spell_scripts");
4390
4391     // check ids
4392     for(ScriptMapMap::const_iterator itr = sSpellScripts.begin(); itr != sSpellScripts.end(); ++itr)
4393     {
4394         SpellEntry const* spellInfo = sSpellStore.LookupEntry(itr->first);
4395
4396         if(!spellInfo)
4397         {
4398             sLog.outErrorDb("Table `spell_scripts` has not existing spell (Id: %u) as script id",itr->first);
4399             continue;
4400         }
4401
4402         //check for correct spellEffect
4403         bool found = false;
4404         for(int i=0; i<3; ++i)
4405         {
4406             // skip empty effects
4407             if( !spellInfo->Effect[i] )
4408                 continue;
4409
4410             if( spellInfo->Effect[i] == SPELL_EFFECT_SCRIPT_EFFECT )
4411             {
4412                 found =  true;
4413                 break;
4414             }
4415         }
4416
4417         if(!found)
4418             sLog.outErrorDb("Table `spell_scripts` has unsupported spell (Id: %u) without SPELL_EFFECT_SCRIPT_EFFECT (%u) spell effect",itr->first,SPELL_EFFECT_SCRIPT_EFFECT);
4419     }
4420 }
4421
4422 void ObjectMgr::LoadEventScripts()
4423 {
4424     LoadScripts(sEventScripts, "event_scripts");
4425
4426     std::set<uint32> evt_scripts;
4427     // Load all possible script entries from gameobjects
4428     for(uint32 i = 1; i < sGOStorage.MaxEntry; ++i)
4429     {
4430         GameObjectInfo const * goInfo = sGOStorage.LookupEntry<GameObjectInfo>(i);
4431         if (goInfo)
4432         {
4433             switch(goInfo->type)
4434             {
4435                 case GAMEOBJECT_TYPE_GOOBER:
4436                     if (goInfo->goober.eventId)
4437                         evt_scripts.insert(goInfo->goober.eventId);
4438                     break;
4439                 case GAMEOBJECT_TYPE_CHEST:
4440                     if (goInfo->chest.eventId)
4441                         evt_scripts.insert(goInfo->chest.eventId);
4442                     break;
4443                 case GAMEOBJECT_TYPE_CAMERA:
4444                     if (goInfo->camera.eventID)
4445                         evt_scripts.insert(goInfo->camera.eventID);
4446                 default:
4447                     break;
4448             }
4449         }
4450     }
4451     // Load all possible script entries from spells
4452     for(uint32 i = 1; i < sSpellStore.GetNumRows(); ++i)
4453     {
4454         SpellEntry const * spell = sSpellStore.LookupEntry(i);
4455         if (spell)
4456         {
4457             for(int j=0; j<3; ++j)
4458             {
4459                 if( spell->Effect[j] == SPELL_EFFECT_SEND_EVENT )
4460                 {
4461                     if (spell->EffectMiscValue[j])
4462                         evt_scripts.insert(spell->EffectMiscValue[j]);
4463                 }
4464             }
4465         }
4466     }
4467     // Then check if all scripts are in above list of possible script entries
4468     for(ScriptMapMap::const_iterator itr = sEventScripts.begin(); itr != sEventScripts.end(); ++itr)
4469     {
4470         std::set<uint32>::const_iterator itr2 = evt_scripts.find(itr->first);
4471         if (itr2 == evt_scripts.end())
4472             sLog.outErrorDb("Table `event_scripts` has script (Id: %u) not referring to any gameobject_template type 10 data2 field, type 3 data6 field, type 13 data 2 field or any spell effect %u",
4473                 itr->first, SPELL_EFFECT_SEND_EVENT);
4474     }
4475 }
4476
4477 void ObjectMgr::LoadGossipScripts()
4478 {
4479     LoadScripts(sGossipScripts, "gossip_scripts");
4480
4481     // checks are done in LoadGossipMenuItems
4482 }
4483
4484 void ObjectMgr::LoadItemTexts()
4485 {
4486     QueryResult *result = CharacterDatabase.Query("SELECT id, text FROM item_text");
4487
4488     uint32 count = 0;
4489
4490     if( !result )
4491     {
4492         barGoLink bar( 1 );
4493         bar.step();
4494
4495         sLog.outString();
4496         sLog.outString( ">> Loaded %u item pages", count );
4497         return;
4498     }
4499
4500     barGoLink bar( result->GetRowCount() );
4501
4502     Field* fields;
4503     do
4504     {
4505         bar.step();
4506
4507         fields = result->Fetch();
4508
4509         mItemTexts[ fields[0].GetUInt32() ] = fields[1].GetCppString();
4510
4511         ++count;
4512
4513     } while ( result->NextRow() );
4514
4515     delete result;
4516
4517     sLog.outString();
4518     sLog.outString( ">> Loaded %u item texts", count );
4519 }
4520
4521 void ObjectMgr::LoadPageTexts()
4522 {
4523     sPageTextStore.Free();                                  // for reload case
4524
4525     sPageTextStore.Load();
4526     sLog.outString( ">> Loaded %u page texts", sPageTextStore.RecordCount );
4527     sLog.outString();
4528
4529     for(uint32 i = 1; i < sPageTextStore.MaxEntry; ++i)
4530     {
4531         // check data correctness
4532         PageText const* page = sPageTextStore.LookupEntry<PageText>(i);
4533         if(!page)
4534             continue;
4535
4536         if(page->Next_Page && !sPageTextStore.LookupEntry<PageText>(page->Next_Page))
4537         {
4538             sLog.outErrorDb("Page text (Id: %u) has not existing next page (Id:%u)", i,page->Next_Page);
4539             continue;
4540         }
4541
4542         // detect circular reference
4543         std::set<uint32> checkedPages;
4544         for(PageText const* pageItr = page; pageItr; pageItr = sPageTextStore.LookupEntry<PageText>(pageItr->Next_Page))
4545         {
4546             if(!pageItr->Next_Page)
4547                 break;
4548             checkedPages.insert(pageItr->Page_ID);
4549             if(checkedPages.find(pageItr->Next_Page)!=checkedPages.end())
4550             {
4551                 std::ostringstream ss;
4552                 ss<< "The text page(s) ";
4553                 for (std::set<uint32>::iterator itr= checkedPages.begin();itr!=checkedPages.end(); ++itr)
4554                     ss << *itr << " ";
4555                 ss << "create(s) a circular reference, which can cause the server to freeze. Changing Next_Page of page "
4556                     << pageItr->Page_ID <<" to 0";
4557                 sLog.outErrorDb("%s", ss.str().c_str());
4558                 const_cast<PageText*>(pageItr)->Next_Page = 0;
4559                 break;
4560             }
4561         }
4562     }
4563 }
4564
4565 void ObjectMgr::LoadPageTextLocales()
4566 {
4567     mPageTextLocaleMap.clear();                             // need for reload case
4568
4569     QueryResult *result = WorldDatabase.Query("SELECT entry,text_loc1,text_loc2,text_loc3,text_loc4,text_loc5,text_loc6,text_loc7,text_loc8 FROM locales_page_text");
4570
4571     if(!result)
4572     {
4573         barGoLink bar(1);
4574
4575         bar.step();
4576
4577         sLog.outString();
4578         sLog.outString(">> Loaded 0 PageText locale strings. DB table `locales_page_text` is empty.");
4579         return;
4580     }
4581
4582     barGoLink bar(result->GetRowCount());
4583
4584     do
4585     {
4586         Field *fields = result->Fetch();
4587         bar.step();
4588
4589         uint32 entry = fields[0].GetUInt32();
4590
4591         PageTextLocale& data = mPageTextLocaleMap[entry];
4592
4593         for(int i = 1; i < MAX_LOCALE; ++i)
4594         {
4595             std::string str = fields[i].GetCppString();
4596             if(str.empty())
4597                 continue;
4598
4599             int idx = GetOrNewIndexForLocale(LocaleConstant(i));
4600             if(idx >= 0)
4601             {
4602                 if(data.Text.size() <= idx)
4603                     data.Text.resize(idx+1);
4604
4605                 data.Text[idx] = str;
4606             }
4607         }
4608
4609     } while (result->NextRow());
4610
4611     delete result;
4612
4613     sLog.outString();
4614     sLog.outString( ">> Loaded %lu PageText locale strings", (unsigned long)mPageTextLocaleMap.size() );
4615 }
4616
4617 struct SQLInstanceLoader : public SQLStorageLoaderBase<SQLInstanceLoader>
4618 {
4619     template<class D>
4620     void convert_from_str(uint32 /*field_pos*/, char *src, D &dst)
4621     {
4622         dst = D(sObjectMgr.GetScriptId(src));
4623     }
4624 };
4625
4626 void ObjectMgr::LoadInstanceTemplate()
4627 {
4628     SQLInstanceLoader loader;
4629     loader.Load(sInstanceTemplate);
4630
4631     for(uint32 i = 0; i < sInstanceTemplate.MaxEntry; i++)
4632     {
4633         InstanceTemplate* temp = (InstanceTemplate*)GetInstanceTemplate(i);
4634         if(!temp)
4635             continue;
4636
4637         if(!MapManager::IsValidMAP(temp->map))
4638             sLog.outErrorDb("ObjectMgr::LoadInstanceTemplate: bad mapid %d for template!", temp->map);
4639
4640         if(!MapManager::IsValidMapCoord(temp->parent,temp->startLocX,temp->startLocY,temp->startLocZ,temp->startLocO))
4641         {
4642             sLog.outErrorDb("ObjectMgr::LoadInstanceTemplate: bad parent entrance coordinates for map id %d template!", temp->map);
4643             temp->parent = 0;                               // will have wrong continent 0 parent, at least existed
4644         }
4645     }
4646
4647     sLog.outString( ">> Loaded %u Instance Template definitions", sInstanceTemplate.RecordCount );
4648     sLog.outString();
4649 }
4650
4651 GossipText const *ObjectMgr::GetGossipText(uint32 Text_ID) const
4652 {
4653     GossipTextMap::const_iterator itr = mGossipText.find(Text_ID);
4654     if(itr != mGossipText.end())
4655         return &itr->second;
4656     return NULL;
4657 }
4658
4659 void ObjectMgr::LoadGossipText()
4660 {
4661     QueryResult *result = WorldDatabase.Query( "SELECT * FROM npc_text" );
4662
4663     int count = 0;
4664     if( !result )
4665     {
4666         barGoLink bar( 1 );
4667         bar.step();
4668
4669         sLog.outString();
4670         sLog.outString( ">> Loaded %u npc texts", count );
4671         return;
4672     }
4673
4674     int cic;
4675
4676     barGoLink bar( result->GetRowCount() );
4677
4678     do
4679     {
4680         ++count;
4681         cic = 0;
4682
4683         Field *fields = result->Fetch();
4684
4685         bar.step();
4686
4687         uint32 Text_ID    = fields[cic++].GetUInt32();
4688         if(!Text_ID)
4689         {
4690             sLog.outErrorDb("Table `npc_text` has record wit reserved id 0, ignore.");
4691             continue;
4692         }
4693
4694         GossipText& gText = mGossipText[Text_ID];
4695
4696         for (int i=0; i< 8; i++)
4697         {
4698             gText.Options[i].Text_0           = fields[cic++].GetCppString();
4699             gText.Options[i].Text_1           = fields[cic++].GetCppString();
4700
4701             gText.Options[i].Language         = fields[cic++].GetUInt32();
4702             gText.Options[i].Probability      = fields[cic++].GetFloat();
4703
4704             for(int j=0; j < 3; ++j)
4705             {
4706                 gText.Options[i].Emotes[j]._Delay  = fields[cic++].GetUInt32();
4707                 gText.Options[i].Emotes[j]._Emote  = fields[cic++].GetUInt32();
4708             }
4709         }
4710     } while( result->NextRow() );
4711
4712     sLog.outString();
4713     sLog.outString( ">> Loaded %u npc texts", count );
4714     delete result;
4715 }
4716
4717 void ObjectMgr::LoadNpcTextLocales()
4718 {
4719     mNpcTextLocaleMap.clear();                              // need for reload case
4720
4721     QueryResult *result = WorldDatabase.Query("SELECT entry,"
4722         "Text0_0_loc1,Text0_1_loc1,Text1_0_loc1,Text1_1_loc1,Text2_0_loc1,Text2_1_loc1,Text3_0_loc1,Text3_1_loc1,Text4_0_loc1,Text4_1_loc1,Text5_0_loc1,Text5_1_loc1,Text6_0_loc1,Text6_1_loc1,Text7_0_loc1,Text7_1_loc1,"
4723         "Text0_0_loc2,Text0_1_loc2,Text1_0_loc2,Text1_1_loc2,Text2_0_loc2,Text2_1_loc2,Text3_0_loc2,Text3_1_loc1,Text4_0_loc2,Text4_1_loc2,Text5_0_loc2,Text5_1_loc2,Text6_0_loc2,Text6_1_loc2,Text7_0_loc2,Text7_1_loc2,"
4724         "Text0_0_loc3,Text0_1_loc3,Text1_0_loc3,Text1_1_loc3,Text2_0_loc3,Text2_1_loc3,Text3_0_loc3,Text3_1_loc1,Text4_0_loc3,Text4_1_loc3,Text5_0_loc3,Text5_1_loc3,Text6_0_loc3,Text6_1_loc3,Text7_0_loc3,Text7_1_loc3,"
4725         "Text0_0_loc4,Text0_1_loc4,Text1_0_loc4,Text1_1_loc4,Text2_0_loc4,Text2_1_loc4,Text3_0_loc4,Text3_1_loc1,Text4_0_loc4,Text4_1_loc4,Text5_0_loc4,Text5_1_loc4,Text6_0_loc4,Text6_1_loc4,Text7_0_loc4,Text7_1_loc4,"
4726         "Text0_0_loc5,Text0_1_loc5,Text1_0_loc5,Text1_1_loc5,Text2_0_loc5,Text2_1_loc5,Text3_0_loc5,Text3_1_loc1,Text4_0_loc5,Text4_1_loc5,Text5_0_loc5,Text5_1_loc5,Text6_0_loc5,Text6_1_loc5,Text7_0_loc5,Text7_1_loc5,"
4727         "Text0_0_loc6,Text0_1_loc6,Text1_0_loc6,Text1_1_loc6,Text2_0_loc6,Text2_1_loc6,Text3_0_loc6,Text3_1_loc1,Text4_0_loc6,Text4_1_loc6,Text5_0_loc6,Text5_1_loc6,Text6_0_loc6,Text6_1_loc6,Text7_0_loc6,Text7_1_loc6,"
4728         "Text0_0_loc7,Text0_1_loc7,Text1_0_loc7,Text1_1_loc7,Text2_0_loc7,Text2_1_loc7,Text3_0_loc7,Text3_1_loc1,Text4_0_loc7,Text4_1_loc7,Text5_0_loc7,Text5_1_loc7,Text6_0_loc7,Text6_1_loc7,Text7_0_loc7,Text7_1_loc7, "
4729         "Text0_0_loc8,Text0_1_loc8,Text1_0_loc8,Text1_1_loc8,Text2_0_loc8,Text2_1_loc8,Text3_0_loc8,Text3_1_loc1,Text4_0_loc8,Text4_1_loc8,Text5_0_loc8,Text5_1_loc8,Text6_0_loc8,Text6_1_loc8,Text7_0_loc8,Text7_1_loc8 "
4730         " FROM locales_npc_text");
4731
4732     if(!result)
4733     {
4734         barGoLink bar(1);
4735
4736         bar.step();
4737
4738         sLog.outString();
4739         sLog.outString(">> Loaded 0 Quest locale strings. DB table `locales_npc_text` is empty.");
4740         return;
4741     }
4742
4743     barGoLink bar(result->GetRowCount());
4744
4745     do
4746     {
4747         Field *fields = result->Fetch();
4748         bar.step();
4749
4750         uint32 entry = fields[0].GetUInt32();
4751
4752         NpcTextLocale& data = mNpcTextLocaleMap[entry];
4753
4754         for(int i=1; i<MAX_LOCALE; ++i)
4755         {
4756             for(int j=0; j<8; ++j)
4757             {
4758                 std::string str0 = fields[1+8*2*(i-1)+2*j].GetCppString();
4759                 if(!str0.empty())
4760                 {
4761                     int idx = GetOrNewIndexForLocale(LocaleConstant(i));
4762                     if(idx >= 0)
4763                     {
4764                         if(data.Text_0[j].size() <= idx)
4765                             data.Text_0[j].resize(idx+1);
4766
4767                         data.Text_0[j][idx] = str0;
4768                     }
4769                 }
4770                 std::string str1 = fields[1+8*2*(i-1)+2*j+1].GetCppString();
4771                 if(!str1.empty())
4772                 {
4773                     int idx = GetOrNewIndexForLocale(LocaleConstant(i));
4774                     if(idx >= 0)
4775                     {
4776                         if(data.Text_1[j].size() <= idx)
4777                             data.Text_1[j].resize(idx+1);
4778
4779                         data.Text_1[j][idx] = str1;
4780                     }
4781                 }
4782             }
4783         }
4784     } while (result->NextRow());
4785
4786     delete result;
4787
4788     sLog.outString();
4789     sLog.outString( ">> Loaded %lu NpcText locale strings", (unsigned long)mNpcTextLocaleMap.size() );
4790 }
4791
4792 //not very fast function but it is called only once a day, or on starting-up
4793 void ObjectMgr::ReturnOrDeleteOldMails(bool serverUp)
4794 {
4795     time_t basetime = time(NULL);
4796     sLog.outDebug("Returning mails current time: hour: %d, minute: %d, second: %d ", localtime(&basetime)->tm_hour, localtime(&basetime)->tm_min, localtime(&basetime)->tm_sec);
4797     //delete all old mails without item and without body immediately, if starting server
4798     if (!serverUp)
4799         CharacterDatabase.PExecute("DELETE FROM mail WHERE expire_time < '" UI64FMTD "' AND has_items = '0' AND itemTextId = 0", (uint64)basetime);
4800     //                                                     0  1           2      3        4          5         6           7   8       9
4801     QueryResult* result = CharacterDatabase.PQuery("SELECT id,messageType,sender,receiver,itemTextId,has_items,expire_time,cod,checked,mailTemplateId FROM mail WHERE expire_time < '" UI64FMTD "'", (uint64)basetime);
4802     if ( !result )
4803     {
4804         barGoLink bar(1);
4805         bar.step();
4806         sLog.outString();
4807         sLog.outString(">> Only expired mails (need to be return or delete) or DB table `mail` is empty.");
4808         return;                                             // any mails need to be returned or deleted
4809     }
4810
4811     //std::ostringstream delitems, delmails; //will be here for optimization
4812     //bool deletemail = false, deleteitem = false;
4813     //delitems << "DELETE FROM item_instance WHERE guid IN ( ";
4814     //delmails << "DELETE FROM mail WHERE id IN ( "
4815
4816     barGoLink bar( result->GetRowCount() );
4817     uint32 count = 0;
4818     Field *fields;
4819
4820     do
4821     {
4822         bar.step();
4823
4824         fields = result->Fetch();
4825         Mail *m = new Mail;
4826         m->messageID = fields[0].GetUInt32();
4827         m->messageType = fields[1].GetUInt8();
4828         m->sender = fields[2].GetUInt32();
4829         m->receiver = fields[3].GetUInt32();
4830         m->itemTextId = fields[4].GetUInt32();
4831         bool has_items = fields[5].GetBool();
4832         m->expire_time = (time_t)fields[6].GetUInt64();
4833         m->deliver_time = 0;
4834         m->COD = fields[7].GetUInt32();
4835         m->checked = fields[8].GetUInt32();
4836         m->mailTemplateId = fields[9].GetInt16();
4837
4838         Player *pl = 0;
4839         if (serverUp)
4840             pl = GetPlayer((uint64)m->receiver);
4841         if (pl)
4842         {                                                   //this code will run very improbably (the time is between 4 and 5 am, in game is online a player, who has old mail
4843             //his in mailbox and he has already listed his mails )
4844             delete m;
4845             continue;
4846         }
4847         //delete or return mail:
4848         if (has_items)
4849         {
4850             QueryResult *resultItems = CharacterDatabase.PQuery("SELECT item_guid,item_template FROM mail_items WHERE mail_id='%u'", m->messageID);
4851             if(resultItems)
4852             {
4853                 do
4854                 {
4855                     Field *fields2 = resultItems->Fetch();
4856
4857                     uint32 item_guid_low = fields2[0].GetUInt32();
4858                     uint32 item_template = fields2[1].GetUInt32();
4859
4860                     m->AddItem(item_guid_low, item_template);
4861                 }
4862                 while (resultItems->NextRow());
4863
4864                 delete resultItems;
4865             }
4866             //if it is mail from AH, it shouldn't be returned, but deleted
4867             if (m->messageType != MAIL_NORMAL || (m->checked & (MAIL_CHECK_MASK_AUCTION | MAIL_CHECK_MASK_COD_PAYMENT | MAIL_CHECK_MASK_RETURNED)))
4868             {
4869                 // mail open and then not returned
4870                 for(std::vector<MailItemInfo>::iterator itr2 = m->items.begin(); itr2 != m->items.end(); ++itr2)
4871                     CharacterDatabase.PExecute("DELETE FROM item_instance WHERE guid = '%u'", itr2->item_guid);
4872             }
4873             else
4874             {
4875                 //mail will be returned:
4876                 CharacterDatabase.PExecute("UPDATE mail SET sender = '%u', receiver = '%u', expire_time = '" UI64FMTD "', deliver_time = '" UI64FMTD "',cod = '0', checked = '%u' WHERE id = '%u'", m->receiver, m->sender, (uint64)(basetime + 30*DAY), (uint64)basetime, MAIL_CHECK_MASK_RETURNED, m->messageID);
4877                 delete m;
4878                 continue;
4879             }
4880         }
4881
4882         if (m->itemTextId)
4883             CharacterDatabase.PExecute("DELETE FROM item_text WHERE id = '%u'", m->itemTextId);
4884
4885         //deletemail = true;
4886         //delmails << m->messageID << ", ";
4887         CharacterDatabase.PExecute("DELETE FROM mail WHERE id = '%u'", m->messageID);
4888         delete m;
4889         ++count;
4890     } while (result->NextRow());
4891     delete result;
4892
4893     sLog.outString();
4894     sLog.outString( ">> Loaded %u mails", count );
4895 }
4896
4897 void ObjectMgr::LoadQuestAreaTriggers()
4898 {
4899     mQuestAreaTriggerMap.clear();                           // need for reload case
4900
4901     QueryResult *result = WorldDatabase.Query( "SELECT id,quest FROM areatrigger_involvedrelation" );
4902
4903     uint32 count = 0;
4904
4905     if( !result )
4906     {
4907         barGoLink bar( 1 );
4908         bar.step();
4909
4910         sLog.outString();
4911         sLog.outString( ">> Loaded %u quest trigger points", count );
4912         return;
4913     }
4914
4915     barGoLink bar( result->GetRowCount() );
4916
4917     do
4918     {
4919         ++count;
4920         bar.step();
4921
4922         Field *fields = result->Fetch();
4923
4924         uint32 trigger_ID = fields[0].GetUInt32();
4925         uint32 quest_ID   = fields[1].GetUInt32();
4926
4927         AreaTriggerEntry const* atEntry = sAreaTriggerStore.LookupEntry(trigger_ID);
4928         if(!atEntry)
4929         {
4930             sLog.outErrorDb("Area trigger (ID:%u) does not exist in `AreaTrigger.dbc`.",trigger_ID);
4931             continue;
4932         }
4933
4934         Quest const* quest = GetQuestTemplate(quest_ID);
4935
4936         if(!quest)
4937         {
4938             sLog.outErrorDb("Table `areatrigger_involvedrelation` has record (id: %u) for not existing quest %u",trigger_ID,quest_ID);
4939             continue;
4940         }
4941
4942         if(!quest->HasFlag(QUEST_MANGOS_FLAGS_EXPLORATION_OR_EVENT))
4943         {
4944             sLog.outErrorDb("Table `areatrigger_involvedrelation` has record (id: %u) for not quest %u, but quest not have flag QUEST_MANGOS_FLAGS_EXPLORATION_OR_EVENT. Trigger or quest flags must be fixed, quest modified to require objective.",trigger_ID,quest_ID);
4945
4946             // this will prevent quest completing without objective
4947             const_cast<Quest*>(quest)->SetFlag(QUEST_MANGOS_FLAGS_EXPLORATION_OR_EVENT);
4948
4949             // continue; - quest modified to required objective and trigger can be allowed.
4950         }
4951
4952         mQuestAreaTriggerMap[trigger_ID] = quest_ID;
4953
4954     } while( result->NextRow() );
4955
4956     delete result;
4957
4958     sLog.outString();
4959     sLog.outString( ">> Loaded %u quest trigger points", count );
4960 }
4961
4962 void ObjectMgr::LoadTavernAreaTriggers()
4963 {
4964     mTavernAreaTriggerSet.clear();                          // need for reload case
4965
4966     QueryResult *result = WorldDatabase.Query("SELECT id FROM areatrigger_tavern");
4967
4968     uint32 count = 0;
4969
4970     if( !result )
4971     {
4972         barGoLink bar( 1 );
4973         bar.step();
4974
4975         sLog.outString();
4976         sLog.outString( ">> Loaded %u tavern triggers", count );
4977         return;
4978     }
4979
4980     barGoLink bar( result->GetRowCount() );
4981
4982     do
4983     {
4984         ++count;
4985         bar.step();
4986
4987         Field *fields = result->Fetch();
4988
4989         uint32 Trigger_ID      = fields[0].GetUInt32();
4990
4991         AreaTriggerEntry const* atEntry = sAreaTriggerStore.LookupEntry(Trigger_ID);
4992         if(!atEntry)
4993         {
4994             sLog.outErrorDb("Area trigger (ID:%u) does not exist in `AreaTrigger.dbc`.",Trigger_ID);
4995             continue;
4996         }
4997
4998         mTavernAreaTriggerSet.insert(Trigger_ID);
4999     } while( result->NextRow() );
5000
5001     delete result;
5002
5003     sLog.outString();
5004     sLog.outString( ">> Loaded %u tavern triggers", count );
5005 }
5006
5007 void ObjectMgr::LoadAreaTriggerScripts()
5008 {
5009     mAreaTriggerScripts.clear();                            // need for reload case
5010     QueryResult *result = WorldDatabase.Query("SELECT entry, ScriptName FROM areatrigger_scripts");
5011
5012     uint32 count = 0;
5013
5014     if( !result )
5015     {
5016         barGoLink bar( 1 );
5017         bar.step();
5018
5019         sLog.outString();
5020         sLog.outString( ">> Loaded %u areatrigger scripts", count );
5021         return;
5022     }
5023
5024     barGoLink bar( result->GetRowCount() );
5025
5026     do
5027     {
5028         ++count;
5029         bar.step();
5030
5031         Field *fields = result->Fetch();
5032
5033         uint32 Trigger_ID      = fields[0].GetUInt32();
5034         const char *scriptName = fields[1].GetString();
5035
5036         AreaTriggerEntry const* atEntry = sAreaTriggerStore.LookupEntry(Trigger_ID);
5037         if(!atEntry)
5038         {
5039             sLog.outErrorDb("Area trigger (ID:%u) does not exist in `AreaTrigger.dbc`.",Trigger_ID);
5040             continue;
5041         }
5042         mAreaTriggerScripts[Trigger_ID] = GetScriptId(scriptName);
5043     } while( result->NextRow() );
5044
5045     delete result;
5046
5047     sLog.outString();
5048     sLog.outString( ">> Loaded %u areatrigger scripts", count );
5049 }
5050
5051 uint32 ObjectMgr::GetNearestTaxiNode( float x, float y, float z, uint32 mapid, uint32 team )
5052 {
5053     bool found = false;
5054     float dist;
5055     uint32 id = 0;
5056
5057     for(uint32 i = 1; i < sTaxiNodesStore.GetNumRows(); ++i)
5058     {
5059         TaxiNodesEntry const* node = sTaxiNodesStore.LookupEntry(i);
5060         if(!node || node->map_id != mapid || !node->MountCreatureID[team == ALLIANCE ? 1 : 0])
5061             continue;
5062
5063         uint8  field   = (uint8)((i - 1) / 32);
5064         uint32 submask = 1<<((i-1)%32);
5065
5066         // skip not taxi network nodes
5067         if((sTaxiNodesMask[field] & submask)==0)
5068             continue;
5069
5070         float dist2 = (node->x - x)*(node->x - x)+(node->y - y)*(node->y - y)+(node->z - z)*(node->z - z);
5071         if(found)
5072         {
5073             if(dist2 < dist)
5074             {
5075                 dist = dist2;
5076                 id = i;
5077             }
5078         }
5079         else
5080         {
5081             found = true;
5082             dist = dist2;
5083             id = i;
5084         }
5085     }
5086
5087     return id;
5088 }
5089
5090 void ObjectMgr::GetTaxiPath( uint32 source, uint32 destination, uint32 &path, uint32 &cost)
5091 {
5092     TaxiPathSetBySource::iterator src_i = sTaxiPathSetBySource.find(source);
5093     if(src_i==sTaxiPathSetBySource.end())
5094     {
5095         path = 0;
5096         cost = 0;
5097         return;
5098     }
5099
5100     TaxiPathSetForSource& pathSet = src_i->second;
5101
5102     TaxiPathSetForSource::iterator dest_i = pathSet.find(destination);
5103     if(dest_i==pathSet.end())
5104     {
5105         path = 0;
5106         cost = 0;
5107         return;
5108     }
5109
5110     cost = dest_i->second.price;
5111     path = dest_i->second.ID;
5112 }
5113
5114 uint32 ObjectMgr::GetTaxiMountDisplayId( uint32 id, uint32 team, bool allowed_alt_team /* = false */)
5115 {
5116     uint16 mount_entry = 0;
5117
5118     // select mount creature id
5119     TaxiNodesEntry const* node = sTaxiNodesStore.LookupEntry(id);
5120     if(node)
5121     {
5122         if (team == ALLIANCE)
5123         {
5124             mount_entry = node->MountCreatureID[1];
5125             if(!mount_entry && allowed_alt_team)
5126                 mount_entry = node->MountCreatureID[0];
5127         }
5128         else if (team == HORDE)
5129         {
5130             mount_entry = node->MountCreatureID[0];
5131
5132             if(!mount_entry && allowed_alt_team)
5133                 mount_entry = node->MountCreatureID[1];
5134         }
5135     }
5136
5137     CreatureInfo const *mount_info = GetCreatureTemplate(mount_entry);
5138     if (!mount_info)
5139         return 0;
5140
5141     uint16 mount_id = ChooseDisplayId(team,mount_info);
5142     if (!mount_id)
5143         return 0;
5144
5145     CreatureModelInfo const *minfo = GetCreatureModelRandomGender(mount_id);
5146     if (minfo)
5147         mount_id = minfo->modelid;
5148
5149     return mount_id;
5150 }
5151
5152 void ObjectMgr::GetTaxiPathNodes( uint32 path, Path &pathnodes, std::vector<uint32>& mapIds)
5153 {
5154     if(path >= sTaxiPathNodesByPath.size())
5155         return;
5156
5157     TaxiPathNodeList& nodeList = sTaxiPathNodesByPath[path];
5158
5159     pathnodes.Resize(nodeList.size());
5160     mapIds.resize(nodeList.size());
5161
5162     for(size_t i = 0; i < nodeList.size(); ++i)
5163     {
5164         pathnodes[ i ].x = nodeList[i].x;
5165         pathnodes[ i ].y = nodeList[i].y;
5166         pathnodes[ i ].z = nodeList[i].z;
5167
5168         mapIds[i] = nodeList[i].mapid;
5169     }
5170 }
5171
5172 void ObjectMgr::GetTransportPathNodes( uint32 path, TransportPath &pathnodes )
5173 {
5174     if(path >= sTaxiPathNodesByPath.size())
5175         return;
5176
5177     TaxiPathNodeList& nodeList = sTaxiPathNodesByPath[path];
5178
5179     pathnodes.Resize(nodeList.size());
5180
5181     for(size_t i = 0; i < nodeList.size(); ++i)
5182     {
5183         pathnodes[ i ].mapid = nodeList[i].mapid;
5184         pathnodes[ i ].x = nodeList[i].x;
5185         pathnodes[ i ].y = nodeList[i].y;
5186         pathnodes[ i ].z = nodeList[i].z;
5187         pathnodes[ i ].actionFlag = nodeList[i].actionFlag;
5188         pathnodes[ i ].delay = nodeList[i].delay;
5189     }
5190 }
5191
5192 void ObjectMgr::LoadGraveyardZones()
5193 {
5194     mGraveYardMap.clear();                                  // need for reload case
5195
5196     QueryResult *result = WorldDatabase.Query("SELECT id,ghost_zone,faction FROM game_graveyard_zone");
5197
5198     uint32 count = 0;
5199
5200     if( !result )
5201     {
5202         barGoLink bar( 1 );
5203         bar.step();
5204
5205         sLog.outString();
5206         sLog.outString( ">> Loaded %u graveyard-zone links", count );
5207         return;
5208     }
5209
5210     barGoLink bar( result->GetRowCount() );
5211
5212     do
5213     {
5214         ++count;
5215         bar.step();
5216
5217         Field *fields = result->Fetch();
5218
5219         uint32 safeLocId = fields[0].GetUInt32();
5220         uint32 zoneId = fields[1].GetUInt32();
5221         uint32 team   = fields[2].GetUInt32();
5222
5223         WorldSafeLocsEntry const* entry = sWorldSafeLocsStore.LookupEntry(safeLocId);
5224         if(!entry)
5225         {
5226             sLog.outErrorDb("Table `game_graveyard_zone` has record for not existing graveyard (WorldSafeLocs.dbc id) %u, skipped.",safeLocId);
5227             continue;
5228         }
5229
5230         AreaTableEntry const *areaEntry = GetAreaEntryByAreaID(zoneId);
5231         if(!areaEntry)
5232         {
5233             sLog.outErrorDb("Table `game_graveyard_zone` has record for not existing zone id (%u), skipped.",zoneId);
5234             continue;
5235         }
5236
5237         if(areaEntry->zone != 0)
5238         {
5239             sLog.outErrorDb("Table `game_graveyard_zone` has record subzone id (%u) instead of zone, skipped.",zoneId);
5240             continue;
5241         }
5242
5243         if(team!=0 && team!=HORDE && team!=ALLIANCE)
5244         {
5245             sLog.outErrorDb("Table `game_graveyard_zone` has record for non player faction (%u), skipped.",team);
5246             continue;
5247         }
5248
5249         if(!AddGraveYardLink(safeLocId,zoneId,team,false))
5250             sLog.outErrorDb("Table `game_graveyard_zone` has a duplicate record for Graveyard (ID: %u) and Zone (ID: %u), skipped.",safeLocId,zoneId);
5251     } while( result->NextRow() );
5252
5253     delete result;
5254
5255     sLog.outString();
5256     sLog.outString( ">> Loaded %u graveyard-zone links", count );
5257 }
5258
5259 WorldSafeLocsEntry const *ObjectMgr::GetClosestGraveYard(float x, float y, float z, uint32 MapId, uint32 team)
5260 {
5261     // search for zone associated closest graveyard
5262     uint32 zoneId = sMapMgr.GetZoneId(MapId,x,y,z);
5263
5264     // Simulate std. algorithm:
5265     //   found some graveyard associated to (ghost_zone,ghost_map)
5266     //
5267     //   if mapId == graveyard.mapId (ghost in plain zone or city or battleground) and search graveyard at same map
5268     //     then check faction
5269     //   if mapId != graveyard.mapId (ghost in instance) and search any graveyard associated
5270     //     then check faction
5271     GraveYardMap::const_iterator graveLow  = mGraveYardMap.lower_bound(zoneId);
5272     GraveYardMap::const_iterator graveUp   = mGraveYardMap.upper_bound(zoneId);
5273     if(graveLow==graveUp)
5274     {
5275         sLog.outErrorDb("Table `game_graveyard_zone` incomplete: Zone %u Team %u does not have a linked graveyard.",zoneId,team);
5276         return NULL;
5277     }
5278
5279     // at corpse map
5280     bool foundNear = false;
5281     float distNear;
5282     WorldSafeLocsEntry const* entryNear = NULL;
5283
5284     // at entrance map for corpse map
5285     bool foundEntr = false;
5286     float distEntr;
5287     WorldSafeLocsEntry const* entryEntr = NULL;
5288
5289     // some where other
5290     WorldSafeLocsEntry const* entryFar = NULL;
5291
5292     MapEntry const* mapEntry = sMapStore.LookupEntry(MapId);
5293
5294     for(GraveYardMap::const_iterator itr = graveLow; itr != graveUp; ++itr)
5295     {
5296         GraveYardData const& data = itr->second;
5297
5298         WorldSafeLocsEntry const* entry = sWorldSafeLocsStore.LookupEntry(data.safeLocId);
5299         if(!entry)
5300         {
5301             sLog.outErrorDb("Table `game_graveyard_zone` has record for not existing graveyard (WorldSafeLocs.dbc id) %u, skipped.",data.safeLocId);
5302             continue;
5303         }
5304
5305         // skip enemy faction graveyard
5306         // team == 0 case can be at call from .neargrave
5307         if(data.team != 0 && team != 0 && data.team != team)
5308             continue;
5309
5310         // find now nearest graveyard at other map
5311         if(MapId != entry->map_id)
5312         {
5313             // if find graveyard at different map from where entrance placed (or no entrance data), use any first
5314             if (!mapEntry ||
5315                  mapEntry->entrance_map < 0 ||
5316                  mapEntry->entrance_map != entry->map_id ||
5317                 (mapEntry->entrance_x == 0 && mapEntry->entrance_y == 0))
5318             {
5319                 // not have any corrdinates for check distance anyway
5320                 entryFar = entry;
5321                 continue;
5322             }
5323
5324             // at entrance map calculate distance (2D);
5325             float dist2 = (entry->x - mapEntry->entrance_x)*(entry->x - mapEntry->entrance_x)
5326                 +(entry->y - mapEntry->entrance_y)*(entry->y - mapEntry->entrance_y);
5327             if(foundEntr)
5328             {
5329                 if(dist2 < distEntr)
5330                 {
5331                     distEntr = dist2;
5332                     entryEntr = entry;
5333                 }
5334             }
5335             else
5336             {
5337                 foundEntr = true;
5338                 distEntr = dist2;
5339                 entryEntr = entry;
5340             }
5341         }
5342         // find now nearest graveyard at same map
5343         else
5344         {
5345             float dist2 = (entry->x - x)*(entry->x - x)+(entry->y - y)*(entry->y - y)+(entry->z - z)*(entry->z - z);
5346             if(foundNear)
5347             {
5348                 if(dist2 < distNear)
5349                 {
5350                     distNear = dist2;
5351                     entryNear = entry;
5352                 }
5353             }
5354             else
5355             {
5356                 foundNear = true;
5357                 distNear = dist2;
5358                 entryNear = entry;
5359             }
5360         }
5361     }
5362
5363     if(entryNear)
5364         return entryNear;
5365
5366     if(entryEntr)
5367         return entryEntr;
5368
5369     return entryFar;
5370 }
5371
5372 GraveYardData const* ObjectMgr::FindGraveYardData(uint32 id, uint32 zoneId)
5373 {
5374     GraveYardMap::const_iterator graveLow  = mGraveYardMap.lower_bound(zoneId);
5375     GraveYardMap::const_iterator graveUp   = mGraveYardMap.upper_bound(zoneId);
5376
5377     for(GraveYardMap::const_iterator itr = graveLow; itr != graveUp; ++itr)
5378     {
5379         if(itr->second.safeLocId==id)
5380             return &itr->second;
5381     }
5382
5383     return NULL;
5384 }
5385
5386 bool ObjectMgr::AddGraveYardLink(uint32 id, uint32 zoneId, uint32 team, bool inDB)
5387 {
5388     if(FindGraveYardData(id,zoneId))
5389         return false;
5390
5391     // add link to loaded data
5392     GraveYardData data;
5393     data.safeLocId = id;
5394     data.team = team;
5395
5396     mGraveYardMap.insert(GraveYardMap::value_type(zoneId,data));
5397
5398     // add link to DB
5399     if(inDB)
5400     {
5401         WorldDatabase.PExecuteLog("INSERT INTO game_graveyard_zone ( id,ghost_zone,faction) "
5402             "VALUES ('%u', '%u','%u')",id,zoneId,team);
5403     }
5404
5405     return true;
5406 }
5407
5408 void ObjectMgr::LoadAreaTriggerTeleports()
5409 {
5410     mAreaTriggers.clear();                                  // need for reload case
5411
5412     uint32 count = 0;
5413
5414     //                                                0   1               2              3               4           5            6                    7                           8                     9           10                 11                 12                 13
5415     QueryResult *result = WorldDatabase.Query("SELECT id, required_level, required_item, required_item2, heroic_key, heroic_key2, required_quest_done, required_quest_done_heroic, required_failed_text, target_map, target_position_x, target_position_y, target_position_z, target_orientation FROM areatrigger_teleport");
5416     if( !result )
5417     {
5418
5419         barGoLink bar( 1 );
5420
5421         bar.step();
5422
5423         sLog.outString();
5424         sLog.outString( ">> Loaded %u area trigger teleport definitions", count );
5425         return;
5426     }
5427
5428     barGoLink bar( result->GetRowCount() );
5429
5430     do
5431     {
5432         Field *fields = result->Fetch();
5433
5434         bar.step();
5435
5436         ++count;
5437
5438         uint32 Trigger_ID = fields[0].GetUInt32();
5439
5440         AreaTrigger at;
5441
5442         at.requiredLevel        = fields[1].GetUInt8();
5443         at.requiredItem         = fields[2].GetUInt32();
5444         at.requiredItem2        = fields[3].GetUInt32();
5445         at.heroicKey            = fields[4].GetUInt32();
5446         at.heroicKey2           = fields[5].GetUInt32();
5447         at.requiredQuest        = fields[6].GetUInt32();
5448         at.requiredQuestHeroic  = fields[7].GetUInt32();
5449         at.requiredFailedText   = fields[8].GetCppString();
5450         at.target_mapId         = fields[9].GetUInt32();
5451         at.target_X             = fields[10].GetFloat();
5452         at.target_Y             = fields[11].GetFloat();
5453         at.target_Z             = fields[12].GetFloat();
5454         at.target_Orientation   = fields[13].GetFloat();
5455
5456         AreaTriggerEntry const* atEntry = sAreaTriggerStore.LookupEntry(Trigger_ID);
5457         if(!atEntry)
5458         {
5459             sLog.outErrorDb("Area trigger (ID:%u) does not exist in `AreaTrigger.dbc`.",Trigger_ID);
5460             continue;
5461         }
5462
5463         if(at.requiredItem)
5464         {
5465             ItemPrototype const *pProto = GetItemPrototype(at.requiredItem);
5466             if(!pProto)
5467             {
5468                 sLog.outError("Key item %u does not exist for trigger %u, removing key requirement.", at.requiredItem, Trigger_ID);
5469                 at.requiredItem = 0;
5470             }
5471         }
5472         if(at.requiredItem2)
5473         {
5474             ItemPrototype const *pProto = GetItemPrototype(at.requiredItem2);
5475             if(!pProto)
5476             {
5477                 sLog.outError("Second item %u not exist for trigger %u, remove key requirement.", at.requiredItem2, Trigger_ID);
5478                 at.requiredItem2 = 0;
5479             }
5480         }
5481
5482         if(at.heroicKey)
5483         {
5484             ItemPrototype const *pProto = GetItemPrototype(at.heroicKey);
5485             if(!pProto)
5486             {
5487                 sLog.outError("Heroic key item %u not exist for trigger %u, remove key requirement.", at.heroicKey, Trigger_ID);
5488                 at.heroicKey = 0;
5489             }
5490         }
5491
5492         if(at.heroicKey2)
5493         {
5494             ItemPrototype const *pProto = GetItemPrototype(at.heroicKey2);
5495             if(!pProto)
5496             {
5497                 sLog.outError("Heroic second key item %u not exist for trigger %u, remove key requirement.", at.heroicKey2, Trigger_ID);
5498                 at.heroicKey2 = 0;
5499             }
5500         }
5501
5502         if(at.requiredQuest)
5503         {
5504             QuestMap::iterator qReqItr = mQuestTemplates.find(at.requiredQuest);
5505             if(qReqItr == mQuestTemplates.end())
5506             {
5507                 sLog.outErrorDb("Required Quest %u not exist for trigger %u, remove quest done requirement.",at.requiredQuest,Trigger_ID);
5508                 at.requiredQuest = 0;
5509             }
5510         }
5511
5512         if(at.requiredQuestHeroic)
5513         {
5514             QuestMap::iterator qReqItr = mQuestTemplates.find(at.requiredQuestHeroic);
5515             if(qReqItr == mQuestTemplates.end())
5516             {
5517                 sLog.outErrorDb("Required Quest %u not exist for trigger %u, remove quest done requirement.",at.requiredQuestHeroic,Trigger_ID);
5518                 at.requiredQuestHeroic = 0;
5519             }
5520         }
5521
5522         MapEntry const* mapEntry = sMapStore.LookupEntry(at.target_mapId);
5523         if(!mapEntry)
5524         {
5525             sLog.outErrorDb("Area trigger (ID:%u) target map (ID: %u) does not exist in `Map.dbc`.",Trigger_ID,at.target_mapId);
5526             continue;
5527         }
5528
5529         if(at.target_X==0 && at.target_Y==0 && at.target_Z==0)
5530         {
5531             sLog.outErrorDb("Area trigger (ID:%u) target coordinates not provided.",Trigger_ID);
5532             continue;
5533         }
5534
5535         mAreaTriggers[Trigger_ID] = at;
5536
5537     } while( result->NextRow() );
5538
5539     delete result;
5540
5541     sLog.outString();
5542     sLog.outString( ">> Loaded %u area trigger teleport definitions", count );
5543 }
5544
5545 /*
5546  * Searches for the areatrigger which teleports players out of the given map
5547  */
5548 AreaTrigger const* ObjectMgr::GetGoBackTrigger(uint32 Map) const
5549 {
5550     const MapEntry *mapEntry = sMapStore.LookupEntry(Map);
5551     if(!mapEntry) return NULL;
5552     for (AreaTriggerMap::const_iterator itr = mAreaTriggers.begin(); itr != mAreaTriggers.end(); ++itr)
5553     {
5554         if(itr->second.target_mapId == mapEntry->entrance_map)
5555         {
5556             AreaTriggerEntry const* atEntry = sAreaTriggerStore.LookupEntry(itr->first);
5557             if(atEntry && atEntry->mapid == Map)
5558                 return &itr->second;
5559         }
5560     }
5561     return NULL;
5562 }
5563
5564 /**
5565  * Searches for the areatrigger which teleports players to the given map
5566  */
5567 AreaTrigger const* ObjectMgr::GetMapEntranceTrigger(uint32 Map) const
5568 {
5569     for (AreaTriggerMap::const_iterator itr = mAreaTriggers.begin(); itr != mAreaTriggers.end(); ++itr)
5570     {
5571         if(itr->second.target_mapId == Map)
5572         {
5573             AreaTriggerEntry const* atEntry = sAreaTriggerStore.LookupEntry(itr->first);
5574             if(atEntry)
5575                 return &itr->second;
5576         }
5577     }
5578     return NULL;
5579 }
5580
5581 void ObjectMgr::SetHighestGuids()
5582 {
5583     QueryResult *result = CharacterDatabase.Query( "SELECT MAX(guid) FROM characters" );
5584     if( result )
5585     {
5586         m_hiCharGuid = (*result)[0].GetUInt32()+1;
5587         delete result;
5588     }
5589
5590     result = WorldDatabase.Query( "SELECT MAX(guid) FROM creature" );
5591     if( result )
5592     {
5593         m_hiCreatureGuid = (*result)[0].GetUInt32()+1;
5594         delete result;
5595     }
5596
5597     result = CharacterDatabase.Query( "SELECT MAX(guid) FROM item_instance" );
5598     if( result )
5599     {
5600         m_hiItemGuid = (*result)[0].GetUInt32()+1;
5601         delete result;
5602     }
5603
5604     // Cleanup other tables from not existed guids (>=m_hiItemGuid)
5605     CharacterDatabase.PExecute("DELETE FROM character_inventory WHERE item >= '%u'", m_hiItemGuid);
5606     CharacterDatabase.PExecute("DELETE FROM mail_items WHERE item_guid >= '%u'", m_hiItemGuid);
5607     CharacterDatabase.PExecute("DELETE FROM auctionhouse WHERE itemguid >= '%u'", m_hiItemGuid);
5608     CharacterDatabase.PExecute("DELETE FROM guild_bank_item WHERE item_guid >= '%u'", m_hiItemGuid);
5609
5610     result = WorldDatabase.Query("SELECT MAX(guid) FROM gameobject" );
5611     if( result )
5612     {
5613         m_hiGoGuid = (*result)[0].GetUInt32()+1;
5614         delete result;
5615     }
5616
5617     result = CharacterDatabase.Query("SELECT MAX(id) FROM auctionhouse" );
5618     if( result )
5619     {
5620         m_auctionid = (*result)[0].GetUInt32()+1;
5621         delete result;
5622     }
5623
5624     result = CharacterDatabase.Query( "SELECT MAX(id) FROM mail" );
5625     if( result )
5626     {
5627         m_mailid = (*result)[0].GetUInt32()+1;
5628         delete result;
5629     }
5630
5631     result = CharacterDatabase.Query( "SELECT MAX(id) FROM item_text" );
5632     if( result )
5633     {
5634         m_ItemTextId = (*result)[0].GetUInt32()+1;
5635         delete result;
5636     }
5637
5638     result = CharacterDatabase.Query( "SELECT MAX(guid) FROM corpse" );
5639     if( result )
5640     {
5641         m_hiCorpseGuid = (*result)[0].GetUInt32()+1;
5642         delete result;
5643     }
5644
5645     result = CharacterDatabase.Query("SELECT MAX(arenateamid) FROM arena_team");
5646     if (result)
5647     {
5648         m_arenaTeamId = (*result)[0].GetUInt32()+1;
5649         delete result;
5650     }
5651
5652     result = CharacterDatabase.Query("SELECT MAX(setguid) FROM character_equipmentsets");
5653     if (result)
5654     {
5655         m_equipmentSetGuid = (*result)[0].GetUInt64()+1;
5656         delete result;
5657     }
5658
5659     result = CharacterDatabase.Query( "SELECT MAX(guildid) FROM guild" );
5660     if (result)
5661     {
5662         m_guildId = (*result)[0].GetUInt32()+1;
5663         delete result;
5664     }
5665 }
5666
5667 uint32 ObjectMgr::GenerateArenaTeamId()
5668 {
5669     if(m_arenaTeamId>=0xFFFFFFFE)
5670     {
5671         sLog.outError("Arena team ids overflow!! Can't continue, shutting down server. ");
5672         World::StopNow(ERROR_EXIT_CODE);
5673     }
5674     return m_arenaTeamId++;
5675 }
5676
5677 uint32 ObjectMgr::GenerateAuctionID()
5678 {
5679     if(m_auctionid>=0xFFFFFFFE)
5680     {
5681         sLog.outError("Auctions ids overflow!! Can't continue, shutting down server. ");
5682         World::StopNow(ERROR_EXIT_CODE);
5683     }
5684     return m_auctionid++;
5685 }
5686
5687 uint64 ObjectMgr::GenerateEquipmentSetGuid()
5688 {
5689     if(m_equipmentSetGuid>=0xFFFFFFFFFFFFFFFEll)
5690     {
5691         sLog.outError("EquipmentSet guid overflow!! Can't continue, shutting down server. ");
5692         World::StopNow(ERROR_EXIT_CODE);
5693     }
5694     return m_equipmentSetGuid++;
5695 }
5696
5697 uint32 ObjectMgr::GenerateGuildId()
5698 {
5699     if(m_guildId>=0xFFFFFFFE)
5700     {
5701         sLog.outError("Guild ids overflow!! Can't continue, shutting down server. ");
5702         World::StopNow(ERROR_EXIT_CODE);
5703     }
5704     return m_guildId++;
5705 }
5706
5707 uint32 ObjectMgr::GenerateMailID()
5708 {
5709     if(m_mailid>=0xFFFFFFFE)
5710     {
5711         sLog.outError("Mail ids overflow!! Can't continue, shutting down server. ");
5712         World::StopNow(ERROR_EXIT_CODE);
5713     }
5714     return m_mailid++;
5715 }
5716
5717 uint32 ObjectMgr::GenerateItemTextID()
5718 {
5719     if(m_ItemTextId>=0xFFFFFFFE)
5720     {
5721         sLog.outError("Item text ids overflow!! Can't continue, shutting down server. ");
5722         World::StopNow(ERROR_EXIT_CODE);
5723     }
5724     return m_ItemTextId++;
5725 }
5726
5727 uint32 ObjectMgr::CreateItemText(std::string text)
5728 {
5729     uint32 newItemTextId = GenerateItemTextID();
5730     //insert new itempage to container
5731     mItemTexts[ newItemTextId ] = text;
5732     //save new itempage
5733     CharacterDatabase.escape_string(text);
5734     //any Delete query needed, itemTextId is maximum of all ids
5735     std::ostringstream query;
5736     query << "INSERT INTO item_text (id,text) VALUES ( '" << newItemTextId << "', '" << text << "')";
5737     CharacterDatabase.Execute(query.str().c_str());         //needs to be run this way, because mail body may be more than 1024 characters
5738     return newItemTextId;
5739 }
5740
5741 uint32 ObjectMgr::GenerateLowGuid(HighGuid guidhigh)
5742 {
5743     switch(guidhigh)
5744     {
5745         case HIGHGUID_ITEM:
5746             if(m_hiItemGuid>=0xFFFFFFFE)
5747             {
5748                 sLog.outError("Item guid overflow!! Can't continue, shutting down server. ");
5749                 World::StopNow(ERROR_EXIT_CODE);
5750             }
5751             return m_hiItemGuid++;
5752         case HIGHGUID_UNIT:
5753             if(m_hiCreatureGuid>=0x00FFFFFE)
5754             {
5755                 sLog.outError("Creature guid overflow!! Can't continue, shutting down server. ");
5756                 World::StopNow(ERROR_EXIT_CODE);
5757             }
5758             return m_hiCreatureGuid++;
5759         case HIGHGUID_PLAYER:
5760             if(m_hiCharGuid>=0xFFFFFFFE)
5761             {
5762                 sLog.outError("Players guid overflow!! Can't continue, shutting down server. ");
5763                 World::StopNow(ERROR_EXIT_CODE);
5764             }
5765             return m_hiCharGuid++;
5766         case HIGHGUID_GAMEOBJECT:
5767             if(m_hiGoGuid>=0x00FFFFFE)
5768             {
5769                 sLog.outError("Gameobject guid overflow!! Can't continue, shutting down server. ");
5770                 World::StopNow(ERROR_EXIT_CODE);
5771             }
5772             return m_hiGoGuid++;
5773         case HIGHGUID_CORPSE:
5774             if(m_hiCorpseGuid>=0xFFFFFFFE)
5775             {
5776                 sLog.outError("Corpse guid overflow!! Can't continue, shutting down server. ");
5777                 World::StopNow(ERROR_EXIT_CODE);
5778             }
5779             return m_hiCorpseGuid++;
5780         default:
5781             ASSERT(0);
5782     }
5783
5784     ASSERT(0);
5785     return 0;
5786 }
5787
5788 void ObjectMgr::LoadGameObjectLocales()
5789 {
5790     mGameObjectLocaleMap.clear();                           // need for reload case
5791
5792     QueryResult *result = WorldDatabase.Query("SELECT entry,"
5793         "name_loc1,name_loc2,name_loc3,name_loc4,name_loc5,name_loc6,name_loc7,name_loc8,"
5794         "castbarcaption_loc1,castbarcaption_loc2,castbarcaption_loc3,castbarcaption_loc4,"
5795         "castbarcaption_loc5,castbarcaption_loc6,castbarcaption_loc7,castbarcaption_loc8 FROM locales_gameobject");
5796
5797     if(!result)
5798     {
5799         barGoLink bar(1);
5800
5801         bar.step();
5802
5803         sLog.outString();
5804         sLog.outString(">> Loaded 0 gameobject locale strings. DB table `locales_gameobject` is empty.");
5805         return;
5806     }
5807
5808     barGoLink bar(result->GetRowCount());
5809
5810     do
5811     {
5812         Field *fields = result->Fetch();
5813         bar.step();
5814
5815         uint32 entry = fields[0].GetUInt32();
5816
5817         GameObjectLocale& data = mGameObjectLocaleMap[entry];
5818
5819         for(int i = 1; i < MAX_LOCALE; ++i)
5820         {
5821             std::string str = fields[i].GetCppString();
5822             if(!str.empty())
5823             {
5824                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
5825                 if(idx >= 0)
5826                 {
5827                     if(data.Name.size() <= idx)
5828                         data.Name.resize(idx+1);
5829
5830                     data.Name[idx] = str;
5831                 }
5832             }
5833         }
5834
5835         for(int i = 1; i < MAX_LOCALE; ++i)
5836         {
5837             std::string str = fields[i+(MAX_LOCALE-1)].GetCppString();
5838             if(!str.empty())
5839             {
5840                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
5841                 if(idx >= 0)
5842                 {
5843                     if(data.CastBarCaption.size() <= idx)
5844                         data.CastBarCaption.resize(idx+1);
5845
5846                     data.CastBarCaption[idx] = str;
5847                 }
5848             }
5849         }
5850
5851     } while (result->NextRow());
5852
5853     delete result;
5854
5855     sLog.outString();
5856     sLog.outString( ">> Loaded %lu gameobject locale strings", (unsigned long)mGameObjectLocaleMap.size() );
5857 }
5858
5859 struct SQLGameObjectLoader : public SQLStorageLoaderBase<SQLGameObjectLoader>
5860 {
5861     template<class D>
5862     void convert_from_str(uint32 /*field_pos*/, char *src, D &dst)
5863     {
5864         dst = D(sObjectMgr.GetScriptId(src));
5865     }
5866 };
5867
5868 inline void CheckGOLockId(GameObjectInfo const* goInfo,uint32 dataN,uint32 N)
5869 {
5870     if (sLockStore.LookupEntry(dataN))
5871         return;
5872
5873     sLog.outErrorDb("Gameobject (Entry: %u GoType: %u) have data%d=%u but lock (Id: %u) not found.",
5874         goInfo->id,goInfo->type,N,goInfo->door.lockId,goInfo->door.lockId);
5875 }
5876
5877 inline void CheckGOLinkedTrapId(GameObjectInfo const* goInfo,uint32 dataN,uint32 N)
5878 {
5879     if (GameObjectInfo const* trapInfo = sGOStorage.LookupEntry<GameObjectInfo>(dataN))
5880     {
5881         if (trapInfo->type!=GAMEOBJECT_TYPE_TRAP)
5882             sLog.outErrorDb("Gameobject (Entry: %u GoType: %u) have data%d=%u but GO (Entry %u) have not GAMEOBJECT_TYPE_TRAP (%u) type.",
5883             goInfo->id,goInfo->type,N,dataN,dataN,GAMEOBJECT_TYPE_TRAP);
5884     }
5885     /* disable check for while (too many error reports baout not existed in trap templates
5886     else
5887         sLog.outErrorDb("Gameobject (Entry: %u GoType: %u) have data%d=%u but trap GO (Entry %u) not exist in `gameobject_template`.",
5888             goInfo->id,goInfo->type,N,dataN,dataN);
5889     */
5890 }
5891
5892 inline void CheckGOSpellId(GameObjectInfo const* goInfo,uint32 dataN,uint32 N)
5893 {
5894     if (sSpellStore.LookupEntry(dataN))
5895         return;
5896
5897     sLog.outErrorDb("Gameobject (Entry: %u GoType: %u) have data%d=%u but Spell (Entry %u) not exist.",
5898         goInfo->id,goInfo->type,N,dataN,dataN);
5899 }
5900
5901 inline void CheckAndFixGOChairHeightId(GameObjectInfo const* goInfo,uint32 const& dataN,uint32 N)
5902 {
5903     if (dataN <= (UNIT_STAND_STATE_SIT_HIGH_CHAIR-UNIT_STAND_STATE_SIT_LOW_CHAIR) )
5904         return;
5905
5906     sLog.outErrorDb("Gameobject (Entry: %u GoType: %u) have data%d=%u but correct chair height in range 0..%i.",
5907         goInfo->id,goInfo->type,N,dataN,UNIT_STAND_STATE_SIT_HIGH_CHAIR-UNIT_STAND_STATE_SIT_LOW_CHAIR);
5908
5909     // prevent client and server unexpected work
5910     const_cast<uint32&>(dataN) = 0;
5911 }
5912
5913 inline void CheckGONoDamageImmuneId(GameObjectInfo const* goInfo,uint32 dataN,uint32 N)
5914 {
5915     // 0/1 correct values
5916     if (dataN <= 1)
5917         return;
5918
5919     sLog.outErrorDb("Gameobject (Entry: %u GoType: %u) have data%d=%u but expected boolean (0/1) noDamageImmune field value.",
5920         goInfo->id,goInfo->type,N,dataN);
5921 }
5922
5923 inline void CheckGOConsumable(GameObjectInfo const* goInfo,uint32 dataN,uint32 N)
5924 {
5925     // 0/1 correct values
5926     if (dataN <= 1)
5927         return;
5928
5929     sLog.outErrorDb("Gameobject (Entry: %u GoType: %u) have data%d=%u but expected boolean (0/1) consumable field value.",
5930         goInfo->id,goInfo->type,N,dataN);
5931 }
5932
5933 void ObjectMgr::LoadGameobjectInfo()
5934 {
5935     SQLGameObjectLoader loader;
5936     loader.Load(sGOStorage);
5937
5938     // some checks
5939     for(uint32 id = 1; id < sGOStorage.MaxEntry; id++)
5940     {
5941         GameObjectInfo const* goInfo = sGOStorage.LookupEntry<GameObjectInfo>(id);
5942         if (!goInfo)
5943             continue;
5944
5945         // some GO types have unused go template, check goInfo->displayId at GO spawn data loading or ignore
5946
5947         switch(goInfo->type)
5948         {
5949             case GAMEOBJECT_TYPE_DOOR:                      //0
5950             {
5951                 if (goInfo->door.lockId)
5952                     CheckGOLockId(goInfo,goInfo->door.lockId,1);
5953                 CheckGONoDamageImmuneId(goInfo,goInfo->door.noDamageImmune,3);
5954                 break;
5955             }
5956             case GAMEOBJECT_TYPE_BUTTON:                    //1
5957             {
5958                 if (goInfo->button.lockId)
5959                     CheckGOLockId(goInfo,goInfo->button.lockId,1);
5960                 CheckGONoDamageImmuneId(goInfo,goInfo->button.noDamageImmune,4);
5961                 break;
5962             }
5963             case GAMEOBJECT_TYPE_QUESTGIVER:                //2
5964             {
5965                 if (goInfo->questgiver.lockId)
5966                     CheckGOLockId(goInfo,goInfo->questgiver.lockId,0);
5967                 CheckGONoDamageImmuneId(goInfo,goInfo->questgiver.noDamageImmune,5);
5968                 break;
5969             }
5970             case GAMEOBJECT_TYPE_CHEST:                     //3
5971             {
5972                 if (goInfo->chest.lockId)
5973                     CheckGOLockId(goInfo,goInfo->chest.lockId,0);
5974
5975                 CheckGOConsumable(goInfo,goInfo->chest.consumable,3);
5976
5977                 if (goInfo->chest.linkedTrapId)              // linked trap
5978                     CheckGOLinkedTrapId(goInfo,goInfo->chest.linkedTrapId,7);
5979                 break;
5980             }
5981             case GAMEOBJECT_TYPE_TRAP:                      //6
5982             {
5983                 if (goInfo->trap.lockId)
5984                     CheckGOLockId(goInfo,goInfo->trap.lockId,0);
5985                 /* disable check for while, too many not existed spells
5986                 if (goInfo->trap.spellId)                   // spell
5987                     CheckGOSpellId(goInfo,goInfo->trap.spellId,3);
5988                 */
5989                 break;
5990             }
5991             case GAMEOBJECT_TYPE_CHAIR:                     //7
5992                 CheckAndFixGOChairHeightId(goInfo,goInfo->chair.height,1);
5993                 break;
5994             case GAMEOBJECT_TYPE_SPELL_FOCUS:               //8
5995             {
5996                 if (goInfo->spellFocus.focusId)
5997                 {
5998                     if (!sSpellFocusObjectStore.LookupEntry(goInfo->spellFocus.focusId))
5999                         sLog.outErrorDb("Gameobject (Entry: %u GoType: %u) have data0=%u but SpellFocus (Id: %u) not exist.",
6000                             id,goInfo->type,goInfo->spellFocus.focusId,goInfo->spellFocus.focusId);
6001                 }
6002
6003                 if (goInfo->spellFocus.linkedTrapId)        // linked trap
6004                     CheckGOLinkedTrapId(goInfo,goInfo->spellFocus.linkedTrapId,2);
6005                 break;
6006             }
6007             case GAMEOBJECT_TYPE_GOOBER:                    //10
6008             {
6009                 if (goInfo->goober.lockId)
6010                     CheckGOLockId(goInfo,goInfo->goober.lockId,0);
6011
6012                 CheckGOConsumable(goInfo,goInfo->goober.consumable,3);
6013
6014                 if (goInfo->goober.pageId)                  // pageId
6015                 {
6016                     if (!sPageTextStore.LookupEntry<PageText>(goInfo->goober.pageId))
6017                         sLog.outErrorDb("Gameobject (Entry: %u GoType: %u) have data7=%u but PageText (Entry %u) not exist.",
6018                             id,goInfo->type,goInfo->goober.pageId,goInfo->goober.pageId);
6019                 }
6020                 /* disable check for while, too many not existed spells
6021                 if (goInfo->goober.spellId)                 // spell
6022                     CheckGOSpellId(goInfo,goInfo->goober.spellId,10);
6023                 */
6024                 CheckGONoDamageImmuneId(goInfo,goInfo->goober.noDamageImmune,11);
6025                 if (goInfo->goober.linkedTrapId)            // linked trap
6026                     CheckGOLinkedTrapId(goInfo,goInfo->goober.linkedTrapId,12);
6027                 break;
6028             }
6029             case GAMEOBJECT_TYPE_AREADAMAGE:                //12
6030             {
6031                 if (goInfo->areadamage.lockId)
6032                     CheckGOLockId(goInfo,goInfo->areadamage.lockId,0);
6033                 break;
6034             }
6035             case GAMEOBJECT_TYPE_CAMERA:                    //13
6036             {
6037                 if (goInfo->camera.lockId)
6038                     CheckGOLockId(goInfo,goInfo->camera.lockId,0);
6039                 break;
6040             }
6041             case GAMEOBJECT_TYPE_MO_TRANSPORT:              //15
6042             {
6043                 if (goInfo->moTransport.taxiPathId)
6044                 {
6045                     if (goInfo->moTransport.taxiPathId >= sTaxiPathNodesByPath.size() || sTaxiPathNodesByPath[goInfo->moTransport.taxiPathId].empty())
6046                         sLog.outErrorDb("Gameobject (Entry: %u GoType: %u) have data0=%u but TaxiPath (Id: %u) not exist.",
6047                             id,goInfo->type,goInfo->moTransport.taxiPathId,goInfo->moTransport.taxiPathId);
6048                 }
6049                 break;
6050             }
6051             case GAMEOBJECT_TYPE_SUMMONING_RITUAL:          //18
6052             {
6053                 /* disable check for while, too many not existed spells
6054                 // always must have spell
6055                 CheckGOSpellId(goInfo,goInfo->summoningRitual.spellId,1);
6056                 */
6057                 break;
6058             }
6059             case GAMEOBJECT_TYPE_SPELLCASTER:               //22
6060             {
6061                 // always must have spell
6062                 CheckGOSpellId(goInfo,goInfo->spellcaster.spellId,0);
6063                 break;
6064             }
6065             case GAMEOBJECT_TYPE_FLAGSTAND:                 //24
6066             {
6067                 if (goInfo->flagstand.lockId)
6068                     CheckGOLockId(goInfo,goInfo->flagstand.lockId,0);
6069                 CheckGONoDamageImmuneId(goInfo,goInfo->flagstand.noDamageImmune,5);
6070                 break;
6071             }
6072             case GAMEOBJECT_TYPE_FISHINGHOLE:               //25
6073             {
6074                 if (goInfo->fishinghole.lockId)
6075                     CheckGOLockId(goInfo,goInfo->fishinghole.lockId,4);
6076                 break;
6077             }
6078             case GAMEOBJECT_TYPE_FLAGDROP:                  //26
6079             {
6080                 if (goInfo->flagdrop.lockId)
6081                     CheckGOLockId(goInfo,goInfo->flagdrop.lockId,0);
6082                 CheckGONoDamageImmuneId(goInfo,goInfo->flagdrop.noDamageImmune,3);
6083                 break;
6084             }
6085             case GAMEOBJECT_TYPE_BARBER_CHAIR:              //32
6086                 CheckAndFixGOChairHeightId(goInfo,goInfo->barberChair.chairheight,0);
6087                 break;
6088         }
6089     }
6090
6091     sLog.outString( ">> Loaded %u game object templates", sGOStorage.RecordCount );
6092     sLog.outString();
6093 }
6094
6095 void ObjectMgr::LoadExplorationBaseXP()
6096 {
6097     uint32 count = 0;
6098     QueryResult *result = WorldDatabase.Query("SELECT level,basexp FROM exploration_basexp");
6099
6100     if( !result )
6101     {
6102         barGoLink bar( 1 );
6103
6104         bar.step();
6105
6106         sLog.outString();
6107         sLog.outString( ">> Loaded %u BaseXP definitions", count );
6108         return;
6109     }
6110
6111     barGoLink bar( result->GetRowCount() );
6112
6113     do
6114     {
6115         bar.step();
6116
6117         Field *fields = result->Fetch();
6118         uint32 level  = fields[0].GetUInt32();
6119         uint32 basexp = fields[1].GetUInt32();
6120         mBaseXPTable[level] = basexp;
6121         ++count;
6122     }
6123     while (result->NextRow());
6124
6125     delete result;
6126
6127     sLog.outString();
6128     sLog.outString( ">> Loaded %u BaseXP definitions", count );
6129 }
6130
6131 uint32 ObjectMgr::GetBaseXP(uint32 level)
6132 {
6133     return mBaseXPTable[level] ? mBaseXPTable[level] : 0;
6134 }
6135
6136 uint32 ObjectMgr::GetXPForLevel(uint32 level)
6137 {
6138     if (level < mPlayerXPperLevel.size())
6139         return mPlayerXPperLevel[level];
6140     return 0;
6141 }
6142
6143 void ObjectMgr::LoadPetNames()
6144 {
6145     uint32 count = 0;
6146     QueryResult *result = WorldDatabase.Query("SELECT word,entry,half FROM pet_name_generation");
6147
6148     if( !result )
6149     {
6150         barGoLink bar( 1 );
6151
6152         bar.step();
6153
6154         sLog.outString();
6155         sLog.outString( ">> Loaded %u pet name parts", count );
6156         return;
6157     }
6158
6159     barGoLink bar( result->GetRowCount() );
6160
6161     do
6162     {
6163         bar.step();
6164
6165         Field *fields = result->Fetch();
6166         std::string word = fields[0].GetString();
6167         uint32 entry     = fields[1].GetUInt32();
6168         bool   half      = fields[2].GetBool();
6169         if(half)
6170             PetHalfName1[entry].push_back(word);
6171         else
6172             PetHalfName0[entry].push_back(word);
6173         ++count;
6174     }
6175     while (result->NextRow());
6176     delete result;
6177
6178     sLog.outString();
6179     sLog.outString( ">> Loaded %u pet name parts", count );
6180 }
6181
6182 void ObjectMgr::LoadPetNumber()
6183 {
6184     QueryResult* result = CharacterDatabase.Query("SELECT MAX(id) FROM character_pet");
6185     if(result)
6186     {
6187         Field *fields = result->Fetch();
6188         m_hiPetNumber = fields[0].GetUInt32()+1;
6189         delete result;
6190     }
6191
6192     barGoLink bar( 1 );
6193     bar.step();
6194
6195     sLog.outString();
6196     sLog.outString( ">> Loaded the max pet number: %d", m_hiPetNumber-1);
6197 }
6198
6199 std::string ObjectMgr::GeneratePetName(uint32 entry)
6200 {
6201     std::vector<std::string> & list0 = PetHalfName0[entry];
6202     std::vector<std::string> & list1 = PetHalfName1[entry];
6203
6204     if(list0.empty() || list1.empty())
6205     {
6206         CreatureInfo const *cinfo = GetCreatureTemplate(entry);
6207         char* petname = GetPetName(cinfo->family, sWorld.GetDefaultDbcLocale());
6208         if(!petname)
6209             petname = cinfo->Name;
6210         return std::string(petname);
6211     }
6212
6213     return *(list0.begin()+urand(0, list0.size()-1)) + *(list1.begin()+urand(0, list1.size()-1));
6214 }
6215
6216 uint32 ObjectMgr::GeneratePetNumber()
6217 {
6218     return ++m_hiPetNumber;
6219 }
6220
6221 void ObjectMgr::LoadCorpses()
6222 {
6223     uint32 count = 0;
6224     //                                                     0           1           2           3            4    5     6     7            8         10
6225     QueryResult *result = CharacterDatabase.Query("SELECT position_x, position_y, position_z, orientation, map, data, time, corpse_type, instance, guid FROM corpse WHERE corpse_type <> 0");
6226
6227     if( !result )
6228     {
6229         barGoLink bar( 1 );
6230
6231         bar.step();
6232
6233         sLog.outString();
6234         sLog.outString( ">> Loaded %u corpses", count );
6235         return;
6236     }
6237
6238     barGoLink bar( result->GetRowCount() );
6239
6240     do
6241     {
6242         bar.step();
6243
6244         Field *fields = result->Fetch();
6245
6246         uint32 guid = fields[result->GetFieldCount()-1].GetUInt32();
6247
6248         Corpse *corpse = new Corpse;
6249         if(!corpse->LoadFromDB(guid,fields))
6250         {
6251             delete corpse;
6252             continue;
6253         }
6254
6255         sObjectAccessor.AddCorpse(corpse);
6256
6257         ++count;
6258     }
6259     while (result->NextRow());
6260     delete result;
6261
6262     sLog.outString();
6263     sLog.outString( ">> Loaded %u corpses", count );
6264 }
6265
6266 void ObjectMgr::LoadReputationOnKill()
6267 {
6268     uint32 count = 0;
6269
6270     //                                                0            1                     2
6271     QueryResult *result = WorldDatabase.Query("SELECT creature_id, RewOnKillRepFaction1, RewOnKillRepFaction2,"
6272     //   3             4             5                   6             7             8                   9
6273         "IsTeamAward1, MaxStanding1, RewOnKillRepValue1, IsTeamAward2, MaxStanding2, RewOnKillRepValue2, TeamDependent "
6274         "FROM creature_onkill_reputation");
6275
6276     if(!result)
6277     {
6278         barGoLink bar(1);
6279
6280         bar.step();
6281
6282         sLog.outString();
6283         sLog.outErrorDb(">> Loaded 0 creature award reputation definitions. DB table `creature_onkill_reputation` is empty.");
6284         return;
6285     }
6286
6287     barGoLink bar(result->GetRowCount());
6288
6289     do
6290     {
6291         Field *fields = result->Fetch();
6292         bar.step();
6293
6294         uint32 creature_id = fields[0].GetUInt32();
6295
6296         ReputationOnKillEntry repOnKill;
6297         repOnKill.repfaction1          = fields[1].GetUInt32();
6298         repOnKill.repfaction2          = fields[2].GetUInt32();
6299         repOnKill.is_teamaward1        = fields[3].GetBool();
6300         repOnKill.reputation_max_cap1  = fields[4].GetUInt32();
6301         repOnKill.repvalue1            = fields[5].GetInt32();
6302         repOnKill.is_teamaward2        = fields[6].GetBool();
6303         repOnKill.reputation_max_cap2  = fields[7].GetUInt32();
6304         repOnKill.repvalue2            = fields[8].GetInt32();
6305         repOnKill.team_dependent       = fields[9].GetUInt8();
6306
6307         if(!GetCreatureTemplate(creature_id))
6308         {
6309             sLog.outErrorDb("Table `creature_onkill_reputation` have data for not existed creature entry (%u), skipped",creature_id);
6310             continue;
6311         }
6312
6313         if(repOnKill.repfaction1)
6314         {
6315             FactionEntry const *factionEntry1 = sFactionStore.LookupEntry(repOnKill.repfaction1);
6316             if(!factionEntry1)
6317             {
6318                 sLog.outErrorDb("Faction (faction.dbc) %u does not exist but is used in `creature_onkill_reputation`",repOnKill.repfaction1);
6319                 continue;
6320             }
6321         }
6322
6323         if(repOnKill.repfaction2)
6324         {
6325             FactionEntry const *factionEntry2 = sFactionStore.LookupEntry(repOnKill.repfaction2);
6326             if(!factionEntry2)
6327             {
6328                 sLog.outErrorDb("Faction (faction.dbc) %u does not exist but is used in `creature_onkill_reputation`",repOnKill.repfaction2);
6329                 continue;
6330             }
6331         }
6332
6333         mRepOnKill[creature_id] = repOnKill;
6334
6335         ++count;
6336     } while (result->NextRow());
6337
6338     delete result;
6339
6340     sLog.outString();
6341     sLog.outString(">> Loaded %u creature award reputation definitions", count);
6342 }
6343
6344 void ObjectMgr::LoadPointsOfInterest()
6345 {
6346     uint32 count = 0;
6347
6348     //                                                0      1  2  3      4     5
6349     QueryResult *result = WorldDatabase.Query("SELECT entry, x, y, icon, flags, data, icon_name FROM points_of_interest");
6350
6351     if(!result)
6352     {
6353         barGoLink bar(1);
6354
6355         bar.step();
6356
6357         sLog.outString();
6358         sLog.outErrorDb(">> Loaded 0 Points of Interest definitions. DB table `points_of_interest` is empty.");
6359         return;
6360     }
6361
6362     barGoLink bar(result->GetRowCount());
6363
6364     do
6365     {
6366         Field *fields = result->Fetch();
6367         bar.step();
6368
6369         uint32 point_id = fields[0].GetUInt32();
6370
6371         PointOfInterest POI;
6372         POI.x                    = fields[1].GetFloat();
6373         POI.y                    = fields[2].GetFloat();
6374         POI.icon                 = fields[3].GetUInt32();
6375         POI.flags                = fields[4].GetUInt32();
6376         POI.data                 = fields[5].GetUInt32();
6377         POI.icon_name            = fields[6].GetCppString();
6378
6379         if(!MaNGOS::IsValidMapCoord(POI.x,POI.y))
6380         {
6381             sLog.outErrorDb("Table `points_of_interest` (Entry: %u) have invalid coordinates (X: %f Y: %f), ignored.",point_id,POI.x,POI.y);
6382             continue;
6383         }
6384
6385         mPointsOfInterest[point_id] = POI;
6386
6387         ++count;
6388     } while (result->NextRow());
6389
6390     delete result;
6391
6392     sLog.outString();
6393     sLog.outString(">> Loaded %u Points of Interest definitions", count);
6394 }
6395
6396 void ObjectMgr::LoadQuestPOI()
6397 {
6398     uint32 count = 0;
6399
6400     //                                                0        1         2      3     4     5     6
6401     QueryResult *result = WorldDatabase.Query("SELECT questId, objIndex, mapId, unk1, unk2, unk3, unk4 FROM quest_poi");
6402
6403     if(!result)
6404     {
6405         barGoLink bar(1);
6406
6407         bar.step();
6408
6409         sLog.outString();
6410         sLog.outErrorDb(">> Loaded 0 quest POI definitions. DB table `quest_poi` is empty.");
6411         return;
6412     }
6413
6414     barGoLink bar(result->GetRowCount());
6415
6416     do
6417     {
6418         Field *fields = result->Fetch();
6419         bar.step();
6420
6421         uint32 questId  = fields[0].GetUInt32();
6422         int32 objIndex  = fields[1].GetInt32();
6423         uint32 mapId    = fields[2].GetUInt32();
6424         uint32 unk1     = fields[3].GetUInt32();
6425         uint32 unk2     = fields[4].GetUInt32();
6426         uint32 unk3     = fields[5].GetUInt32();
6427         uint32 unk4     = fields[6].GetUInt32();
6428
6429         QuestPOI POI(objIndex, mapId, unk1, unk2, unk3, unk4);
6430
6431         QueryResult *points = WorldDatabase.PQuery("SELECT x, y FROM quest_poi_points WHERE questId='%u' AND objIndex='%i'", questId, objIndex);
6432
6433         if(points)
6434         {
6435             do
6436             {
6437                 Field *pointFields = points->Fetch();
6438                 int32 x = pointFields[0].GetInt32();
6439                 int32 y = pointFields[1].GetInt32();
6440                 QuestPOIPoint point(x, y);
6441                 POI.points.push_back(point);
6442             } while (points->NextRow());
6443
6444             delete points;
6445         }
6446
6447         mQuestPOIMap[questId].push_back(POI);
6448
6449         ++count;
6450     } while (result->NextRow());
6451
6452     delete result;
6453
6454     sLog.outString();
6455     sLog.outString(">> Loaded %u quest POI definitions", count);
6456 }
6457
6458 void ObjectMgr::LoadNPCSpellClickSpells()
6459 {
6460     uint32 count = 0;
6461
6462     mSpellClickInfoMap.clear();
6463     //                                                0          1         2            3                   4          5
6464     QueryResult *result = WorldDatabase.Query("SELECT npc_entry, spell_id, quest_start, quest_start_active, quest_end, cast_flags FROM npc_spellclick_spells");
6465
6466     if(!result)
6467     {
6468         barGoLink bar(1);
6469
6470         bar.step();
6471
6472         sLog.outString();
6473         sLog.outErrorDb(">> Loaded 0 spellclick spells. DB table `npc_spellclick_spells` is empty.");
6474         return;
6475     }
6476
6477     barGoLink bar(result->GetRowCount());
6478
6479     do
6480     {
6481         Field *fields = result->Fetch();
6482         bar.step();
6483
6484         uint32 npc_entry = fields[0].GetUInt32();
6485         CreatureInfo const* cInfo = GetCreatureTemplate(npc_entry);
6486         if (!cInfo)
6487         {
6488             sLog.outErrorDb("Table npc_spellclick_spells references unknown creature_template %u. Skipping entry.", npc_entry);
6489             continue;
6490         }
6491
6492         uint32 spellid = fields[1].GetUInt32();
6493         SpellEntry const *spellinfo = sSpellStore.LookupEntry(spellid);
6494         if (!spellinfo)
6495         {
6496             sLog.outErrorDb("Table npc_spellclick_spells references unknown spellid %u. Skipping entry.", spellid);
6497             continue;
6498         }
6499
6500         uint32 quest_start = fields[2].GetUInt32();
6501
6502         // quest might be 0 to enable spellclick independent of any quest
6503         if (quest_start)
6504         {
6505             if(mQuestTemplates.find(quest_start) == mQuestTemplates.end())
6506             {
6507                 sLog.outErrorDb("Table npc_spellclick_spells references unknown start quest %u. Skipping entry.", quest_start);
6508                 continue;
6509             }
6510
6511         }
6512
6513         bool quest_start_active = fields[3].GetBool();
6514
6515         uint32 quest_end = fields[4].GetUInt32();
6516         // quest might be 0 to enable spellclick active infinity after start quest
6517         if (quest_end)
6518         {
6519             if(mQuestTemplates.find(quest_end) == mQuestTemplates.end())
6520             {
6521                 sLog.outErrorDb("Table npc_spellclick_spells references unknown end quest %u. Skipping entry.", quest_end);
6522                 continue;
6523             }
6524
6525         }
6526
6527         uint8 castFlags = fields[5].GetUInt8();
6528         SpellClickInfo info;
6529         info.spellId = spellid;
6530         info.questStart = quest_start;
6531         info.questStartCanActive = quest_start_active;
6532         info.questEnd = quest_end;
6533         info.castFlags = castFlags;
6534         mSpellClickInfoMap.insert(SpellClickInfoMap::value_type(npc_entry, info));
6535
6536         // mark creature template as spell clickable
6537         const_cast<CreatureInfo*>(cInfo)->npcflag |= UNIT_NPC_FLAG_SPELLCLICK;
6538
6539         ++count;
6540     } while (result->NextRow());
6541
6542     delete result;
6543
6544     sLog.outString();
6545     sLog.outString(">> Loaded %u spellclick definitions", count);
6546 }
6547
6548 void ObjectMgr::LoadWeatherZoneChances()
6549 {
6550     uint32 count = 0;
6551
6552     //                                                0     1                   2                   3                    4                   5                   6                    7                 8                 9                  10                  11                  12
6553     QueryResult *result = WorldDatabase.Query("SELECT zone, spring_rain_chance, spring_snow_chance, spring_storm_chance, summer_rain_chance, summer_snow_chance, summer_storm_chance, fall_rain_chance, fall_snow_chance, fall_storm_chance, winter_rain_chance, winter_snow_chance, winter_storm_chance FROM game_weather");
6554
6555     if(!result)
6556     {
6557         barGoLink bar(1);
6558
6559         bar.step();
6560
6561         sLog.outString();
6562         sLog.outErrorDb(">> Loaded 0 weather definitions. DB table `game_weather` is empty.");
6563         return;
6564     }
6565
6566     barGoLink bar(result->GetRowCount());
6567
6568     do
6569     {
6570         Field *fields = result->Fetch();
6571         bar.step();
6572
6573         uint32 zone_id = fields[0].GetUInt32();
6574
6575         WeatherZoneChances& wzc = mWeatherZoneMap[zone_id];
6576
6577         for(int season = 0; season < WEATHER_SEASONS; ++season)
6578         {
6579             wzc.data[season].rainChance  = fields[season * (MAX_WEATHER_TYPE-1) + 1].GetUInt32();
6580             wzc.data[season].snowChance  = fields[season * (MAX_WEATHER_TYPE-1) + 2].GetUInt32();
6581             wzc.data[season].stormChance = fields[season * (MAX_WEATHER_TYPE-1) + 3].GetUInt32();
6582
6583             if(wzc.data[season].rainChance > 100)
6584             {
6585                 wzc.data[season].rainChance = 25;
6586                 sLog.outErrorDb("Weather for zone %u season %u has wrong rain chance > 100%%",zone_id,season);
6587             }
6588
6589             if(wzc.data[season].snowChance > 100)
6590             {
6591                 wzc.data[season].snowChance = 25;
6592                 sLog.outErrorDb("Weather for zone %u season %u has wrong snow chance > 100%%",zone_id,season);
6593             }
6594
6595             if(wzc.data[season].stormChance > 100)
6596             {
6597                 wzc.data[season].stormChance = 25;
6598                 sLog.outErrorDb("Weather for zone %u season %u has wrong storm chance > 100%%",zone_id,season);
6599             }
6600         }
6601
6602         ++count;
6603     } while (result->NextRow());
6604
6605     delete result;
6606
6607     sLog.outString();
6608     sLog.outString(">> Loaded %u weather definitions", count);
6609 }
6610
6611 void ObjectMgr::SaveCreatureRespawnTime(uint32 loguid, uint32 instance, time_t t)
6612 {
6613     mCreatureRespawnTimes[MAKE_PAIR64(loguid,instance)] = t;
6614     WorldDatabase.PExecute("DELETE FROM creature_respawn WHERE guid = '%u' AND instance = '%u'", loguid, instance);
6615     if(t)
6616         WorldDatabase.PExecute("INSERT INTO creature_respawn VALUES ( '%u', '" UI64FMTD "', '%u' )", loguid, uint64(t), instance);
6617 }
6618
6619 void ObjectMgr::DeleteCreatureData(uint32 guid)
6620 {
6621     // remove mapid*cellid -> guid_set map
6622     CreatureData const* data = GetCreatureData(guid);
6623     if(data)
6624         RemoveCreatureFromGrid(guid, data);
6625
6626     mCreatureDataMap.erase(guid);
6627 }
6628
6629 void ObjectMgr::SaveGORespawnTime(uint32 loguid, uint32 instance, time_t t)
6630 {
6631     mGORespawnTimes[MAKE_PAIR64(loguid,instance)] = t;
6632     WorldDatabase.PExecute("DELETE FROM gameobject_respawn WHERE guid = '%u' AND instance = '%u'", loguid, instance);
6633     if(t)
6634         WorldDatabase.PExecute("INSERT INTO gameobject_respawn VALUES ( '%u', '" UI64FMTD "', '%u' )", loguid, uint64(t), instance);
6635 }
6636
6637 void ObjectMgr::DeleteRespawnTimeForInstance(uint32 instance)
6638 {
6639     RespawnTimes::iterator next;
6640
6641     for(RespawnTimes::iterator itr = mGORespawnTimes.begin(); itr != mGORespawnTimes.end(); itr = next)
6642     {
6643         next = itr;
6644         ++next;
6645
6646         if(GUID_HIPART(itr->first)==instance)
6647             mGORespawnTimes.erase(itr);
6648     }
6649
6650     for(RespawnTimes::iterator itr = mCreatureRespawnTimes.begin(); itr != mCreatureRespawnTimes.end(); itr = next)
6651     {
6652         next = itr;
6653         ++next;
6654
6655         if(GUID_HIPART(itr->first)==instance)
6656             mCreatureRespawnTimes.erase(itr);
6657     }
6658
6659     WorldDatabase.PExecute("DELETE FROM creature_respawn WHERE instance = '%u'", instance);
6660     WorldDatabase.PExecute("DELETE FROM gameobject_respawn WHERE instance = '%u'", instance);
6661 }
6662
6663 void ObjectMgr::DeleteGOData(uint32 guid)
6664 {
6665     // remove mapid*cellid -> guid_set map
6666     GameObjectData const* data = GetGOData(guid);
6667     if(data)
6668         RemoveGameobjectFromGrid(guid, data);
6669
6670     mGameObjectDataMap.erase(guid);
6671 }
6672
6673 void ObjectMgr::AddCorpseCellData(uint32 mapid, uint32 cellid, uint32 player_guid, uint32 instance)
6674 {
6675     // corpses are always added to spawn mode 0 and they are spawned by their instance id
6676     CellObjectGuids& cell_guids = mMapObjectGuids[MAKE_PAIR32(mapid,0)][cellid];
6677     cell_guids.corpses[player_guid] = instance;
6678 }
6679
6680 void ObjectMgr::DeleteCorpseCellData(uint32 mapid, uint32 cellid, uint32 player_guid)
6681 {
6682     // corpses are always added to spawn mode 0 and they are spawned by their instance id
6683     CellObjectGuids& cell_guids = mMapObjectGuids[MAKE_PAIR32(mapid,0)][cellid];
6684     cell_guids.corpses.erase(player_guid);
6685 }
6686
6687 void ObjectMgr::LoadQuestRelationsHelper(QuestRelations& map,char const* table)
6688 {
6689     map.clear();                                            // need for reload case
6690
6691     uint32 count = 0;
6692
6693     QueryResult *result = WorldDatabase.PQuery("SELECT id,quest FROM %s",table);
6694
6695     if(!result)
6696     {
6697         barGoLink bar(1);
6698
6699         bar.step();
6700
6701         sLog.outString();
6702         sLog.outErrorDb(">> Loaded 0 quest relations from %s. DB table `%s` is empty.",table,table);
6703         return;
6704     }
6705
6706     barGoLink bar(result->GetRowCount());
6707
6708     do
6709     {
6710         Field *fields = result->Fetch();
6711         bar.step();
6712
6713         uint32 id    = fields[0].GetUInt32();
6714         uint32 quest = fields[1].GetUInt32();
6715
6716         if(mQuestTemplates.find(quest) == mQuestTemplates.end())
6717         {
6718             sLog.outErrorDb("Table `%s: Quest %u listed for entry %u does not exist.",table,quest,id);
6719             continue;
6720         }
6721
6722         map.insert(QuestRelations::value_type(id,quest));
6723
6724         ++count;
6725     } while (result->NextRow());
6726
6727     delete result;
6728
6729     sLog.outString();
6730     sLog.outString(">> Loaded %u quest relations from %s", count,table);
6731 }
6732
6733 void ObjectMgr::LoadGameobjectQuestRelations()
6734 {
6735     LoadQuestRelationsHelper(mGOQuestRelations,"gameobject_questrelation");
6736
6737     for(QuestRelations::iterator itr = mGOQuestRelations.begin(); itr != mGOQuestRelations.end(); ++itr)
6738     {
6739         GameObjectInfo const* goInfo = GetGameObjectInfo(itr->first);
6740         if(!goInfo)
6741             sLog.outErrorDb("Table `gameobject_questrelation` have data for not existed gameobject entry (%u) and existed quest %u",itr->first,itr->second);
6742         else if(goInfo->type != GAMEOBJECT_TYPE_QUESTGIVER)
6743             sLog.outErrorDb("Table `gameobject_questrelation` have data gameobject entry (%u) for quest %u, but GO is not GAMEOBJECT_TYPE_QUESTGIVER",itr->first,itr->second);
6744     }
6745 }
6746
6747 void ObjectMgr::LoadGameobjectInvolvedRelations()
6748 {
6749     LoadQuestRelationsHelper(mGOQuestInvolvedRelations,"gameobject_involvedrelation");
6750
6751     for(QuestRelations::iterator itr = mGOQuestInvolvedRelations.begin(); itr != mGOQuestInvolvedRelations.end(); ++itr)
6752     {
6753         GameObjectInfo const* goInfo = GetGameObjectInfo(itr->first);
6754         if(!goInfo)
6755             sLog.outErrorDb("Table `gameobject_involvedrelation` have data for not existed gameobject entry (%u) and existed quest %u",itr->first,itr->second);
6756         else if(goInfo->type != GAMEOBJECT_TYPE_QUESTGIVER)
6757             sLog.outErrorDb("Table `gameobject_involvedrelation` have data gameobject entry (%u) for quest %u, but GO is not GAMEOBJECT_TYPE_QUESTGIVER",itr->first,itr->second);
6758     }
6759 }
6760
6761 void ObjectMgr::LoadCreatureQuestRelations()
6762 {
6763     LoadQuestRelationsHelper(mCreatureQuestRelations,"creature_questrelation");
6764
6765     for(QuestRelations::iterator itr = mCreatureQuestRelations.begin(); itr != mCreatureQuestRelations.end(); ++itr)
6766     {
6767         CreatureInfo const* cInfo = GetCreatureTemplate(itr->first);
6768         if(!cInfo)
6769             sLog.outErrorDb("Table `creature_questrelation` have data for not existed creature entry (%u) and existed quest %u",itr->first,itr->second);
6770         else if(!(cInfo->npcflag & UNIT_NPC_FLAG_QUESTGIVER))
6771             sLog.outErrorDb("Table `creature_questrelation` has creature entry (%u) for quest %u, but npcflag does not include UNIT_NPC_FLAG_QUESTGIVER",itr->first,itr->second);
6772     }
6773 }
6774
6775 void ObjectMgr::LoadCreatureInvolvedRelations()
6776 {
6777     LoadQuestRelationsHelper(mCreatureQuestInvolvedRelations,"creature_involvedrelation");
6778
6779     for(QuestRelations::iterator itr = mCreatureQuestInvolvedRelations.begin(); itr != mCreatureQuestInvolvedRelations.end(); ++itr)
6780     {
6781         CreatureInfo const* cInfo = GetCreatureTemplate(itr->first);
6782         if(!cInfo)
6783             sLog.outErrorDb("Table `creature_involvedrelation` have data for not existed creature entry (%u) and existed quest %u",itr->first,itr->second);
6784         else if(!(cInfo->npcflag & UNIT_NPC_FLAG_QUESTGIVER))
6785             sLog.outErrorDb("Table `creature_involvedrelation` has creature entry (%u) for quest %u, but npcflag does not include UNIT_NPC_FLAG_QUESTGIVER",itr->first,itr->second);
6786     }
6787 }
6788
6789 void ObjectMgr::LoadReservedPlayersNames()
6790 {
6791     m_ReservedNames.clear();                                // need for reload case
6792
6793     QueryResult *result = WorldDatabase.Query("SELECT name FROM reserved_name");
6794
6795     uint32 count = 0;
6796
6797     if( !result )
6798     {
6799         barGoLink bar( 1 );
6800         bar.step();
6801
6802         sLog.outString();
6803         sLog.outString( ">> Loaded %u reserved player names", count );
6804         return;
6805     }
6806
6807     barGoLink bar( result->GetRowCount() );
6808
6809     Field* fields;
6810     do
6811     {
6812         bar.step();
6813         fields = result->Fetch();
6814         std::string name= fields[0].GetCppString();
6815
6816         std::wstring wstr;
6817         if(!Utf8toWStr (name,wstr))
6818         {
6819             sLog.outError("Table `reserved_name` have invalid name: %s", name.c_str() );
6820             continue;
6821         }
6822
6823         wstrToLower(wstr);
6824
6825         m_ReservedNames.insert(wstr);
6826         ++count;
6827     } while ( result->NextRow() );
6828
6829     delete result;
6830
6831     sLog.outString();
6832     sLog.outString( ">> Loaded %u reserved player names", count );
6833 }
6834
6835 bool ObjectMgr::IsReservedName( const std::string& name ) const
6836 {
6837     std::wstring wstr;
6838     if(!Utf8toWStr (name,wstr))
6839         return false;
6840
6841     wstrToLower(wstr);
6842
6843     return m_ReservedNames.find(wstr) != m_ReservedNames.end();
6844 }
6845
6846 enum LanguageType
6847 {
6848     LT_BASIC_LATIN    = 0x0000,
6849     LT_EXTENDEN_LATIN = 0x0001,
6850     LT_CYRILLIC       = 0x0002,
6851     LT_EAST_ASIA      = 0x0004,
6852     LT_ANY            = 0xFFFF
6853 };
6854
6855 static LanguageType GetRealmLanguageType(bool create)
6856 {
6857     switch(sWorld.getConfig(CONFIG_REALM_ZONE))
6858     {
6859         case REALM_ZONE_UNKNOWN:                            // any language
6860         case REALM_ZONE_DEVELOPMENT:
6861         case REALM_ZONE_TEST_SERVER:
6862         case REALM_ZONE_QA_SERVER:
6863             return LT_ANY;
6864         case REALM_ZONE_UNITED_STATES:                      // extended-Latin
6865         case REALM_ZONE_OCEANIC:
6866         case REALM_ZONE_LATIN_AMERICA:
6867         case REALM_ZONE_ENGLISH:
6868         case REALM_ZONE_GERMAN:
6869         case REALM_ZONE_FRENCH:
6870         case REALM_ZONE_SPANISH:
6871             return LT_EXTENDEN_LATIN;
6872         case REALM_ZONE_KOREA:                              // East-Asian
6873         case REALM_ZONE_TAIWAN:
6874         case REALM_ZONE_CHINA:
6875             return LT_EAST_ASIA;
6876         case REALM_ZONE_RUSSIAN:                            // Cyrillic
6877             return LT_CYRILLIC;
6878         default:
6879             return create ? LT_BASIC_LATIN : LT_ANY;        // basic-Latin at create, any at login
6880     }
6881 }
6882
6883 bool isValidString(std::wstring wstr, uint32 strictMask, bool numericOrSpace, bool create = false)
6884 {
6885     if(strictMask==0)                                       // any language, ignore realm
6886     {
6887         if(isExtendedLatinString(wstr,numericOrSpace))
6888             return true;
6889         if(isCyrillicString(wstr,numericOrSpace))
6890             return true;
6891         if(isEastAsianString(wstr,numericOrSpace))
6892             return true;
6893         return false;
6894     }
6895
6896     if(strictMask & 0x2)                                    // realm zone specific
6897     {
6898         LanguageType lt = GetRealmLanguageType(create);
6899         if(lt & LT_EXTENDEN_LATIN)
6900             if(isExtendedLatinString(wstr,numericOrSpace))
6901                 return true;
6902         if(lt & LT_CYRILLIC)
6903             if(isCyrillicString(wstr,numericOrSpace))
6904                 return true;
6905         if(lt & LT_EAST_ASIA)
6906             if(isEastAsianString(wstr,numericOrSpace))
6907                 return true;
6908     }
6909
6910     if(strictMask & 0x1)                                    // basic Latin
6911     {
6912         if(isBasicLatinString(wstr,numericOrSpace))
6913             return true;
6914     }
6915
6916     return false;
6917 }
6918
6919 uint8 ObjectMgr::CheckPlayerName( const std::string& name, bool create )
6920 {
6921     std::wstring wname;
6922     if(!Utf8toWStr(name,wname))
6923         return CHAR_NAME_INVALID_CHARACTER;
6924
6925     if(wname.size() > MAX_PLAYER_NAME)
6926         return CHAR_NAME_TOO_LONG;
6927
6928     uint32 minName = sWorld.getConfig(CONFIG_MIN_PLAYER_NAME);
6929     if(wname.size() < minName)
6930         return CHAR_NAME_TOO_SHORT;
6931
6932     uint32 strictMask = sWorld.getConfig(CONFIG_STRICT_PLAYER_NAMES);
6933     if(!isValidString(wname,strictMask,false,create))
6934         return CHAR_NAME_MIXED_LANGUAGES;
6935
6936     return CHAR_NAME_SUCCESS;
6937 }
6938
6939 bool ObjectMgr::IsValidCharterName( const std::string& name )
6940 {
6941     std::wstring wname;
6942     if(!Utf8toWStr(name,wname))
6943         return false;
6944
6945     if(wname.size() > MAX_CHARTER_NAME)
6946         return false;
6947
6948     uint32 minName = sWorld.getConfig(CONFIG_MIN_CHARTER_NAME);
6949     if(wname.size() < minName)
6950         return false;
6951
6952     uint32 strictMask = sWorld.getConfig(CONFIG_STRICT_CHARTER_NAMES);
6953
6954     return isValidString(wname,strictMask,true);
6955 }
6956
6957 PetNameInvalidReason ObjectMgr::CheckPetName( const std::string& name )
6958 {
6959     std::wstring wname;
6960     if(!Utf8toWStr(name,wname))
6961         return PET_NAME_INVALID;
6962
6963     if(wname.size() > MAX_PET_NAME)
6964         return PET_NAME_TOO_LONG;
6965
6966     uint32 minName = sWorld.getConfig(CONFIG_MIN_PET_NAME);
6967     if(wname.size() < minName)
6968         return PET_NAME_TOO_SHORT;
6969
6970     uint32 strictMask = sWorld.getConfig(CONFIG_STRICT_PET_NAMES);
6971     if(!isValidString(wname,strictMask,false))
6972         return PET_NAME_MIXED_LANGUAGES;
6973
6974     return PET_NAME_SUCCESS;
6975 }
6976
6977 int ObjectMgr::GetIndexForLocale( LocaleConstant loc )
6978 {
6979     if(loc==LOCALE_enUS)
6980         return -1;
6981
6982     for(size_t i=0;i < m_LocalForIndex.size(); ++i)
6983         if(m_LocalForIndex[i]==loc)
6984             return i;
6985
6986     return -1;
6987 }
6988
6989 LocaleConstant ObjectMgr::GetLocaleForIndex(int i)
6990 {
6991     if (i<0 || i>=m_LocalForIndex.size())
6992         return LOCALE_enUS;
6993
6994     return m_LocalForIndex[i];
6995 }
6996
6997 int ObjectMgr::GetOrNewIndexForLocale( LocaleConstant loc )
6998 {
6999     if(loc==LOCALE_enUS)
7000         return -1;
7001
7002     for(size_t i=0;i < m_LocalForIndex.size(); ++i)
7003         if(m_LocalForIndex[i]==loc)
7004             return i;
7005
7006     m_LocalForIndex.push_back(loc);
7007     return m_LocalForIndex.size()-1;
7008 }
7009
7010 void ObjectMgr::LoadGameObjectForQuests()
7011 {
7012     mGameObjectForQuestSet.clear();                         // need for reload case
7013
7014     if( !sGOStorage.MaxEntry )
7015     {
7016         barGoLink bar( 1 );
7017         bar.step();
7018         sLog.outString();
7019         sLog.outString( ">> Loaded 0 GameObjects for quests" );
7020         return;
7021     }
7022
7023     barGoLink bar( sGOStorage.MaxEntry - 1 );
7024     uint32 count = 0;
7025
7026     // collect GO entries for GO that must activated
7027     for(uint32 go_entry = 1; go_entry < sGOStorage.MaxEntry; ++go_entry)
7028     {
7029         bar.step();
7030         GameObjectInfo const* goInfo = sGOStorage.LookupEntry<GameObjectInfo>(go_entry);
7031         if(!goInfo)
7032             continue;
7033
7034         switch(goInfo->type)
7035         {
7036             // scan GO chest with loot including quest items
7037             case GAMEOBJECT_TYPE_CHEST:
7038             {
7039                 uint32 loot_id = goInfo->GetLootId();
7040
7041                 // find quest loot for GO
7042                 if(LootTemplates_Gameobject.HaveQuestLootFor(loot_id))
7043                 {
7044                     mGameObjectForQuestSet.insert(go_entry);
7045                     ++count;
7046                 }
7047                 break;
7048             }
7049             case GAMEOBJECT_TYPE_GOOBER:
7050             {
7051                 if(goInfo->goober.questId)                  //quests objects
7052                 {
7053                     mGameObjectForQuestSet.insert(go_entry);
7054                     count++;
7055                 }
7056                 break;
7057             }
7058             default:
7059                 break;
7060         }
7061     }
7062
7063     sLog.outString();
7064     sLog.outString( ">> Loaded %u GameObjects for quests", count );
7065 }
7066
7067 bool ObjectMgr::LoadMangosStrings(DatabaseType& db, char const* table, int32 min_value, int32 max_value)
7068 {
7069     int32 start_value = min_value;
7070     int32 end_value   = max_value;
7071     // some string can have negative indexes range
7072     if (start_value < 0)
7073     {
7074         if (end_value >= start_value)
7075         {
7076             sLog.outErrorDb("Table '%s' attempt loaded with invalid range (%d - %d), strings not loaded.",table,min_value,max_value);
7077             return false;
7078         }
7079
7080         // real range (max+1,min+1) exaple: (-10,-1000) -> -999...-10+1
7081         std::swap(start_value,end_value);
7082         ++start_value;
7083         ++end_value;
7084     }
7085     else
7086     {
7087         if (start_value >= end_value)
7088         {
7089             sLog.outErrorDb("Table '%s' attempt loaded with invalid range (%d - %d), strings not loaded.",table,min_value,max_value);
7090             return false;
7091         }
7092     }
7093
7094     // cleanup affected map part for reloading case
7095     for(MangosStringLocaleMap::iterator itr = mMangosStringLocaleMap.begin(); itr != mMangosStringLocaleMap.end();)
7096     {
7097         if (itr->first >= start_value && itr->first < end_value)
7098             mMangosStringLocaleMap.erase(itr++);
7099         else
7100             ++itr;
7101     }
7102
7103     QueryResult *result = db.PQuery("SELECT entry,content_default,content_loc1,content_loc2,content_loc3,content_loc4,content_loc5,content_loc6,content_loc7,content_loc8 FROM %s",table);
7104
7105     if (!result)
7106     {
7107         barGoLink bar(1);
7108
7109         bar.step();
7110
7111         sLog.outString();
7112         if (min_value == MIN_MANGOS_STRING_ID)              // error only in case internal strings
7113             sLog.outErrorDb(">> Loaded 0 mangos strings. DB table `%s` is empty. Cannot continue.",table);
7114         else
7115             sLog.outString(">> Loaded 0 string templates. DB table `%s` is empty.",table);
7116         return false;
7117     }
7118
7119     uint32 count = 0;
7120
7121     barGoLink bar(result->GetRowCount());
7122
7123     do
7124     {
7125         Field *fields = result->Fetch();
7126         bar.step();
7127
7128         int32 entry = fields[0].GetInt32();
7129
7130         if (entry==0)
7131         {
7132             sLog.outErrorDb("Table `%s` contain reserved entry 0, ignored.",table);
7133             continue;
7134         }
7135         else if (entry < start_value || entry >= end_value)
7136         {
7137             sLog.outErrorDb("Table `%s` contain entry %i out of allowed range (%d - %d), ignored.",table,entry,min_value,max_value);
7138             continue;
7139         }
7140
7141         MangosStringLocale& data = mMangosStringLocaleMap[entry];
7142
7143         if (data.Content.size() > 0)
7144         {
7145             sLog.outErrorDb("Table `%s` contain data for already loaded entry  %i (from another table?), ignored.",table,entry);
7146             continue;
7147         }
7148
7149         data.Content.resize(1);
7150         ++count;
7151
7152         // 0 -> default, idx in to idx+1
7153         data.Content[0] = fields[1].GetCppString();
7154
7155         for(int i = 1; i < MAX_LOCALE; ++i)
7156         {
7157             std::string str = fields[i+1].GetCppString();
7158             if (!str.empty())
7159             {
7160                 int idx = GetOrNewIndexForLocale(LocaleConstant(i));
7161                 if (idx >= 0)
7162                 {
7163                     // 0 -> default, idx in to idx+1
7164                     if (data.Content.size() <= idx+1)
7165                         data.Content.resize(idx+2);
7166
7167                     data.Content[idx+1] = str;
7168                 }
7169             }
7170         }
7171     } while (result->NextRow());
7172
7173     delete result;
7174
7175     sLog.outString();
7176     if (min_value == MIN_MANGOS_STRING_ID)
7177         sLog.outString( ">> Loaded %u MaNGOS strings from table %s", count,table);
7178     else
7179         sLog.outString( ">> Loaded %u string templates from %s", count,table);
7180
7181     return true;
7182 }
7183
7184 const char *ObjectMgr::GetMangosString(int32 entry, int locale_idx) const
7185 {
7186     // locale_idx==-1 -> default, locale_idx >= 0 in to idx+1
7187     // Content[0] always exist if exist MangosStringLocale
7188     if(MangosStringLocale const *msl = GetMangosStringLocale(entry))
7189     {
7190         if(msl->Content.size() > locale_idx+1 && !msl->Content[locale_idx+1].empty())
7191             return msl->Content[locale_idx+1].c_str();
7192         else
7193             return msl->Content[0].c_str();
7194     }
7195
7196     if(entry > 0)
7197         sLog.outErrorDb("Entry %i not found in `mangos_string` table.",entry);
7198     else
7199         sLog.outErrorDb("Mangos string entry %i not found in DB.",entry);
7200     return "<error>";
7201 }
7202
7203 void ObjectMgr::LoadFishingBaseSkillLevel()
7204 {
7205     mFishingBaseForArea.clear();                            // for reload case
7206
7207     uint32 count = 0;
7208     QueryResult *result = WorldDatabase.Query("SELECT entry,skill FROM skill_fishing_base_level");
7209
7210     if( !result )
7211     {
7212         barGoLink bar( 1 );
7213
7214         bar.step();
7215
7216         sLog.outString();
7217         sLog.outErrorDb(">> Loaded `skill_fishing_base_level`, table is empty!");
7218         return;
7219     }
7220
7221     barGoLink bar( result->GetRowCount() );
7222
7223     do
7224     {
7225         bar.step();
7226
7227         Field *fields = result->Fetch();
7228         uint32 entry  = fields[0].GetUInt32();
7229         int32 skill   = fields[1].GetInt32();
7230
7231         AreaTableEntry const* fArea = GetAreaEntryByAreaID(entry);
7232         if(!fArea)
7233         {
7234             sLog.outErrorDb("AreaId %u defined in `skill_fishing_base_level` does not exist",entry);
7235             continue;
7236         }
7237
7238         mFishingBaseForArea[entry] = skill;
7239         ++count;
7240     }
7241     while (result->NextRow());
7242
7243     delete result;
7244
7245     sLog.outString();
7246     sLog.outString( ">> Loaded %u areas for fishing base skill level", count );
7247 }
7248
7249 // Searches for the same condition already in Conditions store
7250 // Returns Id if found, else adds it to Conditions and returns Id
7251 uint16 ObjectMgr::GetConditionId( ConditionType condition, uint32 value1, uint32 value2 )
7252 {
7253     PlayerCondition lc = PlayerCondition(condition, value1, value2);
7254     for (uint16 i=0; i < mConditions.size(); ++i)
7255     {
7256         if (lc == mConditions[i])
7257             return i;
7258     }
7259
7260     mConditions.push_back(lc);
7261
7262     if(mConditions.size() > 0xFFFF)
7263     {
7264         sLog.outError("Conditions store overflow! Current and later loaded conditions will ignored!");
7265         return 0;
7266     }
7267
7268     return mConditions.size() - 1;
7269 }
7270
7271 bool ObjectMgr::CheckDeclinedNames( std::wstring mainpart, DeclinedName const& names )
7272 {
7273     for(int i =0; i < MAX_DECLINED_NAME_CASES; ++i)
7274     {
7275         std::wstring wname;
7276         if(!Utf8toWStr(names.name[i],wname))
7277             return false;
7278
7279         if(mainpart!=GetMainPartOfName(wname,i+1))
7280             return false;
7281     }
7282     return true;
7283 }
7284
7285 uint32 ObjectMgr::GetAreaTriggerScriptId(uint32 trigger_id)
7286 {
7287     AreaTriggerScriptMap::const_iterator i = mAreaTriggerScripts.find(trigger_id);
7288     if(i!= mAreaTriggerScripts.end())
7289         return i->second;
7290     return 0;
7291 }
7292
7293 // Checks if player meets the condition
7294 bool PlayerCondition::Meets(Player const * player) const
7295 {
7296     if( !player )
7297         return false;                                       // player not present, return false
7298
7299     switch (condition)
7300     {
7301         case CONDITION_NONE:
7302             return true;                                    // empty condition, always met
7303         case CONDITION_AURA:
7304             return player->HasAura(value1, value2);
7305         case CONDITION_ITEM:
7306             return player->HasItemCount(value1, value2);
7307         case CONDITION_ITEM_EQUIPPED:
7308             return player->HasItemOrGemWithIdEquipped(value1,1);
7309         case CONDITION_ZONEID:
7310             return player->GetZoneId() == value1;
7311         case CONDITION_REPUTATION_RANK:
7312         {
7313             FactionEntry const* faction = sFactionStore.LookupEntry(value1);
7314             return faction && player->GetReputationMgr().GetRank(faction) >= int32(value2);
7315         }
7316         case CONDITION_TEAM:
7317             return player->GetTeam() == value1;
7318         case CONDITION_SKILL:
7319             return player->HasSkill(value1) && player->GetBaseSkillValue(value1) >= value2;
7320         case CONDITION_QUESTREWARDED:
7321             return player->GetQuestRewardStatus(value1);
7322         case CONDITION_QUESTTAKEN:
7323         {
7324             QuestStatus status = player->GetQuestStatus(value1);
7325             return (status == QUEST_STATUS_INCOMPLETE);
7326         }
7327         case CONDITION_AD_COMMISSION_AURA:
7328         {
7329             Unit::AuraMap const& auras = player->GetAuras();
7330             for(Unit::AuraMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
7331                 if((itr->second->GetSpellProto()->Attributes & 0x1000010) && itr->second->GetSpellProto()->SpellVisual[0]==3580)
7332                     return true;
7333             return false;
7334         }
7335         case CONDITION_NO_AURA:
7336             return !player->HasAura(value1, value2);
7337         case CONDITION_ACTIVE_EVENT:
7338             return sGameEventMgr.IsActiveEvent(value1);
7339         case CONDITION_AREA_FLAG:
7340         {
7341             if (AreaTableEntry const *pAreaEntry = GetAreaEntryByAreaID(player->GetAreaId()))
7342             {
7343                 if ((!value1 || (pAreaEntry->flags & value1)) && (!value2 || !(pAreaEntry->flags & value2)))
7344                     return true;
7345             }
7346             return false;
7347         }
7348         case CONDITION_RACE_CLASS:
7349             if ((!value1 || (player->getRaceMask() & value1)) && (!value2 || (player->getClassMask() & value2)))
7350                 return true;
7351             return false;
7352         case CONDITION_LEVEL:
7353         {
7354             switch(value2)
7355             {
7356                 case 0: return player->getLevel() == value1;
7357                 case 1: return player->getLevel() >= value1;
7358                 case 2: return player->getLevel() <= value1;
7359             }
7360             return false;
7361         }
7362         default:
7363             return false;
7364     }
7365 }
7366
7367 // Verification of condition values validity
7368 bool PlayerCondition::IsValid(ConditionType condition, uint32 value1, uint32 value2)
7369 {
7370     if( condition >= MAX_CONDITION)                         // Wrong condition type
7371     {
7372         sLog.outErrorDb("Condition has bad type of %u, skipped ", condition );
7373         return false;
7374     }
7375
7376     switch (condition)
7377     {
7378         case CONDITION_AURA:
7379         {
7380             if(!sSpellStore.LookupEntry(value1))
7381             {
7382                 sLog.outErrorDb("Aura condition requires to have non existing spell (Id: %d), skipped", value1);
7383                 return false;
7384             }
7385             if(value2 > 2)
7386             {
7387                 sLog.outErrorDb("Aura condition requires to have non existing effect index (%u) (must be 0..2), skipped", value2);
7388                 return false;
7389             }
7390             break;
7391         }
7392         case CONDITION_ITEM:
7393         {
7394             ItemPrototype const *proto = ObjectMgr::GetItemPrototype(value1);
7395             if(!proto)
7396             {
7397                 sLog.outErrorDb("Item condition requires to have non existing item (%u), skipped", value1);
7398                 return false;
7399             }
7400             break;
7401         }
7402         case CONDITION_ITEM_EQUIPPED:
7403         {
7404             ItemPrototype const *proto = ObjectMgr::GetItemPrototype(value1);
7405             if(!proto)
7406             {
7407                 sLog.outErrorDb("ItemEquipped condition requires to have non existing item (%u) equipped, skipped", value1);
7408                 return false;
7409             }
7410             break;
7411         }
7412         case CONDITION_ZONEID:
7413         {
7414             AreaTableEntry const* areaEntry = GetAreaEntryByAreaID(value1);
7415             if(!areaEntry)
7416             {
7417                 sLog.outErrorDb("Zone condition requires to be in non existing area (%u), skipped", value1);
7418                 return false;
7419             }
7420             if(areaEntry->zone != 0)
7421             {
7422                 sLog.outErrorDb("Zone condition requires to be in area (%u) which is a subzone but zone expected, skipped", value1);
7423                 return false;
7424             }
7425             break;
7426         }
7427         case CONDITION_REPUTATION_RANK:
7428         {
7429             FactionEntry const* factionEntry = sFactionStore.LookupEntry(value1);
7430             if(!factionEntry)
7431             {
7432                 sLog.outErrorDb("Reputation condition requires to have reputation non existing faction (%u), skipped", value1);
7433                 return false;
7434             }
7435             break;
7436         }
7437         case CONDITION_TEAM:
7438         {
7439             if (value1 != ALLIANCE && value1 != HORDE)
7440             {
7441                 sLog.outErrorDb("Team condition specifies unknown team (%u), skipped", value1);
7442                 return false;
7443             }
7444             break;
7445         }
7446         case CONDITION_SKILL:
7447         {
7448             SkillLineEntry const *pSkill = sSkillLineStore.LookupEntry(value1);
7449             if (!pSkill)
7450             {
7451                 sLog.outErrorDb("Skill condition specifies non-existing skill (%u), skipped", value1);
7452                 return false;
7453             }
7454             if (value2 < 1 || value2 > sWorld.GetConfigMaxSkillValue() )
7455             {
7456                 sLog.outErrorDb("Skill condition specifies invalid skill value (%u), skipped", value2);
7457                 return false;
7458             }
7459             break;
7460         }
7461         case CONDITION_QUESTREWARDED:
7462         case CONDITION_QUESTTAKEN:
7463         {
7464             Quest const *Quest = sObjectMgr.GetQuestTemplate(value1);
7465             if (!Quest)
7466             {
7467                 sLog.outErrorDb("Quest condition specifies non-existing quest (%u), skipped", value1);
7468                 return false;
7469             }
7470             if(value2)
7471                 sLog.outErrorDb("Quest condition has useless data in value2 (%u)!", value2);
7472             break;
7473         }
7474         case CONDITION_AD_COMMISSION_AURA:
7475         {
7476             if(value1)
7477                 sLog.outErrorDb("Quest condition has useless data in value1 (%u)!", value1);
7478             if(value2)
7479                 sLog.outErrorDb("Quest condition has useless data in value2 (%u)!", value2);
7480             break;
7481         }
7482         case CONDITION_NO_AURA:
7483         {
7484             if(!sSpellStore.LookupEntry(value1))
7485             {
7486                 sLog.outErrorDb("Aura condition requires to have non existing spell (Id: %d), skipped", value1);
7487                 return false;
7488             }
7489             if(value2 > 2)
7490             {
7491                 sLog.outErrorDb("Aura condition requires to have non existing effect index (%u) (must be 0..2), skipped", value2);
7492                 return false;
7493             }
7494             break;
7495         }
7496         case CONDITION_ACTIVE_EVENT:
7497         {
7498             GameEventMgr::GameEventDataMap const& events = sGameEventMgr.GetEventMap();
7499             if(value1 >=events.size() || !events[value1].isValid())
7500             {
7501                 sLog.outErrorDb("Active event condition requires existed event id (%u), skipped", value1);
7502                 return false;
7503             }
7504             break;
7505         }
7506         case CONDITION_AREA_FLAG:
7507         {
7508             if (!value1 && !value2)
7509             {
7510                 sLog.outErrorDb("Area flag condition has both values like 0, skipped");
7511                 return false;
7512             }
7513             break;
7514         }
7515         case CONDITION_RACE_CLASS:
7516         {
7517             if (!value1 && !value2)
7518             {
7519                 sLog.outErrorDb("Race_class condition has both values like 0, skipped");
7520                 return false;
7521             }
7522
7523             if (value1 && !(value1 & RACEMASK_ALL_PLAYABLE))
7524             {
7525                 sLog.outErrorDb("Race_class condition has invalid player class %u, skipped", value1);
7526                 return false;
7527             }
7528
7529             if (value2 && !(value2 & CLASSMASK_ALL_PLAYABLE))
7530             {
7531                 sLog.outErrorDb("Race_class condition has invalid race mask %u, skipped", value2);
7532                 return false;
7533             }
7534             break;
7535         }
7536         case CONDITION_LEVEL:
7537         {
7538             if (!value1 || value1 > sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL))
7539             {
7540                 sLog.outErrorDb("Level condition has invalid level %u, skipped", value1);
7541                 return false;
7542             }
7543
7544             if (value2 > 2)
7545             {
7546                 sLog.outErrorDb("Level condition has invalid argument %u (must be 0..2), skipped", value2);
7547                 return false;
7548             }
7549
7550             break;
7551         }
7552         case CONDITION_NONE:
7553             break;
7554     }
7555     return true;
7556 }
7557
7558 SkillRangeType GetSkillRangeType(SkillLineEntry const *pSkill, bool racial)
7559 {
7560     switch(pSkill->categoryId)
7561     {
7562         case SKILL_CATEGORY_LANGUAGES: return SKILL_RANGE_LANGUAGE;
7563         case SKILL_CATEGORY_WEAPON:
7564             if(pSkill->id!=SKILL_FIST_WEAPONS)
7565                 return SKILL_RANGE_LEVEL;
7566             else
7567                 return SKILL_RANGE_MONO;
7568         case SKILL_CATEGORY_ARMOR:
7569         case SKILL_CATEGORY_CLASS:
7570             if(pSkill->id != SKILL_LOCKPICKING)
7571                 return SKILL_RANGE_MONO;
7572             else
7573                 return SKILL_RANGE_LEVEL;
7574         case SKILL_CATEGORY_SECONDARY:
7575         case SKILL_CATEGORY_PROFESSION:
7576             // not set skills for professions and racial abilities
7577             if(IsProfessionSkill(pSkill->id))
7578                 return SKILL_RANGE_RANK;
7579             else if(racial)
7580                 return SKILL_RANGE_NONE;
7581             else
7582                 return SKILL_RANGE_MONO;
7583         default:
7584         case SKILL_CATEGORY_ATTRIBUTES:                     //not found in dbc
7585         case SKILL_CATEGORY_GENERIC:                        //only GENERIC(DND)
7586             return SKILL_RANGE_NONE;
7587     }
7588 }
7589
7590 void ObjectMgr::LoadGameTele()
7591 {
7592     m_GameTeleMap.clear();                                  // for reload case
7593
7594     uint32 count = 0;
7595     QueryResult *result = WorldDatabase.Query("SELECT id, position_x, position_y, position_z, orientation, map, name FROM game_tele");
7596
7597     if( !result )
7598     {
7599         barGoLink bar( 1 );
7600
7601         bar.step();
7602
7603         sLog.outString();
7604         sLog.outErrorDb(">> Loaded `game_tele`, table is empty!");
7605         return;
7606     }
7607
7608     barGoLink bar( result->GetRowCount() );
7609
7610     do
7611     {
7612         bar.step();
7613
7614         Field *fields = result->Fetch();
7615
7616         uint32 id         = fields[0].GetUInt32();
7617
7618         GameTele gt;
7619
7620         gt.position_x     = fields[1].GetFloat();
7621         gt.position_y     = fields[2].GetFloat();
7622         gt.position_z     = fields[3].GetFloat();
7623         gt.orientation    = fields[4].GetFloat();
7624         gt.mapId          = fields[5].GetUInt32();
7625         gt.name           = fields[6].GetCppString();
7626
7627         if(!MapManager::IsValidMapCoord(gt.mapId,gt.position_x,gt.position_y,gt.position_z,gt.orientation))
7628         {
7629             sLog.outErrorDb("Wrong position for id %u (name: %s) in `game_tele` table, ignoring.",id,gt.name.c_str());
7630             continue;
7631         }
7632
7633         if(!Utf8toWStr(gt.name,gt.wnameLow))
7634         {
7635             sLog.outErrorDb("Wrong UTF8 name for id %u in `game_tele` table, ignoring.",id);
7636             continue;
7637         }
7638
7639         wstrToLower( gt.wnameLow );
7640
7641         m_GameTeleMap[id] = gt;
7642
7643         ++count;
7644     }
7645     while (result->NextRow());
7646     delete result;
7647
7648     sLog.outString();
7649     sLog.outString( ">> Loaded %u GameTeleports", count );
7650 }
7651
7652 GameTele const* ObjectMgr::GetGameTele(const std::string& name) const
7653 {
7654     // explicit name case
7655     std::wstring wname;
7656     if(!Utf8toWStr(name,wname))
7657         return false;
7658
7659     // converting string that we try to find to lower case
7660     wstrToLower( wname );
7661
7662     // Alternative first GameTele what contains wnameLow as substring in case no GameTele location found
7663     const GameTele* alt = NULL;
7664     for(GameTeleMap::const_iterator itr = m_GameTeleMap.begin(); itr != m_GameTeleMap.end(); ++itr)
7665         if(itr->second.wnameLow == wname)
7666             return &itr->second;
7667         else if (alt == NULL && itr->second.wnameLow.find(wname) != std::wstring::npos)
7668             alt = &itr->second;
7669
7670     return alt;
7671 }
7672
7673 bool ObjectMgr::AddGameTele(GameTele& tele)
7674 {
7675     // find max id
7676     uint32 new_id = 0;
7677     for(GameTeleMap::const_iterator itr = m_GameTeleMap.begin(); itr != m_GameTeleMap.end(); ++itr)
7678         if(itr->first > new_id)
7679             new_id = itr->first;
7680
7681     // use next
7682     ++new_id;
7683
7684     if(!Utf8toWStr(tele.name,tele.wnameLow))
7685         return false;
7686
7687     wstrToLower( tele.wnameLow );
7688
7689     m_GameTeleMap[new_id] = tele;
7690
7691     return WorldDatabase.PExecuteLog("INSERT INTO game_tele (id,position_x,position_y,position_z,orientation,map,name) VALUES (%u,%f,%f,%f,%f,%d,'%s')",
7692         new_id,tele.position_x,tele.position_y,tele.position_z,tele.orientation,tele.mapId,tele.name.c_str());
7693 }
7694
7695 bool ObjectMgr::DeleteGameTele(const std::string& name)
7696 {
7697     // explicit name case
7698     std::wstring wname;
7699     if(!Utf8toWStr(name,wname))
7700         return false;
7701
7702     // converting string that we try to find to lower case
7703     wstrToLower( wname );
7704
7705     for(GameTeleMap::iterator itr = m_GameTeleMap.begin(); itr != m_GameTeleMap.end(); ++itr)
7706     {
7707         if(itr->second.wnameLow == wname)
7708         {
7709             WorldDatabase.PExecuteLog("DELETE FROM game_tele WHERE name = '%s'",itr->second.name.c_str());
7710             m_GameTeleMap.erase(itr);
7711             return true;
7712         }
7713     }
7714
7715     return false;
7716 }
7717
7718 void ObjectMgr::LoadMailLevelRewards()
7719 {
7720     m_mailLevelRewardMap.clear();                           // for reload case
7721
7722     uint32 count = 0;
7723     QueryResult *result = WorldDatabase.Query("SELECT level, raceMask, mailTemplateId, senderEntry FROM mail_level_reward");
7724
7725     if( !result )
7726     {
7727         barGoLink bar( 1 );
7728
7729         bar.step();
7730
7731         sLog.outString();
7732         sLog.outErrorDb(">> Loaded `mail_level_reward`, table is empty!");
7733         return;
7734     }
7735
7736     barGoLink bar( result->GetRowCount() );
7737
7738     do
7739     {
7740         bar.step();
7741
7742         Field *fields = result->Fetch();
7743
7744         uint8 level           = fields[0].GetUInt8();
7745         uint32 raceMask       = fields[1].GetUInt32();
7746         uint32 mailTemplateId = fields[2].GetUInt32();
7747         uint32 senderEntry    = fields[3].GetUInt32();
7748
7749         if(level > MAX_LEVEL)
7750         {
7751             sLog.outErrorDb("Table `mail_level_reward` have data for level %u that more supported by client (%u), ignoring.",level,MAX_LEVEL);
7752             continue;
7753         }
7754
7755         if(!(raceMask & RACEMASK_ALL_PLAYABLE))
7756         {
7757             sLog.outErrorDb("Table `mail_level_reward` have raceMask (%u) for level %u that not include any player races, ignoring.",raceMask,level);
7758             continue;
7759         }
7760
7761         if(!sMailTemplateStore.LookupEntry(mailTemplateId))
7762         {
7763             sLog.outErrorDb("Table `mail_level_reward` have invalid mailTemplateId (%u) for level %u that invalid not include any player races, ignoring.",mailTemplateId,level);
7764             continue;
7765         }
7766
7767         if(!GetCreatureTemplateStore(senderEntry))
7768         {
7769             sLog.outErrorDb("Table `mail_level_reward` have not existed sender creature entry (%u) for level %u that invalid not include any player races, ignoring.",senderEntry,level);
7770             continue;
7771         }
7772
7773         m_mailLevelRewardMap[level].push_back(MailLevelReward(raceMask,mailTemplateId,senderEntry));
7774
7775         ++count;
7776     }
7777     while (result->NextRow());
7778     delete result;
7779
7780     sLog.outString();
7781     sLog.outString( ">> Loaded %u level dependent mail rewards,", count );
7782 }
7783
7784 void ObjectMgr::LoadTrainerSpell()
7785 {
7786     // For reload case
7787     for (CacheTrainerSpellMap::iterator itr = m_mCacheTrainerSpellMap.begin(); itr != m_mCacheTrainerSpellMap.end(); ++itr)
7788         itr->second.Clear();
7789     m_mCacheTrainerSpellMap.clear();
7790
7791     std::set<uint32> skip_trainers;
7792
7793     QueryResult *result = WorldDatabase.Query("SELECT entry, spell,spellcost,reqskill,reqskillvalue,reqlevel FROM npc_trainer");
7794
7795     if( !result )
7796     {
7797         barGoLink bar( 1 );
7798
7799         bar.step();
7800
7801         sLog.outString();
7802         sLog.outErrorDb(">> Loaded `npc_trainer`, table is empty!");
7803         return;
7804     }
7805
7806     barGoLink bar( result->GetRowCount() );
7807
7808     std::set<uint32> talentIds;
7809
7810     uint32 count = 0;
7811     do
7812     {
7813         bar.step();
7814
7815         Field* fields = result->Fetch();
7816
7817         uint32 entry  = fields[0].GetUInt32();
7818         uint32 spell  = fields[1].GetUInt32();
7819
7820         CreatureInfo const* cInfo = GetCreatureTemplate(entry);
7821
7822         if(!cInfo)
7823         {
7824             sLog.outErrorDb("Table `npc_trainer` have entry for not existed creature template (Entry: %u), ignore", entry);
7825             continue;
7826         }
7827
7828         if(!(cInfo->npcflag & UNIT_NPC_FLAG_TRAINER))
7829         {
7830             if(skip_trainers.count(entry) == 0)
7831             {
7832                 sLog.outErrorDb("Table `npc_trainer` have data for not creature template (Entry: %u) without trainer flag, ignore", entry);
7833                 skip_trainers.insert(entry);
7834             }
7835             continue;
7836         }
7837
7838         SpellEntry const *spellinfo = sSpellStore.LookupEntry(spell);
7839         if(!spellinfo)
7840         {
7841             sLog.outErrorDb("Table `npc_trainer` for Trainer (Entry: %u ) has non existing spell %u, ignore", entry,spell);
7842             continue;
7843         }
7844
7845         if(!SpellMgr::IsSpellValid(spellinfo))
7846         {
7847             sLog.outErrorDb("Table `npc_trainer` for Trainer (Entry: %u) has broken learning spell %u, ignore", entry, spell);
7848             continue;
7849         }
7850
7851         if(GetTalentSpellCost(spell))
7852         {
7853             if(talentIds.count(spell)==0)
7854             {
7855                 sLog.outErrorDb("Table `npc_trainer` has talent as learning spell %u, ignore", spell);
7856                 talentIds.insert(spell);
7857             }
7858             continue;
7859         }
7860
7861         TrainerSpellData& data = m_mCacheTrainerSpellMap[entry];
7862
7863         TrainerSpell& trainerSpell = data.spellList[spell];
7864         trainerSpell.spell         = spell;
7865         trainerSpell.spellCost     = fields[2].GetUInt32();
7866         trainerSpell.reqSkill      = fields[3].GetUInt32();
7867         trainerSpell.reqSkillValue = fields[4].GetUInt32();
7868         trainerSpell.reqLevel      = fields[5].GetUInt32();
7869
7870         if(!trainerSpell.reqLevel)
7871             trainerSpell.reqLevel = spellinfo->spellLevel;
7872
7873         // calculate learned spell for profession case when stored cast-spell
7874         trainerSpell.learnedSpell = spell;
7875         for(int i = 0; i <3; ++i)
7876         {
7877             if(spellinfo->Effect[i] != SPELL_EFFECT_LEARN_SPELL)
7878                 continue;
7879             if(SpellMgr::IsProfessionOrRidingSpell(spellinfo->EffectTriggerSpell[i]))
7880             {
7881                 trainerSpell.learnedSpell = spellinfo->EffectTriggerSpell[i];
7882                 break;
7883             }
7884         }
7885
7886         if(SpellMgr::IsProfessionSpell(trainerSpell.learnedSpell))
7887             data.trainerType = 2;
7888
7889         ++count;
7890
7891     } while (result->NextRow());
7892     delete result;
7893
7894     sLog.outString();
7895     sLog.outString( ">> Loaded %d Trainers", count );
7896 }
7897
7898 void ObjectMgr::LoadVendors()
7899 {
7900     // For reload case
7901     for (CacheVendorItemMap::iterator itr = m_mCacheVendorItemMap.begin(); itr != m_mCacheVendorItemMap.end(); ++itr)
7902         itr->second.Clear();
7903     m_mCacheVendorItemMap.clear();
7904
7905     std::set<uint32> skip_vendors;
7906
7907     QueryResult *result = WorldDatabase.Query("SELECT entry, item, maxcount, incrtime, ExtendedCost FROM npc_vendor");
7908     if( !result )
7909     {
7910         barGoLink bar( 1 );
7911
7912         bar.step();
7913
7914         sLog.outString();
7915         sLog.outErrorDb(">> Loaded `npc_vendor`, table is empty!");
7916         return;
7917     }
7918
7919     barGoLink bar( result->GetRowCount() );
7920
7921     uint32 count = 0;
7922     do
7923     {
7924         bar.step();
7925         Field* fields = result->Fetch();
7926
7927         uint32 entry        = fields[0].GetUInt32();
7928         uint32 item_id      = fields[1].GetUInt32();
7929         uint32 maxcount     = fields[2].GetUInt32();
7930         uint32 incrtime     = fields[3].GetUInt32();
7931         uint32 ExtendedCost = fields[4].GetUInt32();
7932
7933         if(!IsVendorItemValid(entry,item_id,maxcount,incrtime,ExtendedCost,NULL,&skip_vendors))
7934             continue;
7935
7936         VendorItemData& vList = m_mCacheVendorItemMap[entry];
7937
7938         vList.AddItem(item_id,maxcount,incrtime,ExtendedCost);
7939         ++count;
7940
7941     } while (result->NextRow());
7942     delete result;
7943
7944     sLog.outString();
7945     sLog.outString( ">> Loaded %d Vendors ", count );
7946 }
7947
7948 void ObjectMgr::LoadNpcTextId()
7949 {
7950
7951     m_mCacheNpcTextIdMap.clear();
7952
7953     QueryResult* result = WorldDatabase.Query("SELECT npc_guid, textid FROM npc_gossip");
7954     if( !result )
7955     {
7956         barGoLink bar( 1 );
7957
7958         bar.step();
7959
7960         sLog.outString();
7961         sLog.outErrorDb(">> Loaded `npc_gossip`, table is empty!");
7962         return;
7963     }
7964
7965     barGoLink bar( result->GetRowCount() );
7966
7967     uint32 count = 0;
7968     uint32 guid,textid;
7969     do
7970     {
7971         bar.step();
7972
7973         Field* fields = result->Fetch();
7974
7975         guid   = fields[0].GetUInt32();
7976         textid = fields[1].GetUInt32();
7977
7978         if (!GetCreatureData(guid))
7979         {
7980             sLog.outErrorDb("Table `npc_gossip` have not existed creature (GUID: %u) entry, ignore. ",guid);
7981             continue;
7982         }
7983         if (!GetGossipText(textid))
7984         {
7985             sLog.outErrorDb("Table `npc_gossip` for creature (GUID: %u) have wrong Textid (%u), ignore. ", guid, textid);
7986             continue;
7987         }
7988
7989         m_mCacheNpcTextIdMap[guid] = textid ;
7990         ++count;
7991
7992     } while (result->NextRow());
7993     delete result;
7994
7995     sLog.outString();
7996     sLog.outString( ">> Loaded %d NpcTextId ", count );
7997 }
7998
7999 void ObjectMgr::LoadGossipMenu()
8000 {
8001     m_mGossipMenusMap.clear();
8002
8003     QueryResult* result = WorldDatabase.Query("SELECT entry, text_id, "
8004         "cond_1, cond_1_val_1, cond_1_val_2, cond_2, cond_2_val_1, cond_2_val_2 FROM gossip_menu");
8005
8006     if (!result)
8007     {
8008         barGoLink bar(1);
8009
8010         bar.step();
8011
8012         sLog.outString();
8013         sLog.outErrorDb(">> Loaded gossip_menu, table is empty!");
8014         return;
8015     }
8016
8017     barGoLink bar( result->GetRowCount() );
8018
8019     uint32 count = 0;
8020
8021     do
8022     {
8023         bar.step();
8024
8025         Field* fields = result->Fetch();
8026
8027         GossipMenus gMenu;
8028
8029         gMenu.entry             = fields[0].GetUInt32();
8030         gMenu.text_id           = fields[1].GetUInt32();
8031
8032         ConditionType cond_1    = (ConditionType)fields[2].GetUInt32();
8033         uint32 cond_1_val_1     = fields[3].GetUInt32();
8034         uint32 cond_1_val_2     = fields[4].GetUInt32();
8035         ConditionType cond_2    = (ConditionType)fields[5].GetUInt32();
8036         uint32 cond_2_val_1     = fields[6].GetUInt32();
8037         uint32 cond_2_val_2     = fields[7].GetUInt32();
8038
8039         if (!GetGossipText(gMenu.text_id))
8040         {
8041             sLog.outErrorDb("Table gossip_menu entry %u are using non-existing text_id %u", gMenu.entry, gMenu.text_id);
8042             continue;
8043         }
8044
8045         if (!PlayerCondition::IsValid(cond_1, cond_1_val_1, cond_1_val_2))
8046         {
8047             sLog.outErrorDb("Table gossip_menu entry %u, invalid condition 1 for id %u", gMenu.entry, gMenu.text_id);
8048             continue;
8049         }
8050
8051         if (!PlayerCondition::IsValid(cond_2, cond_2_val_1, cond_2_val_2))
8052         {
8053             sLog.outErrorDb("Table gossip_menu entry %u, invalid condition 2 for id %u", gMenu.entry, gMenu.text_id);
8054             continue;
8055         }
8056
8057         gMenu.cond_1 = GetConditionId(cond_1, cond_1_val_1, cond_1_val_2);
8058         gMenu.cond_2 = GetConditionId(cond_2, cond_2_val_1, cond_2_val_2);
8059
8060         m_mGossipMenusMap.insert(GossipMenusMap::value_type(gMenu.entry, gMenu));
8061
8062         ++count;
8063     }
8064     while(result->NextRow());
8065
8066     delete result;
8067
8068     sLog.outString();
8069     sLog.outString( ">> Loaded %u gossip_menu entries", count);
8070 }
8071
8072 void ObjectMgr::LoadGossipMenuItems()
8073 {
8074     m_mGossipMenuItemsMap.clear();
8075
8076     QueryResult *result = WorldDatabase.Query(
8077         "SELECT menu_id, id, option_icon, option_text, option_id, npc_option_npcflag, "
8078         "action_menu_id, action_poi_id, action_script_id, box_coded, box_money, box_text, "
8079         "cond_1, cond_1_val_1, cond_1_val_2, "
8080         "cond_2, cond_2_val_1, cond_2_val_2, "
8081         "cond_3, cond_3_val_1, cond_3_val_2 "
8082         "FROM gossip_menu_option");
8083
8084     if (!result)
8085     {
8086         barGoLink bar(1);
8087
8088         bar.step();
8089
8090         sLog.outString();
8091         sLog.outErrorDb(">> Loaded gossip_menu_option, table is empty!");
8092         return;
8093     }
8094
8095     barGoLink bar(result->GetRowCount());
8096
8097     uint32 count = 0;
8098
8099     std::set<uint32> gossipScriptSet;
8100
8101     for(ScriptMapMap::const_iterator itr = sGossipScripts.begin(); itr != sGossipScripts.end(); ++itr)
8102         gossipScriptSet.insert(itr->first);
8103
8104     do
8105     {
8106         bar.step();
8107
8108         Field* fields = result->Fetch();
8109
8110         GossipMenuItems gMenuItem;
8111
8112         gMenuItem.menu_id               = fields[0].GetUInt32();
8113         gMenuItem.id                    = fields[1].GetUInt32();
8114         gMenuItem.option_icon           = fields[2].GetUInt8();
8115         gMenuItem.option_text           = fields[3].GetCppString();
8116         gMenuItem.option_id             = fields[4].GetUInt32();
8117         gMenuItem.npc_option_npcflag    = fields[5].GetUInt32();
8118         gMenuItem.action_menu_id        = fields[6].GetUInt32();
8119         gMenuItem.action_poi_id         = fields[7].GetUInt32();
8120         gMenuItem.action_script_id      = fields[8].GetUInt32();
8121         gMenuItem.box_coded             = fields[9].GetUInt8() != 0;
8122         gMenuItem.box_money             = fields[10].GetUInt32();
8123         gMenuItem.box_text              = fields[11].GetCppString();
8124
8125         ConditionType cond_1            = (ConditionType)fields[12].GetUInt32();
8126         uint32 cond_1_val_1             = fields[13].GetUInt32();
8127         uint32 cond_1_val_2             = fields[14].GetUInt32();
8128         ConditionType cond_2            = (ConditionType)fields[15].GetUInt32();
8129         uint32 cond_2_val_1             = fields[16].GetUInt32();
8130         uint32 cond_2_val_2             = fields[17].GetUInt32();
8131         ConditionType cond_3            = (ConditionType)fields[18].GetUInt32();
8132         uint32 cond_3_val_1             = fields[19].GetUInt32();
8133         uint32 cond_3_val_2             = fields[20].GetUInt32();
8134
8135         if (!PlayerCondition::IsValid(cond_1, cond_1_val_1, cond_1_val_2))
8136         {
8137             sLog.outErrorDb("Table gossip_menu_option menu %u, invalid condition 1 for id %u", gMenuItem.menu_id, gMenuItem.id);
8138             continue;
8139         }
8140         if (!PlayerCondition::IsValid(cond_2, cond_2_val_1, cond_2_val_2))
8141         {
8142             sLog.outErrorDb("Table gossip_menu_option menu %u, invalid condition 2 for id %u", gMenuItem.menu_id, gMenuItem.id);
8143             continue;
8144         }
8145         if (!PlayerCondition::IsValid(cond_3, cond_3_val_1, cond_3_val_2))
8146         {
8147             sLog.outErrorDb("Table gossip_menu_option menu %u, invalid condition 3 for id %u", gMenuItem.menu_id, gMenuItem.id);
8148             continue;
8149         }
8150
8151         if (gMenuItem.option_icon >= GOSSIP_ICON_MAX)
8152         {
8153             sLog.outErrorDb("Table gossip_menu_option for menu %u, id %u has unknown icon id %u. Replacing with GOSSIP_ICON_CHAT", gMenuItem.menu_id, gMenuItem.id, gMenuItem.option_icon);
8154             gMenuItem.option_icon = GOSSIP_ICON_CHAT;
8155         }
8156
8157         if (gMenuItem.option_id == GOSSIP_OPTION_NONE)
8158             sLog.outErrorDb("Table gossip_menu_option for menu %u, id %u use option id GOSSIP_OPTION_NONE. Option will never be used", gMenuItem.menu_id, gMenuItem.id);
8159
8160         if (gMenuItem.option_id >= GOSSIP_OPTION_MAX)
8161             sLog.outErrorDb("Table gossip_menu_option for menu %u, id %u has unknown option id %u. Option will not be used", gMenuItem.menu_id, gMenuItem.id, gMenuItem.option_id);
8162
8163         if (gMenuItem.action_poi_id && !GetPointOfInterest(gMenuItem.action_poi_id))
8164         {
8165             sLog.outErrorDb("Table gossip_menu_option for menu %u, id %u use non-existing action_poi_id %u, ignoring", gMenuItem.menu_id, gMenuItem.id, gMenuItem.action_poi_id);
8166             gMenuItem.action_poi_id = 0;
8167         }
8168
8169         if (gMenuItem.action_script_id)
8170         {
8171             if (gMenuItem.option_id != GOSSIP_OPTION_GOSSIP)
8172             {
8173                 sLog.outErrorDb("Table gossip_menu_option for menu %u, id %u have action_script_id %u but option_id is not GOSSIP_OPTION_GOSSIP, ignoring", gMenuItem.menu_id, gMenuItem.id, gMenuItem.action_script_id);
8174                 continue;
8175             }
8176
8177             if (sGossipScripts.find(gMenuItem.action_script_id) == sGossipScripts.end())
8178             {
8179                 sLog.outErrorDb("Table gossip_menu_option for menu %u, id %u have action_script_id %u that does not exist in `gossip_scripts`, ignoring", gMenuItem.menu_id, gMenuItem.id, gMenuItem.action_script_id);
8180                 continue;
8181             }
8182
8183             gossipScriptSet.erase(gMenuItem.action_script_id);
8184         }
8185
8186         gMenuItem.cond_1 = GetConditionId(cond_1, cond_1_val_1, cond_1_val_2);
8187         gMenuItem.cond_2 = GetConditionId(cond_2, cond_2_val_1, cond_2_val_2);
8188         gMenuItem.cond_3 = GetConditionId(cond_3, cond_3_val_1, cond_3_val_2);
8189
8190         m_mGossipMenuItemsMap.insert(GossipMenuItemsMap::value_type(gMenuItem.menu_id, gMenuItem));
8191
8192         ++count;
8193
8194     }
8195     while(result->NextRow());
8196
8197     delete result;
8198
8199     if (!gossipScriptSet.empty())
8200     {
8201         for(std::set<uint32>::const_iterator itr = gossipScriptSet.begin(); itr != gossipScriptSet.end(); ++itr)
8202             sLog.outErrorDb("Table `gossip_scripts` contain unused script, id %u.", *itr);
8203     }
8204
8205     sLog.outString();
8206     sLog.outString(">> Loaded %u gossip_menu_option entries", count);
8207 }
8208
8209 void ObjectMgr::AddVendorItem( uint32 entry,uint32 item, uint32 maxcount, uint32 incrtime, uint32 extendedcost )
8210 {
8211     VendorItemData& vList = m_mCacheVendorItemMap[entry];
8212     vList.AddItem(item,maxcount,incrtime,extendedcost);
8213
8214     WorldDatabase.PExecuteLog("INSERT INTO npc_vendor (entry,item,maxcount,incrtime,extendedcost) VALUES('%u','%u','%u','%u','%u')",entry, item, maxcount,incrtime,extendedcost);
8215 }
8216
8217 bool ObjectMgr::RemoveVendorItem( uint32 entry,uint32 item )
8218 {
8219     CacheVendorItemMap::iterator  iter = m_mCacheVendorItemMap.find(entry);
8220     if(iter == m_mCacheVendorItemMap.end())
8221         return false;
8222
8223     if(!iter->second.FindItem(item))
8224         return false;
8225
8226     iter->second.RemoveItem(item);
8227     WorldDatabase.PExecuteLog("DELETE FROM npc_vendor WHERE entry='%u' AND item='%u'",entry, item);
8228     return true;
8229 }
8230
8231 bool ObjectMgr::IsVendorItemValid( uint32 vendor_entry, uint32 item_id, uint32 maxcount, uint32 incrtime, uint32 ExtendedCost, Player* pl, std::set<uint32>* skip_vendors ) const
8232 {
8233     CreatureInfo const* cInfo = GetCreatureTemplate(vendor_entry);
8234     if(!cInfo)
8235     {
8236         if(pl)
8237             ChatHandler(pl).SendSysMessage(LANG_COMMAND_VENDORSELECTION);
8238         else
8239             sLog.outErrorDb("Table `npc_vendor` have data for not existed creature template (Entry: %u), ignore", vendor_entry);
8240         return false;
8241     }
8242
8243     if(!(cInfo->npcflag & UNIT_NPC_FLAG_VENDOR))
8244     {
8245         if(!skip_vendors || skip_vendors->count(vendor_entry)==0)
8246         {
8247             if(pl)
8248                 ChatHandler(pl).SendSysMessage(LANG_COMMAND_VENDORSELECTION);
8249             else
8250                 sLog.outErrorDb("Table `npc_vendor` have data for not creature template (Entry: %u) without vendor flag, ignore", vendor_entry);
8251
8252             if(skip_vendors)
8253                 skip_vendors->insert(vendor_entry);
8254         }
8255         return false;
8256     }
8257
8258     if(!GetItemPrototype(item_id))
8259     {
8260         if(pl)
8261             ChatHandler(pl).PSendSysMessage(LANG_ITEM_NOT_FOUND, item_id);
8262         else
8263             sLog.outErrorDb("Table `npc_vendor` for Vendor (Entry: %u) have in item list non-existed item (%u), ignore",vendor_entry,item_id);
8264         return false;
8265     }
8266
8267     if(ExtendedCost && !sItemExtendedCostStore.LookupEntry(ExtendedCost))
8268     {
8269         if(pl)
8270             ChatHandler(pl).PSendSysMessage(LANG_EXTENDED_COST_NOT_EXIST,ExtendedCost);
8271         else
8272             sLog.outErrorDb("Table `npc_vendor` have Item (Entry: %u) with wrong ExtendedCost (%u) for vendor (%u), ignore",item_id,ExtendedCost,vendor_entry);
8273         return false;
8274     }
8275
8276     if(maxcount > 0 && incrtime == 0)
8277     {
8278         if(pl)
8279             ChatHandler(pl).PSendSysMessage("MaxCount!=0 (%u) but IncrTime==0", maxcount);
8280         else
8281             sLog.outErrorDb( "Table `npc_vendor` has `maxcount` (%u) for item %u of vendor (Entry: %u) but `incrtime`=0, ignore", maxcount, item_id, vendor_entry);
8282         return false;
8283     }
8284     else if(maxcount==0 && incrtime > 0)
8285     {
8286         if(pl)
8287             ChatHandler(pl).PSendSysMessage("MaxCount==0 but IncrTime<>=0");
8288         else
8289             sLog.outErrorDb( "Table `npc_vendor` has `maxcount`=0 for item %u of vendor (Entry: %u) but `incrtime`<>0, ignore", item_id, vendor_entry);
8290         return false;
8291     }
8292
8293     VendorItemData const* vItems = GetNpcVendorItemList(vendor_entry);
8294     if(!vItems)
8295         return true;                                        // later checks for non-empty lists
8296
8297     if(vItems->FindItem(item_id))
8298     {
8299         if(pl)
8300             ChatHandler(pl).PSendSysMessage(LANG_ITEM_ALREADY_IN_LIST,item_id);
8301         else
8302             sLog.outErrorDb( "Table `npc_vendor` has duplicate items %u for vendor (Entry: %u), ignore", item_id, vendor_entry);
8303         return false;
8304     }
8305
8306     if(vItems->GetItemCount() >= MAX_VENDOR_ITEMS)
8307     {
8308         if(pl)
8309             ChatHandler(pl).SendSysMessage(LANG_COMMAND_ADDVENDORITEMITEMS);
8310         else
8311             sLog.outErrorDb( "Table `npc_vendor` has too many items (%u >= %i) for vendor (Entry: %u), ignore", vItems->GetItemCount(), MAX_VENDOR_ITEMS, vendor_entry);
8312         return false;
8313     }
8314
8315     return true;
8316 }
8317
8318 void ObjectMgr::LoadScriptNames()
8319 {
8320     m_scriptNames.push_back("");
8321     QueryResult *result = WorldDatabase.Query(
8322       "SELECT DISTINCT(ScriptName) FROM creature_template WHERE ScriptName <> '' "
8323       "UNION "
8324       "SELECT DISTINCT(ScriptName) FROM gameobject_template WHERE ScriptName <> '' "
8325       "UNION "
8326       "SELECT DISTINCT(ScriptName) FROM item_template WHERE ScriptName <> '' "
8327       "UNION "
8328       "SELECT DISTINCT(ScriptName) FROM areatrigger_scripts WHERE ScriptName <> '' "
8329       "UNION "
8330       "SELECT DISTINCT(script) FROM instance_template WHERE script <> ''");
8331
8332     if( !result )
8333     {
8334         barGoLink bar( 1 );
8335         bar.step();
8336         sLog.outString();
8337         sLog.outErrorDb(">> Loaded empty set of Script Names!");
8338         return;
8339     }
8340
8341     barGoLink bar( result->GetRowCount() );
8342     uint32 count = 0;
8343
8344     do
8345     {
8346         bar.step();
8347         m_scriptNames.push_back((*result)[0].GetString());
8348         ++count;
8349     } while (result->NextRow());
8350     delete result;
8351
8352     std::sort(m_scriptNames.begin(), m_scriptNames.end());
8353     sLog.outString();
8354     sLog.outString( ">> Loaded %d Script Names", count );
8355 }
8356
8357 uint32 ObjectMgr::GetScriptId(const char *name)
8358 {
8359     // use binary search to find the script name in the sorted vector
8360     // assume "" is the first element
8361     if(!name) return 0;
8362     ScriptNameMap::const_iterator itr =
8363         std::lower_bound(m_scriptNames.begin(), m_scriptNames.end(), name);
8364     if(itr == m_scriptNames.end() || *itr != name) return 0;
8365     return itr - m_scriptNames.begin();
8366 }
8367
8368 void ObjectMgr::CheckScripts(ScriptMapMap const& scripts,std::set<int32>& ids)
8369 {
8370     for(ScriptMapMap::const_iterator itrMM = scripts.begin(); itrMM != scripts.end(); ++itrMM)
8371     {
8372         for(ScriptMap::const_iterator itrM = itrMM->second.begin(); itrM != itrMM->second.end(); ++itrM)
8373         {
8374             switch(itrM->second.command)
8375             {
8376                 case SCRIPT_COMMAND_TALK:
8377                 {
8378                     if(!GetMangosStringLocale (itrM->second.dataint))
8379                         sLog.outErrorDb( "Table `db_script_string` is missing string id %u, used in database script id %u.", itrM->second.dataint, itrMM->first);
8380
8381                     if(ids.count(itrM->second.dataint))
8382                         ids.erase(itrM->second.dataint);
8383                 }
8384             }
8385         }
8386     }
8387 }
8388
8389 void ObjectMgr::LoadDbScriptStrings()
8390 {
8391     LoadMangosStrings(WorldDatabase,"db_script_string",MIN_DB_SCRIPT_STRING_ID,MAX_DB_SCRIPT_STRING_ID);
8392
8393     std::set<int32> ids;
8394
8395     for(int32 i = MIN_DB_SCRIPT_STRING_ID; i < MAX_DB_SCRIPT_STRING_ID; ++i)
8396         if(GetMangosStringLocale(i))
8397             ids.insert(i);
8398
8399     CheckScripts(sQuestEndScripts,ids);
8400     CheckScripts(sQuestStartScripts,ids);
8401     CheckScripts(sSpellScripts,ids);
8402     CheckScripts(sGameObjectScripts,ids);
8403     CheckScripts(sEventScripts,ids);
8404     CheckScripts(sGossipScripts,ids);
8405
8406     sWaypointMgr.CheckTextsExistance(ids);
8407
8408     for(std::set<int32>::const_iterator itr = ids.begin(); itr != ids.end(); ++itr)
8409         sLog.outErrorDb( "Table `db_script_string` has unused string id  %u", *itr);
8410 }
8411
8412 // Functions for scripting access
8413 uint32 GetAreaTriggerScriptId(uint32 trigger_id)
8414 {
8415     return sObjectMgr.GetAreaTriggerScriptId(trigger_id);
8416 }
8417
8418 bool LoadMangosStrings(DatabaseType& db, char const* table,int32 start_value, int32 end_value)
8419 {
8420     // MAX_DB_SCRIPT_STRING_ID is max allowed negative value for scripts (scrpts can use only more deep negative values
8421     // start/end reversed for negative values
8422     if (start_value > MAX_DB_SCRIPT_STRING_ID || end_value >= start_value)
8423     {
8424         sLog.outErrorDb("Table '%s' attempt loaded with reserved by mangos range (%d - %d), strings not loaded.",table,start_value,end_value+1);
8425         return false;
8426     }
8427
8428     return sObjectMgr.LoadMangosStrings(db,table,start_value,end_value);
8429 }
8430
8431 uint32 MANGOS_DLL_SPEC GetScriptId(const char *name)
8432 {
8433     return sObjectMgr.GetScriptId(name);
8434 }
8435
8436 ObjectMgr::ScriptNameMap & GetScriptNames()
8437 {
8438     return sObjectMgr.GetScriptNames();
8439 }
8440
8441 CreatureInfo const* GetCreatureTemplateStore(uint32 entry)
8442 {
8443     return sCreatureStorage.LookupEntry<CreatureInfo>(entry);
8444 }
8445
8446 Quest const* GetQuestTemplateStore(uint32 entry)
8447 {
8448     return sObjectMgr.GetQuestTemplate(entry);
8449 }