InstanceLockMgr.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "InstanceLockMgr.h"
#include "DatabaseEnv.h"
#include "DB2Stores.h"
#include "Errors.h"
#include "GameTime.h"
#include "Log.h"
#include "Map.h" // for TransferAbortReason
#include "MapManager.h"
#include "World.h"
 
InstanceLockData::InstanceLockData() = default;
InstanceLockData::~InstanceLockData() = default;
 
InstanceLock::InstanceLock(uint32 mapId, Difficulty difficultyId, InstanceResetTimePoint expiryTime, uint32 instanceId)
 : _mapId(mapId), _difficultyId(difficultyId), _instanceId(instanceId), _expiryTime(expiryTime), _extended(false),
 _isInUse(false), _isNew(false)
{
}
 
InstanceLock::~InstanceLock() = default;
 
bool InstanceLock::IsExpired() const
{
 return _expiryTime < GameTime::GetSystemTime();
}
 
InstanceResetTimePoint InstanceLock::GetEffectiveExpiryTime() const
{
 if (!IsExtended())
 return GetExpiryTime();
 
 MapDb2Entries entries{ _mapId, _difficultyId };
 
 // return next reset time
 if (IsExpired())
 return sInstanceLockMgr.GetNextResetTime(entries);
 
 // if not expired, return expiration time + 1 reset period
 return GetExpiryTime() + Seconds(entries.MapDifficulty->GetRaidDuration());
}
 
SharedInstanceLockData::SharedInstanceLockData() = default;
 
SharedInstanceLockData::~SharedInstanceLockData()
{
 // Cleanup database
 if (InstanceId)
 sInstanceLockMgr.OnSharedInstanceLockDataDelete(InstanceId);
}
 
SharedInstanceLock::SharedInstanceLock(uint32 mapId, Difficulty difficultyId, InstanceResetTimePoint expiryTime, uint32 instanceId,
 std::shared_ptr<SharedInstanceLockData> sharedData)
 : InstanceLock(mapId, difficultyId, expiryTime, instanceId), _sharedData(std::move(sharedData))
{
}
 
MapDb2Entries::MapDb2Entries(uint32 mapId, Difficulty difficulty)
 : Map(sMapStore.AssertEntry(mapId)), MapDifficulty(ASSERT_NOTNULL(sDB2Manager.GetMapDifficultyData(mapId, difficulty)))
{
}
 
MapDb2Entries::MapDb2Entries(MapEntry const* map, MapDifficultyEntry const* mapDifficulty)
 : Map(map), MapDifficulty(mapDifficulty)
{
}
 
InstanceLockKey MapDb2Entries::GetKey() const
{
 return { MapDifficulty->MapID, MapDifficulty->LockID };
}
 
bool MapDb2Entries::IsInstanceIdBound() const
{
 return !Map->IsFlexLocking() && !MapDifficulty->IsUsingEncounterLocks();
}
 
InstanceLockUpdateEvent::InstanceLockUpdateEvent(InstanceLockUpdateEvent&& other) noexcept = default;
InstanceLockUpdateEvent& InstanceLockUpdateEvent::operator=(InstanceLockUpdateEvent&&) noexcept = default;
InstanceLockUpdateEvent::~InstanceLockUpdateEvent() = default;
 
InstanceLockMgr::InstanceLockMgr() = default;
 
InstanceLockMgr::~InstanceLockMgr() = default;
 
