Core/Pooling: Remove respawn times from the database when despawning a pool (#24422)

* Core/Pooling: Remove respawn times from the database when despawning a pool

Remove respawn times from the database when despawning a pool. This is needed when a Game Event ends but there are still some respawn times saved in the database.

* Remove respawn time of active pool objects even if they are not spawned

(cherry picked from commit 4f33fd3932d362466ee017111895bf14fcc79c88)

src/server/game/Maps/Map.cpp

@@ -3330,17 +3330,22 @@ void Map::DeleteRespawnInfo(RespawnInfo* info, CharacterDatabaseTransaction dbTr
     _respawnTimes.erase(info->handle);
 
     // database
-    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_RESPAWN);
-    stmt->setUInt16(0, info->type);
-    stmt->setUInt64(1, info->spawnId);
-    stmt->setUInt16(2, GetId());
-    stmt->setUInt32(3, GetInstanceId());
-    CharacterDatabase.ExecuteOrAppend(dbTrans, stmt);
+    DeleteRespawnInfoFromDB(info->type, info->spawnId, dbTrans);
 
     // then cleanup the object
     delete info;
 }
 
+void Map::DeleteRespawnInfoFromDB(SpawnObjectType type, ObjectGuid::LowType spawnId, CharacterDatabaseTransaction dbTrans)
+{
+    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_RESPAWN);
+    stmt->setUInt16(0, type);
+    stmt->setUInt64(1, spawnId);
+    stmt->setUInt16(2, GetId());
+    stmt->setUInt32(3, GetInstanceId());
+    CharacterDatabase.ExecuteOrAppend(dbTrans, stmt);
+}
+
 void Map::DoRespawn(SpawnObjectType type, ObjectGuid::LowType spawnId, uint32 gridId)
 {
     if (!IsGridLoaded(gridId)) // if grid isn't loaded, this will be processed in grid load handler

src/server/game/Maps/Map.h

@@ -753,6 +753,7 @@ class TC_GAME_API Map : public GridRefManager<NGridType>
         bool AddRespawnInfo(RespawnInfo const& info);
         void UnloadAllRespawnInfos();
         void DeleteRespawnInfo(RespawnInfo* info, CharacterDatabaseTransaction dbTrans = nullptr);
+        void DeleteRespawnInfoFromDB(SpawnObjectType type, ObjectGuid::LowType spawnId, CharacterDatabaseTransaction dbTrans = nullptr);
 
     public:
         void GetRespawnInfo(std::vector<RespawnInfo*>& respawnData, SpawnObjectTypeMask types) const;
@@ -763,10 +764,13 @@ class TC_GAME_API Map : public GridRefManager<NGridType>
                 Respawn(info, dbTrans);
         }
         void Respawn(RespawnInfo* info, CharacterDatabaseTransaction dbTrans = nullptr);
-        void RemoveRespawnTime(SpawnObjectType type, ObjectGuid::LowType spawnId, CharacterDatabaseTransaction dbTrans = nullptr)
+        void RemoveRespawnTime(SpawnObjectType type, ObjectGuid::LowType spawnId, CharacterDatabaseTransaction dbTrans = nullptr, bool alwaysDeleteFromDB = false)
         {
             if (RespawnInfo* info = GetRespawnInfo(type, spawnId))
                 DeleteRespawnInfo(info, dbTrans);
+            // Some callers might need to make sure the database doesn't contain any respawn time
+            else if (alwaysDeleteFromDB)
+                DeleteRespawnInfoFromDB(type, spawnId, dbTrans);
         }
         size_t DespawnAll(SpawnObjectType type, ObjectGuid::LowType spawnId);
 

src/server/game/Pools/PoolMgr.cpp

@@ -140,7 +140,7 @@ bool PoolGroup<T>::CheckPool() const
 // If no guid is passed, the pool is just removed (event end case)
 // If guid is filled, cache will be used and no removal will occur, it just fill the cache
 template<class T>
-void PoolGroup<T>::DespawnObject(ActivePoolData& spawns, uint64 guid)
+void PoolGroup<T>::DespawnObject(ActivePoolData& spawns, uint64 guid, bool alwaysDeleteRespawnTime)
 {
     for (size_t i=0; i < EqualChanced.size(); ++i)
     {
@@ -149,10 +149,12 @@ void PoolGroup<T>::DespawnObject(ActivePoolData& spawns, uint64 guid)
         {
             if (!guid || EqualChanced[i].guid == guid)
             {
-                Despawn1Object(EqualChanced[i].guid);
+                Despawn1Object(EqualChanced[i].guid, alwaysDeleteRespawnTime);
                 spawns.RemoveObject<T>(EqualChanced[i].guid, poolId);
             }
         }
+        else if (alwaysDeleteRespawnTime)
+            RemoveRespawnTimeFromDB(EqualChanced[i].guid);
     }
 
     for (size_t i = 0; i < ExplicitlyChanced.size(); ++i)
@@ -162,16 +164,18 @@ void PoolGroup<T>::DespawnObject(ActivePoolData& spawns, uint64 guid)
         {
             if (!guid || ExplicitlyChanced[i].guid == guid)
             {
-                Despawn1Object(ExplicitlyChanced[i].guid);
+                Despawn1Object(ExplicitlyChanced[i].guid, alwaysDeleteRespawnTime);
                 spawns.RemoveObject<T>(ExplicitlyChanced[i].guid, poolId);
             }
         }
+        else if (alwaysDeleteRespawnTime)
+            RemoveRespawnTimeFromDB(ExplicitlyChanced[i].guid);
     }
 }
 
 // Method that is actualy doing the removal job on one creature
 template<>
