InstanceSaveManager Class Reference

#include <InstanceSaveMgr.h>

Classes
struct	InstResetEvent

Public Types
typedef std::unordered_map < uint32, InstanceSave * >	InstanceSaveHashMap
typedef std::multimap< time_t, InstResetEvent >	ResetTimeQueue

Public Member Functions
void	Unload ()
void	LoadInstances ()
void	LoadResetTimes ()
time_t	GetResetTimeFor (uint32 mapid, Difficulty d) const
time_t	GetSubsequentResetTime (uint32 mapid, Difficulty difficulty, time_t resetTime) const
void	InitializeResetTimeFor (uint32 mapid, Difficulty d, time_t t)
void	SetResetTimeFor (uint32 mapid, Difficulty d, time_t t)
ResetTimeByMapDifficultyMap const &	GetResetTimeMap () const
void	ScheduleReset (bool add, time_t time, InstResetEvent event)
void	ForceGlobalReset (uint32 mapId, Difficulty difficulty)
void	Update ()
InstanceSave *	AddInstanceSave (uint32 mapId, uint32 instanceId, Difficulty difficulty, time_t resetTime, bool canReset, bool load=false)
void	RemoveInstanceSave (uint32 InstanceId)
void	UnloadInstanceSave (uint32 InstanceId)
InstanceSave *	GetInstanceSave (uint32 InstanceId)
uint32	GetNumInstanceSaves () const
uint32	GetNumBoundPlayersTotal () const
uint32	GetNumBoundGroupsTotal () const

Static Public Member Functions
static InstanceSaveManager *	instance ()
static void	DeleteInstanceFromDB (uint32 instanceid)

Static Protected Attributes
static uint16	ResetTimeDelay [] = {3600, 900, 300, 60}

Private Member Functions
	InstanceSaveManager ()
	~InstanceSaveManager ()
void	_ResetOrWarnAll (uint32 mapid, Difficulty difficulty, bool warn, time_t resetTime)
void	_ResetInstance (uint32 mapid, uint32 instanceId)
void	_ResetSave (InstanceSaveHashMap::iterator &itr)

Private Attributes
bool	lock_instLists
InstanceSaveHashMap	m_instanceSaveById
ResetTimeByMapDifficultyMap	m_resetTimeByMapDifficulty
ResetTimeQueue	m_resetTimeQueue

Friends
class	InstanceSave

Member Typedef Documentation

typedef std::unordered_map<uint32 , InstanceSave*> InstanceSaveManager::InstanceSaveHashMap

typedef std::multimap<time_t , InstResetEvent> InstanceSaveManager::ResetTimeQueue

Constructor & Destructor Documentation

InstanceSaveManager::InstanceSaveManager ( )

inlineprivate

: lock_instLists(false) { };

InstanceSaveManager::~InstanceSaveManager ( )

private

{
}

Member Function Documentation

void InstanceSaveManager::_ResetInstance ( uint32  mapid, uint32  instanceId  )

private