void InstanceLockMgr::Load()
{
 std::unordered_map<uint32, std::shared_ptr<SharedInstanceLockData>> instanceLockDataById;
 
 // 0 1 2
 if (QueryResult result = CharacterDatabase.Query("SELECT instanceId, data, completedEncountersMask FROM instance"))
 {
 do
 {
 Field* fields = result->Fetch();
 uint32 instanceId = fields[0].GetUInt32();
 
 std::shared_ptr<SharedInstanceLockData> data = std::make_shared<SharedInstanceLockData>();
 data->Data = fields[1].GetString();
 data->CompletedEncountersMask = fields[2].GetUInt32();
 data->InstanceId = instanceId;
 
 instanceLockDataById[instanceId] = std::move(data);
 
 } while (result->NextRow());
 }
 
 // ORDER BY required by MapManager::RegisterInstanceId
 // 0 1 2 3 4 5 6 7 8
 if (QueryResult result = CharacterDatabase.Query("SELECT guid, mapId, lockId, instanceId, difficulty, data, completedEncountersMask, expiryTime, extended FROM character_instance_lock ORDER BY instanceId"))
 {
 do
 {
 Field* fields = result->Fetch();
 
 ObjectGuid playerGuid = ObjectGuid::Create<HighGuid::Player>(fields[0].GetUInt64());
 uint32 mapId = fields[1].GetUInt32();
 uint32 lockId = fields[2].GetUInt32();
 uint32 instanceId = fields[3].GetUInt32();
 Difficulty difficulty = Difficulty(fields[4].GetUInt8());
 InstanceResetTimePoint expiryTime = std::chrono::system_clock::from_time_t(time_t(fields[7].GetUInt64()));
 
 // Mark instance id as being used
 sMapMgr->RegisterInstanceId(instanceId);
 
 InstanceLock* instanceLock;
 if (MapDb2Entries{ mapId, difficulty }.IsInstanceIdBound())
 {
 auto sharedDataItr = instanceLockDataById.find(instanceId);
 if (sharedDataItr == instanceLockDataById.end())
 {
 TC_LOG_ERROR("instance.locks", "Missing instance data for instance id based lock (id {})", instanceId);
 CharacterDatabase.PExecute("DELETE FROM character_instance_lock WHERE instanceId = {}", instanceId);
 continue;
 }
 
 instanceLock = new SharedInstanceLock(mapId, difficulty, expiryTime, instanceId, sharedDataItr->second);
 _instanceLockDataById[instanceId] = sharedDataItr->second;
 }
 else
 instanceLock = new InstanceLock(mapId, difficulty, expiryTime, instanceId);
 
 instanceLock->GetData()->Data = fields[5].GetString();
 instanceLock->GetData()->CompletedEncountersMask = fields[6].GetUInt32();
 instanceLock->SetExtended(fields[8].GetBool());
 
 _instanceLocksByPlayer[playerGuid][InstanceLockKey{ mapId, lockId }].reset(instanceLock);
 
 } while (result->NextRow());
 }
}
 
void InstanceLockMgr::Unload()
{
 _unloading = true;
 _instanceLocksByPlayer.clear();
 _instanceLockDataById.clear();
}
 
TransferAbortReason InstanceLockMgr::CanJoinInstanceLock(ObjectGuid const& playerGuid, MapDb2Entries const& entries, InstanceLock const* instanceLock) const
{
 InstanceLock const* playerInstanceLock = FindActiveInstanceLock(playerGuid, entries);
 if (!playerInstanceLock)
 return TRANSFER_ABORT_NONE;
 
 if (entries.Map->IsFlexLocking())
 {
 // compare completed encounters - if instance has any encounters unkilled in players lock then cannot enter
 if (playerInstanceLock->GetData()->CompletedEncountersMask & ~instanceLock->GetData()->CompletedEncountersMask)
 return TRANSFER_ABORT_ALREADY_COMPLETED_ENCOUNTER;
 
 return TRANSFER_ABORT_NONE;
 }
 
 if (!entries.MapDifficulty->IsUsingEncounterLocks() && !playerInstanceLock->IsNew() && playerInstanceLock->GetInstanceId() != instanceLock->GetInstanceId())
 return TRANSFER_ABORT_LOCKED_TO_DIFFERENT_INSTANCE;
 
 return TRANSFER_ABORT_NONE;
}
 
InstanceLock* InstanceLockMgr::FindInstanceLock(LockMap const& locks, ObjectGuid const& playerGuid, MapDb2Entries const& entries)
{
 auto playerLocksItr = locks.find(playerGuid);
 if (playerLocksItr == locks.end())
 return nullptr;
 
 auto lockItr = playerLocksItr->second.find(entries.GetKey());
 if (lockItr == playerLocksItr->second.end())
 return nullptr;
 
 return lockItr->second.get();
}
 
InstanceLock* InstanceLockMgr::FindActiveInstanceLock(ObjectGuid const& playerGuid, MapDb2Entries const& entries) const
{
 return FindActiveInstanceLock(playerGuid, entries, false, true);
}
 
InstanceLock* InstanceLockMgr::FindActiveInstanceLock(ObjectGuid const& playerGuid, MapDb2Entries const& entries, bool ignoreTemporary, bool ignoreExpired) const
{
 if (!entries.MapDifficulty->HasResetSchedule())
 return nullptr;
 
 std::shared_lock<std::shared_mutex> guard(_locksMutex);
 
 InstanceLock* lock = FindInstanceLock(_instanceLocksByPlayer, playerGuid, entries);
 
 // Ignore expired and not extended locks
 if (lock && (!lock->IsExpired() || lock->IsExtended() || !ignoreExpired))
 return lock;
 
 if (ignoreTemporary)
 return nullptr;
 
 return FindInstanceLock(_temporaryInstanceLocksByPlayer, playerGuid, entries);
}
 
