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