{
 TC_LOG_DEBUG("maps", "InstanceSaveMgr::_ResetInstance %u, %u", mapid, instanceId);
 Map const* map = sMapMgr->CreateBaseMap(mapid);
 if (!map->Instanceable())
 return;

 InstanceSaveHashMap::iterator itr = m_instanceSaveById.find(instanceId);
 if (itr != m_instanceSaveById.end())
 _ResetSave(itr);

 DeleteInstanceFromDB(instanceId); // even if save not loaded

 Map* iMap = ((MapInstanced*)map)->FindInstanceMap(instanceId);

 if (iMap && iMap->IsDungeon())
 ((InstanceMap*)iMap)->Reset(INSTANCE_RESET_RESPAWN_DELAY);

 if (iMap)
 {
 iMap->DeleteRespawnTimes();
 iMap->DeleteCorpseData();
 }
 else
 Map::DeleteRespawnTimesInDB(mapid, instanceId);

 // Free up the instance id and allow it to be reused
 sMapMgr->FreeInstanceId(instanceId);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void InstanceSaveManager::_ResetOrWarnAll ( uint32  mapid, Difficulty  difficulty, bool  warn, time_t  resetTime  )

private

Todo:

delete creature/gameobject respawn times even if the maps are not loaded

{
 // global reset for all instances of the given map
 MapEntry const* mapEntry = sMapStore.LookupEntry(mapid);
 if (!mapEntry->Instanceable())
 return;
 TC_LOG_DEBUG("misc", "InstanceSaveManager::ResetOrWarnAll: Processing map %s (%u) on difficulty %u (warn? %u)", mapEntry->MapName_lang, mapid, uint8(difficulty), warn);

 time_t now = time(NULL);

 if (!warn)
 {
 // calculate the next reset time
 time_t next_reset = GetSubsequentResetTime(mapid, difficulty, resetTime);
 if (!next_reset)
 return;

 // delete/promote instance binds from the DB, even if not loaded
 SQLTransaction trans = CharacterDatabase.BeginTransaction();

 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_EXPIRED_CHAR_INSTANCE_BY_MAP_DIFF);
 stmt->setUInt16(0, uint16(mapid));
 stmt->setUInt8(1, uint8(difficulty));
 trans->Append(stmt);

 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GROUP_INSTANCE_BY_MAP_DIFF);
 stmt->setUInt16(0, uint16(mapid));
 stmt->setUInt8(1, uint8(difficulty));
 trans->Append(stmt);

 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_EXPIRED_INSTANCE_BY_MAP_DIFF);
 stmt->setUInt16(0, uint16(mapid));
 stmt->setUInt8(1, uint8(difficulty));
 trans->Append(stmt);

 stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_EXPIRE_CHAR_INSTANCE_BY_MAP_DIFF);
 stmt->setUInt16(0, uint16(mapid));
 stmt->setUInt8(1, uint8(difficulty));
 trans->Append(stmt);

 CharacterDatabase.CommitTransaction(trans);

 // promote loaded binds to instances of the given map
 for (InstanceSaveHashMap::iterator itr = m_instanceSaveById.begin(); itr != m_instanceSaveById.end();)
 {
 if (itr->second->GetMapId() == mapid && itr->second->GetDifficultyID() == difficulty)
 _ResetSave(itr);
 else
 ++itr;
 }

 SetResetTimeFor(mapid, difficulty, next_reset);
 ScheduleReset(true, time_t(next_reset-3600), InstResetEvent(1, mapid, difficulty, 0));

 // Update it in the DB
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GLOBAL_INSTANCE_RESETTIME);

 stmt->setUInt32(0, next_reset);
 stmt->setUInt16(1, uint16(mapid));
 stmt->setUInt8(2, uint8(difficulty));

 CharacterDatabase.Execute(stmt);
 }

 // note: this isn't fast but it's meant to be executed very rarely
 Map const* map = sMapMgr->CreateBaseMap(mapid); // _not_ include difficulty
 MapInstanced::InstancedMaps &instMaps = ((MapInstanced*)map)->GetInstancedMaps();
 MapInstanced::InstancedMaps::iterator mitr;
 uint32 timeLeft;

 for (mitr = instMaps.begin(); mitr != instMaps.end(); ++mitr)
 {
 Map* map2 = mitr->second;
 if (!map2->IsDungeon())
 continue;

 if (warn)
 {
 if (now >= resetTime)
 timeLeft = 0;
 else
 timeLeft = uint32(resetTime - now);

 ((InstanceMap*)map2)->SendResetWarnings(timeLeft);
 }
 else
 ((InstanceMap*)map2)->Reset(INSTANCE_RESET_GLOBAL);
 }

}

Here is the call graph for this function:

Here is the caller graph for this function:

void InstanceSaveManager::_ResetSave ( InstanceSaveHashMap::iterator &  itr )