-void PoolGroup<Creature>::Despawn1Object(uint64 guid)
+void PoolGroup<Creature>::Despawn1Object(uint64 guid, bool alwaysDeleteRespawnTime)
 {
     if (CreatureData const* data = sObjectMgr->GetCreatureData(guid))
     {
@@ -190,13 +194,16 @@ void PoolGroup<Creature>::Despawn1Object(uint64 guid)
                     creature->SaveRespawnTime();
                 creature->AddObjectToRemoveList();
             }
+
+            if (alwaysDeleteRespawnTime)
+                map->RemoveRespawnTime(SpawnObjectType::SPAWN_TYPE_CREATURE, guid, nullptr, true);
         }
     }
 }
 
 // Same on one gameobject
 template<>
-void PoolGroup<GameObject>::Despawn1Object(uint64 guid)
+void PoolGroup<GameObject>::Despawn1Object(uint64 guid, bool alwaysDeleteRespawnTime)
 {
     if (GameObjectData const* data = sObjectMgr->GetGameObjectData(guid))
     {
@@ -216,13 +223,16 @@ void PoolGroup<GameObject>::Despawn1Object(uint64 guid)
                     go->SaveRespawnTime();
                 go->AddObjectToRemoveList();
             }
+
+            if (alwaysDeleteRespawnTime)
+                map->RemoveRespawnTime(SpawnObjectType::SPAWN_TYPE_GAMEOBJECT, guid, nullptr, true);
         }
     }
 }
 
 // Same on one pool
 template<>
-void PoolGroup<Pool>::Despawn1Object(uint64 child_pool_id)
+void PoolGroup<Pool>::Despawn1Object(uint64 child_pool_id, bool /*alwaysDeleteRespawnTime*/)
 {
     sPoolMgr->DespawnPool(child_pool_id);
 }
@@ -380,6 +390,35 @@ void PoolGroup<GameObject>::ReSpawn1Object(PoolObject* /*obj*/)
 template <>
 void PoolGroup<Pool>::ReSpawn1Object(PoolObject* /*obj*/) { }
 
+template <>
+void PoolGroup<Creature>::RemoveRespawnTimeFromDB(uint64 guid)
+{
+    if (CreatureData const* data = sObjectMgr->GetCreatureData(guid))
+    {
+        Map* map = sMapMgr->CreateBaseMap(data->mapId);
+        if (!map->Instanceable())
+        {
+            map->RemoveRespawnTime(SPAWN_TYPE_CREATURE, guid, nullptr, true);
+        }
+    }
+}
+
+template <>
+void PoolGroup<GameObject>::RemoveRespawnTimeFromDB(uint64 guid)
+{
+    if (GameObjectData const* data = sObjectMgr->GetGameObjectData(guid))
+    {
+        Map* map = sMapMgr->CreateBaseMap(data->mapId);
+        if (!map->Instanceable())
+        {
+            map->RemoveRespawnTime(SPAWN_TYPE_GAMEOBJECT, guid, nullptr, true);
+        }
+    }
+}
+
+template <>
+void PoolGroup<Pool>::RemoveRespawnTimeFromDB(uint64 /*guid*/) { }
+
 ////////////////////////////////////////////////////////////
 // Methods of class PoolMgr
 
@@ -737,12 +776,12 @@ void PoolMgr::DespawnPool(uint32 pool_id)
     {
         auto it = mPoolCreatureGroups.find(pool_id);
         if (it != mPoolCreatureGroups.end() && !it->second.isEmpty())
-            it->second.DespawnObject(mSpawnedData);
+            it->second.DespawnObject(mSpawnedData, 0, true);
     }
     {
         auto it = mPoolGameobjectGroups.find(pool_id);
         if (it != mPoolGameobjectGroups.end() && !it->second.isEmpty())
-            it->second.DespawnObject(mSpawnedData);
+            it->second.DespawnObject(mSpawnedData, 0, true);
     }
     {
         auto it = mPoolPoolGroups.find(pool_id);

src/server/game/Pools/PoolMgr.h

@@ -78,9 +78,10 @@ class TC_GAME_API PoolGroup
         bool isEmpty() const { return ExplicitlyChanced.empty() && EqualChanced.empty(); }
         void AddEntry(PoolObject& poolitem, uint32 maxentries);
         bool CheckPool() const;
-        void DespawnObject(ActivePoolData& spawns, uint64 guid=0);
-        void Despawn1Object(uint64 guid);
+        void DespawnObject(ActivePoolData& spawns, uint64 guid=0, bool alwaysDeleteRespawnTime = false);
+        void Despawn1Object(uint64 guid, bool alwaysDeleteRespawnTime = false);
         void SpawnObject(ActivePoolData& spawns, uint32 limit, uint64 triggerFrom);
+        void RemoveRespawnTimeFromDB(uint64 guid);
 
         void Spawn1Object(PoolObject* obj);
         void ReSpawn1Object(PoolObject* obj);