Core/Maps: Removed MapInstanced - no longer neccessary for grid data reference counting (moved to TerrainInfo)

src/server/game/Maps/MapManager.cpp

@@ -16,34 +16,31 @@
  */
 
 #include "MapManager.h"
-#include "InstanceSaveMgr.h"
+#include "Battleground.h"
+#include "Containers.h"
 #include "DatabaseEnv.h"
 #include "DBCStores.h"
-#include "Log.h"
-#include "ObjectAccessor.h"
-#include "Transport.h"
-#include "GridDefines.h"
-#include "MapInstanced.h"
-#include "InstanceScript.h"
-#include "Config.h"
-#include "World.h"
-#include "Corpse.h"
-#include "ObjectMgr.h"
-#include "Language.h"
-#include "WorldPacket.h"
 #include "Group.h"
-#include "Player.h"
-#include "WorldSession.h"
+#include "InstanceSaveMgr.h"
+#include "Language.h"
+#include "Log.h"
+#include "Map.h"
 #include "Opcodes.h"
+#include "Player.h"
+#include "World.h"
+#include "WorldPacket.h"
+#include "WorldSession.h"
+#include <boost/dynamic_bitset.hpp>
+#include <numeric>
 
 MapManager::MapManager()
-    : _nextInstanceId(0), _scheduledScripts(0)
+    : _freeInstanceIds(std::make_unique<InstanceIds>()), _nextInstanceId(0), _scheduledScripts(0)
 {
     i_gridCleanUpDelay = sWorld->getIntConfig(CONFIG_INTERVAL_GRIDCLEAN);
     i_timer.SetInterval(sWorld->getIntConfig(CONFIG_INTERVAL_MAPUPDATE));
 }
 
-MapManager::~MapManager() { }
+MapManager::~MapManager() = default;
 
 void MapManager::Initialize()
 {
@@ -67,79 +64,182 @@ MapManager* MapManager::instance()
     return &instance;
 }
 
-Map* MapManager::CreateBaseMap(uint32 id)
+Map* MapManager::FindMap_i(uint32 mapId, uint32 instanceId) const
 {
-    Map* map = FindBaseMap(id);
+    return Trinity::Containers::MapGetValuePtr(i_maps, { mapId, instanceId });
+}
 