private

{
 // unbind all players bound to the instance
 // do not allow UnbindInstance to automatically unload the InstanceSaves
 lock_instLists = true;

 bool shouldDelete = true;
 InstanceSave::PlayerListType &pList = itr->second->m_playerList;
 std::vector<Player*> temp; // list of expired binds that should be unbound
 for (Player* player : pList)
 {
 if (InstancePlayerBind* bind = player->GetBoundInstance(itr->second->GetMapId(), itr->second->GetDifficultyID()))
 {
 ASSERT(bind->save == itr->second);
 if (bind->perm && bind->extendState) // permanent and not already expired
 {
 // actual promotion in DB already happened in caller
 bind->extendState = bind->extendState == EXTEND_STATE_EXTENDED ? EXTEND_STATE_NORMAL : EXTEND_STATE_EXPIRED;
 shouldDelete = false;
 continue;
 }
 }
 temp.push_back(player);
 }
 for (Player* player : temp)
 {
 player->UnbindInstance(itr->second->GetMapId(), itr->second->GetDifficultyID(), true);
 }

 InstanceSave::GroupListType &gList = itr->second->m_groupList;
 while (!gList.empty())
 {
 Group* group = *(gList.begin());
 group->UnbindInstance(itr->second->GetMapId(), itr->second->GetDifficultyID(), true);
 }

 if (shouldDelete)
 {
 delete itr->second;
 itr = m_instanceSaveById.erase(itr);
 }
 else
 ++itr;

 lock_instLists = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

InstanceSave * InstanceSaveManager::AddInstanceSave	(	uint32	mapId,
		uint32	instanceId,
		Difficulty	difficulty,
		time_t	resetTime,
		bool	canReset,
		bool	load = false
	)

{
 if (InstanceSave* old_save = GetInstanceSave(instanceId))
 return old_save;

 const MapEntry* entry = sMapStore.LookupEntry(mapId);
 if (!entry)
 {
 TC_LOG_ERROR("misc", "InstanceSaveManager::AddInstanceSave: wrong mapid = %d, instanceid = %d!", mapId, instanceId);
 return NULL;
 }

 if (instanceId == 0)
 {
 TC_LOG_ERROR("misc", "InstanceSaveManager::AddInstanceSave: mapid = %d, wrong instanceid = %d!", mapId, instanceId);
 return NULL;
 }

 DifficultyEntry const* difficultyEntry = sDifficultyStore.LookupEntry(difficulty);
 if (!difficultyEntry || difficultyEntry->InstanceType != entry->InstanceType)
 {
 TC_LOG_ERROR("misc", "InstanceSaveManager::AddInstanceSave: mapid = %d, instanceid = %d, wrong dificalty %u!", mapId, instanceId, difficulty);
 return NULL;
 }

 if (!resetTime)
 {
 // initialize reset time
 // for normal instances if no creatures are killed the instance will reset in two hours
 if (entry->IsRaid() || difficulty > DIFFICULTY_NORMAL)
 resetTime = GetResetTimeFor(mapId, difficulty);
 else
 {
 resetTime = time(NULL) + 2 * HOUR;
 // normally this will be removed soon after in InstanceMap::Add, prevent error
 ScheduleReset(true, resetTime, InstResetEvent(0, mapId, difficulty, instanceId));
 }
 }

 TC_LOG_DEBUG("maps", "InstanceSaveManager::AddInstanceSave: mapid = %d, instanceid = %d", mapId, instanceId);

 InstanceSave* save = new InstanceSave(mapId, instanceId, difficulty, resetTime, canReset);
 if (!load)
 save->SaveToDB();

 m_instanceSaveById[instanceId] = save;
 return save;
}

Here is the call graph for this function:

void InstanceSaveManager::DeleteInstanceFromDB ( uint32  instanceid )

static

{
 SQLTransaction trans = CharacterDatabase.BeginTransaction();

 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_INSTANCE_BY_INSTANCE);
 stmt->setUInt32(0, instanceid);
 trans->Append(stmt);

 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_INSTANCE_BY_INSTANCE);
 stmt->setUInt32(0, instanceid);
 trans->Append(stmt);

 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GROUP_INSTANCE_BY_INSTANCE);
 stmt->setUInt32(0, instanceid);
 trans->Append(stmt);

 CharacterDatabase.CommitTransaction(trans);
 // Respawn times should be deleted only when the map gets unloaded
}

