src/game/ObjectMgr.h

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #ifndef _OBJECTMGR_H
  20 #define _OBJECTMGR_H
  21
  22 #include "Log.h"
  23 #include "Object.h"
  24 #include "Bag.h"
  25 #include "Creature.h"
  26 #include "Player.h"
  27 #include "GameObject.h"
  28 #include "Corpse.h"
  29 #include "QuestDef.h"
  30 #include "Path.h"
  31 #include "ItemPrototype.h"
  32 #include "NPCHandler.h"
  33 #include "Database/DatabaseEnv.h"
  34 #include "Mail.h"
  35 #include "Map.h"
  36 #include "ObjectAccessor.h"
  37 #include "ObjectDefines.h"
  38 #include "Policies/Singleton.h"
  39 #include "Database/SQLStorage.h"
  40
  41 #include <string>
  42 #include <map>
  43 #include <limits>
  44
  45 extern SQLStorage sCreatureStorage;
  46 extern SQLStorage sCreatureDataAddonStorage;
  47 extern SQLStorage sCreatureInfoAddonStorage;
  48 extern SQLStorage sCreatureModelStorage;
  49 extern SQLStorage sEquipmentStorage;
  50 extern SQLStorage sGOStorage;
  51 extern SQLStorage sPageTextStore;
  52 extern SQLStorage sItemStorage;
  53 extern SQLStorage sInstanceTemplate;
  54
  55 class Group;
  56 class Guild;
  57 class ArenaTeam;
  58 class Path;
  59 class TransportPath;
  60 class Item;
  61
  62 struct GameTele
  63 {
  64     float  position_x;
  65     float  position_y;
  66     float  position_z;
  67     float  orientation;
  68     uint32 mapId;
  69     std::string name;
  70     std::wstring wnameLow;
  71 };
  72
  73 typedef UNORDERED_MAP<uint32, GameTele > GameTeleMap;
  74
  75 struct ScriptInfo
  76 {
  77     uint32 id;
  78     uint32 delay;
  79     uint32 command;
  80     uint32 datalong;
  81     uint32 datalong2;
  82     int32  dataint;
  83     float x;
  84     float y;
  85     float z;
  86     float o;
  87 };
  88
  89 typedef std::multimap<uint32, ScriptInfo> ScriptMap;
  90 typedef std::map<uint32, ScriptMap > ScriptMapMap;
  91 extern ScriptMapMap sQuestEndScripts;
  92 extern ScriptMapMap sQuestStartScripts;
  93 extern ScriptMapMap sSpellScripts;
  94 extern ScriptMapMap sGameObjectScripts;
  95 extern ScriptMapMap sEventScripts;
  96
  97 struct SpellClickInfo
  98 {
  99     uint32 spellId;
 100     uint32 questStart;                                      // quest start (quest must be active or rewarded for spell apply)
 101     uint32 questEnd;                                        // quest end (quest don't must be rewarded for spell apply)
 102     bool   questStartCanActive;                             // if true then quest start can be active (not only rewarded)
 103     uint8 castFlags;
 104
 105     // helpers
 106     bool IsFitToRequirements(Player const* player) const;
 107 };
 108
 109 typedef std::multimap<uint32, SpellClickInfo> SpellClickInfoMap;
 110 typedef std::pair<SpellClickInfoMap::const_iterator,SpellClickInfoMap::const_iterator> SpellClickInfoMapBounds;
 111
 112 struct AreaTrigger
 113 {
 114     uint8  requiredLevel;
 115     uint32 requiredItem;
 116     uint32 requiredItem2;
 117     uint32 heroicKey;
 118     uint32 heroicKey2;
 119     uint32 requiredQuest;
 120     uint32 requiredQuestHeroic;
 121     std::string requiredFailedText;
 122     uint32 target_mapId;
 123     float  target_X;
 124     float  target_Y;
 125     float  target_Z;
 126     float  target_Orientation;
 127 };
 128
 129 typedef std::set<uint32> CellGuidSet;
 130 typedef std::map<uint32/*player guid*/,uint32/*instance*/> CellCorpseSet;
 131 struct CellObjectGuids
 132 {
 133     CellGuidSet creatures;
 134     CellGuidSet gameobjects;
 135     CellCorpseSet corpses;
 136 };
 137 typedef UNORDERED_MAP<uint32/*cell_id*/,CellObjectGuids> CellObjectGuidsMap;
 138 typedef UNORDERED_MAP<uint32/*(mapid,spawnMode) pair*/,CellObjectGuidsMap> MapObjectGuids;
 139
 140 typedef UNORDERED_MAP<uint64/*(instance,guid) pair*/,time_t> RespawnTimes;
 141
 142
 143 // mangos string ranges
 144 #define MIN_MANGOS_STRING_ID           1                    // 'mangos_string'
 145 #define MAX_MANGOS_STRING_ID           2000000000
 146 #define MIN_DB_SCRIPT_STRING_ID        MAX_MANGOS_STRING_ID // 'db_script_string'
 147 #define MAX_DB_SCRIPT_STRING_ID        2000010000
 148 #define MIN_CREATURE_AI_TEXT_STRING_ID (-1)                 // 'creature_ai_texts'
 149 #define MAX_CREATURE_AI_TEXT_STRING_ID (-1000000)
 150
 151 struct MangosStringLocale
 152 {
 153     std::vector<std::string> Content;                       // 0 -> default, i -> i-1 locale index
 154 };
 155
 156 typedef UNORDERED_MAP<uint32,CreatureData> CreatureDataMap;
 157 typedef UNORDERED_MAP<uint32,GameObjectData> GameObjectDataMap;
 158 typedef UNORDERED_MAP<uint32,CreatureLocale> CreatureLocaleMap;
 159 typedef UNORDERED_MAP<uint32,GameObjectLocale> GameObjectLocaleMap;
 160 typedef UNORDERED_MAP<uint32,ItemLocale> ItemLocaleMap;
 161 typedef UNORDERED_MAP<uint32,QuestLocale> QuestLocaleMap;
 162 typedef UNORDERED_MAP<uint32,NpcTextLocale> NpcTextLocaleMap;
 163 typedef UNORDERED_MAP<uint32,PageTextLocale> PageTextLocaleMap;
 164 typedef UNORDERED_MAP<int32,MangosStringLocale> MangosStringLocaleMap;
 165 typedef UNORDERED_MAP<uint32,NpcOptionLocale> NpcOptionLocaleMap;
 166 typedef UNORDERED_MAP<uint32,PointOfInterestLocale> PointOfInterestLocaleMap;
 167
 168 typedef std::multimap<uint32,uint32> QuestRelations;
 169 typedef std::multimap<uint32,ItemRequiredTarget> ItemRequiredTargetMap;
 170 typedef std::pair<ItemRequiredTargetMap::const_iterator, ItemRequiredTargetMap::const_iterator>  ItemRequiredTargetMapBounds;
 171
 172 struct PetLevelInfo
 173 {
 174     PetLevelInfo() : health(0), mana(0) { for(int i=0; i < MAX_STATS; ++i ) stats[i] = 0; }
 175
 176     uint16 stats[MAX_STATS];
 177     uint16 health;
 178     uint16 mana;
 179     uint16 armor;
 180 };
 181
 182 struct ReputationOnKillEntry
 183 {
 184     uint32 repfaction1;
 185     uint32 repfaction2;
 186     bool is_teamaward1;
 187     uint32 reputation_max_cap1;
 188     int32 repvalue1;
 189     bool is_teamaward2;
 190     uint32 reputation_max_cap2;
 191     int32 repvalue2;
 192     bool team_dependent;
 193 };
 194
 195 struct PointOfInterest
 196 {
 197     uint32 entry;
 198     float x;
 199     float y;
 200     uint32 icon;
 201     uint32 flags;
 202     uint32 data;
 203     std::string icon_name;
 204 };
 205
 206 #define WEATHER_SEASONS 4
 207 struct WeatherSeasonChances
 208 {
 209     uint32 rainChance;
 210     uint32 snowChance;
 211     uint32 stormChance;
 212 };
 213
 214 struct WeatherZoneChances
 215 {
 216     WeatherSeasonChances data[WEATHER_SEASONS];
 217 };
 218
 219 struct GraveYardData
 220 {
 221     uint32 safeLocId;
 222     uint32 team;
 223 };
 224 typedef std::multimap<uint32,GraveYardData> GraveYardMap;
 225
 226 enum ConditionType
 227 {                                                           // value1       value2  for the Condition enumed
 228     CONDITION_NONE                  = 0,                    // 0            0
 229     CONDITION_AURA                  = 1,                    // spell_id     effindex
 230     CONDITION_ITEM                  = 2,                    // item_id      count
 231     CONDITION_ITEM_EQUIPPED         = 3,                    // item_id      0
 232     CONDITION_ZONEID                = 4,                    // zone_id      0
 233     CONDITION_REPUTATION_RANK       = 5,                    // faction_id   min_rank
 234     CONDITION_TEAM                  = 6,                    // player_team  0,      (469 - Alliance 67 - Horde)
 235     CONDITION_SKILL                 = 7,                    // skill_id     skill_value
 236     CONDITION_QUESTREWARDED         = 8,                    // quest_id     0
 237     CONDITION_QUESTTAKEN            = 9,                    // quest_id     0,      for condition true while quest active.
 238     CONDITION_AD_COMMISSION_AURA    = 10,                   // 0            0,      for condition true while one from AD commission aura active
 239     CONDITION_NO_AURA               = 11,                   // spell_id     effindex
 240     CONDITION_ACTIVE_EVENT          = 12,                   // event_id
 241 };
 242
 243 #define MAX_CONDITION                 13                    // maximum value in ConditionType enum
 244
 245 struct PlayerCondition
 246 {
 247     ConditionType condition;                                // additional condition type
 248     uint32  value1;                                         // data for the condition - see ConditionType definition
 249     uint32  value2;
 250
 251     PlayerCondition(uint8 _condition = 0, uint32 _value1 = 0, uint32 _value2 = 0)
 252         : condition(ConditionType(_condition)), value1(_value1), value2(_value2) {}
 253
 254     static bool IsValid(ConditionType condition, uint32 value1, uint32 value2);
 255     // Checks correctness of values
 256     bool Meets(Player const * APlayer) const;               // Checks if the player meets the condition
 257     bool operator == (PlayerCondition const& lc) const
 258     {
 259         return (lc.condition == condition && lc.value1 == value1 && lc.value2 == value2);
 260     }
 261 };
 262
 263 // NPC gossip text id
 264 typedef UNORDERED_MAP<uint32, uint32> CacheNpcTextIdMap;
 265 typedef std::list<GossipOption> CacheNpcOptionList;
 266
 267 typedef UNORDERED_MAP<uint32, VendorItemData> CacheVendorItemMap;
 268 typedef UNORDERED_MAP<uint32, TrainerSpellData> CacheTrainerSpellMap;
 269
 270 enum SkillRangeType
 271 {
 272     SKILL_RANGE_LANGUAGE,                                   // 300..300
 273     SKILL_RANGE_LEVEL,                                      // 1..max skill for level
 274     SKILL_RANGE_MONO,                                       // 1..1, grey monolite bar
 275     SKILL_RANGE_RANK,                                       // 1..skill for known rank
 276     SKILL_RANGE_NONE,                                       // 0..0 always
 277 };
 278
 279 SkillRangeType GetSkillRangeType(SkillLineEntry const *pSkill, bool racial);
 280
 281 #define MAX_PLAYER_NAME          12                         // max allowed by client name length
 282 #define MAX_INTERNAL_PLAYER_NAME 15                         // max server internal player name length ( > MAX_PLAYER_NAME for support declined names )
 283 #define MAX_PET_NAME             12                         // max allowed by client name length
 284 #define MAX_CHARTER_NAME         24                         // max allowed by client name length
 285
 286 bool normalizePlayerName(std::string& name);
 287
 288 struct MANGOS_DLL_SPEC LanguageDesc
 289 {
 290     Language lang_id;
 291     uint32   spell_id;
 292     uint32   skill_id;
 293 };
 294
 295 extern LanguageDesc lang_description[LANGUAGES_COUNT];
 296 MANGOS_DLL_SPEC LanguageDesc const* GetLanguageDescByID(uint32 lang);
 297
 298 class PlayerDumpReader;
 299
 300 class ObjectMgr
 301 {
 302     friend class PlayerDumpReader;
 303
 304     public:
 305         ObjectMgr();
 306         ~ObjectMgr();
 307
 308         typedef UNORDERED_MAP<uint32, Item*> ItemMap;
 309
 310         typedef std::set< Group * > GroupSet;
 311
 312         typedef UNORDERED_MAP<uint32, Guild *> GuildMap;
 313
 314         typedef UNORDERED_MAP<uint32, ArenaTeam*> ArenaTeamMap;
 315
 316         typedef UNORDERED_MAP<uint32, Quest*> QuestMap;
 317
 318         typedef UNORDERED_MAP<uint32, AreaTrigger> AreaTriggerMap;
 319
 320         typedef UNORDERED_MAP<uint32, uint32> AreaTriggerScriptMap;
 321
 322         typedef UNORDERED_MAP<uint32, ReputationOnKillEntry> RepOnKillMap;
 323         typedef UNORDERED_MAP<uint32, PointOfInterest> PointOfInterestMap;
 324
 325         typedef UNORDERED_MAP<uint32, WeatherZoneChances> WeatherZoneMap;
 326
 327         typedef std::vector<std::string> ScriptNameMap;
 328
 329         Player* GetPlayer(const char* name) const { return ObjectAccessor::Instance().FindPlayerByName(name);}
 330         Player* GetPlayer(uint64 guid) const { return ObjectAccessor::FindPlayer(guid); }
 331
 332         static GameObjectInfo const *GetGameObjectInfo(uint32 id) { return sGOStorage.LookupEntry<GameObjectInfo>(id); }
 333
 334         void LoadGameobjectInfo();
 335         void AddGameobjectInfo(GameObjectInfo *goinfo);
 336
 337         Group * GetGroupByLeader(const uint64 &guid) const;
 338         void AddGroup(Group* group) { mGroupSet.insert( group ); }
 339         void RemoveGroup(Group* group) { mGroupSet.erase( group ); }
 340
 341         Guild* GetGuildByLeader(uint64 const&guid) const;
 342         Guild* GetGuildById(uint32 GuildId) const;
 343         Guild* GetGuildByName(const std::string& guildname) const;
 344         std::string GetGuildNameById(uint32 GuildId) const;
 345         void AddGuild(Guild* guild);
 346         void RemoveGuild(uint32 Id);
 347
 348         ArenaTeam* GetArenaTeamById(uint32 arenateamid) const;
 349         ArenaTeam* GetArenaTeamByName(const std::string& arenateamname) const;
 350         ArenaTeam* GetArenaTeamByCaptain(uint64 const& guid) const;
 351         void AddArenaTeam(ArenaTeam* arenaTeam);
 352         void RemoveArenaTeam(uint32 Id);
 353         ArenaTeamMap::iterator GetArenaTeamMapBegin() { return mArenaTeamMap.begin(); }
 354         ArenaTeamMap::iterator GetArenaTeamMapEnd()   { return mArenaTeamMap.end(); }
 355
 356         static CreatureInfo const *GetCreatureTemplate( uint32 id );
 357         CreatureModelInfo const *GetCreatureModelInfo( uint32 modelid );
 358         CreatureModelInfo const* GetCreatureModelRandomGender(uint32 display_id);
 359         uint32 ChooseDisplayId(uint32 team, const CreatureInfo *cinfo, const CreatureData *data = NULL);
 360         EquipmentInfo const *GetEquipmentInfo( uint32 entry );
 361         static CreatureDataAddon const *GetCreatureAddon( uint32 lowguid )
 362         {
 363             return sCreatureDataAddonStorage.LookupEntry<CreatureDataAddon>(lowguid);
 364         }
 365
 366         static CreatureDataAddon const *GetCreatureTemplateAddon( uint32 entry )
 367         {
 368             return sCreatureInfoAddonStorage.LookupEntry<CreatureDataAddon>(entry);
 369         }
 370
 371         static ItemPrototype const* GetItemPrototype(uint32 id) { return sItemStorage.LookupEntry<ItemPrototype>(id); }
 372
 373         static InstanceTemplate const* GetInstanceTemplate(uint32 map)
 374         {
 375             return sInstanceTemplate.LookupEntry<InstanceTemplate>(map);
 376         }
 377
 378         PetLevelInfo const* GetPetLevelInfo(uint32 creature_id, uint32 level) const;
 379
 380         PlayerClassInfo const* GetPlayerClassInfo(uint32 class_) const
 381         {
 382             if(class_ >= MAX_CLASSES) return NULL;
 383             return &playerClassInfo[class_];
 384         }
 385         void GetPlayerClassLevelInfo(uint32 class_,uint32 level, PlayerClassLevelInfo* info) const;
 386
 387         PlayerInfo const* GetPlayerInfo(uint32 race, uint32 class_) const
 388         {
 389             if(race   >= MAX_RACES)   return NULL;
 390             if(class_ >= MAX_CLASSES) return NULL;
 391             PlayerInfo const* info = &playerInfo[race][class_];
 392             if(info->displayId_m==0 || info->displayId_f==0) return NULL;
 393             return info;
 394         }
 395         void GetPlayerLevelInfo(uint32 race, uint32 class_,uint32 level, PlayerLevelInfo* info) const;
 396
 397         uint64 GetPlayerGUIDByName(std::string name) const;
 398         bool GetPlayerNameByGUID(const uint64 &guid, std::string &name) const;
 399         uint32 GetPlayerTeamByGUID(const uint64 &guid) const;
 400         uint32 GetPlayerAccountIdByGUID(const uint64 &guid) const;
 401         uint32 GetPlayerAccountIdByPlayerName(const std::string& name) const;
 402
 403         uint32 GetNearestTaxiNode( float x, float y, float z, uint32 mapid, uint32 team );
 404         void GetTaxiPath( uint32 source, uint32 destination, uint32 &path, uint32 &cost);
 405         uint32 GetTaxiMountDisplayId( uint32 id, uint32 team, bool allowed_alt_team = false);
 406         void GetTaxiPathNodes( uint32 path, Path &pathnodes, std::vector<uint32>& mapIds );
 407         void GetTransportPathNodes( uint32 path, TransportPath &pathnodes );
 408
 409         Quest const* GetQuestTemplate(uint32 quest_id) const
 410         {
 411             QuestMap::const_iterator itr = mQuestTemplates.find(quest_id);
 412             return itr != mQuestTemplates.end() ? itr->second : NULL;
 413         }
 414         QuestMap const& GetQuestTemplates() const { return mQuestTemplates; }
 415
 416         uint32 GetQuestForAreaTrigger(uint32 Trigger_ID) const
 417         {
 418             QuestAreaTriggerMap::const_iterator itr = mQuestAreaTriggerMap.find(Trigger_ID);
 419             if(itr != mQuestAreaTriggerMap.end())
 420                 return itr->second;
 421             return 0;
 422         }
 423         bool IsTavernAreaTrigger(uint32 Trigger_ID) const
 424         {
 425             return mTavernAreaTriggerSet.find(Trigger_ID) != mTavernAreaTriggerSet.end();
 426         }
 427
 428         bool IsGameObjectForQuests(uint32 entry) const
 429         {
 430             return mGameObjectForQuestSet.find(entry) != mGameObjectForQuestSet.end();
 431         }
 432
 433         GossipText const* GetGossipText(uint32 Text_ID) const;
 434
 435         WorldSafeLocsEntry const *GetClosestGraveYard(float x, float y, float z, uint32 MapId, uint32 team);
 436         bool AddGraveYardLink(uint32 id, uint32 zone, uint32 team, bool inDB = true);
 437         void LoadGraveyardZones();
 438         GraveYardData const* FindGraveYardData(uint32 id, uint32 zone);
 439
 440         AreaTrigger const* GetAreaTrigger(uint32 trigger) const
 441         {
 442             AreaTriggerMap::const_iterator itr = mAreaTriggers.find( trigger );
 443             if( itr != mAreaTriggers.end( ) )
 444                 return &itr->second;
 445             return NULL;
 446         }
 447
 448         AreaTrigger const* GetGoBackTrigger(uint32 Map) const;
 449         AreaTrigger const* GetMapEntranceTrigger(uint32 Map) const;
 450
 451         uint32 GetAreaTriggerScriptId(uint32 trigger_id);
 452
 453         ReputationOnKillEntry const* GetReputationOnKilEntry(uint32 id) const
 454         {
 455             RepOnKillMap::const_iterator itr = mRepOnKill.find(id);
 456             if(itr != mRepOnKill.end())
 457                 return &itr->second;
 458             return NULL;
 459         }
 460
 461         PointOfInterest const* GetPointOfInterest(uint32 id) const
 462         {
 463             PointOfInterestMap::const_iterator itr = mPointsOfInterest.find(id);
 464             if(itr != mPointsOfInterest.end())
 465                 return &itr->second;
 466             return NULL;
 467         }
 468
 469         void LoadGuilds();
 470         void LoadArenaTeams();
 471         void LoadGroups();
 472         void LoadQuests();
 473         void LoadQuestRelations()
 474         {
 475             LoadGameobjectQuestRelations();
 476             LoadGameobjectInvolvedRelations();
 477             LoadCreatureQuestRelations();
 478             LoadCreatureInvolvedRelations();
 479         }
 480         void LoadGameobjectQuestRelations();
 481         void LoadGameobjectInvolvedRelations();
 482         void LoadCreatureQuestRelations();
 483         void LoadCreatureInvolvedRelations();
 484
 485         QuestRelations mGOQuestRelations;
 486         QuestRelations mGOQuestInvolvedRelations;
 487         QuestRelations mCreatureQuestRelations;
 488         QuestRelations mCreatureQuestInvolvedRelations;
 489
 490         void LoadGameObjectScripts();
 491         void LoadQuestEndScripts();
 492         void LoadQuestStartScripts();
 493         void LoadEventScripts();
 494         void LoadSpellScripts();
 495
 496         bool LoadMangosStrings(DatabaseType& db, char const* table, int32 min_value, int32 max_value);
 497         bool LoadMangosStrings() { return LoadMangosStrings(WorldDatabase,"mangos_string",MIN_MANGOS_STRING_ID,MAX_MANGOS_STRING_ID); }
 498         void LoadDbScriptStrings();
 499         void LoadCreatureLocales();
 500         void LoadCreatureTemplates();
 501         void LoadCreatures();
 502         void LoadCreatureRespawnTimes();
 503         void LoadCreatureAddons();
 504         void LoadCreatureModelInfo();
 505         void LoadEquipmentTemplates();
 506         void LoadGameObjectLocales();
 507         void LoadGameobjects();
 508         void LoadGameobjectRespawnTimes();
 509         void LoadItemPrototypes();
 510         void LoadItemRequiredTarget();
 511         void LoadItemLocales();
 512         void LoadQuestLocales();
 513         void LoadNpcTextLocales();
 514         void LoadPageTextLocales();
 515         void LoadNpcOptionLocales();
 516         void LoadPointOfInterestLocales();
 517         void LoadInstanceTemplate();
 518
 519         void LoadGossipText();
 520
 521         void LoadAreaTriggerTeleports();
 522         void LoadQuestAreaTriggers();
 523         void LoadAreaTriggerScripts();
 524         void LoadTavernAreaTriggers();
 525         void LoadGameObjectForQuests();
 526
 527         void LoadItemTexts();
 528         void LoadPageTexts();
 529
 530         void LoadPlayerInfo();
 531         void LoadPetLevelInfo();
 532         void LoadExplorationBaseXP();
 533         void LoadPetNames();
 534         void LoadPetNumber();
 535         void LoadCorpses();
 536         void LoadFishingBaseSkillLevel();
 537
 538         void LoadReputationOnKill();
 539         void LoadPointsOfInterest();
 540
 541         void LoadNPCSpellClickSpells();
 542
 543         void LoadWeatherZoneChances();
 544         void LoadGameTele();
 545
 546         void LoadNpcOptions();
 547         void LoadNpcTextId();
 548         void LoadVendors();
 549         void LoadTrainerSpell();
 550
 551         std::string GeneratePetName(uint32 entry);
 552         uint32 GetBaseXP(uint32 level);
 553         uint32 GetXPForLevel(uint32 level);
 554
 555         int32 GetFishingBaseSkillLevel(uint32 entry) const
 556         {
 557             FishingBaseSkillMap::const_iterator itr = mFishingBaseForArea.find(entry);
 558             return itr != mFishingBaseForArea.end() ? itr->second : 0;
 559         }
 560
 561         void ReturnOrDeleteOldMails(bool serverUp);
 562
 563         void SetHighestGuids();
 564         uint32 GenerateLowGuid(HighGuid guidhigh);
 565         uint32 GenerateArenaTeamId();
 566         uint32 GenerateAuctionID();
 567         uint64 GenerateEquipmentSetGuid();
 568         uint32 GenerateGuildId();
 569         uint32 GenerateItemTextID();
 570         uint32 GenerateMailID();
 571         uint32 GeneratePetNumber();
 572
 573         uint32 CreateItemText(std::string text);
 574         void AddItemText(uint32 itemTextId, std::string text) { mItemTexts[itemTextId] = text; }
 575         std::string GetItemText( uint32 id )
 576         {
 577             ItemTextMap::const_iterator itr = mItemTexts.find( id );
 578             if ( itr != mItemTexts.end() )
 579                 return itr->second;
 580             else
 581                 return "There is no info for this item";
 582         }
 583
 584         typedef std::multimap<int32, uint32> ExclusiveQuestGroups;
 585         ExclusiveQuestGroups mExclusiveQuestGroups;
 586
 587         WeatherZoneChances const* GetWeatherChances(uint32 zone_id) const
 588         {
 589             WeatherZoneMap::const_iterator itr = mWeatherZoneMap.find(zone_id);
 590             if(itr != mWeatherZoneMap.end())
 591                 return &itr->second;
 592             else
 593                 return NULL;
 594         }
 595
 596         CellObjectGuids const& GetCellObjectGuids(uint16 mapid, uint8 spawnMode, uint32 cell_id)
 597         {
 598             return mMapObjectGuids[MAKE_PAIR32(mapid,spawnMode)][cell_id];
 599         }
 600
 601         CreatureData const* GetCreatureData(uint32 guid) const
 602         {
 603             CreatureDataMap::const_iterator itr = mCreatureDataMap.find(guid);
 604             if(itr==mCreatureDataMap.end()) return NULL;
 605             return &itr->second;
 606         }
 607         CreatureData& NewOrExistCreatureData(uint32 guid) { return mCreatureDataMap[guid]; }
 608         void DeleteCreatureData(uint32 guid);
 609         CreatureLocale const* GetCreatureLocale(uint32 entry) const
 610         {
 611             CreatureLocaleMap::const_iterator itr = mCreatureLocaleMap.find(entry);
 612             if(itr==mCreatureLocaleMap.end()) return NULL;
 613             return &itr->second;
 614         }
 615         GameObjectLocale const* GetGameObjectLocale(uint32 entry) const
 616         {
 617             GameObjectLocaleMap::const_iterator itr = mGameObjectLocaleMap.find(entry);
 618             if(itr==mGameObjectLocaleMap.end()) return NULL;
 619             return &itr->second;
 620         }
 621         ItemLocale const* GetItemLocale(uint32 entry) const
 622         {
 623             ItemLocaleMap::const_iterator itr = mItemLocaleMap.find(entry);
 624             if(itr==mItemLocaleMap.end()) return NULL;
 625             return &itr->second;
 626         }
 627         QuestLocale const* GetQuestLocale(uint32 entry) const
 628         {
 629             QuestLocaleMap::const_iterator itr = mQuestLocaleMap.find(entry);
 630             if(itr==mQuestLocaleMap.end()) return NULL;
 631             return &itr->second;
 632         }
 633         NpcTextLocale const* GetNpcTextLocale(uint32 entry) const
 634         {
 635             NpcTextLocaleMap::const_iterator itr = mNpcTextLocaleMap.find(entry);
 636             if(itr==mNpcTextLocaleMap.end()) return NULL;
 637             return &itr->second;
 638         }
 639         PageTextLocale const* GetPageTextLocale(uint32 entry) const
 640         {
 641             PageTextLocaleMap::const_iterator itr = mPageTextLocaleMap.find(entry);
 642             if(itr==mPageTextLocaleMap.end()) return NULL;
 643             return &itr->second;
 644         }
 645         NpcOptionLocale const* GetNpcOptionLocale(uint32 entry) const
 646         {
 647             NpcOptionLocaleMap::const_iterator itr = mNpcOptionLocaleMap.find(entry);
 648             if(itr==mNpcOptionLocaleMap.end()) return NULL;
 649             return &itr->second;
 650         }
 651         PointOfInterestLocale const* GetPointOfInterestLocale(uint32 poi_id) const
 652         {
 653             PointOfInterestLocaleMap::const_iterator itr = mPointOfInterestLocaleMap.find(poi_id);
 654             if(itr==mPointOfInterestLocaleMap.end()) return NULL;
 655             return &itr->second;
 656         }
 657
 658         GameObjectData const* GetGOData(uint32 guid) const
 659         {
 660             GameObjectDataMap::const_iterator itr = mGameObjectDataMap.find(guid);
 661             if(itr==mGameObjectDataMap.end()) return NULL;
 662             return &itr->second;
 663         }
 664         GameObjectData& NewGOData(uint32 guid) { return mGameObjectDataMap[guid]; }
 665         void DeleteGOData(uint32 guid);
 666
 667         MangosStringLocale const* GetMangosStringLocale(int32 entry) const
 668         {
 669             MangosStringLocaleMap::const_iterator itr = mMangosStringLocaleMap.find(entry);
 670             if(itr==mMangosStringLocaleMap.end()) return NULL;
 671             return &itr->second;
 672         }
 673         const char *GetMangosString(int32 entry, int locale_idx) const;
 674         const char *GetMangosStringForDBCLocale(int32 entry) const { return GetMangosString(entry,DBCLocaleIndex); }
 675         int32 GetDBCLocaleIndex() const { return DBCLocaleIndex; }
 676         void SetDBCLocaleIndex(uint32 lang) { DBCLocaleIndex = GetIndexForLocale(LocaleConstant(lang)); }
 677
 678         void AddCorpseCellData(uint32 mapid, uint32 cellid, uint32 player_guid, uint32 instance);
 679         void DeleteCorpseCellData(uint32 mapid, uint32 cellid, uint32 player_guid);
 680
 681         time_t GetCreatureRespawnTime(uint32 loguid, uint32 instance) { return mCreatureRespawnTimes[MAKE_PAIR64(loguid,instance)]; }
 682         void SaveCreatureRespawnTime(uint32 loguid, uint32 instance, time_t t);
 683         time_t GetGORespawnTime(uint32 loguid, uint32 instance) { return mGORespawnTimes[MAKE_PAIR64(loguid,instance)]; }
 684         void SaveGORespawnTime(uint32 loguid, uint32 instance, time_t t);
 685         void DeleteRespawnTimeForInstance(uint32 instance);
 686
 687         // grid objects
 688         void AddCreatureToGrid(uint32 guid, CreatureData const* data);
 689         void RemoveCreatureFromGrid(uint32 guid, CreatureData const* data);
 690         void AddGameobjectToGrid(uint32 guid, GameObjectData const* data);
 691         void RemoveGameobjectFromGrid(uint32 guid, GameObjectData const* data);
 692
 693         // reserved names
 694         void LoadReservedPlayersNames();
 695         bool IsReservedName(const std::string& name) const;
 696
 697         // name with valid structure and symbols
 698         static uint8 CheckPlayerName( const std::string& name, bool create = false );
 699         static PetNameInvalidReason CheckPetName( const std::string& name );
 700         static bool IsValidCharterName( const std::string& name );
 701
 702         static bool CheckDeclinedNames(std::wstring mainpart, DeclinedName const& names);
 703
 704         int GetIndexForLocale(LocaleConstant loc);
 705         LocaleConstant GetLocaleForIndex(int i);
 706
 707         uint16 GetConditionId(ConditionType condition, uint32 value1, uint32 value2);
 708         bool IsPlayerMeetToCondition(Player const* player, uint16 condition_id) const
 709         {
 710             if(condition_id >= mConditions.size())
 711                 return false;
 712
 713             return mConditions[condition_id].Meets(player);
 714         }
 715
 716         GameTele const* GetGameTele(uint32 id) const
 717         {
 718             GameTeleMap::const_iterator itr = m_GameTeleMap.find(id);
 719             if(itr==m_GameTeleMap.end()) return NULL;
 720             return &itr->second;
 721         }
 722         GameTele const* GetGameTele(const std::string& name) const;
 723         GameTeleMap const& GetGameTeleMap() const { return m_GameTeleMap; }
 724         bool AddGameTele(GameTele& data);
 725         bool DeleteGameTele(const std::string& name);
 726
 727         CacheNpcOptionList const& GetNpcOptions() const { return m_mCacheNpcOptionList; }
 728
 729         uint32 GetNpcGossip(uint32 entry) const
 730         {
 731             CacheNpcTextIdMap::const_iterator iter = m_mCacheNpcTextIdMap.find(entry);
 732             if(iter == m_mCacheNpcTextIdMap.end())
 733                 return 0;
 734
 735             return iter->second;
 736         }
 737
 738         TrainerSpellData const* GetNpcTrainerSpells(uint32 entry) const
 739         {
 740             CacheTrainerSpellMap::const_iterator  iter = m_mCacheTrainerSpellMap.find(entry);
 741             if(iter == m_mCacheTrainerSpellMap.end())
 742                 return NULL;
 743
 744             return &iter->second;
 745         }
 746
 747         VendorItemData const* GetNpcVendorItemList(uint32 entry) const
 748         {
 749             CacheVendorItemMap::const_iterator  iter = m_mCacheVendorItemMap.find(entry);
 750             if(iter == m_mCacheVendorItemMap.end())
 751                 return NULL;
 752
 753             return &iter->second;
 754         }
 755         void AddVendorItem(uint32 entry,uint32 item, uint32 maxcount, uint32 incrtime, uint32 ExtendedCost);
 756         bool RemoveVendorItem(uint32 entry,uint32 item);
 757         bool IsVendorItemValid( uint32 vendor_entry, uint32 item, uint32 maxcount, uint32 ptime, uint32 ExtendedCost, Player* pl = NULL, std::set<uint32>* skip_vendors = NULL ) const;
 758
 759         void LoadScriptNames();
 760         ScriptNameMap &GetScriptNames() { return m_scriptNames; }
 761         const char * GetScriptName(uint32 id) { return id < m_scriptNames.size() ? m_scriptNames[id].c_str() : ""; }
 762         uint32 GetScriptId(const char *name);
 763
 764         int GetOrNewIndexForLocale(LocaleConstant loc);
 765
 766         SpellClickInfoMapBounds GetSpellClickInfoMapBounds(uint32 creature_id) const
 767         {
 768             return SpellClickInfoMapBounds(mSpellClickInfoMap.lower_bound(creature_id),mSpellClickInfoMap.upper_bound(creature_id));
 769         }
 770
 771         ItemRequiredTargetMapBounds GetItemRequiredTargetMapBounds(uint32 uiItemEntry) const
 772         {
 773             return ItemRequiredTargetMapBounds(m_ItemRequiredTarget.lower_bound(uiItemEntry),m_ItemRequiredTarget.upper_bound(uiItemEntry));
 774         }
 775
 776     protected:
 777
 778         // first free id for selected id type
 779         uint32 m_arenaTeamId;
 780         uint32 m_auctionid;
 781         uint64 m_equipmentSetGuid;
 782         uint32 m_guildId;
 783         uint32 m_ItemTextId;
 784         uint32 m_mailid;
 785         uint32 m_hiPetNumber;
 786
 787         // first free low guid for seelcted guid type
 788         uint32 m_hiCharGuid;
 789         uint32 m_hiCreatureGuid;
 790         uint32 m_hiItemGuid;
 791         uint32 m_hiGoGuid;
 792         uint32 m_hiCorpseGuid;
 793
 794         QuestMap            mQuestTemplates;
 795
 796         typedef UNORDERED_MAP<uint32, GossipText> GossipTextMap;
 797         typedef UNORDERED_MAP<uint32, uint32> QuestAreaTriggerMap;
 798         typedef UNORDERED_MAP<uint32, std::string> ItemTextMap;
 799         typedef std::set<uint32> TavernAreaTriggerSet;
 800         typedef std::set<uint32> GameObjectForQuestSet;
 801
 802         GroupSet            mGroupSet;
 803         GuildMap            mGuildMap;
 804         ArenaTeamMap        mArenaTeamMap;
 805
 806         ItemTextMap         mItemTexts;
 807
 808         QuestAreaTriggerMap mQuestAreaTriggerMap;
 809         TavernAreaTriggerSet mTavernAreaTriggerSet;
 810         GameObjectForQuestSet mGameObjectForQuestSet;
 811         GossipTextMap       mGossipText;
 812         AreaTriggerMap      mAreaTriggers;
 813         AreaTriggerScriptMap  mAreaTriggerScripts;
 814
 815         RepOnKillMap        mRepOnKill;
 816
 817         PointOfInterestMap mPointsOfInterest;
 818
 819         WeatherZoneMap      mWeatherZoneMap;
 820
 821         //character reserved names
 822         typedef std::set<std::wstring> ReservedNamesMap;
 823         ReservedNamesMap    m_ReservedNames;
 824
 825         GraveYardMap        mGraveYardMap;
 826
 827         GameTeleMap         m_GameTeleMap;
 828
 829         ScriptNameMap       m_scriptNames;
 830
 831         SpellClickInfoMap   mSpellClickInfoMap;
 832
 833         ItemRequiredTargetMap m_ItemRequiredTarget;
 834
 835         typedef             std::vector<LocaleConstant> LocalForIndex;
 836         LocalForIndex        m_LocalForIndex;
 837
 838         int DBCLocaleIndex;
 839
 840     private:
 841         void LoadScripts(ScriptMapMap& scripts, char const* tablename);
 842         void CheckScripts(ScriptMapMap const& scripts,std::set<int32>& ids);
 843         void LoadCreatureAddons(SQLStorage& creatureaddons, char const* entryName, char const* comment);
 844         void ConvertCreatureAddonAuras(CreatureDataAddon* addon, char const* table, char const* guidEntryStr);
 845         void LoadQuestRelationsHelper(QuestRelations& map,char const* table);
 846
 847         typedef std::map<uint32,PetLevelInfo*> PetLevelInfoMap;
 848         // PetLevelInfoMap[creature_id][level]
 849         PetLevelInfoMap petInfo;                            // [creature_id][level]
 850
 851         PlayerClassInfo playerClassInfo[MAX_CLASSES];
 852
 853         void BuildPlayerLevelInfo(uint8 race, uint8 class_, uint8 level, PlayerLevelInfo* plinfo) const;
 854         PlayerInfo playerInfo[MAX_RACES][MAX_CLASSES];
 855
 856         typedef std::vector<uint32> PlayerXPperLevel;       // [level]
 857         PlayerXPperLevel mPlayerXPperLevel;
 858
 859         typedef std::map<uint32,uint32> BaseXPMap;          // [area level][base xp]
 860         BaseXPMap mBaseXPTable;
 861
 862         typedef std::map<uint32,int32> FishingBaseSkillMap; // [areaId][base skill level]
 863         FishingBaseSkillMap mFishingBaseForArea;
 864
 865         typedef std::map<uint32,std::vector<std::string> > HalfNameMap;
 866         HalfNameMap PetHalfName0;
 867         HalfNameMap PetHalfName1;
 868
 869         MapObjectGuids mMapObjectGuids;
 870         CreatureDataMap mCreatureDataMap;
 871         CreatureLocaleMap mCreatureLocaleMap;
 872         GameObjectDataMap mGameObjectDataMap;
 873         GameObjectLocaleMap mGameObjectLocaleMap;
 874         ItemLocaleMap mItemLocaleMap;
 875         QuestLocaleMap mQuestLocaleMap;
 876         NpcTextLocaleMap mNpcTextLocaleMap;
 877         PageTextLocaleMap mPageTextLocaleMap;
 878         MangosStringLocaleMap mMangosStringLocaleMap;
 879         NpcOptionLocaleMap mNpcOptionLocaleMap;
 880         PointOfInterestLocaleMap mPointOfInterestLocaleMap;
 881         RespawnTimes mCreatureRespawnTimes;
 882         RespawnTimes mGORespawnTimes;
 883
 884         // Storage for Conditions. First element (index 0) is reserved for zero-condition (nothing required)
 885         typedef std::vector<PlayerCondition> ConditionStore;
 886         ConditionStore mConditions;
 887
 888         CacheNpcOptionList m_mCacheNpcOptionList;
 889         CacheNpcTextIdMap m_mCacheNpcTextIdMap;
 890         CacheVendorItemMap m_mCacheVendorItemMap;
 891         CacheTrainerSpellMap m_mCacheTrainerSpellMap;
 892 };
 893
 894 #define objmgr MaNGOS::Singleton<ObjectMgr>::Instance()
 895
 896 // scripting access functions
 897 MANGOS_DLL_SPEC bool LoadMangosStrings(DatabaseType& db, char const* table,int32 start_value = MAX_CREATURE_AI_TEXT_STRING_ID, int32 end_value = std::numeric_limits<int32>::min());
 898 MANGOS_DLL_SPEC uint32 GetAreaTriggerScriptId(uint32 trigger_id);
 899 MANGOS_DLL_SPEC uint32 GetScriptId(const char *name);
 900 MANGOS_DLL_SPEC ObjectMgr::ScriptNameMap& GetScriptNames();
 901 MANGOS_DLL_SPEC CreatureInfo const* GetCreatureTemplateStore(uint32 entry);
 902 MANGOS_DLL_SPEC Quest const* GetQuestTemplateStore(uint32 entry);
 903
 904 #endif