-    if (!map)
+Map* MapManager::CreateWorldMap(uint32 mapId, uint32 instanceId)
+{
+    Map* map = new Map(mapId, i_gridCleanUpDelay, instanceId, REGULAR_DIFFICULTY);
+    map->LoadRespawnTimes();
+    map->LoadCorpseData();
+
+    if (sWorld->getBoolConfig(CONFIG_BASEMAP_LOAD_GRIDS))
+        map->LoadAllCells();
+
+    return map;
+}
+
+InstanceMap* MapManager::CreateInstance(uint32 mapId, uint32 instanceId, InstanceSave* save, Difficulty difficulty, TeamId team)
+{
+    // make sure we have a valid map id
+    MapEntry const* entry = sMapStore.LookupEntry(mapId);
+    if (!entry)
     {
-        MapEntry const* entry = sMapStore.AssertEntry(id);
-        if (entry->ParentMapID != -1)
+        TC_LOG_ERROR("maps", "CreateInstance: no entry for map %d", mapId);
+        ABORT();
+    }
+
+    // some instances only have one difficulty
+    sDBCManager.GetDownscaledMapDifficultyData(mapId, difficulty);
+
+    TC_LOG_DEBUG("maps", "MapInstanced::CreateInstance: %s map instance %d for %d created with difficulty %u", save ? "" : "new ", instanceId, mapId, static_cast<uint32>(difficulty));
+
+    InstanceMap* map = new InstanceMap(mapId, i_gridCleanUpDelay, instanceId, difficulty, team);
+    ASSERT(map->IsDungeon());
+
+    map->LoadRespawnTimes();
+    map->LoadCorpseData();
+
+    bool load_data = save != nullptr;
+    map->CreateInstanceData(load_data);
+
+    if (sWorld->getBoolConfig(CONFIG_INSTANCEMAP_LOAD_GRIDS))
+        map->LoadAllCells();
+
+    return map;
+}
+
+BattlegroundMap* MapManager::CreateBattleground(uint32 mapId, uint32 instanceId, Battleground* bg)
+{
+    TC_LOG_DEBUG("maps", "MapInstanced::CreateBattleground: map bg %d for %d created.", instanceId, mapId);
+
+    BattlegroundMap* map = new BattlegroundMap(mapId, i_gridCleanUpDelay, instanceId, REGULAR_DIFFICULTY);
+    ASSERT(map->IsBattlegroundOrArena());
+    map->SetBG(bg);
+    bg->SetBgMap(map);
+    return map;
+}
+
+/*
+- return the right instance for the object, based on its InstanceId
+- create the instance if it's not created already
+- the player is not actually added to the instance (only in InstanceMap::Add)
+*/
+Map* MapManager::CreateMap(uint32 mapId, Player* player, uint32 loginInstanceId /*= 0*/)
+{
+    if (!player)
+        return nullptr;
+
+    MapEntry const* entry = sMapStore.LookupEntry(mapId);
+    if (!entry)
+        return nullptr;
+
+    std::unique_lock<std::shared_mutex> lock(_mapsLock);
+
+    Map* map = nullptr;
+    uint32 newInstanceId = 0;                       // instanceId of the resulting map
+
+    if (entry->IsBattlegroundOrArena())
+    {
+        // instantiate or find existing bg map for player
+        // the instance id is set in battlegroundid
+        newInstanceId = player->GetBattlegroundId();
+        if (!newInstanceId)
+            return nullptr;
+
+        map = FindMap(mapId, newInstanceId);
+        if (!map)
         {
-            CreateBaseMap(entry->ParentMapID);
-
-            // must have been created by parent map
-            map = FindBaseMap(id);
-            return ASSERT_NOTNULL(map);
+            if (Battleground* bg = player->GetBattleground())
+                map = CreateBattleground(mapId, newInstanceId, bg);
+            else
+            {
+                player->TeleportToBGEntryPoint();
+                return nullptr;
+            }
         }
-
-        std::lock_guard<std::mutex> lock(_mapsLock);
-        map = CreateBaseMap_i(entry);
     }
-
-    ASSERT(map);
-    return map;
-}
-
-Map* MapManager::CreateBaseMap_i(MapEntry const* mapEntry)
-{
-    Map* map;
-    if (mapEntry->Instanceable())
-        map = new MapInstanced(mapEntry->ID, i_gridCleanUpDelay);
-    else
-        map = new Map(mapEntry->ID, i_gridCleanUpDelay, 0, REGULAR_DIFFICULTY);
-
-    i_maps[mapEntry->ID] = map;
-
-    if (!mapEntry->Instanceable())
+    else if (entry->IsDungeon())
     {
-        map->LoadRespawnTimes();
-        map->LoadCorpseData();
+        InstancePlayerBind* pBind = player->GetBoundInstance(mapId, player->GetDifficulty(entry->IsRaid()));
+        InstanceSave* pSave = pBind ? pBind->save : nullptr;
+
+        // priority:
+        // 1. player's permanent bind
+        // 2. player's current instance id if this is at login
+        // 3. group's current bind
+        // 4. player's current bind
+        if (!pBind || !pBind->perm)
+        {
+            if (loginInstanceId) // if the player has a saved instance id on login, we either use this instance or relocate him out (return null)
+            {
+                map = FindMap_i(mapId, loginInstanceId);
+                if (!map && pSave && pSave->GetInstanceId() == loginInstanceId)
+                    map = CreateInstance(mapId, loginInstanceId, pSave, pSave->GetDifficulty(), player->GetTeamId());
+                return map;
+            }
+
+            InstanceGroupBind* groupBind = nullptr;
+            Group* group = player->GetGroup();
+            // use the player's difficulty setting (it may not be the same as the group's)
+            if (group)
+            {
+                groupBind = group->GetBoundInstance(entry);
+                if (groupBind)
+                {
+                    // solo saves should be reset when entering a group's instance
+                    player->UnbindInstance(mapId, player->GetDifficulty(entry->IsRaid()));
+                    pSave = groupBind->save;
+                }
+            }
+        }
+        if (pSave)
+        {
+            // solo/perm/group
+            newInstanceId = pSave->GetInstanceId();
+            map = FindMap_i(mapId, newInstanceId);
+            // it is possible that the save exists but the map doesn't
+            if (!map)
+                map = CreateInstance(mapId, newInstanceId, pSave, pSave->GetDifficulty(), player->GetTeamId());
+        }
+        else
+        {
+            Difficulty diff = player->GetGroup() ? player->GetGroup()->GetDifficulty(entry->IsRaid()) : player->GetDifficulty(entry->IsRaid());
+
+            // if no instanceId via group members or instance saves is found
+            // the instance will be created for the first time
+            newInstanceId = GenerateInstanceId();
+
+            //Seems it is now possible, but I do not know if it should be allowed
+            //ASSERT(!FindInstanceMap(NewInstanceId));
+            map = FindMap_i(mapId, newInstanceId);
+            if (!map)
+                map = CreateInstance(mapId, newInstanceId, nullptr, diff, player->GetTeamId());
+        }
+    }
+    else
+    {
+        newInstanceId = 0;
+        map = FindMap_i(mapId, newInstanceId);
+        if (!map)
+            map = CreateWorldMap(mapId, newInstanceId);
     }
 
+    if (map)
+        i_maps[{ map->GetId(), map->GetInstanceId() }] = map;
+
     return map;
 }
 
