src/game/MapManager.cpp

   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 #include "MapManager.h"
  20 #include "InstanceSaveMgr.h"
  21 #include "Policies/SingletonImp.h"
  22 #include "Database/DatabaseEnv.h"
  23 #include "Log.h"
  24 #include "ObjectAccessor.h"
  25 #include "Transports.h"
  26 #include "GridDefines.h"
  27 #include "MapInstanced.h"
  28 #include "DestinationHolderImp.h"
  29 #include "World.h"
  30 #include "CellImpl.h"
  31 #include "Corpse.h"
  32 #include "ObjectMgr.h"
  33
  34 #define CLASS_LOCK MaNGOS::ClassLevelLockable<MapManager, ACE_Thread_Mutex>
  35 INSTANTIATE_SINGLETON_2(MapManager, CLASS_LOCK);
  36 INSTANTIATE_CLASS_MUTEX(MapManager, ACE_Thread_Mutex);
  37
  38 extern GridState* si_GridStates[];                          // debugging code, should be deleted some day
  39
  40 MapManager::MapManager() : i_gridCleanUpDelay(sWorld.getConfig(CONFIG_INTERVAL_GRIDCLEAN))
  41 {
  42     i_timer.SetInterval(sWorld.getConfig(CONFIG_INTERVAL_MAPUPDATE));
  43 }
  44
  45 MapManager::~MapManager()
  46 {
  47     for(MapMapType::iterator iter=i_maps.begin(); iter != i_maps.end(); ++iter)
  48         delete iter->second;
  49
  50     for(TransportSet::iterator i = m_Transports.begin(); i != m_Transports.end(); ++i)
  51         delete *i;
  52
  53     Map::DeleteStateMachine();
  54 }
  55
  56 void
  57 MapManager::Initialize()
  58 {
  59     Map::InitStateMachine();
  60
  61     // debugging code, should be deleted some day
  62     {
  63         for(int i=0;i<MAX_GRID_STATE; i++)
  64         {
  65             i_GridStates[i] = si_GridStates[i];
  66         }
  67         i_GridStateErrorCount = 0;
  68     }
  69
  70     InitMaxInstanceId();
  71 }
  72
  73 // debugging code, should be deleted some day
  74 void MapManager::checkAndCorrectGridStatesArray()
  75 {
  76     bool ok = true;
  77     for(int i=0;i<MAX_GRID_STATE; i++)
  78     {
  79         if(i_GridStates[i] != si_GridStates[i])
  80         {
  81             sLog.outError("MapManager::checkGridStates(), GridState: si_GridStates is currupt !!!");
  82             ok = false;
  83             si_GridStates[i] = i_GridStates[i];
  84         }
  85         #ifdef MANGOS_DEBUG
  86         // inner class checking only when compiled with debug
  87         if(!si_GridStates[i]->checkMagic())
  88         {
  89             ok = false;
  90             si_GridStates[i]->setMagic();
  91         }
  92         #endif
  93     }
  94     if(!ok)
  95         ++i_GridStateErrorCount;
  96     if(i_GridStateErrorCount > 2)
  97         assert(false);                                      // force a crash. Too many errors
  98 }
  99
 100 Map*
 101 MapManager::_createBaseMap(uint32 id)
 102 {
 103     Map *m = _findMap(id);
 104
 105     if( m == NULL )
 106     {
 107         Guard guard(*this);
 108
 109         const MapEntry* entry = sMapStore.LookupEntry(id);
 110         if (entry && entry->Instanceable())
 111         {
 112             m = new MapInstanced(id, i_gridCleanUpDelay);
 113         }
 114         else
 115         {
 116             m = new Map(id, i_gridCleanUpDelay, 0, 0);
 117         }
 118         i_maps[id] = m;
 119     }
 120
 121     assert(m != NULL);
 122     return m;
 123 }
 124
 125 Map* MapManager::CreateMap(uint32 id, const WorldObject* obj)
 126 {
 127     ASSERT(obj);
 128     //if(!obj->IsInWorld()) sLog.outError("GetMap: called for map %d with object (typeid %d, guid %d, mapid %d, instanceid %d) who is not in world!", id, obj->GetTypeId(), obj->GetGUIDLow(), obj->GetMapId(), obj->GetInstanceId());
 129     Map *m = _createBaseMap(id);
 130
 131     if (m && (obj->GetTypeId() == TYPEID_PLAYER) && m->Instanceable()) m = ((MapInstanced*)m)->CreateInstance(id, (Player*)obj);
 132
 133     return m;
 134 }
 135
 136 Map* MapManager::FindMap(uint32 mapid, uint32 instanceId) const
 137 {
 138     Map *map = _findMap(mapid);
 139     if(!map)
 140         return NULL;
 141
 142     if(!map->Instanceable())
 143         return instanceId == 0 ? map : NULL;
 144
 145     return ((MapInstanced*)map)->FindMap(instanceId);
 146 }
 147
 148 /*
 149     checks that do not require a map to be created
 150     will send transfer error messages on fail
 151 */
 152 bool MapManager::CanPlayerEnter(uint32 mapid, Player* player)
 153 {
 154     const MapEntry *entry = sMapStore.LookupEntry(mapid);
 155     if(!entry) return false;
 156     const char *mapName = entry->name[player->GetSession()->GetSessionDbcLocale()];
 157
 158     if(entry->map_type == MAP_INSTANCE || entry->map_type == MAP_RAID)
 159     {
 160         if (entry->map_type == MAP_RAID)
 161         {
 162             // GMs can avoid raid limitations
 163             if(!player->isGameMaster() && !sWorld.getConfig(CONFIG_INSTANCE_IGNORE_RAID))
 164             {
 165                 // can only enter in a raid group
 166                 Group* group = player->GetGroup();
 167                 if (!group || !group->isRaidGroup())
 168                 {
 169                     // probably there must be special opcode, because client has this string constant in GlobalStrings.lua
 170                     // TODO: this is not a good place to send the message
 171                     player->GetSession()->SendAreaTriggerMessage("You must be in a raid group to enter %s instance", mapName);
 172                     sLog.outDebug("MAP: Player '%s' must be in a raid group to enter instance of '%s'", player->GetName(), mapName);
 173                     return false;
 174                 }
 175             }
 176         }
 177
 178         //The player has a heroic mode and tries to enter into instance which has no a heroic mode
 179         if (!entry->SupportsHeroicMode() && player->GetDifficulty() == DIFFICULTY_HEROIC)
 180         {
 181             //Send aborted message
 182             player->SendTransferAborted(mapid, TRANSFER_ABORT_DIFFICULTY, DIFFICULTY_HEROIC);
 183             return false;
 184         }
 185
 186         if (!player->isAlive())
 187         {
 188             if(Corpse *corpse = player->GetCorpse())
 189             {
 190                 // let enter in ghost mode in instance that connected to inner instance with corpse
 191                 uint32 instance_map = corpse->GetMapId();
 192                 do
 193                 {
 194                     if(instance_map==mapid)
 195                         break;
 196
 197                     InstanceTemplate const* instance = objmgr.GetInstanceTemplate(instance_map);
 198                     instance_map = instance ? instance->parent : 0;
 199                 }
 200                 while (instance_map);
 201
 202                 if (!instance_map)
 203                 {
 204                     player->GetSession()->SendAreaTriggerMessage("You cannot enter %s while in a ghost mode", mapName);
 205                     sLog.outDebug("MAP: Player '%s' doesn't has a corpse in instance '%s' and can't enter", player->GetName(), mapName);
 206                     return false;
 207                 }
 208                 sLog.outDebug("MAP: Player '%s' has corpse in instance '%s' and can enter", player->GetName(), mapName);
 209             }
 210             else
 211             {
 212                 sLog.outDebug("Map::CanEnter - player '%s' is dead but doesn't have a corpse!", player->GetName());
 213             }
 214         }
 215
 216         // TODO: move this to a map dependent location
 217         /*if(i_data && i_data->IsEncounterInProgress())
 218         {
 219             sLog.outDebug("MAP: Player '%s' can't enter instance '%s' while an encounter is in progress.", player->GetName(), GetMapName());
 220             player->SendTransferAborted(GetId(), TRANSFER_ABORT_ZONE_IN_COMBAT);
 221             return(false);
 222         }*/
 223         return true;
 224     }
 225     else
 226         return true;
 227 }
 228
 229 void MapManager::DeleteInstance(uint32 mapid, uint32 instanceId)
 230 {
 231     Map *m = _createBaseMap(mapid);
 232     if (m && m->Instanceable())
 233         ((MapInstanced*)m)->DestroyInstance(instanceId);
 234 }
 235
 236 void MapManager::RemoveBonesFromMap(uint32 mapid, uint64 guid, float x, float y)
 237 {
 238     bool remove_result = _createBaseMap(mapid)->RemoveBones(guid, x, y);
 239
 240     if (!remove_result)
 241     {
 242         sLog.outDebug("Bones %u not found in world. Delete from DB also.", GUID_LOPART(guid));
 243     }
 244 }
 245
 246 void
 247 MapManager::Update(uint32 diff)
 248 {
 249     i_timer.Update(diff);
 250     if( !i_timer.Passed() )
 251         return;
 252
 253     for(MapMapType::iterator iter=i_maps.begin(); iter != i_maps.end(); ++iter)
 254     {
 255         checkAndCorrectGridStatesArray();                   // debugging code, should be deleted some day
 256         iter->second->Update(i_timer.GetCurrent());
 257     }
 258
 259     ObjectAccessor::Instance().Update(i_timer.GetCurrent());
 260     for (TransportSet::iterator iter = m_Transports.begin(); iter != m_Transports.end(); ++iter)
 261         (*iter)->Update(i_timer.GetCurrent());
 262
 263     i_timer.SetCurrent(0);
 264 }
 265
 266 void MapManager::DoDelayedMovesAndRemoves()
 267 {
 268     for(MapMapType::iterator iter=i_maps.begin(); iter != i_maps.end(); ++iter)
 269         iter->second->DoDelayedMovesAndRemoves();
 270 }
 271
 272 bool MapManager::ExistMapAndVMap(uint32 mapid, float x,float y)
 273 {
 274     GridPair p = MaNGOS::ComputeGridPair(x,y);
 275
 276     int gx=63-p.x_coord;
 277     int gy=63-p.y_coord;
 278
 279     return Map::ExistMap(mapid,gx,gy) && Map::ExistVMap(mapid,gx,gy);
 280 }
 281
 282 bool MapManager::IsValidMAP(uint32 mapid)
 283 {
 284     MapEntry const* mEntry = sMapStore.LookupEntry(mapid);
 285     return mEntry && (!mEntry->IsDungeon() || objmgr.GetInstanceTemplate(mapid));
 286     // TODO: add check for battleground template
 287 }
 288
 289 void MapManager::UnloadAll()
 290 {
 291     for(MapMapType::iterator iter=i_maps.begin(); iter != i_maps.end(); ++iter)
 292         iter->second->UnloadAll(true);
 293
 294     while(!i_maps.empty())
 295     {
 296         delete i_maps.begin()->second;
 297         i_maps.erase(i_maps.begin());
 298     }
 299 }
 300
 301 void MapManager::InitMaxInstanceId()
 302 {
 303     i_MaxInstanceId = 0;
 304
 305     QueryResult *result = CharacterDatabase.Query( "SELECT MAX(id) FROM instance" );
 306     if( result )
 307     {
 308         i_MaxInstanceId = result->Fetch()[0].GetUInt32();
 309         delete result;
 310     }
 311 }
 312
 313 uint32 MapManager::GetNumInstances()
 314 {
 315     uint32 ret = 0;
 316     for(MapMapType::iterator itr = i_maps.begin(); itr != i_maps.end(); ++itr)
 317     {
 318         Map *map = itr->second;
 319         if(!map->Instanceable()) continue;
 320         MapInstanced::InstancedMaps &maps = ((MapInstanced *)map)->GetInstancedMaps();
 321         for(MapInstanced::InstancedMaps::iterator mitr = maps.begin(); mitr != maps.end(); ++mitr)
 322             if(mitr->second->IsDungeon()) ret++;
 323     }
 324     return ret;
 325 }
 326
 327 uint32 MapManager::GetNumPlayersInInstances()
 328 {
 329     uint32 ret = 0;
 330     for(MapMapType::iterator itr = i_maps.begin(); itr != i_maps.end(); ++itr)
 331     {
 332         Map *map = itr->second;
 333         if(!map->Instanceable()) continue;
 334         MapInstanced::InstancedMaps &maps = ((MapInstanced *)map)->GetInstancedMaps();
 335         for(MapInstanced::InstancedMaps::iterator mitr = maps.begin(); mitr != maps.end(); ++mitr)
 336             if(mitr->second->IsDungeon())
 337                 ret += ((InstanceMap*)mitr->second)->GetPlayers().getSize();
 338     }
 339     return ret;
 340 }