root/trunk/src/game/ObjectMgr.h @ 268

Revision 263, 34.9 kB (checked in by yumileroy, 17 years ago)

Some missing changes. This should fix the bug that loading char causes crash.
Please do not commit to the other tip (I do not know how to delete it).

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