src/game/ObjectMgr.cpp

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