src/game/MapManager.h

   1 /*
   2  * Copyright (C) 2005-2013 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 MANGOS_MAPMANAGER_H
  20 #define MANGOS_MAPMANAGER_H
  21
  22 #include "Common.h"
  23 #include "Platform/Define.h"
  24 #include "Policies/Singleton.h"
  25 #include "ace/Recursive_Thread_Mutex.h"
  26 #include "Map.h"
  27 #include "GridStates.h"
  28
  29 class Transport;
  30 class BattleGround;
  31
  32 struct MANGOS_DLL_DECL MapID
  33 {
  34     explicit MapID(uint32 id) : nMapId(id), nInstanceId(0) {}
  35     MapID(uint32 id, uint32 instid) : nMapId(id), nInstanceId(instid) {}
  36
  37     bool operator<(const MapID& val) const
  38     {
  39         if (nMapId == val.nMapId)
  40             return nInstanceId < val.nInstanceId;
  41
  42         return nMapId < val.nMapId;
  43     }
  44
  45     bool operator==(const MapID& val) const { return nMapId == val.nMapId && nInstanceId == val.nInstanceId; }
  46
  47     uint32 nMapId;
  48     uint32 nInstanceId;
  49 };
  50
  51 class MANGOS_DLL_DECL MapManager : public MaNGOS::Singleton<MapManager, MaNGOS::ClassLevelLockable<MapManager, ACE_Recursive_Thread_Mutex> >
  52 {
  53         friend class MaNGOS::OperatorNew<MapManager>;
  54
  55         typedef ACE_Recursive_Thread_Mutex LOCK_TYPE;
  56         typedef ACE_Guard<LOCK_TYPE> LOCK_TYPE_GUARD;
  57         typedef MaNGOS::ClassLevelLockable<MapManager, ACE_Recursive_Thread_Mutex>::Lock Guard;
  58
  59     public:
  60         typedef std::map<MapID, Map* > MapMapType;
  61
  62         Map* CreateMap(uint32, const WorldObject* obj);
  63         Map* CreateBgMap(uint32 mapid, BattleGround* bg);
  64         Map* FindMap(uint32 mapid, uint32 instanceId = 0) const;
  65
  66         void UpdateGridState(grid_state_t state, Map& map, NGridType& ngrid, GridInfo& ginfo, const uint32& x, const uint32& y, const uint32& t_diff);
  67
  68         // only const version for outer users
  69         void DeleteInstance(uint32 mapid, uint32 instanceId);
  70
  71         void Initialize(void);
  72         void Update(uint32);
  73
  74         void SetGridCleanUpDelay(uint32 t)
  75         {
  76             if (t < MIN_GRID_DELAY)
  77                 i_gridCleanUpDelay = MIN_GRID_DELAY;
  78             else
  79                 i_gridCleanUpDelay = t;
  80         }
  81
  82         void SetMapUpdateInterval(uint32 t)
  83         {
  84             if (t > MIN_MAP_UPDATE_DELAY)
  85                 t = MIN_MAP_UPDATE_DELAY;
  86
  87             i_timer.SetInterval(t);
  88             i_timer.Reset();
  89         }
  90
  91         // void LoadGrid(int mapid, int instId, float x, float y, const WorldObject* obj, bool no_unload = false);
  92         void UnloadAll();
  93
  94         static bool ExistMapAndVMap(uint32 mapid, float x, float y);
  95         static bool IsValidMAP(uint32 mapid);
  96
  97         static bool IsValidMapCoord(uint32 mapid, float x, float y)
  98         {
  99             return IsValidMAP(mapid) && MaNGOS::IsValidMapCoord(x, y);
 100         }
 101
 102         static bool IsValidMapCoord(uint32 mapid, float x, float y, float z)
 103         {
 104             return IsValidMAP(mapid) && MaNGOS::IsValidMapCoord(x, y, z);
 105         }
 106
 107         static bool IsValidMapCoord(uint32 mapid, float x, float y, float z, float o)
 108         {
 109             return IsValidMAP(mapid) && MaNGOS::IsValidMapCoord(x, y, z, o);
 110         }
 111
 112         static bool IsValidMapCoord(WorldLocation const& loc)
 113         {
 114             return IsValidMapCoord(loc.mapid, loc.coord_x, loc.coord_y, loc.coord_z, loc.orientation);
 115         }
 116
 117         void RemoveAllObjectsInRemoveList();
 118
 119         void LoadTransports();
 120
 121         typedef std::set<Transport*> TransportSet;
 122         TransportSet m_Transports;
 123
 124         typedef std::map<uint32, TransportSet> TransportMap;
 125         TransportMap m_TransportsByMap;
 126
 127         void InitializeVisibilityDistanceInfo();
 128
 129         /* statistics */
 130         uint32 GetNumInstances();
 131         uint32 GetNumPlayersInInstances();
 132
 133
 134         // get list of all maps
 135         const MapMapType& Maps() const { return i_maps; }
 136
 137         template<typename Do>
 138         void DoForAllMapsWithMapId(uint32 mapId, Do& _do);
 139
 140     private:
 141
 142         // debugging code, should be deleted some day
 143         GridState* si_GridStates[MAX_GRID_STATE];
 144         int i_GridStateErrorCount;
 145
 146     private:
 147
 148         MapManager();
 149         ~MapManager();
 150
 151         MapManager(const MapManager&);
 152         MapManager& operator=(const MapManager&);
 153
 154         void InitStateMachine();
 155         void DeleteStateMachine();
 156
 157         Map* CreateInstance(uint32 id, Player* player);
 158         DungeonMap* CreateDungeonMap(uint32 id, uint32 InstanceId, Difficulty difficulty, DungeonPersistentState* save = NULL);
 159         BattleGroundMap* CreateBattleGroundMap(uint32 id, uint32 InstanceId, BattleGround* bg);
 160
 161         uint32 i_gridCleanUpDelay;
 162         MapMapType i_maps;
 163         IntervalTimer i_timer;
 164 };
 165
 166 template<typename Do>
 167 inline void MapManager::DoForAllMapsWithMapId(uint32 mapId, Do& _do)
 168 {
 169     MapMapType::const_iterator start = i_maps.lower_bound(MapID(mapId, 0));
 170     MapMapType::const_iterator end   = i_maps.lower_bound(MapID(mapId + 1, 0));
 171     for (MapMapType::const_iterator itr = start; itr != end; ++itr)
 172         _do(itr->second);
 173 }
 174
 175 #define sMapMgr MapManager::Instance()
 176
 177 #endif