// used in world update thread (THREADUNSAFE packets) - no locking neccessary
std::vector<InstanceLock const*> InstanceLockMgr::GetInstanceLocksForPlayer(ObjectGuid const& playerGuid) const
{
 std::vector<InstanceLock const*> locks;
 auto playerLocksItr = _instanceLocksByPlayer.find(playerGuid);
 if (playerLocksItr != _instanceLocksByPlayer.end())
 {
 locks.reserve(playerLocksItr->second.size());
 std::transform(playerLocksItr->second.begin(), playerLocksItr->second.end(), std::back_inserter(locks),
 [](PlayerLockMap::value_type const& p) { return p.second.get(); });
 }
 
 return locks;
}
 
// used in world update thread (cross map teleportation) - no locking neccessary
InstanceLock* InstanceLockMgr::CreateInstanceLockForNewInstance(ObjectGuid const& playerGuid, MapDb2Entries const& entries, uint32 instanceId)
{
 if (!entries.MapDifficulty->HasResetSchedule())
 return nullptr;
 
 InstanceLock* instanceLock;
 if (entries.IsInstanceIdBound())
 {
 std::shared_ptr<SharedInstanceLockData> sharedData = std::make_shared<SharedInstanceLockData>();
 _instanceLockDataById[instanceId] = sharedData;
 instanceLock = new SharedInstanceLock(entries.MapDifficulty->MapID, Difficulty(entries.MapDifficulty->DifficultyID),
 GetNextResetTime(entries), instanceId, std::move(sharedData));
 }
 else
 instanceLock = new InstanceLock(entries.MapDifficulty->MapID, Difficulty(entries.MapDifficulty->DifficultyID),
 GetNextResetTime(entries), instanceId);
 
 instanceLock->SetIsNew(true);
 
 _temporaryInstanceLocksByPlayer[playerGuid][entries.GetKey()].reset(instanceLock);
 TC_LOG_DEBUG("instance.locks", "[{}-{} | {}-{}] Created new temporary instance lock for {} in instance {}",
 entries.Map->ID, entries.Map->MapName[sWorld->GetDefaultDbcLocale()],
 uint32(entries.MapDifficulty->DifficultyID), sDifficultyStore.AssertEntry(entries.MapDifficulty->DifficultyID)->Name[sWorld->GetDefaultDbcLocale()],
 playerGuid.ToString(), instanceId);
 return instanceLock;
}
 
