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