-Map* MapManager::FindBaseNonInstanceMap(uint32 mapId) const
+Map* MapManager::FindMap(uint32 mapId, uint32 instanceId) const
 {
-    Map* map = FindBaseMap(mapId);
-    if (map && map->Instanceable())
-        return nullptr;
-    return map;
-}
-
-Map* MapManager::CreateMap(uint32 id, Player* player, uint32 loginInstanceId)
-{
-    Map* m = CreateBaseMap(id);
-
-    if (m && m->Instanceable())
-        m = ((MapInstanced*)m)->CreateInstanceForPlayer(id, player, loginInstanceId);
-
-    return m;
-}
-
-Map* MapManager::FindMap(uint32 mapid, uint32 instanceId) const
-{
-    Map* map = FindBaseMap(mapid);
-    if (!map)
-        return nullptr;
-
-    if (!map->Instanceable())
-        return instanceId == 0 ? map : nullptr;
-
-    return ((MapInstanced*)map)->FindInstanceMap(instanceId);
+    std::shared_lock<std::shared_mutex> lock(_mapsLock);
+    return FindMap_i(mapId, instanceId);
 }
 
+/*
 Map::EnterState MapManager::PlayerCannotEnter(uint32 mapid, Player* player, bool loginCheck)
 {
     MapEntry const* entry = sMapStore.LookupEntry(mapid);
@@ -229,7 +329,7 @@ Map::EnterState MapManager::PlayerCannotEnter(uint32 mapid, Player* player, bool
     else
         return Map::CANNOT_ENTER_UNSPECIFIED_REASON;
 }
-
+*/
 void MapManager::Update(uint32 diff)
 {
     i_timer.Update(diff);
@@ -237,12 +337,24 @@ void MapManager::Update(uint32 diff)
         return;
 
     MapMapType::iterator iter = i_maps.begin();
-    for (; iter != i_maps.end(); ++iter)
+    while (iter != i_maps.end())
     {
+        if (iter->second->CanUnload(diff))
+        {
+            if (DestroyMap(iter->second))
+                iter = i_maps.erase(iter);
+            else
+                ++iter;
+
+            continue;
+        }
+
         if (m_updater.activated())
             m_updater.schedule_update(*iter->second, uint32(i_timer.GetCurrent()));
         else
             iter->second->Update(uint32(i_timer.GetCurrent()));
+
+        ++iter;
     }
     if (m_updater.activated())
         m_updater.wait();
@@ -253,7 +365,22 @@ void MapManager::Update(uint32 diff)
     i_timer.SetCurrent(0);
 }
 
-void MapManager::DoDelayedMovesAndRemoves() { }
+bool MapManager::DestroyMap(Map* map)
+{
+    map->RemoveAllPlayers();
+    if (map->HavePlayers())
+        return false;
+
+    map->UnloadAll();
+
+    // Free up the instance id and allow it to be reused for bgs and arenas (other instances are handled in the InstanceSaveMgr)
+    if (map->IsBattlegroundOrArena())
+        sMapMgr->FreeInstanceId(map->GetInstanceId());
+
+    // erase map
+    delete map;
+    return true;
+}
 
 bool MapManager::IsValidMAP(uint32 mapid, bool startUp)
 {
@@ -285,37 +412,16 @@ void MapManager::UnloadAll()
     Map::DeleteStateMachine();
 }
 
