src/game/ObjectMgr.h

   1 /*
   2  * Copyright (C) 2005-2010 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 "ObjectGuid.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 extern ScriptMapMap sGossipScripts;
  97
  98 struct SpellClickInfo
  99 {
 100     uint32 spellId;
 101     uint32 questStart;                                      // quest start (quest must be active or rewarded for spell apply)
 102     uint32 questEnd;                                        // quest end (quest don't must be rewarded for spell apply)
 103     bool   questStartCanActive;                             // if true then quest start can be active (not only rewarded)
 104     uint8 castFlags;
 105
 106     // helpers
 107     bool IsFitToRequirements(Player const* player) const;
 108 };
 109
 110 typedef std::multimap<uint32, SpellClickInfo> SpellClickInfoMap;
 111 typedef std::pair<SpellClickInfoMap::const_iterator,SpellClickInfoMap::const_iterator> SpellClickInfoMapBounds;
 112
 113 struct AreaTrigger
 114 {
 115     uint8  requiredLevel;
 116     uint32 requiredItem;
 117     uint32 requiredItem2;
 118     uint32 heroicKey;
 119     uint32 heroicKey2;
 120     uint32 requiredQuest;
 121     uint32 requiredQuestHeroic;
 122     std::string requiredFailedText;
 123     uint32 target_mapId;
 124     float  target_X;
 125     float  target_Y;
 126     float  target_Z;
 127     float  target_Orientation;
 128 };
 129
 130 typedef std::set<uint32> CellGuidSet;
 131 typedef std::map<uint32/*player guid*/,uint32/*instance*/> CellCorpseSet;
 132 struct CellObjectGuids
 133 {
 134     CellGuidSet creatures;
 135     CellGuidSet gameobjects;
 136     CellCorpseSet corpses;
 137 };
 138 typedef UNORDERED_MAP<uint32/*cell_id*/,CellObjectGuids> CellObjectGuidsMap;
 139 typedef UNORDERED_MAP<uint32/*(mapid,spawnMode) pair*/,CellObjectGuidsMap> MapObjectGuids;
 140
 141 typedef UNORDERED_MAP<uint64/*(instance,guid) pair*/,time_t> RespawnTimes;
 142
 143
 144 // mangos string ranges
 145 #define MIN_MANGOS_STRING_ID           1                    // 'mangos_string'
 146 #define MAX_MANGOS_STRING_ID           2000000000
 147 #define MIN_DB_SCRIPT_STRING_ID        MAX_MANGOS_STRING_ID // 'db_script_string'
 148 #define MAX_DB_SCRIPT_STRING_ID        2000010000
 149 #define MIN_CREATURE_AI_TEXT_STRING_ID (-1)                 // 'creature_ai_texts'
 150 #define MAX_CREATURE_AI_TEXT_STRING_ID (-1000000)
 151
 152 struct MangosStringLocale
 153 {
 154     std::vector<std::string> Content;                       // 0 -> default, i -> i-1 locale index
 155 };
 156
 157 typedef UNORDERED_MAP<uint32,CreatureData> CreatureDataMap;
 158 typedef UNORDERED_MAP<uint32,GameObjectData> GameObjectDataMap;
 159 typedef UNORDERED_MAP<uint32,CreatureLocale> CreatureLocaleMap;
 160 typedef UNORDERED_MAP<uint32,GameObjectLocale> GameObjectLocaleMap;
 161 typedef UNORDERED_MAP<uint32,ItemLocale> ItemLocaleMap;
 162 typedef UNORDERED_MAP<uint32,QuestLocale> QuestLocaleMap;
 163 typedef UNORDERED_MAP<uint32,NpcTextLocale> NpcTextLocaleMap;
 164 typedef UNORDERED_MAP<uint32,PageTextLocale> PageTextLocaleMap;
 165 typedef UNORDERED_MAP<int32,MangosStringLocale> MangosStringLocaleMap;
 166 typedef UNORDERED_MAP<uint32,GossipMenuItemsLocale> GossipMenuItemsLocaleMap;
 167 typedef UNORDERED_MAP<uint32,PointOfInterestLocale> PointOfInterestLocaleMap;
 168
 169 typedef std::multimap<uint32,uint32> QuestRelations;
 170 typedef std::multimap<uint32,ItemRequiredTarget> ItemRequiredTargetMap;
 171 typedef std::pair<ItemRequiredTargetMap::const_iterator, ItemRequiredTargetMap::const_iterator>  ItemRequiredTargetMapBounds;
 172
 173 struct PetLevelInfo
 174 {
 175     PetLevelInfo() : health(0), mana(0) { for(int i=0; i < MAX_STATS; ++i ) stats[i] = 0; }
 176
 177     uint16 stats[MAX_STATS];
 178     uint16 health;
 179     uint16 mana;
 180     uint16 armor;
 181 };
 182
 183 struct MailLevelReward
 184 {
 185     MailLevelReward() : raceMask(0), mailTemplateId(0), senderEntry(0) {}
 186     MailLevelReward(uint32 _raceMask, uint32 _mailTemplateId, uint32 _senderEntry) : raceMask(_raceMask), mailTemplateId(_mailTemplateId), senderEntry(_senderEntry) {}
 187
 188     uint32 raceMask;
 189     uint32 mailTemplateId;
 190     uint32 senderEntry;
 191 };
 192
 193 typedef std::list<MailLevelReward> MailLevelRewardList;
 194 typedef UNORDERED_MAP<uint8,MailLevelRewardList> MailLevelRewardMap;
 195
 196 struct ReputationOnKillEntry
 197 {
 198     uint32 repfaction1;
 199     uint32 repfaction2;
 200     bool is_teamaward1;
 201     uint32 reputation_max_cap1;
 202     int32 repvalue1;
 203     bool is_teamaward2;
 204     uint32 reputation_max_cap2;
 205     int32 repvalue2;
 206     bool team_dependent;
 207 };
 208
 209 struct PointOfInterest
 210 {
 211     uint32 entry;
 212     float x;
 213     float y;
 214     uint32 icon;
 215     uint32 flags;
 216     uint32 data;
 217     std::string icon_name;
 218 };
 219
 220 struct GossipMenuItems
 221 {
 222     uint32          menu_id;
 223     uint32          id;
 224     uint8           option_icon;
 225     std::string     option_text;
 226     uint32          option_id;
 227     uint32          npc_option_npcflag;
 228     uint32          action_menu_id;
 229     uint32          action_poi_id;
 230     uint32          action_script_id;
 231     bool            box_coded;
 232     uint32          box_money;
 233     std::string     box_text;
 234     uint16          cond_1;
 235     uint16          cond_2;
 236     uint16          cond_3;
 237 };
 238
 239 struct GossipMenus
 240 {
 241     uint32          entry;
 242     uint32          text_id;
 243     uint16          cond_1;
 244     uint16          cond_2;
 245 };
 246
 247 typedef std::multimap<uint32,GossipMenus> GossipMenusMap;
 248 typedef std::pair<GossipMenusMap::const_iterator, GossipMenusMap::const_iterator> GossipMenusMapBounds;
 249 typedef std::multimap<uint32,GossipMenuItems> GossipMenuItemsMap;
 250 typedef std::pair<GossipMenuItemsMap::const_iterator, GossipMenuItemsMap::const_iterator> GossipMenuItemsMapBounds;
 251
 252 struct QuestPOIPoint
 253 {
 254     int32 x;
 255     int32 y;
 256
 257     QuestPOIPoint() : x(0), y(0) {}
 258     QuestPOIPoint(int32 _x, int32 _y) : x(_x), y(_y) {}
 259 };
 260
 261 struct QuestPOI
 262 {
 263     int32 ObjectiveIndex;
 264     uint32 MapId;
 265     uint32 Unk1;
 266     uint32 Unk2;
 267     uint32 Unk3;
 268     uint32 Unk4;
 269     std::vector<QuestPOIPoint> points;
 270
 271     QuestPOI() : ObjectiveIndex(0), MapId(0), Unk1(0), Unk2(0), Unk3(0), Unk4(0) {}
 272     QuestPOI(int32 objIndex, uint32 mapId, uint32 unk1, uint32 unk2, uint32 unk3, uint32 unk4) : ObjectiveIndex(objIndex), MapId(mapId), Unk1(unk1), Unk2(unk2), Unk3(unk3), Unk4(unk4) {}
 273 };
 274
 275 typedef std::vector<QuestPOI> QuestPOIVector;
 276 typedef UNORDERED_MAP<uint32, QuestPOIVector> QuestPOIMap;
 277
 278 #define WEATHER_SEASONS 4
 279 struct WeatherSeasonChances
 280 {
 281     uint32 rainChance;
 282     uint32 snowChance;
 283     uint32 stormChance;
 284 };
 285
 286 struct WeatherZoneChances
 287 {
 288     WeatherSeasonChances data[WEATHER_SEASONS];
 289 };
 290
 291 struct GraveYardData
 292 {
 293     uint32 safeLocId;
 294     uint32 team;
 295 };
 296 typedef std::multimap<uint32,GraveYardData> GraveYardMap;
 297
 298 enum ConditionType
 299 {                                                           // value1       value2  for the Condition enumed
 300     CONDITION_NONE                  = 0,                    // 0            0
 301     CONDITION_AURA                  = 1,                    // spell_id     effindex
 302     CONDITION_ITEM                  = 2,                    // item_id      count
 303     CONDITION_ITEM_EQUIPPED         = 3,                    // item_id      0
 304     CONDITION_ZONEID                = 4,                    // zone_id      0
 305     CONDITION_REPUTATION_RANK       = 5,                    // faction_id   min_rank
 306     CONDITION_TEAM                  = 6,                    // player_team  0,      (469 - Alliance 67 - Horde)
 307     CONDITION_SKILL                 = 7,                    // skill_id     skill_value
 308     CONDITION_QUESTREWARDED         = 8,                    // quest_id     0
 309     CONDITION_QUESTTAKEN            = 9,                    // quest_id     0,      for condition true while quest active.
 310     CONDITION_AD_COMMISSION_AURA    = 10,                   // 0            0,      for condition true while one from AD commission aura active
 311     CONDITION_NO_AURA               = 11,                   // spell_id     effindex
 312     CONDITION_ACTIVE_EVENT          = 12,                   // event_id     0
 313     CONDITION_AREA_FLAG             = 13,                   // area_flag    area_flag_not
 314     CONDITION_RACE_CLASS            = 14,                   // race_mask    class_mask
 315     CONDITION_LEVEL                 = 15,                   // player_level 0, 1 or 2 (0: equal to, 1: equal or higher than, 2: equal or less than)
 316     CONDITION_NOITEM                = 16,                   // item_id      count
 317 };
 318
 319 #define MAX_CONDITION                 17                    // maximum value in ConditionType enum
 320
 321 struct PlayerCondition
 322 {
 323     ConditionType condition;                                // additional condition type
 324     uint32  value1;                                         // data for the condition - see ConditionType definition
 325     uint32  value2;
 326
 327     PlayerCondition(uint8 _condition = 0, uint32 _value1 = 0, uint32 _value2 = 0)
 328         : condition(ConditionType(_condition)), value1(_value1), value2(_value2) {}
 329
 330     static bool IsValid(ConditionType condition, uint32 value1, uint32 value2);
 331     // Checks correctness of values
 332     bool Meets(Player const * APlayer) const;               // Checks if the player meets the condition
 333     bool operator == (PlayerCondition const& lc) const
 334     {
 335         return (lc.condition == condition && lc.value1 == value1 && lc.value2 == value2);
 336     }
 337 };
 338
 339 // NPC gossip text id
 340 typedef UNORDERED_MAP<uint32, uint32> CacheNpcTextIdMap;
 341
 342 typedef UNORDERED_MAP<uint32, VendorItemData> CacheVendorItemMap;
 343 typedef UNORDERED_MAP<uint32, TrainerSpellData> CacheTrainerSpellMap;
 344
 345 enum SkillRangeType
 346 {
 347     SKILL_RANGE_LANGUAGE,                                   // 300..300
 348     SKILL_RANGE_LEVEL,                                      // 1..max skill for level
 349     SKILL_RANGE_MONO,                                       // 1..1, grey monolite bar
 350     SKILL_RANGE_RANK,                                       // 1..skill for known rank
 351     SKILL_RANGE_NONE,                                       // 0..0 always
 352 };
 353
 354 SkillRangeType GetSkillRangeType(SkillLineEntry const *pSkill, bool racial);
 355
 356 #define MAX_PLAYER_NAME          12                         // max allowed by client name length
 357 #define MAX_INTERNAL_PLAYER_NAME 15                         // max server internal player name length ( > MAX_PLAYER_NAME for support declined names )
 358 #define MAX_PET_NAME             12                         // max allowed by client name length
 359 #define MAX_CHARTER_NAME         24                         // max allowed by client name length
 360
 361 bool normalizePlayerName(std::string& name);
 362
 363 struct MANGOS_DLL_SPEC LanguageDesc
 364 {
 365     Language lang_id;
 366     uint32   spell_id;
 367     uint32   skill_id;
 368 };
 369
 370 extern LanguageDesc lang_description[LANGUAGES_COUNT];
 371 MANGOS_DLL_SPEC LanguageDesc const* GetLanguageDescByID(uint32 lang);
 372
 373 class PlayerDumpReader;
 374
 375 template<typename T>
 376 class IdGenerator
 377 {
 378     public:                                                 // constructors
 379         explicit IdGenerator(char const* _name) : m_name(_name), m_nextGuid(1) {}
 380
 381     public:                                                 // modifiers
 382         void Set(T val) { m_nextGuid = val; }
 383         T Generate();
 384
 385     public:                                                 // accessors
 386         T GetNextAfterMaxUsed() const { return m_nextGuid; }
 387
 388     private:                                                // fields
 389         char const* m_name;
 390         T m_nextGuid;
 391 };
 392
 393 class ObjectMgr
 394 {
 395     friend class PlayerDumpReader;
 396
 397     public:
 398         ObjectMgr();
 399         ~ObjectMgr();
 400
 401         typedef UNORDERED_MAP<uint32, Item*> ItemMap;
 402
 403         typedef UNORDERED_MAP<uint32, Group*> GroupMap;
 404
 405         typedef UNORDERED_MAP<uint32, Guild*> GuildMap;
 406
 407         typedef UNORDERED_MAP<uint32, ArenaTeam*> ArenaTeamMap;
 408
 409         typedef UNORDERED_MAP<uint32, Quest*> QuestMap;
 410
 411         typedef UNORDERED_MAP<uint32, AreaTrigger> AreaTriggerMap;
 412
 413         typedef UNORDERED_MAP<uint32, uint32> AreaTriggerScriptMap;
 414
 415         typedef UNORDERED_MAP<uint32, ReputationOnKillEntry> RepOnKillMap;
 416         typedef UNORDERED_MAP<uint32, PointOfInterest> PointOfInterestMap;
 417
 418         typedef UNORDERED_MAP<uint32, WeatherZoneChances> WeatherZoneMap;
 419
 420         typedef std::vector<std::string> ScriptNameMap;
 421
 422         Player* GetPlayer(const char* name) const { return ObjectAccessor::FindPlayerByName(name);}
 423         Player* GetPlayer(ObjectGuid guid) const { return ObjectAccessor::FindPlayer(guid); }
 424
 425         static GameObjectInfo const *GetGameObjectInfo(uint32 id) { return sGOStorage.LookupEntry<GameObjectInfo>(id); }
 426
 427         void LoadGameobjectInfo();
 428         void AddGameobjectInfo(GameObjectInfo *goinfo);
 429
 430         void PackGroupIds();
 431         Group* GetGroupById(uint32 id) const;
 432         void AddGroup(Group* group);
 433         void RemoveGroup(Group* group);
 434
 435         Guild* GetGuildByLeader(uint64 const&guid) const;
 436         Guild* GetGuildById(uint32 GuildId) const;
 437         Guild* GetGuildByName(const std::string& guildname) const;
 438         std::string GetGuildNameById(uint32 GuildId) const;
 439         void AddGuild(Guild* guild);
 440         void RemoveGuild(uint32 Id);
 441
 442         ArenaTeam* GetArenaTeamById(uint32 arenateamid) const;
 443         ArenaTeam* GetArenaTeamByName(const std::string& arenateamname) const;
 444         ArenaTeam* GetArenaTeamByCaptain(uint64 const& guid) const;
 445         void AddArenaTeam(ArenaTeam* arenaTeam);
 446         void RemoveArenaTeam(uint32 Id);
 447         ArenaTeamMap::iterator GetArenaTeamMapBegin() { return mArenaTeamMap.begin(); }
 448         ArenaTeamMap::iterator GetArenaTeamMapEnd()   { return mArenaTeamMap.end(); }
 449
 450         static CreatureInfo const *GetCreatureTemplate( uint32 id );
 451         CreatureModelInfo const *GetCreatureModelInfo( uint32 modelid );
 452         CreatureModelInfo const* GetCreatureModelRandomGender(uint32 display_id);
 453         uint32 ChooseDisplayId(uint32 team, const CreatureInfo *cinfo, const CreatureData *data = NULL);
 454         EquipmentInfo const *GetEquipmentInfo( uint32 entry );
 455         static CreatureDataAddon const *GetCreatureAddon( uint32 lowguid )
 456         {
 457             return sCreatureDataAddonStorage.LookupEntry<CreatureDataAddon>(lowguid);
 458         }
 459
 460         static CreatureDataAddon const *GetCreatureTemplateAddon( uint32 entry )
 461         {
 462             return sCreatureInfoAddonStorage.LookupEntry<CreatureDataAddon>(entry);
 463         }
 464
 465         static ItemPrototype const* GetItemPrototype(uint32 id) { return sItemStorage.LookupEntry<ItemPrototype>(id); }
 466
 467         static InstanceTemplate const* GetInstanceTemplate(uint32 map)
 468         {
 469             return sInstanceTemplate.LookupEntry<InstanceTemplate>(map);
 470         }
 471
 472         PetLevelInfo const* GetPetLevelInfo(uint32 creature_id, uint32 level) const;
 473
 474         PlayerClassInfo const* GetPlayerClassInfo(uint32 class_) const
 475         {
 476             if(class_ >= MAX_CLASSES) return NULL;
 477             return &playerClassInfo[class_];
 478         }
 479         void GetPlayerClassLevelInfo(uint32 class_,uint32 level, PlayerClassLevelInfo* info) const;
 480
 481         PlayerInfo const* GetPlayerInfo(uint32 race, uint32 class_) const
 482         {
 483             if(race   >= MAX_RACES)   return NULL;
 484             if(class_ >= MAX_CLASSES) return NULL;
 485             PlayerInfo const* info = &playerInfo[race][class_];
 486             if(info->displayId_m==0 || info->displayId_f==0) return NULL;
 487             return info;
 488         }
 489         void GetPlayerLevelInfo(uint32 race, uint32 class_,uint32 level, PlayerLevelInfo* info) const;
 490
 491         uint64 GetPlayerGUIDByName(std::string name) const;
 492         bool GetPlayerNameByGUID(const uint64 &guid, std::string &name) const;
 493         uint32 GetPlayerTeamByGUID(const uint64 &guid) const;
 494         uint32 GetPlayerAccountIdByGUID(const uint64 &guid) const;
 495         uint32 GetPlayerAccountIdByPlayerName(const std::string& name) const;
 496
 497         uint32 GetNearestTaxiNode( float x, float y, float z, uint32 mapid, uint32 team );
 498         void GetTaxiPath( uint32 source, uint32 destination, uint32 &path, uint32 &cost);
 499         uint32 GetTaxiMountDisplayId( uint32 id, uint32 team, bool allowed_alt_team = false);
 500         void GetTaxiPathNodes( uint32 path, Path &pathnodes, std::vector<uint32>& mapIds );
 501         void GetTransportPathNodes( uint32 path, TransportPath &pathnodes );
 502
 503         Quest const* GetQuestTemplate(uint32 quest_id) const
 504         {
 505             QuestMap::const_iterator itr = mQuestTemplates.find(quest_id);
 506             return itr != mQuestTemplates.end() ? itr->second : NULL;
 507         }
 508         QuestMap const& GetQuestTemplates() const { return mQuestTemplates; }
 509
 510         uint32 GetQuestForAreaTrigger(uint32 Trigger_ID) const
 511         {
 512             QuestAreaTriggerMap::const_iterator itr = mQuestAreaTriggerMap.find(Trigger_ID);
 513             if(itr != mQuestAreaTriggerMap.end())
 514                 return itr->second;
 515             return 0;
 516         }
 517         bool IsTavernAreaTrigger(uint32 Trigger_ID) const
 518         {
 519             return mTavernAreaTriggerSet.find(Trigger_ID) != mTavernAreaTriggerSet.end();
 520         }
 521
 522         bool IsGameObjectForQuests(uint32 entry) const
 523         {
 524             return mGameObjectForQuestSet.find(entry) != mGameObjectForQuestSet.end();
 525         }
 526
 527         GossipText const* GetGossipText(uint32 Text_ID) const;
 528
 529         WorldSafeLocsEntry const *GetClosestGraveYard(float x, float y, float z, uint32 MapId, uint32 team);
 530         bool AddGraveYardLink(uint32 id, uint32 zone, uint32 team, bool inDB = true);
 531         void LoadGraveyardZones();
 532         GraveYardData const* FindGraveYardData(uint32 id, uint32 zone);
 533
 534         AreaTrigger const* GetAreaTrigger(uint32 trigger) const
 535         {
 536             AreaTriggerMap::const_iterator itr = mAreaTriggers.find( trigger );
 537             if( itr != mAreaTriggers.end( ) )
 538                 return &itr->second;
 539             return NULL;
 540         }
 541
 542         AreaTrigger const* GetGoBackTrigger(uint32 Map) const;
 543         AreaTrigger const* GetMapEntranceTrigger(uint32 Map) const;
 544
 545         uint32 GetAreaTriggerScriptId(uint32 trigger_id);
 546
 547         ReputationOnKillEntry const* GetReputationOnKilEntry(uint32 id) const
 548         {
 549             RepOnKillMap::const_iterator itr = mRepOnKill.find(id);
 550             if(itr != mRepOnKill.end())
 551                 return &itr->second;
 552             return NULL;
 553         }
 554
 555         PointOfInterest const* GetPointOfInterest(uint32 id) const
 556         {
 557             PointOfInterestMap::const_iterator itr = mPointsOfInterest.find(id);
 558             if(itr != mPointsOfInterest.end())
 559                 return &itr->second;
 560             return NULL;
 561         }
 562
 563         QuestPOIVector const* GetQuestPOIVector(uint32 questId)
 564         {
 565             QuestPOIMap::const_iterator itr = mQuestPOIMap.find(questId);
 566             if(itr != mQuestPOIMap.end())
 567                 return &itr->second;
 568             return NULL;
 569         }
 570
 571         void LoadGuilds();
 572         void LoadArenaTeams();
 573         void LoadGroups();
 574         void LoadQuests();
 575         void LoadQuestRelations()
 576         {
 577             LoadGameobjectQuestRelations();
 578             LoadGameobjectInvolvedRelations();
 579             LoadCreatureQuestRelations();
 580             LoadCreatureInvolvedRelations();
 581         }
 582         void LoadGameobjectQuestRelations();
 583         void LoadGameobjectInvolvedRelations();
 584         void LoadCreatureQuestRelations();
 585         void LoadCreatureInvolvedRelations();
 586
 587         QuestRelations mGOQuestRelations;
 588         QuestRelations mGOQuestInvolvedRelations;
 589         QuestRelations mCreatureQuestRelations;
 590         QuestRelations mCreatureQuestInvolvedRelations;
 591
 592         void LoadGameObjectScripts();
 593         void LoadQuestEndScripts();
 594         void LoadQuestStartScripts();
 595         void LoadEventScripts();
 596         void LoadSpellScripts();
 597         void LoadGossipScripts();
 598
 599         bool LoadMangosStrings(DatabaseType& db, char const* table, int32 min_value, int32 max_value);
 600         bool LoadMangosStrings() { return LoadMangosStrings(WorldDatabase,"mangos_string",MIN_MANGOS_STRING_ID,MAX_MANGOS_STRING_ID); }
 601         void LoadDbScriptStrings();
 602         void LoadCreatureLocales();
 603         void LoadCreatureTemplates();
 604         void LoadCreatures();
 605         void LoadCreatureRespawnTimes();
 606         void LoadCreatureAddons();
 607         void LoadCreatureModelInfo();
 608         void LoadEquipmentTemplates();
 609         void LoadGameObjectLocales();
 610         void LoadGameobjects();
 611         void LoadGameobjectRespawnTimes();
 612         void LoadItemPrototypes();
 613         void LoadItemRequiredTarget();
 614         void LoadItemLocales();
 615         void LoadQuestLocales();
 616         void LoadNpcTextLocales();
 617         void LoadPageTextLocales();
 618         void LoadGossipMenuItemsLocales();
 619         void LoadPointOfInterestLocales();
 620         void LoadInstanceTemplate();
 621         void LoadMailLevelRewards();
 622
 623         void LoadGossipText();
 624
 625         void LoadAreaTriggerTeleports();
 626         void LoadQuestAreaTriggers();
 627         void LoadAreaTriggerScripts();
 628         void LoadTavernAreaTriggers();
 629         void LoadGameObjectForQuests();
 630
 631         void LoadItemTexts();
 632         void LoadPageTexts();
 633
 634         void LoadPlayerInfo();
 635         void LoadPetLevelInfo();
 636         void LoadExplorationBaseXP();
 637         void LoadPetNames();
 638         void LoadPetNumber();
 639         void LoadCorpses();
 640         void LoadFishingBaseSkillLevel();
 641
 642         void LoadReputationOnKill();
 643         void LoadPointsOfInterest();
 644         void LoadQuestPOI();
 645
 646         void LoadNPCSpellClickSpells();
 647
 648         void LoadWeatherZoneChances();
 649         void LoadGameTele();
 650
 651         void LoadNpcTextId();
 652
 653         void LoadGossipMenu();
 654         void LoadGossipMenuItems();
 655
 656         void LoadVendors();
 657         void LoadTrainerSpell();
 658
 659         std::string GeneratePetName(uint32 entry);
 660         uint32 GetBaseXP(uint32 level) const;
 661         uint32 GetXPForLevel(uint32 level) const;
 662         uint32 GetXPForPetLevel(uint32 level) const { return GetXPForLevel(level)/20; }
 663
 664         int32 GetFishingBaseSkillLevel(uint32 entry) const
 665         {
 666             FishingBaseSkillMap::const_iterator itr = mFishingBaseForArea.find(entry);
 667             return itr != mFishingBaseForArea.end() ? itr->second : 0;
 668         }
 669
 670         void ReturnOrDeleteOldMails(bool serverUp);
 671
 672         void SetHighestGuids();
 673         uint32 GenerateLowGuid(HighGuid guidhigh);
 674         uint32 GenerateArenaTeamId() { return m_ArenaTeamIds.Generate(); }
 675         uint32 GenerateAuctionID() { return m_AuctionIds.Generate(); }
 676         uint64 GenerateEquipmentSetGuid() { return m_EquipmentSetIds.Generate(); }
 677         uint32 GenerateGuildId() { return m_GuildIds.Generate(); }
 678         uint32 GenerateGroupId() { return m_GroupIds.Generate(); }
 679         uint32 GenerateItemTextID() { return m_ItemGuids.Generate(); }
 680         uint32 GenerateMailID() { return m_MailIds.Generate(); }
 681         uint32 GeneratePetNumber() { return m_PetNumbers.Generate(); }
 682
 683         uint32 CreateItemText(std::string text);
 684         void AddItemText(uint32 itemTextId, std::string text) { mItemTexts[itemTextId] = text; }
 685         std::string GetItemText( uint32 id )
 686         {
 687             ItemTextMap::const_iterator itr = mItemTexts.find( id );
 688             if ( itr != mItemTexts.end() )
 689                 return itr->second;
 690             else
 691                 return "There is no info for this item";
 692         }
 693
 694         typedef std::multimap<int32, uint32> ExclusiveQuestGroups;
 695         ExclusiveQuestGroups mExclusiveQuestGroups;
 696
 697         MailLevelReward const* GetMailLevelReward(uint32 level,uint32 raceMask)
 698         {
 699             MailLevelRewardMap::const_iterator map_itr = m_mailLevelRewardMap.find(level);
 700             if (map_itr == m_mailLevelRewardMap.end())
 701                 return NULL;
 702
 703             for(MailLevelRewardList::const_iterator set_itr = map_itr->second.begin(); set_itr != map_itr->second.end(); ++set_itr)
 704                 if (set_itr->raceMask & raceMask)
 705                     return &*set_itr;
 706
 707             return NULL;
 708         }
 709
 710         WeatherZoneChances const* GetWeatherChances(uint32 zone_id) const
 711         {
 712             WeatherZoneMap::const_iterator itr = mWeatherZoneMap.find(zone_id);
 713             if(itr != mWeatherZoneMap.end())
 714                 return &itr->second;
 715             else
 716                 return NULL;
 717         }
 718
 719         CellObjectGuids const& GetCellObjectGuids(uint16 mapid, uint8 spawnMode, uint32 cell_id)
 720         {
 721             return mMapObjectGuids[MAKE_PAIR32(mapid,spawnMode)][cell_id];
 722         }
 723
 724         CreatureData const* GetCreatureData(uint32 guid) const
 725         {
 726             CreatureDataMap::const_iterator itr = mCreatureDataMap.find(guid);
 727             if(itr==mCreatureDataMap.end()) return NULL;
 728             return &itr->second;
 729         }
 730         CreatureData& NewOrExistCreatureData(uint32 guid) { return mCreatureDataMap[guid]; }
 731         void DeleteCreatureData(uint32 guid);
 732         CreatureLocale const* GetCreatureLocale(uint32 entry) const
 733         {
 734             CreatureLocaleMap::const_iterator itr = mCreatureLocaleMap.find(entry);
 735             if(itr==mCreatureLocaleMap.end()) return NULL;
 736             return &itr->second;
 737         }
 738         GameObjectLocale const* GetGameObjectLocale(uint32 entry) const
 739         {
 740             GameObjectLocaleMap::const_iterator itr = mGameObjectLocaleMap.find(entry);
 741             if(itr==mGameObjectLocaleMap.end()) return NULL;
 742             return &itr->second;
 743         }
 744         ItemLocale const* GetItemLocale(uint32 entry) const
 745         {
 746             ItemLocaleMap::const_iterator itr = mItemLocaleMap.find(entry);
 747             if(itr==mItemLocaleMap.end()) return NULL;
 748             return &itr->second;
 749         }
 750         QuestLocale const* GetQuestLocale(uint32 entry) const
 751         {
 752             QuestLocaleMap::const_iterator itr = mQuestLocaleMap.find(entry);
 753             if(itr==mQuestLocaleMap.end()) return NULL;
 754             return &itr->second;
 755         }
 756         NpcTextLocale const* GetNpcTextLocale(uint32 entry) const
 757         {
 758             NpcTextLocaleMap::const_iterator itr = mNpcTextLocaleMap.find(entry);
 759             if(itr==mNpcTextLocaleMap.end()) return NULL;
 760             return &itr->second;
 761         }
 762         PageTextLocale const* GetPageTextLocale(uint32 entry) const
 763         {
 764             PageTextLocaleMap::const_iterator itr = mPageTextLocaleMap.find(entry);
 765             if(itr==mPageTextLocaleMap.end()) return NULL;
 766             return &itr->second;
 767         }
 768         GossipMenuItemsLocale const* GetGossipMenuItemsLocale(uint32 entry) const
 769         {
 770             GossipMenuItemsLocaleMap::const_iterator itr = mGossipMenuItemsLocaleMap.find(entry);
 771             if(itr==mGossipMenuItemsLocaleMap.end()) return NULL;
 772             return &itr->second;
 773         }
 774         PointOfInterestLocale const* GetPointOfInterestLocale(uint32 poi_id) const
 775         {
 776             PointOfInterestLocaleMap::const_iterator itr = mPointOfInterestLocaleMap.find(poi_id);
 777             if(itr==mPointOfInterestLocaleMap.end()) return NULL;
 778             return &itr->second;
 779         }
 780
 781         GameObjectData const* GetGOData(uint32 guid) const
 782         {
 783             GameObjectDataMap::const_iterator itr = mGameObjectDataMap.find(guid);
 784             if(itr==mGameObjectDataMap.end()) return NULL;
 785             return &itr->second;
 786         }
 787         GameObjectData& NewGOData(uint32 guid) { return mGameObjectDataMap[guid]; }
 788         void DeleteGOData(uint32 guid);
 789
 790         MangosStringLocale const* GetMangosStringLocale(int32 entry) const
 791         {
 792             MangosStringLocaleMap::const_iterator itr = mMangosStringLocaleMap.find(entry);
 793             if(itr==mMangosStringLocaleMap.end()) return NULL;
 794             return &itr->second;
 795         }
 796         const char *GetMangosString(int32 entry, int locale_idx) const;
 797         const char *GetMangosStringForDBCLocale(int32 entry) const { return GetMangosString(entry,DBCLocaleIndex); }
 798         int32 GetDBCLocaleIndex() const { return DBCLocaleIndex; }
 799         void SetDBCLocaleIndex(uint32 lang) { DBCLocaleIndex = GetIndexForLocale(LocaleConstant(lang)); }
 800
 801         void AddCorpseCellData(uint32 mapid, uint32 cellid, uint32 player_guid, uint32 instance);
 802         void DeleteCorpseCellData(uint32 mapid, uint32 cellid, uint32 player_guid);
 803
 804         time_t GetCreatureRespawnTime(uint32 loguid, uint32 instance) { return mCreatureRespawnTimes[MAKE_PAIR64(loguid,instance)]; }
 805         void SaveCreatureRespawnTime(uint32 loguid, uint32 instance, time_t t);
 806         time_t GetGORespawnTime(uint32 loguid, uint32 instance) { return mGORespawnTimes[MAKE_PAIR64(loguid,instance)]; }
 807         void SaveGORespawnTime(uint32 loguid, uint32 instance, time_t t);
 808         void DeleteRespawnTimeForInstance(uint32 instance);
 809
 810         // grid objects
 811         void AddCreatureToGrid(uint32 guid, CreatureData const* data);
 812         void RemoveCreatureFromGrid(uint32 guid, CreatureData const* data);
 813         void AddGameobjectToGrid(uint32 guid, GameObjectData const* data);
 814         void RemoveGameobjectFromGrid(uint32 guid, GameObjectData const* data);
 815
 816         // reserved names
 817         void LoadReservedPlayersNames();
 818         bool IsReservedName(const std::string& name) const;
 819
 820         // name with valid structure and symbols
 821         static uint8 CheckPlayerName( const std::string& name, bool create = false );
 822         static PetNameInvalidReason CheckPetName( const std::string& name );
 823         static bool IsValidCharterName( const std::string& name );
 824
 825         static bool CheckDeclinedNames(std::wstring mainpart, DeclinedName const& names);
 826
 827         int GetIndexForLocale(LocaleConstant loc);
 828         LocaleConstant GetLocaleForIndex(int i);
 829
 830         uint16 GetConditionId(ConditionType condition, uint32 value1, uint32 value2);
 831         bool IsPlayerMeetToCondition(Player const* player, uint16 condition_id) const
 832         {
 833             if(condition_id >= mConditions.size())
 834                 return false;
 835
 836             return mConditions[condition_id].Meets(player);
 837         }
 838
 839         GameTele const* GetGameTele(uint32 id) const
 840         {
 841             GameTeleMap::const_iterator itr = m_GameTeleMap.find(id);
 842             if(itr==m_GameTeleMap.end()) return NULL;
 843             return &itr->second;
 844         }
 845         GameTele const* GetGameTele(const std::string& name) const;
 846         GameTeleMap const& GetGameTeleMap() const { return m_GameTeleMap; }
 847         bool AddGameTele(GameTele& data);
 848         bool DeleteGameTele(const std::string& name);
 849
 850         uint32 GetNpcGossip(uint32 entry) const
 851         {
 852             CacheNpcTextIdMap::const_iterator iter = m_mCacheNpcTextIdMap.find(entry);
 853             if(iter == m_mCacheNpcTextIdMap.end())
 854                 return 0;
 855
 856             return iter->second;
 857         }
 858
 859         TrainerSpellData const* GetNpcTrainerSpells(uint32 entry) const
 860         {
 861             CacheTrainerSpellMap::const_iterator  iter = m_mCacheTrainerSpellMap.find(entry);
 862             if(iter == m_mCacheTrainerSpellMap.end())
 863                 return NULL;
 864
 865             return &iter->second;
 866         }
 867
 868         VendorItemData const* GetNpcVendorItemList(uint32 entry) const
 869         {
 870             CacheVendorItemMap::const_iterator  iter = m_mCacheVendorItemMap.find(entry);
 871             if(iter == m_mCacheVendorItemMap.end())
 872                 return NULL;
 873
 874             return &iter->second;
 875         }
 876         void AddVendorItem(uint32 entry,uint32 item, uint32 maxcount, uint32 incrtime, uint32 ExtendedCost);
 877         bool RemoveVendorItem(uint32 entry,uint32 item);
 878         bool IsVendorItemValid( uint32 vendor_entry, uint32 item, uint32 maxcount, uint32 ptime, uint32 ExtendedCost, Player* pl = NULL, std::set<uint32>* skip_vendors = NULL ) const;
 879
 880         void LoadScriptNames();
 881         ScriptNameMap &GetScriptNames() { return m_scriptNames; }
 882         const char * GetScriptName(uint32 id) { return id < m_scriptNames.size() ? m_scriptNames[id].c_str() : ""; }
 883         uint32 GetScriptId(const char *name);
 884
 885         int GetOrNewIndexForLocale(LocaleConstant loc);
 886
 887         SpellClickInfoMapBounds GetSpellClickInfoMapBounds(uint32 creature_id) const
 888         {
 889             return SpellClickInfoMapBounds(mSpellClickInfoMap.lower_bound(creature_id),mSpellClickInfoMap.upper_bound(creature_id));
 890         }
 891
 892         ItemRequiredTargetMapBounds GetItemRequiredTargetMapBounds(uint32 uiItemEntry) const
 893         {
 894             return ItemRequiredTargetMapBounds(m_ItemRequiredTarget.lower_bound(uiItemEntry),m_ItemRequiredTarget.upper_bound(uiItemEntry));
 895         }
 896
 897         GossipMenusMapBounds GetGossipMenusMapBounds(uint32 uiMenuId) const
 898         {
 899             return GossipMenusMapBounds(m_mGossipMenusMap.lower_bound(uiMenuId),m_mGossipMenusMap.upper_bound(uiMenuId));
 900         }
 901
 902         GossipMenuItemsMapBounds GetGossipMenuItemsMapBounds(uint32 uiMenuId) const
 903         {
 904             return GossipMenuItemsMapBounds(m_mGossipMenuItemsMap.lower_bound(uiMenuId),m_mGossipMenuItemsMap.upper_bound(uiMenuId));
 905         }
 906
 907     protected:
 908
 909         // first free id for selected id type
 910         IdGenerator<uint32> m_ArenaTeamIds;
 911         IdGenerator<uint32> m_AuctionIds;
 912         IdGenerator<uint64> m_EquipmentSetIds;
 913         IdGenerator<uint32> m_GuildIds;
 914         IdGenerator<uint32> m_ItemTextIds;
 915         IdGenerator<uint32> m_MailIds;
 916         IdGenerator<uint32> m_PetNumbers;
 917         IdGenerator<uint32> m_GroupIds;
 918
 919         // first free low guid for selected guid type
 920         ObjectGuidGenerator<HIGHGUID_PLAYER>     m_CharGuids;
 921         ObjectGuidGenerator<HIGHGUID_UNIT>       m_CreatureGuids;
 922         ObjectGuidGenerator<HIGHGUID_ITEM>       m_ItemGuids;
 923         ObjectGuidGenerator<HIGHGUID_GAMEOBJECT> m_GameobjectGuids;
 924         ObjectGuidGenerator<HIGHGUID_CORPSE>     m_CorpseGuids;
 925
 926         QuestMap            mQuestTemplates;
 927
 928         typedef UNORDERED_MAP<uint32, GossipText> GossipTextMap;
 929         typedef UNORDERED_MAP<uint32, uint32> QuestAreaTriggerMap;
 930         typedef UNORDERED_MAP<uint32, std::string> ItemTextMap;
 931         typedef std::set<uint32> TavernAreaTriggerSet;
 932         typedef std::set<uint32> GameObjectForQuestSet;
 933
 934         GroupMap            mGroupMap;
 935         GuildMap            mGuildMap;
 936         ArenaTeamMap        mArenaTeamMap;
 937
 938         ItemTextMap         mItemTexts;
 939
 940         QuestAreaTriggerMap mQuestAreaTriggerMap;
 941         TavernAreaTriggerSet mTavernAreaTriggerSet;
 942         GameObjectForQuestSet mGameObjectForQuestSet;
 943         GossipTextMap       mGossipText;
 944         AreaTriggerMap      mAreaTriggers;
 945         AreaTriggerScriptMap  mAreaTriggerScripts;
 946
 947         RepOnKillMap        mRepOnKill;
 948
 949         GossipMenusMap      m_mGossipMenusMap;
 950         GossipMenuItemsMap  m_mGossipMenuItemsMap;
 951         PointOfInterestMap  mPointsOfInterest;
 952
 953         QuestPOIMap         mQuestPOIMap;
 954
 955         WeatherZoneMap      mWeatherZoneMap;
 956
 957         //character reserved names
 958         typedef std::set<std::wstring> ReservedNamesMap;
 959         ReservedNamesMap    m_ReservedNames;
 960
 961         GraveYardMap        mGraveYardMap;
 962
 963         GameTeleMap         m_GameTeleMap;
 964
 965         ScriptNameMap       m_scriptNames;
 966
 967         SpellClickInfoMap   mSpellClickInfoMap;
 968
 969         ItemRequiredTargetMap m_ItemRequiredTarget;
 970
 971         typedef             std::vector<LocaleConstant> LocalForIndex;
 972         LocalForIndex        m_LocalForIndex;
 973
 974         int DBCLocaleIndex;
 975
 976     private:
 977         void LoadScripts(ScriptMapMap& scripts, char const* tablename);
 978         void CheckScripts(ScriptMapMap const& scripts,std::set<int32>& ids);
 979         void LoadCreatureAddons(SQLStorage& creatureaddons, char const* entryName, char const* comment);
 980         void ConvertCreatureAddonAuras(CreatureDataAddon* addon, char const* table, char const* guidEntryStr);
 981         void LoadQuestRelationsHelper(QuestRelations& map,char const* table);
 982
 983         MailLevelRewardMap m_mailLevelRewardMap;
 984
 985         typedef std::map<uint32,PetLevelInfo*> PetLevelInfoMap;
 986         // PetLevelInfoMap[creature_id][level]
 987         PetLevelInfoMap petInfo;                            // [creature_id][level]
 988
 989         PlayerClassInfo playerClassInfo[MAX_CLASSES];
 990
 991         void BuildPlayerLevelInfo(uint8 race, uint8 class_, uint8 level, PlayerLevelInfo* plinfo) const;
 992         PlayerInfo playerInfo[MAX_RACES][MAX_CLASSES];
 993
 994         typedef std::vector<uint32> PlayerXPperLevel;       // [level]
 995         PlayerXPperLevel mPlayerXPperLevel;
 996
 997         typedef std::map<uint32,uint32> BaseXPMap;          // [area level][base xp]
 998         BaseXPMap mBaseXPTable;
 999
1000         typedef std::map<uint32,int32> FishingBaseSkillMap; // [areaId][base skill level]
1001         FishingBaseSkillMap mFishingBaseForArea;
1002
1003         typedef std::map<uint32,std::vector<std::string> > HalfNameMap;
1004         HalfNameMap PetHalfName0;
1005         HalfNameMap PetHalfName1;
1006
1007         MapObjectGuids mMapObjectGuids;
1008         CreatureDataMap mCreatureDataMap;
1009         CreatureLocaleMap mCreatureLocaleMap;
1010         GameObjectDataMap mGameObjectDataMap;
1011         GameObjectLocaleMap mGameObjectLocaleMap;
1012         ItemLocaleMap mItemLocaleMap;
1013         QuestLocaleMap mQuestLocaleMap;
1014         NpcTextLocaleMap mNpcTextLocaleMap;
1015         PageTextLocaleMap mPageTextLocaleMap;
1016         MangosStringLocaleMap mMangosStringLocaleMap;
1017         GossipMenuItemsLocaleMap mGossipMenuItemsLocaleMap;
1018         PointOfInterestLocaleMap mPointOfInterestLocaleMap;
1019         RespawnTimes mCreatureRespawnTimes;
1020         RespawnTimes mGORespawnTimes;
1021
1022         // Storage for Conditions. First element (index 0) is reserved for zero-condition (nothing required)
1023         typedef std::vector<PlayerCondition> ConditionStore;
1024         ConditionStore mConditions;
1025
1026         CacheNpcTextIdMap m_mCacheNpcTextIdMap;
1027         CacheVendorItemMap m_mCacheVendorItemMap;
1028         CacheTrainerSpellMap m_mCacheTrainerSpellMap;
1029 };
1030
1031 #define sObjectMgr MaNGOS::Singleton<ObjectMgr>::Instance()
1032
1033 // scripting access functions
1034 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());
1035 MANGOS_DLL_SPEC uint32 GetAreaTriggerScriptId(uint32 trigger_id);
1036 MANGOS_DLL_SPEC uint32 GetScriptId(const char *name);
1037 MANGOS_DLL_SPEC ObjectMgr::ScriptNameMap& GetScriptNames();
1038 MANGOS_DLL_SPEC CreatureInfo const* GetCreatureTemplateStore(uint32 entry);
1039 MANGOS_DLL_SPEC Quest const* GetQuestTemplateStore(uint32 entry);
1040
1041 #endif