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