src/game/ObjectMgr.cpp

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