InstanceLock* InstanceLockMgr::UpdateInstanceLockForPlayer(CharacterDatabaseTransaction trans, ObjectGuid const& playerGuid,
 MapDb2Entries const& entries, InstanceLockUpdateEvent&& updateEvent)
{
 InstanceLock* instanceLock = FindActiveInstanceLock(playerGuid, entries, true, true);
 if (!instanceLock)
 {
 std::unique_lock<std::shared_mutex> guard(_locksMutex);
 
 // Move lock from temporary storage if it exists there
 // This is to avoid destroying expired locks before any boss is killed in a fresh lock
 // player can still change his mind, exit instance and reactivate old lock
 auto playerLocksItr = _temporaryInstanceLocksByPlayer.find(playerGuid);
 if (playerLocksItr != _temporaryInstanceLocksByPlayer.end())
 {
 auto lockItr = playerLocksItr->second.find(entries.GetKey());
 if (lockItr != playerLocksItr->second.end())
 {
 instanceLock = lockItr->second.release();
 _instanceLocksByPlayer[playerGuid][entries.GetKey()].reset(instanceLock);
 
 playerLocksItr->second.erase(lockItr);
 if (playerLocksItr->second.empty())
 _temporaryInstanceLocksByPlayer.erase(playerLocksItr);
 
 TC_LOG_DEBUG("instance.locks", "[{}-{} | {}-{}] Promoting temporary lock to permanent for {} in instance {}",
 entries.Map->ID, entries.Map->MapName[sWorld->GetDefaultDbcLocale()],
 uint32(entries.MapDifficulty->DifficultyID), sDifficultyStore.AssertEntry(entries.MapDifficulty->DifficultyID)->Name[sWorld->GetDefaultDbcLocale()],
 playerGuid.ToString(), updateEvent.InstanceId);
 }
 }
 }
 
 if (!instanceLock)
 {
 if (entries.IsInstanceIdBound())
 {
 auto sharedDataItr = _instanceLockDataById.find(updateEvent.InstanceId);
 ASSERT(sharedDataItr != _instanceLockDataById.end());
 ASSERT(!sharedDataItr->second.expired());
 
 instanceLock = new SharedInstanceLock(entries.MapDifficulty->MapID, Difficulty(entries.MapDifficulty->DifficultyID),
 GetNextResetTime(entries), updateEvent.InstanceId, sharedDataItr->second.lock());
 ASSERT(static_cast<SharedInstanceLock*>(instanceLock)->GetSharedData()->InstanceId == updateEvent.InstanceId);
 }
 else
 instanceLock = new InstanceLock(entries.MapDifficulty->MapID, Difficulty(entries.MapDifficulty->DifficultyID),
 GetNextResetTime(entries), updateEvent.InstanceId);
 
 {
 std::unique_lock<std::shared_mutex> guard(_locksMutex);
 
 _instanceLocksByPlayer[playerGuid][entries.GetKey()].reset(instanceLock);
 }
 
 TC_LOG_DEBUG("instance.locks", "[{}-{} | {}-{}] Created new instance lock for {} in instance {}",
 entries.Map->ID, entries.Map->MapName[sWorld->GetDefaultDbcLocale()],
 uint32(entries.MapDifficulty->DifficultyID), sDifficultyStore.AssertEntry(entries.MapDifficulty->DifficultyID)->Name[sWorld->GetDefaultDbcLocale()],
 playerGuid.ToString(), updateEvent.InstanceId);
 }
 else
 {
 if (entries.IsInstanceIdBound())
 {
 ASSERT(instanceLock->GetInstanceId() == updateEvent.InstanceId);
 auto sharedDataItr = _instanceLockDataById.find(updateEvent.InstanceId);
 ASSERT(sharedDataItr != _instanceLockDataById.end());
 ASSERT(sharedDataItr->second.lock().get() == static_cast<SharedInstanceLock*>(instanceLock)->GetSharedData());
 }
 
 instanceLock->SetInstanceId(updateEvent.InstanceId);
 }
 
 instanceLock->SetIsNew(false);
 instanceLock->GetData()->Data = std::move(updateEvent.NewData);
 if (updateEvent.CompletedEncounter)
 {
 instanceLock->GetData()->CompletedEncountersMask |= 1u << updateEvent.CompletedEncounter->Bit;
 TC_LOG_DEBUG("instance.locks", "[{}-{} | {}-{}] Instance lock for {} in instance {} gains completed encounter [{}-{}]",
 entries.Map->ID, entries.Map->MapName[sWorld->GetDefaultDbcLocale()],
 uint32(entries.MapDifficulty->DifficultyID), sDifficultyStore.AssertEntry(entries.MapDifficulty->DifficultyID)->Name[sWorld->GetDefaultDbcLocale()],
 playerGuid.ToString(), updateEvent.InstanceId,
 updateEvent.CompletedEncounter->ID, updateEvent.CompletedEncounter->Name[sWorld->GetDefaultDbcLocale()]);
 }
 
 // Synchronize map completed encounters into players completed encounters for UI
 if (!entries.MapDifficulty->IsUsingEncounterLocks())
 instanceLock->GetData()->CompletedEncountersMask |= updateEvent.InstanceCompletedEncountersMask;
 
 if (updateEvent.EntranceWorldSafeLocId)
 instanceLock->GetData()->EntranceWorldSafeLocId = *updateEvent.EntranceWorldSafeLocId;
 
 if (instanceLock->IsExpired())
 {
 instanceLock->SetExpiryTime(GetNextResetTime(entries));
 instanceLock->SetExtended(false);
 TC_LOG_DEBUG("instance.locks", "[{}-{} | {}-{}] Expired instance lock for {} in instance {} is now active",
 entries.Map->ID, entries.Map->MapName[sWorld->GetDefaultDbcLocale()],
 uint32(entries.MapDifficulty->DifficultyID), sDifficultyStore.AssertEntry(entries.MapDifficulty->DifficultyID)->Name[sWorld->GetDefaultDbcLocale()],
 playerGuid.ToString(), updateEvent.InstanceId);
 }
 
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHARACTER_INSTANCE_LOCK);
 stmt->setUInt64(0, playerGuid.GetCounter());
 stmt->setUInt32(1, entries.MapDifficulty->MapID);
 stmt->setUInt32(2, entries.MapDifficulty->LockID);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHARACTER_INSTANCE_LOCK);
 stmt->setUInt64(0, playerGuid.GetCounter());
 stmt->setUInt32(1, entries.MapDifficulty->MapID);
 stmt->setUInt32(2, entries.MapDifficulty->LockID);
 stmt->setUInt32(3, instanceLock->GetInstanceId());
 stmt->setUInt8(4, entries.MapDifficulty->DifficultyID);
 stmt->setString(5, instanceLock->GetData()->Data);
 stmt->setUInt32(6, instanceLock->GetData()->CompletedEncountersMask);
 stmt->setUInt32(7, instanceLock->GetData()->EntranceWorldSafeLocId);
 stmt->setUInt64(8, uint64(std::chrono::system_clock::to_time_t(instanceLock->GetExpiryTime())));
 stmt->setUInt8(9, instanceLock->IsExtended() ? 1 : 0);
 trans->Append(stmt);
 
 return instanceLock;
}
 