Here is the call graph for this function:

Here is the caller graph for this function:

void InstanceSaveManager::ForceGlobalReset	(	uint32	mapId,
		Difficulty	difficulty
	)

{
 if (!GetDownscaledMapDifficultyData(mapId, difficulty))
 return;
 // remove currently scheduled reset times
 ScheduleReset(false, 0, InstResetEvent(1, mapId, difficulty, 0));
 ScheduleReset(false, 0, InstResetEvent(4, mapId, difficulty, 0));
 // force global reset on the instance
 _ResetOrWarnAll(mapId, difficulty, false, time(nullptr));
}

Here is the call graph for this function:

InstanceSave * InstanceSaveManager::GetInstanceSave

(

uint32

InstanceId

)

{
 InstanceSaveHashMap::iterator itr = m_instanceSaveById.find(InstanceId);
 return itr != m_instanceSaveById.end() ? itr->second : NULL;
}

Here is the caller graph for this function:

uint32 InstanceSaveManager::GetNumBoundGroupsTotal

(

)

const

{
 uint32 ret = 0;
 for (InstanceSaveHashMap::const_iterator itr = m_instanceSaveById.begin(); itr != m_instanceSaveById.end(); ++itr)
 ret += itr->second->GetGroupCount();

 return ret;
}

uint32 InstanceSaveManager::GetNumBoundPlayersTotal

(

)

const

{
 uint32 ret = 0;
 for (InstanceSaveHashMap::const_iterator itr = m_instanceSaveById.begin(); itr != m_instanceSaveById.end(); ++itr)
 ret += itr->second->GetPlayerCount();

 return ret;
}

uint32 InstanceSaveManager::GetNumInstanceSaves ( ) const

inline

{ return uint32(m_instanceSaveById.size()); }

time_t InstanceSaveManager::GetResetTimeFor ( uint32  mapid, Difficulty  d  ) const