-uint32 MapManager::GetNumInstances()
+uint32 MapManager::GetNumInstances() const
 {
-    std::lock_guard<std::mutex> lock(_mapsLock);
-
-    uint32 ret = 0;
-    for (MapMapType::iterator itr = i_maps.begin(); itr != i_maps.end(); ++itr)
-    {
-        Map* map = itr->second;
-        if (!map->IsDungeon())
-            continue;
-        MapInstanced::InstancedMaps &maps = ((MapInstanced*)map)->GetInstancedMaps();
-        ret += maps.size();
-    }
-    return ret;
+    std::shared_lock<std::shared_mutex> lock(_mapsLock);
+    return std::count_if(i_maps.begin(), i_maps.end(), [](MapMapType::value_type const& value) { return value.second->IsDungeon(); });
 }
 
-uint32 MapManager::GetNumPlayersInInstances()
+uint32 MapManager::GetNumPlayersInInstances() const
 {
-    std::lock_guard<std::mutex> lock(_mapsLock);
-
-    uint32 ret = 0;
-    for (MapMapType::iterator itr = i_maps.begin(); itr != i_maps.end(); ++itr)
-    {
-        Map* map = itr->second;
-        if (!map->IsDungeon())
-            continue;
-        MapInstanced::InstancedMaps &maps = ((MapInstanced*)map)->GetInstancedMaps();
-        for (MapInstanced::InstancedMaps::iterator mitr = maps.begin(); mitr != maps.end(); ++mitr)
-            ret += mitr->second->GetPlayers().getSize();
-    }
-    return ret;
+    std::shared_lock<std::shared_mutex> lock(_mapsLock);
+    return std::accumulate(i_maps.begin(), i_maps.end(), 0u, [](uint32 total, MapMapType::value_type const& value) { return total + (value.second->IsDungeon() ? value.second->GetPlayers().getSize() : 0); });
 }
 
 void MapManager::InitInstanceIds()
@@ -323,18 +429,18 @@ void MapManager::InitInstanceIds()
     _nextInstanceId = 1;
 
     if (QueryResult result = CharacterDatabase.Query("SELECT IFNULL(MAX(id), 0) FROM instance"))
-        _freeInstanceIds.resize((*result)[0].GetUInt64() + 2, true); // make space for one extra to be able to access [_nextInstanceId] index in case all slots are taken
+        _freeInstanceIds->resize((*result)[0].GetUInt64() + 2, true); // make space for one extra to be able to access [_nextInstanceId] index in case all slots are taken
     else
-        _freeInstanceIds.resize(_nextInstanceId + 1, true);
+        _freeInstanceIds->resize(_nextInstanceId + 1, true);
 
     // never allow 0 id
-    _freeInstanceIds[0] = false;
+    _freeInstanceIds->set(0, false);
 }
 
 void MapManager::RegisterInstanceId(uint32 instanceId)
 {
     // Allocation and sizing was done in InitInstanceIds()
-    _freeInstanceIds[instanceId] = false;
+    _freeInstanceIds->set(instanceId, false);
 
     // Instances are pulled in ascending order from db and nextInstanceId is initialized with 1,
     // so if the instance id is used, increment until we find the first unused one for a potential new instance
@@ -352,15 +458,15 @@ uint32 MapManager::GenerateInstanceId()
     }
 
     uint32 newInstanceId = _nextInstanceId;
-    ASSERT(newInstanceId < _freeInstanceIds.size());
-    _freeInstanceIds[newInstanceId] = false;
+    ASSERT(newInstanceId < _freeInstanceIds->size());
+    _freeInstanceIds->set(newInstanceId, false);
 
     // Find the lowest available id starting from the current NextInstanceId (which should be the lowest according to the logic in FreeInstanceId()
-    size_t nextFreedId = _freeInstanceIds.find_next(_nextInstanceId++);
+    size_t nextFreedId = _freeInstanceIds->find_next(_nextInstanceId++);
     if (nextFreedId == InstanceIds::npos)
     {
-        _nextInstanceId = uint32(_freeInstanceIds.size());
-        _freeInstanceIds.push_back(true);
+        _nextInstanceId = uint32(_freeInstanceIds->size());
+        _freeInstanceIds->push_back(true);
     }
     else
         _nextInstanceId = uint32(nextFreedId);
@@ -372,5 +478,5 @@ void MapManager::FreeInstanceId(uint32 instanceId)
 {
     // If freed instance id is lower than the next id available for new instances, use the freed one instead
     _nextInstanceId = std::min(instanceId, _nextInstanceId);
-    _freeInstanceIds[instanceId] = true;
+    _freeInstanceIds->set(instanceId, true);
 }