void InstanceLockMgr::UpdateSharedInstanceLock(CharacterDatabaseTransaction trans, InstanceLockUpdateEvent&& updateEvent)
{
 auto sharedDataItr = _instanceLockDataById.find(updateEvent.InstanceId);
 ASSERT(sharedDataItr != _instanceLockDataById.end());
 std::shared_ptr<SharedInstanceLockData> sharedData = sharedDataItr->second.lock();
 ASSERT(sharedData);
 ASSERT(!sharedData->InstanceId || sharedData->InstanceId == updateEvent.InstanceId);
 sharedData->Data = std::move(updateEvent.NewData);
 sharedData->InstanceId = updateEvent.InstanceId;
 if (updateEvent.CompletedEncounter)
 {
 sharedData->CompletedEncountersMask |= 1u << updateEvent.CompletedEncounter->Bit;
 TC_LOG_DEBUG("instance.locks", "Instance {} gains completed encounter [{}-{}]",
 updateEvent.InstanceId, updateEvent.CompletedEncounter->ID, updateEvent.CompletedEncounter->Name[sWorld->GetDefaultDbcLocale()]);
 }
 
 if (updateEvent.EntranceWorldSafeLocId)
 sharedData->EntranceWorldSafeLocId = *updateEvent.EntranceWorldSafeLocId;
 
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_INSTANCE);
 stmt->setUInt32(0, sharedData->InstanceId);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_INSTANCE);
 stmt->setUInt32(0, sharedData->InstanceId);
 stmt->setString(1, sharedData->Data);
 stmt->setUInt32(2, sharedData->CompletedEncountersMask);
 stmt->setUInt32(3, sharedData->EntranceWorldSafeLocId);
 trans->Append(stmt);
}
 
void InstanceLockMgr::OnSharedInstanceLockDataDelete(uint32 instanceId)
{
 if (_unloading)
 return;
 
 auto itr = _instanceLockDataById.find(instanceId);
 if (itr == _instanceLockDataById.end())
 return;
 
 // weak_ptr state must be checked as well, it might be pointing to a different and valid lock data
 if (!itr->second.expired())
 return;
 
 _instanceLockDataById.erase(itr);
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_INSTANCE);
 stmt->setUInt32(0, instanceId);
 CharacterDatabase.Execute(stmt);
 TC_LOG_DEBUG("instance.locks", "Deleting instance {} as it is no longer referenced by any player", instanceId);
}
 
std::pair<InstanceResetTimePoint, InstanceResetTimePoint> InstanceLockMgr::UpdateInstanceLockExtensionForPlayer(ObjectGuid const& playerGuid,
 MapDb2Entries const& entries, bool extended)
{
 if (InstanceLock* instanceLock = FindActiveInstanceLock(playerGuid, entries, true, false))
 {
 InstanceResetTimePoint oldExpiryTime = instanceLock->GetEffectiveExpiryTime();
 instanceLock->SetExtended(extended);
 
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHARACTER_INSTANCE_LOCK_EXTENSION);
 stmt->setUInt8(0, extended ? 1 : 0);
 stmt->setUInt64(1, playerGuid.GetCounter());
 stmt->setUInt32(2, entries.MapDifficulty->MapID);
 stmt->setUInt32(3, entries.MapDifficulty->LockID);
 CharacterDatabase.Execute(stmt);
 
 TC_LOG_DEBUG("instance.locks", "[{}-{} | {}-{}] Instance lock for {} is {} extended",
 entries.Map->ID, entries.Map->MapName[sWorld->GetDefaultDbcLocale()],
 uint32(entries.MapDifficulty->DifficultyID), sDifficultyStore.AssertEntry(entries.MapDifficulty->DifficultyID)->Name[sWorld->GetDefaultDbcLocale()],
 playerGuid.ToString(), extended ? "now" : "no longer");
 
 return { oldExpiryTime, instanceLock->GetEffectiveExpiryTime() };
 }
 
 return { InstanceResetTimePoint::min(), InstanceResetTimePoint::min() };
}
 