inline

 {
 ResetTimeByMapDifficultyMap::const_iterator itr = m_resetTimeByMapDifficulty.find(MAKE_PAIR64(mapid, d));
 return itr != m_resetTimeByMapDifficulty.end() ? itr->second : 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ResetTimeByMapDifficultyMap const& InstanceSaveManager::GetResetTimeMap ( ) const

inline

 {
 return m_resetTimeByMapDifficulty;
 }

time_t InstanceSaveManager::GetSubsequentResetTime	(	uint32	mapid,
		Difficulty	difficulty,
		time_t	resetTime
	)		const

{
 MapDifficultyEntry const* mapDiff = GetMapDifficultyData(mapid, difficulty);
 if (!mapDiff || !mapDiff->RaidDuration)
 {
 TC_LOG_ERROR("misc", "InstanceSaveManager::GetSubsequentResetTime: not valid difficulty or no reset delay for map %u", mapid);
 return 0;
 }

 time_t diff = sWorld->getIntConfig(CONFIG_INSTANCE_RESET_TIME_HOUR) * HOUR;
 time_t period = uint32(((mapDiff->RaidDuration * sWorld->getRate(RATE_INSTANCE_RESET_TIME)) / DAY) * DAY);
 if (period < DAY)
 period = DAY;

 return ((resetTime + MINUTE) / DAY * DAY) + period + diff;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void InstanceSaveManager::InitializeResetTimeFor ( uint32  mapid, Difficulty  d, time_t  t  )

inline

 {
 m_resetTimeByMapDifficulty[MAKE_PAIR64(mapid, d)] = t;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

InstanceSaveManager * InstanceSaveManager::instance ( )

static

{
 static InstanceSaveManager instance;
 return &instance;
}

Here is the caller graph for this function:

void InstanceSaveManager::LoadInstances

(

)

{
 uint32 oldMSTime = getMSTime();

 // Delete expired instances (Instance related spawns are removed in the following cleanup queries)
 CharacterDatabase.DirectExecute("DELETE i FROM instance i LEFT JOIN instance_reset ir ON mapid = map AND i.difficulty = ir.difficulty "
 "WHERE (i.resettime > 0 AND i.resettime < UNIX_TIMESTAMP()) OR (ir.resettime IS NOT NULL AND ir.resettime < UNIX_TIMESTAMP())");

 // Delete invalid character_instance and group_instance references
 CharacterDatabase.DirectExecute("DELETE ci.* FROM character_instance AS ci LEFT JOIN characters AS c ON ci.guid = c.guid WHERE c.guid IS NULL");
 CharacterDatabase.DirectExecute("DELETE gi.* FROM group_instance AS gi LEFT JOIN groups AS g ON gi.guid = g.guid WHERE g.guid IS NULL");

 // Delete invalid instance references
 CharacterDatabase.DirectExecute("DELETE i.* FROM instance AS i LEFT JOIN character_instance AS ci ON i.id = ci.instance LEFT JOIN group_instance AS gi ON i.id = gi.instance WHERE ci.guid IS NULL AND gi.guid IS NULL");

 // Delete invalid references to instance
 CharacterDatabase.DirectExecute("DELETE FROM creature_respawn WHERE instanceId > 0 AND instanceId NOT IN (SELECT id FROM instance)");
 CharacterDatabase.DirectExecute("DELETE FROM gameobject_respawn WHERE instanceId > 0 AND instanceId NOT IN (SELECT id FROM instance)");
 CharacterDatabase.DirectExecute("DELETE tmp.* FROM character_instance AS tmp LEFT JOIN instance ON tmp.instance = instance.id WHERE tmp.instance > 0 AND instance.id IS NULL");
 CharacterDatabase.DirectExecute("DELETE tmp.* FROM group_instance AS tmp LEFT JOIN instance ON tmp.instance = instance.id WHERE tmp.instance > 0 AND instance.id IS NULL");

 // Clean invalid references to instance
 CharacterDatabase.DirectExecute("UPDATE corpse SET instanceId = 0 WHERE instanceId > 0 AND instanceId NOT IN (SELECT id FROM instance)");
 CharacterDatabase.DirectExecute("UPDATE characters AS tmp LEFT JOIN instance ON tmp.instance_id = instance.id SET tmp.instance_id = 0 WHERE tmp.instance_id > 0 AND instance.id IS NULL");

 // Initialize instance id storage (Needs to be done after the trash has been clean out)
 sMapMgr->InitInstanceIds();

 // Load reset times and clean expired instances
 sInstanceSaveMgr->LoadResetTimes();

 TC_LOG_INFO("server.loading", ">> Loaded instances in %u ms", GetMSTimeDiffToNow(oldMSTime));

}

Here is the call graph for this function:

void InstanceSaveManager::LoadResetTimes

(

)

{
 time_t now = time(NULL);
 time_t today = (now / DAY) * DAY;

 // NOTE: Use DirectPExecute for tables that will be queried later

 // get the current reset times for normal instances (these may need to be updated)
 // these are only kept in memory for InstanceSaves that are loaded later
 // resettime = 0 in the DB for raid/heroic instances so those are skipped
 typedef std::pair<uint32 /*PAIR32(map, difficulty)*/, time_t> ResetTimeMapDiffType;
 typedef std::map<uint32, ResetTimeMapDiffType> InstResetTimeMapDiffType;
 InstResetTimeMapDiffType instResetTime;

 // index instance ids by map/difficulty pairs for fast reset warning send
 typedef std::multimap<uint32 /*PAIR32(map, difficulty)*/, uint32 /*instanceid*/ > ResetTimeMapDiffInstances;
 typedef std::pair<ResetTimeMapDiffInstances::const_iterator, ResetTimeMapDiffInstances::const_iterator> ResetTimeMapDiffInstancesBounds;
 ResetTimeMapDiffInstances mapDiffResetInstances;

 QueryResult result = CharacterDatabase.Query("SELECT id, map, difficulty, resettime FROM instance ORDER BY id ASC");
 if (result)
 {
 do
 {
 Field* fields = result->Fetch();

 uint32 instanceId = fields[0].GetUInt32();

 // 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
 if (sMapMgr->GetNextInstanceId() == instanceId)
 sMapMgr->SetNextInstanceId(instanceId + 1);

 // Mark instance id as being used
 sMapMgr->RegisterInstanceId(instanceId);

 if (time_t resettime = time_t(fields[3].GetUInt32()))
 {
 uint32 mapid = fields[1].GetUInt16();
 uint32 difficulty = fields[2].GetUInt8();

 instResetTime[instanceId] = ResetTimeMapDiffType(MAKE_PAIR32(mapid, difficulty), resettime);
 mapDiffResetInstances.insert(ResetTimeMapDiffInstances::value_type(MAKE_PAIR32(mapid, difficulty), instanceId));
 }
 }
 while (result->NextRow());

 // update reset time for normal instances with the max creature respawn time + X hours
 if (PreparedQueryResult result2 = CharacterDatabase.Query(CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAX_CREATURE_RESPAWNS)))
 {
 do
 {
 Field* fields = result2->Fetch();
 uint32 instance = fields[1].GetUInt32();
 time_t resettime = time_t(fields[0].GetUInt32() + 2 * HOUR);
 InstResetTimeMapDiffType::iterator itr = instResetTime.find(instance);
 if (itr != instResetTime.end() && itr->second.second != resettime)
 {
 CharacterDatabase.DirectPExecute("UPDATE instance SET resettime = '" UI64FMTD "' WHERE id = '%u'", uint64(resettime), instance);
 itr->second.second = resettime;
 }
 }
 while (result->NextRow());
 }

 // schedule the reset times
 for (InstResetTimeMapDiffType::iterator itr = instResetTime.begin(); itr != instResetTime.end(); ++itr)
 if (itr->second.second > now)
 ScheduleReset(true, itr->second.second, InstResetEvent(0, PAIR32_LOPART(itr->second.first), Difficulty(PAIR32_HIPART(itr->second.first)), itr->first));
 }

 // load the global respawn times for raid/heroic instances
 uint32 diff = sWorld->getIntConfig(CONFIG_INSTANCE_RESET_TIME_HOUR) * HOUR;
 result = CharacterDatabase.Query("SELECT mapid, difficulty, resettime FROM instance_reset");
 if (result)
 {
 do
 {
 Field* fields = result->Fetch();
 uint32 mapid = fields[0].GetUInt16();
 Difficulty difficulty = Difficulty(fields[1].GetUInt8());
 uint64 oldresettime = fields[2].GetUInt32();

 MapDifficultyEntry const* mapDiff = GetMapDifficultyData(mapid, difficulty);
 if (!mapDiff)
 {
 TC_LOG_ERROR("misc", "InstanceSaveManager::LoadResetTimes: invalid mapid(%u)/difficulty(%u) pair in instance_reset!", mapid, difficulty);
 CharacterDatabase.DirectPExecute("DELETE FROM instance_reset WHERE mapid = '%u' AND difficulty = '%u'", mapid, difficulty);
 continue;
 }

 // update the reset time if the hour in the configs changes
 uint64 newresettime = (oldresettime / DAY) * DAY + diff;
 if (oldresettime != newresettime)
 CharacterDatabase.DirectPExecute("UPDATE instance_reset SET resettime = '%u' WHERE mapid = '%u' AND difficulty = '%u'", uint32(newresettime), mapid, difficulty);

 InitializeResetTimeFor(mapid, difficulty, newresettime);
 } while (result->NextRow());
 }

 // calculate new global reset times for expired instances and those that have never been reset yet
 // add the global reset times to the priority queue
 for (auto& mapDifficultyPair : sMapDifficultyMap)
 {
 uint32 mapid = mapDifficultyPair.first;

 for (auto& difficultyPair : mapDifficultyPair.second)
 {
 Difficulty difficulty = Difficulty(difficultyPair.first);
 MapDifficultyEntry const* mapDiff = difficultyPair.second;
 if (!mapDiff->RaidDuration)
 continue;

 // the reset_delay must be at least one day
 uint32 period = uint32(((mapDiff->RaidDuration * sWorld->getRate(RATE_INSTANCE_RESET_TIME)) / DAY) * DAY);
 if (period < DAY)
 period = DAY;

 time_t t = GetResetTimeFor(mapid, difficulty);
 if (!t)
 {
 // initialize the reset time
 t = today + period + diff;
 CharacterDatabase.DirectPExecute("INSERT INTO instance_reset VALUES ('%u', '%u', '%u')", mapid, difficulty, (uint32)t);
 }

 if (t < now)
 {
 // assume that expired instances have already been cleaned
 // calculate the next reset time
 t = (t / DAY) * DAY;
 t += ((today - t) / period + 1) * period + diff;
 CharacterDatabase.DirectPExecute("UPDATE instance_reset SET resettime = '" UI64FMTD "' WHERE mapid = '%u' AND difficulty= '%u'", (uint64)t, mapid, difficulty);
 }

 InitializeResetTimeFor(mapid, difficulty, t);

 // schedule the global reset/warning
 uint8 type;
 for (type = 1; type < 4; ++type)
 if (t - ResetTimeDelay[type - 1] > now)
 break;

 ScheduleReset(true, t - ResetTimeDelay[type - 1], InstResetEvent(type, mapid, difficulty, 0));

 ResetTimeMapDiffInstancesBounds range = mapDiffResetInstances.equal_range(MAKE_PAIR32(mapid, difficulty));
 for (; range.first != range.second; ++range.first)
 ScheduleReset(true, t - ResetTimeDelay[type - 1], InstResetEvent(type, mapid, difficulty, range.first->second));
 }
 }
}

Here is the call graph for this function:

void InstanceSaveManager::RemoveInstanceSave

(

uint32

InstanceId

)

{
 InstanceSaveHashMap::iterator itr = m_instanceSaveById.find(InstanceId);
 if (itr != m_instanceSaveById.end())
 {
 // save the resettime for normal instances only when they get unloaded
 if (time_t resettime = itr->second->GetResetTimeForDB())
 {
 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_INSTANCE_RESETTIME);

 stmt->setUInt32(0, uint32(resettime));
 stmt->setUInt32(1, InstanceId);

 CharacterDatabase.Execute(stmt);
 }

 itr->second->SetToDelete(true);
 m_instanceSaveById.erase(itr);
 }
}

Here is the call graph for this function:

void InstanceSaveManager::ScheduleReset	(	bool	add,
		time_t	time,
		InstResetEvent	event
	)

{
 if (!add)
 {
 // find the event in the queue and remove it
 ResetTimeQueue::iterator itr;
 std::pair<ResetTimeQueue::iterator, ResetTimeQueue::iterator> range;
 range = m_resetTimeQueue.equal_range(time);
 for (itr = range.first; itr != range.second; ++itr)
 {
 if (itr->second == event)
 {
 m_resetTimeQueue.erase(itr);
 return;
 }
 }

 // in case the reset time changed (should happen very rarely), we search the whole queue
 if (itr == range.second)
 {
 for (itr = m_resetTimeQueue.begin(); itr != m_resetTimeQueue.end(); ++itr)
 {
 if (itr->second == event)
 {
 m_resetTimeQueue.erase(itr);
 return;
 }
 }

 if (itr == m_resetTimeQueue.end())
 TC_LOG_ERROR("misc", "InstanceSaveManager::ScheduleReset: cannot cancel the reset, the event(%d, %d, %d) was not found!", event.type, event.mapid, event.instanceId);
 }
 }
 else
 m_resetTimeQueue.insert(std::pair<time_t, InstResetEvent>(time, event));
}

Here is the caller graph for this function:

void InstanceSaveManager::SetResetTimeFor ( uint32  mapid, Difficulty  d, time_t  t  )

inline

 {
 ResetTimeByMapDifficultyMap::iterator itr = m_resetTimeByMapDifficulty.find(MAKE_PAIR64(mapid, d));
 ASSERT(itr != m_resetTimeByMapDifficulty.end());
 itr->second = t;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void InstanceSaveManager::Unload

(

)

{
 lock_instLists = true;
 for (InstanceSaveHashMap::iterator itr = m_instanceSaveById.begin(); itr != m_instanceSaveById.end(); ++itr)
 {
 InstanceSave* save = itr->second;

 for (InstanceSave::PlayerListType::iterator itr2 = save->m_playerList.begin(), next = itr2; itr2 != save->m_playerList.end(); itr2 = next)
 {
 ++next;
 (*itr2)->UnbindInstance(save->GetMapId(), save->GetDifficultyID(), true);
 }

 for (InstanceSave::GroupListType::iterator itr2 = save->m_groupList.begin(), next = itr2; itr2 != save->m_groupList.end(); itr2 = next)
 {
 ++next;
 (*itr2)->UnbindInstance(save->GetMapId(), save->GetDifficultyID(), true);
 }

 delete save;
 }
}

Here is the call graph for this function:

void InstanceSaveManager::UnloadInstanceSave

(

uint32

InstanceId

)

{
 if (InstanceSave* save = GetInstanceSave(InstanceId))
 save->UnloadIfEmpty();
}

Here is the call graph for this function:

void InstanceSaveManager::Update

(

)

{
 time_t now = time(NULL);
 time_t t;

 while (!m_resetTimeQueue.empty())
 {
 t = m_resetTimeQueue.begin()->first;
 if (t >= now)
 break;

 InstResetEvent &event = m_resetTimeQueue.begin()->second;
 if (event.type == 0)
 {
 // for individual normal instances, max creature respawn + X hours
 _ResetInstance(event.mapid, event.instanceId);
 m_resetTimeQueue.erase(m_resetTimeQueue.begin());
 }
 else
 {
 // global reset/warning for a certain map
 time_t resetTime = GetResetTimeFor(event.mapid, event.difficulty);
 _ResetOrWarnAll(event.mapid, event.difficulty, event.type != 4, resetTime);
 if (event.type != 4)
 {
 // schedule the next warning/reset
 ++event.type;
 ScheduleReset(true, resetTime - ResetTimeDelay[event.type-1], event);
 }
 m_resetTimeQueue.erase(m_resetTimeQueue.begin());
 }
 }
}

Here is the call graph for this function:

Friends And Related Function Documentation

friend class InstanceSave

friend

Member Data Documentation

bool InstanceSaveManager::lock_instLists

private

InstanceSaveHashMap InstanceSaveManager::m_instanceSaveById

private

ResetTimeByMapDifficultyMap InstanceSaveManager::m_resetTimeByMapDifficulty

private

ResetTimeQueue InstanceSaveManager::m_resetTimeQueue

private

uint16 InstanceSaveManager::ResetTimeDelay = {3600, 900, 300, 60}

staticprotected

---

The documentation for this class was generated from the following files:

• src/server/game/Instances/InstanceSaveMgr.h
• src/server/game/Instances/InstanceSaveMgr.cpp