src/game/ObjectMgr.cpp

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