void InstanceLockMgr::ResetInstanceLocksForPlayer(ObjectGuid const& playerGuid, Optional<uint32> mapId, Optional<Difficulty> difficulty,
 std::vector<InstanceLock const*>* locksReset, std::vector<InstanceLock const*>* locksFailedToReset)
{
 auto playerLocksItr = _instanceLocksByPlayer.find(playerGuid);
 if (playerLocksItr == _instanceLocksByPlayer.end())
 return;
 
 for (PlayerLockMap::value_type const& playerLockPair : playerLocksItr->second)
 {
 if (playerLockPair.second->IsInUse())
 {
 locksFailedToReset->push_back(playerLockPair.second.get());
 continue;
 }
 
 if (mapId && *mapId != playerLockPair.second->GetMapId())
 continue;
 
 if (difficulty && *difficulty != playerLockPair.second->GetDifficultyId())
 continue;
 
 if (playerLockPair.second->IsExpired())
 continue;
 
 locksReset->push_back(playerLockPair.second.get());
 }
 
 if (!locksReset->empty())
 {
 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 for (InstanceLock const* instanceLock : *locksReset)
 {
 MapDb2Entries entries(instanceLock->GetMapId(), instanceLock->GetDifficultyId());
 InstanceResetTimePoint newExpiryTime = GetNextResetTime(entries) - Seconds(entries.MapDifficulty->GetRaidDuration());
 // set reset time to last reset time
 const_cast<InstanceLock*>(instanceLock)->SetExpiryTime(newExpiryTime);
 const_cast<InstanceLock*>(instanceLock)->SetExtended(false);
 
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHARACTER_INSTANCE_LOCK_FORCE_EXPIRE);
 stmt->setUInt64(0, uint64(std::chrono::system_clock::to_time_t(newExpiryTime)));
 stmt->setUInt64(1, playerGuid.GetCounter());
 stmt->setUInt32(2, entries.MapDifficulty->MapID);
 stmt->setUInt32(3, entries.MapDifficulty->LockID);
 trans->Append(stmt);
 }
 CharacterDatabase.CommitTransaction(trans);
 }
}
 
InstanceLocksStatistics InstanceLockMgr::GetStatistics() const
{
 InstanceLocksStatistics statistics;
 statistics.InstanceCount = _instanceLockDataById.size();
 statistics.PlayerCount = _instanceLocksByPlayer.size();
 return statistics;
}
 
InstanceResetTimePoint InstanceLockMgr::GetNextResetTime(MapDb2Entries const& entries)
{
 tm dateTime = *GameTime::GetDateAndTime();
 dateTime.tm_sec = 0;
 dateTime.tm_min = 0;
 int32 resetHour = sWorld->getIntConfig(CONFIG_RESET_SCHEDULE_HOUR);
 switch (entries.MapDifficulty->ResetInterval)
 {
 case MAP_DIFFICULTY_RESET_DAILY:
 {
 if (dateTime.tm_hour >= resetHour)
 ++dateTime.tm_mday;
 
 dateTime.tm_hour = resetHour;
 break;
 }
 case MAP_DIFFICULTY_RESET_WEEKLY:
 {
 int32 resetDay = sWorld->getIntConfig(CONFIG_RESET_SCHEDULE_WEEK_DAY);
 int32 daysAdjust = resetDay - dateTime.tm_wday;
 if (dateTime.tm_wday > resetDay || (dateTime.tm_wday == resetDay && dateTime.tm_hour >= resetHour))
 daysAdjust += 7; // passed it for current week, grab time from next week
 
 dateTime.tm_hour = resetHour;
 dateTime.tm_mday += daysAdjust;
 break;
 }
 default:
 break;
 }
 
 return std::chrono::system_clock::from_time_t(mktime(&dateTime));
}
 
InstanceLockMgr& InstanceLockMgr::Instance()
{
 static InstanceLockMgr instance;
 return instance;
}