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