自学教程：C++ GetResetTimeFor函数代码示例

void DungeonResetScheduler::Update(){    time_t now = time(nullptr);    while (!m_resetTimeQueue.empty() && m_resetTimeQueue.begin()->first < now)    {        DungeonResetEvent& event = m_resetTimeQueue.begin()->second;        if (event.type == RESET_EVENT_NORMAL_DUNGEON)        {            // for individual normal instances, max creature respawn + X hours            m_InstanceSaves._ResetInstance(event.mapid, event.instanceId);        }        else        {            // global reset/warning for a certain map            time_t resetTime = GetResetTimeFor(event.mapid);            uint32 timeLeft = uint32(std::max(int32(resetTime - now), 0));            bool warn = event.type != RESET_EVENT_INFORM_LAST && event.type != RESET_EVENT_FORCED_INFORM_LAST;            m_InstanceSaves._ResetOrWarnAll(event.mapid, warn, timeLeft);            if (event.type != RESET_EVENT_INFORM_LAST && event.type != RESET_EVENT_FORCED_INFORM_LAST)            {                // schedule the next warning/reset                event.type = ResetEventType(event.type + 1);                ScheduleReset(true, resetTime - resetEventTypeDelay[event.type], event);            }            else            {                // re-schedule the next/new global reset/warning                // calculate the next reset time                InstanceTemplate const* instanceTemplate = ObjectMgr::GetInstanceTemplate(event.mapid);                MANGOS_ASSERT(instanceTemplate);                time_t next_reset = DungeonResetScheduler::CalculateNextResetTime(instanceTemplate, resetTime);                CharacterDatabase.DirectPExecute("UPDATE instance_reset SET resettime = '" UI64FMTD "' WHERE mapid = '%u'", uint64(next_reset), uint32(event.mapid));                SetResetTimeFor(event.mapid, next_reset);                ResetEventType type = RESET_EVENT_INFORM_1;                for (; type < RESET_EVENT_INFORM_LAST; type = ResetEventType(type + 1))                    if (next_reset > time_t(now + resetEventTypeDelay[type]))                        break;                // add new scheduler event to the queue                event.type = type;                ScheduleReset(true, next_reset - resetEventTypeDelay[event.type], event);            }        }        m_resetTimeQueue.erase(m_resetTimeQueue.begin());    }}

void DungeonResetScheduler::Update(){    time_t now = time(NULL);    while(!m_resetTimeQueue.empty() && (m_resetTimeQueue.begin()->first) < now)    {        DungeonResetEvent &event = m_resetTimeQueue.begin()->second;        if (event.type == RESET_EVENT_NORMAL_DUNGEON)        {            // for individual normal instances, max creature respawn + X hours            m_InstanceSaves._ResetInstance(event.mapid, event.instanceId);        }        else        {            // global reset/warning for a certain map            time_t resetTime = GetResetTimeFor(event.mapid,event.difficulty);            //MapDifficultyEntry const* mapDiff = GetMapDifficultyData(event.mapid,event.difficulty);            m_InstanceSaves._ResetOrWarnAll(event.mapid, event.difficulty, event.type != RESET_EVENT_INFORM_LAST, resetTime);            if(event.type != RESET_EVENT_INFORM_LAST)            {                // schedule the next warning/reset                event.type = ResetEventType(event.type+1);                ScheduleReset(true, resetTime - resetEventTypeDelay[event.type], event);            }            else            {                // re-schedule the next/new global reset/warning                // calculate the next reset time                MapDifficultyEntry const* mapDiff = GetMapDifficultyData(event.mapid,event.difficulty);                MANGOS_ASSERT(mapDiff);                time_t next_reset = DungeonResetScheduler::CalculateNextResetTime(mapDiff);                CharacterDatabase.DirectPExecute("UPDATE instance_reset SET resettime = '"UI64FMTD"' WHERE mapid = '%u' AND difficulty = '%u'", (uint64)next_reset, uint32(event.mapid), uint32(event.difficulty));                SetResetTimeFor(event.mapid, event.difficulty, next_reset);                ResetEventType type = RESET_EVENT_INFORM_1;                for (; type < RESET_EVENT_INFORM_LAST; type = ResetEventType(type + 1))                    if (next_reset > time_t(now + resetEventTypeDelay[type]))                        break;                // add new scheduler event to the queue                event.type = type;                ScheduleReset(true, next_reset - resetEventTypeDelay[event.type], event);            }        }        m_resetTimeQueue.erase(m_resetTimeQueue.begin());    }}

void InstanceSaveManager::_ResetSave(InstanceSaveHashMap::iterator &itr){    lock_instLists = true;    InstanceSave::PlayerListType &pList = itr->second->m_playerList;    for (InstanceSave::PlayerListType::iterator iter = pList.begin(), iter2; iter != pList.end(); )    {        iter2 = iter++;        PlayerUnbindInstanceNotExtended(*iter2, itr->second->GetMapId(), itr->second->GetDifficulty(), ObjectAccessor::GetObjectInOrOutOfWorld(MAKE_NEW_GUID(*iter2, 0, HIGHGUID_PLAYER), (Player*)NULL));    }    // delete stuff if no players left (noone extended id)    if (pList.empty())    {        // delete character_instance per id, delete instance per id        PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_INSTANCE_BY_INSTANCE);        stmt->setUInt32(0, itr->second->GetInstanceId());        CharacterDatabase.Execute(stmt);        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_INSTANCE_BY_INSTANCE);        stmt->setUInt32(0, itr->second->GetInstanceId());        CharacterDatabase.Execute(stmt);        // clear respawn times if the map is already unloaded and won't do it by itself        if (!sMapMgr->FindMap(itr->second->GetMapId(), itr->second->GetInstanceId()))            Map::DeleteRespawnTimesInDB(itr->second->GetMapId(), itr->second->GetInstanceId());        delete itr->second;        m_instanceSaveById.erase(itr);    }    else    {        // delete character_instance per id where extended = 0, transtaction with set extended = 0, transaction is used to avoid mysql thread races        SQLTransaction trans = CharacterDatabase.BeginTransaction();        PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_INSTANCE_BY_INSTANCE_NOT_EXTENDED);        stmt->setUInt32(0, itr->second->GetInstanceId());        trans->Append(stmt);        stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_INSTANCE_SET_NOT_EXTENDED);        stmt->setUInt32(0, itr->second->GetInstanceId());        trans->Append(stmt);        CharacterDatabase.CommitTransaction(trans);        // update reset time and extended reset time for instance save        itr->second->SetResetTime(GetResetTimeFor(itr->second->GetMapId(), itr->second->GetDifficulty()));        itr->second->SetExtendedResetTime(GetExtendedResetTimeFor(itr->second->GetMapId(), itr->second->GetDifficulty()));    }    lock_instLists = false;}

/*- adding instance into manager- called from InstanceMap::Add, _LoadBoundInstances, LoadGroups*/InstanceSave* InstanceSaveManager::AddInstanceSave(uint32 mapId, uint32 instanceId, Difficulty difficulty, time_t resetTime, bool canReset, bool load){    if (InstanceSave* old_save = GetInstanceSave(instanceId))        return old_save;    const MapEntry* entry = sMapStore.LookupEntry(mapId);    if (!entry)    {        TC_LOG_ERROR(LOG_FILTER_GENERAL, "InstanceSaveManager::AddInstanceSave: wrong mapid = %d, instanceid = %d!", mapId, instanceId);        return NULL;    }    if (instanceId == 0)    {        TC_LOG_ERROR(LOG_FILTER_GENERAL, "InstanceSaveManager::AddInstanceSave: mapid = %d, wrong instanceid = %d!", mapId, instanceId);        return NULL;    }    if (difficulty >= (entry->IsRaid() ? MAX_RAID_DIFFICULTY : MAX_DUNGEON_DIFFICULTY))    {        TC_LOG_ERROR(LOG_FILTER_GENERAL, "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->map_type == MAP_RAID || difficulty > DUNGEON_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(LOG_FILTER_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;    sScriptMgr->AllInstanceAdd(save);    return save;}

/*- adding instance into manager- called from InstanceMap::Add, _LoadBoundInstances, LoadGroups*/InstanceSave* InstanceSaveManager::AddInstanceSave(uint32 mapId, uint32 instanceId, Difficulty difficulty, time_t resetTime, bool canReset, bool load){    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;}

void InstanceSaveManager::Update(){    time_t now = time(NULL);    time_t t, t2;    while (!m_resetTimeQueue.empty())    {        t = m_resetTimeQueue.begin()->first;        if (t >= now)            break;        // if m_resetTime has new resetTime, then write it to Queue, not delete the active instance..         InstResetEvent &event = m_resetTimeQueue.begin()->second;        time_t resetTime = GetResetTimeFor(event.mapid, event.difficulty);        if (InstanceSave* save = GetInstanceSave(event.instanceId))        {            if (t2 = save->GetResetTime())                if (t2 >= t)                {                    m_resetTimeQueue.erase(m_resetTimeQueue.begin());                    m_resetTimeQueue.insert(std::pair<time_t, InstResetEvent>(t2, event));                    break;                }        }               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            _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());        }    }}

void InstanceSaveManager::Update(){    time_t now = time(NULL);    time_t t;    bool resetOccurred = false;    while (!m_resetTimeQueue.empty())    {        t = m_resetTimeQueue.begin()->first;        if (t >= now)            break;        InstResetEvent &event = m_resetTimeQueue.begin()->second;        if (event.type)        {            // global reset/warning for a certain map            time_t resetTime = GetResetTimeFor(event.mapid, event.difficulty);            bool warn = event.type < 5;            _ResetOrWarnAll(event.mapid, event.difficulty, warn, resetTime);            if (warn)            {                // schedule the next warning/reset                ++event.type;                ScheduleReset(resetTime - ResetTimeDelay[event.type-1], event);            }            else                resetOccurred = true;        }        m_resetTimeQueue.erase(m_resetTimeQueue.begin());    }    // pussywizard: send updated calendar and raid info    if (resetOccurred)    {        sLog->outString("Instance ID reset occurred, sending updated calendar and raid info to all players!");        WorldPacket dummy;        for (SessionMap::const_iterator itr = sWorld->GetAllSessions().begin(); itr != sWorld->GetAllSessions().end(); ++itr)            if (Player* plr = itr->second->GetPlayer())            {                itr->second->HandleCalendarGetCalendar(dummy);                plr->SendRaidInfo();            }    }}

/*- adding instance into manager- called from InstanceMap::Add, _LoadBoundInstances, LoadGroups*/InstanceSave* InstanceSaveManager::AddInstanceSave(uint32 mapId, uint32 instanceId, time_t resetTime, bool canReset, bool load){    if (InstanceSave* old_save = GetInstanceSave(instanceId))        return old_save;    const MapEntry* entry = sMapStore.LookupEntry(mapId);    if (!entry)    {        sLog->outError("InstanceSaveManager::AddInstanceSave: wrong mapid = %d, instanceid = %d!", mapId, instanceId);        return NULL;    }    if (instanceId == 0)    {        sLog->outError("InstanceSaveManager::AddInstanceSave: mapid = %d, wrong instanceid = %d!", mapId, instanceId);        return NULL;    }    if (!resetTime)    {        // initialize reset time        // for normal instances if no creatures are killed the instance will reset in two hours        if (entry->map_type == MAP_RAID)            resetTime = GetResetTimeFor(mapId);        else        {            resetTime = time(NULL) + 2 * HOUR;            // normally this will be removed soon after in InstanceMap::Add, prevent error            ScheduleReset(true, resetTime, InstResetEvent(0, mapId, instanceId));        }    }    sLog->outDebug(LOG_FILTER_MAPS, "InstanceSaveManager::AddInstanceSave: mapid = %d, instanceid = %d", mapId, instanceId);    InstanceSave* save = new InstanceSave(mapId, instanceId, resetTime, canReset);    if (!load)        save->SaveToDB();    m_instanceSaveById[instanceId] = save;    return save;}

/*- adding instance into manager*/InstanceSave* InstanceSaveManager::AddInstanceSave(uint32 mapId, uint32 instanceId, Difficulty difficulty, bool startup /*=false*/){    ASSERT(!GetInstanceSave(instanceId));    const MapEntry* entry = sMapStore.LookupEntry(mapId);    if (!entry)    {        sLog->outError("InstanceSaveManager::AddInstanceSave: wrong mapid = %d, instanceid = %d!", mapId, instanceId);        return NULL;    }    if (instanceId == 0)    {        sLog->outError("InstanceSaveManager::AddInstanceSave: mapid = %d, wrong instanceid = %d!", mapId, instanceId);        return NULL;    }    if (difficulty >= (entry->IsRaid() ? MAX_RAID_DIFFICULTY : MAX_DUNGEON_DIFFICULTY))    {        sLog->outError("InstanceSaveManager::AddInstanceSave: mapid = %d, instanceid = %d, wrong dificalty %u!", mapId, instanceId, difficulty);        return NULL;    }    time_t resetTime, extendedResetTime;    if (entry->map_type == MAP_RAID || difficulty > DUNGEON_DIFFICULTY_NORMAL)    {        resetTime = GetResetTimeFor(mapId, difficulty);        extendedResetTime = GetExtendedResetTimeFor(mapId, difficulty);    }    else    {        resetTime = time(NULL) + 3*DAY; // normals expire after 3 days even if someone is still bound to them, cleared on startup        extendedResetTime = 0;    }    InstanceSave* save = new InstanceSave(mapId, instanceId, difficulty, resetTime, extendedResetTime);    if (!startup)        save->InsertToDB();    m_instanceSaveById[instanceId] = save;    return save;}

//.........这里部分代码省略.........                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());            delete result;        }        // schedule the reset times        for(InstResetTimeMapDiffType::iterator itr = instResetTime.begin(); itr != instResetTime.end(); ++itr)            if(itr->second.second > now)                ScheduleReset(true, itr->second.second, InstanceResetEvent(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.getConfig(CONFIG_UINT32_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].GetUInt32();            Difficulty difficulty = Difficulty(fields[1].GetUInt32());            uint64 oldresettime = fields[2].GetUInt64();            MapDifficulty const* mapDiff = GetMapDifficultyData(mapid,difficulty);            if(!mapDiff)            {                sLog.outError("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 = '"UI64FMTD"' WHERE mapid = '%u' AND difficulty = '%u'", newresettime, mapid, difficulty);            SetResetTimeFor(mapid,difficulty,newresettime);        } while(result->NextRow());        delete result;    }    // clean expired instances, references to them will be deleted in CleanupInstances    // must be done before calculating new reset times    m_InstanceSaves._CleanupExpiredInstancesAtTime(now);    // 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(MapDifficultyMap::const_iterator itr = sMapDifficultyMap.begin(); itr != sMapDifficultyMap.end(); ++itr)    {        uint32 map_diff_pair = itr->first;        uint32 mapid = PAIR32_LOPART(map_diff_pair);        Difficulty difficulty = Difficulty(PAIR32_HIPART(map_diff_pair));        MapDifficulty const* mapDiff = &itr->second;        if (!mapDiff->resetTime)            continue;        // the reset_delay must be at least one day        uint32 period =  uint32(mapDiff->resetTime / DAY * sWorld.getConfig(CONFIG_FLOAT_RATE_INSTANCE_RESET_TIME)) * 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','"UI64FMTD"')", mapid, difficulty, (uint64)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);        }        SetResetTimeFor(mapid,difficulty,t);        // schedule the global reset/warning        uint8 type = 1;        static int tim[4] = {3600, 900, 300, 60};        for(; type < 4; type++)            if(t - tim[type-1] > now)                break;        for(ResetTimeMapDiffInstances::const_iterator in_itr = mapDiffResetInstances.lower_bound(map_diff_pair);            in_itr != mapDiffResetInstances.upper_bound(map_diff_pair); ++in_itr)        {            ScheduleReset(true, t - tim[type-1], InstanceResetEvent(type, mapid, difficulty, in_itr->second));        }    }}

//.........这里部分代码省略.........        result = CharacterDatabase.Query("SELECT MAX(respawntime), instance FROM creature_respawn WHERE instance > 0 GROUP BY instance");        if( result )        {            do            {                Field *fields = result->Fetch();                uint32 instance = fields[1].GetUInt32();                time_t resettime = time_t(fields[0].GetUInt64() + 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());            delete result;        }        // schedule the reset times        for(InstResetTimeMapDiffType::iterator itr = instResetTime.begin(); itr != instResetTime.end(); ++itr)            if(itr->second.second > now)                ScheduleReset(true, itr->second.second, InstanceResetEvent(RESET_EVENT_DUNGEON, 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.getConfig(CONFIG_UINT32_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].GetUInt32();            Difficulty difficulty = Difficulty(fields[1].GetUInt32());            uint64 oldresettime = fields[2].GetUInt64();            MapDifficulty const* mapDiff = GetMapDifficultyData(mapid,difficulty);            if(!mapDiff)            {                sLog.outError("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            uint32 offset = sMapStore.LookupEntry(mapid)->instanceResetOffset;            uint64 start_point = INSTANCE_RESET_SCHEDULE_START_TIME + offset + diff;            uint64 newresettime = start_point + uint32((oldresettime - start_point) / DAY) * DAY;            if(oldresettime != newresettime)                CharacterDatabase.DirectPExecute("UPDATE instance_reset SET resettime = '"UI64FMTD"' WHERE mapid = '%u' AND difficulty = '%u'", newresettime, mapid, difficulty);            SetResetTimeFor(mapid,difficulty,newresettime);        } while(result->NextRow());        delete result;    }    // clean expired instances, references to them will be deleted in CleanupInstances    // must be done before calculating new reset times    m_InstanceSaves._CleanupExpiredInstancesAtTime(now);    // 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(MapDifficultyMap::const_iterator itr = sMapDifficultyMap.begin(); itr != sMapDifficultyMap.end(); ++itr)    {        uint32 map_diff_pair = itr->first;        uint32 mapid = PAIR32_LOPART(map_diff_pair);        Difficulty difficulty = Difficulty(PAIR32_HIPART(map_diff_pair));        MapDifficulty const* mapDiff = &itr->second;        // skip mapDiff without global reset time        if (!mapDiff->resetTime)            continue;        uint32 period = GetMaxResetTimeFor(mapDiff);        time_t t = GetResetTimeFor(mapid,difficulty);        if(!t || t < now)        {            bool existsInDB = bool(t);            uint32 offset = sMapStore.LookupEntry(mapid)->instanceResetOffset;            uint64 start_point = INSTANCE_RESET_SCHEDULE_START_TIME + offset + diff;            t = start_point + uint32(ceil(float(now - start_point) / period) * period);            if(existsInDB)                CharacterDatabase.DirectPExecute("UPDATE instance_reset SET resettime = '"UI64FMTD"' WHERE mapid = '%u' AND difficulty= '%u'", (uint64)t, mapid, difficulty);            else                CharacterDatabase.DirectPExecute("INSERT INTO instance_reset VALUES ('%u','%u','"UI64FMTD"')", mapid, difficulty, (uint64)t);        }        SetResetTimeFor(mapid,difficulty,t);        // schedule the global reset/warning        ResetEventType type = RESET_EVENT_INFORM_1;        for(; type < RESET_EVENT_INFORM_LAST; type = ResetEventType(type+1))            if(t - resetEventTypeDelay[type] > now)                break;        ScheduleReset(true, t - resetEventTypeDelay[type], InstanceResetEvent(type, mapid, difficulty, 0));    }}

//.........这里部分代码省略.........            }            while (result->NextRow());            delete result;        }        // schedule the reset times        for (ResetTimeMapType::iterator itr = InstResetTime.begin(); itr != InstResetTime.end(); ++itr)            if (itr->second.second > now)                ScheduleReset(true, itr->second.second, DungeonResetEvent(RESET_EVENT_NORMAL_DUNGEON, itr->second.first, itr->first));    }    // load the global respawn times for raid/heroic instances    uint32 diff = sWorld.getConfig(CONFIG_UINT32_INSTANCE_RESET_TIME_HOUR) * HOUR;    m_resetTimeByMapId.resize(sMapStore.GetNumRows() + 1);    result = CharacterDatabase.Query("SELECT mapid, resettime FROM instance_reset");    if (result)    {        do        {            Field* fields = result->Fetch();            uint32 mapid            = fields[0].GetUInt32();            MapEntry const* mapEntry = sMapStore.LookupEntry(mapid);            if (!mapEntry || !mapEntry->IsDungeon() || !ObjectMgr::GetInstanceTemplate(mapid))            {                sLog.outError("MapPersistentStateManager::LoadResetTimes: invalid mapid %u in instance_reset!", mapid);                CharacterDatabase.DirectPExecute("DELETE FROM instance_reset WHERE mapid = '%u'", mapid);                continue;            }            // update the reset time if the hour in the configs changes            uint64 oldresettime = fields[1].GetUInt64();            uint64 newresettime = (oldresettime / DAY) * DAY + diff;            if (oldresettime != newresettime)                CharacterDatabase.DirectPExecute("UPDATE instance_reset SET resettime = '" UI64FMTD "' WHERE mapid = '%u'", newresettime, mapid);            SetResetTimeFor(mapid, newresettime);        }        while (result->NextRow());        delete result;    }    // clean expired instances, references to them will be deleted in CleanupInstances    // must be done before calculating new reset times    m_InstanceSaves._CleanupExpiredInstancesAtTime(now);    // 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 (uint32 i = 0; i < sInstanceTemplate.GetMaxEntry(); i++)    {        InstanceTemplate const* temp = ObjectMgr::GetInstanceTemplate(i);        if (!temp)            continue;        // only raid/heroic maps have a global reset time        MapEntry const* mapEntry = sMapStore.LookupEntry(temp->map);        if (!mapEntry || !mapEntry->IsDungeon() || !mapEntry->HasResetTime())            continue;        uint32 period = GetMaxResetTimeFor(temp);        time_t t = GetResetTimeFor(temp->map);        if (!t)        {            // initialize the reset time            // generate time by config on first server launch            tm localTm = *localtime(&now);            localTm.tm_hour = sWorld.getConfig(CONFIG_UINT32_QUEST_DAILY_RESET_HOUR);            localTm.tm_min = 0;            localTm.tm_sec = 0;            if (period > DAY) // resets bigger than 1 day start on config day                localTm.tm_mday += ((7 - localTm.tm_wday + sWorld.getConfig(CONFIG_UINT32_ARENA_FIRST_RESET_DAY)) % 7);            else // resets day and less start on next day                localTm.tm_mday += 1;            localTm.tm_isdst = -1;            t = mktime(&localTm);            CharacterDatabase.DirectPExecute("INSERT INTO instance_reset VALUES ('%u','" UI64FMTD "')", temp->map, (uint64)t);        }        if (t < now || t > nextWeek)        {            // 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'", (uint64)t, temp->map);        }        SetResetTimeFor(temp->map, t);        // schedule the global reset/warning        ResetEventType type = RESET_EVENT_INFORM_1;        for (; type < RESET_EVENT_INFORM_LAST; type = ResetEventType(type + 1))            if (t > time_t(now + resetEventTypeDelay[type]))                break;        ScheduleReset(true, t - resetEventTypeDelay[type], DungeonResetEvent(type, temp->map, 0));    }}

void InstanceSaveManager::_ResetOrWarnAll(uint32 mapid, bool warn, time_t resetTime){    // global reset for all instances of the given map    MapEntry const* mapEntry = sMapStore.LookupEntry(mapid);    if (!mapEntry->Instanceable())        return;    time_t now = time(NULL);    if (!warn)    {        // remove all binds to instances of the given map        for (InstanceSaveHashMap::iterator itr = m_instanceSaveById.begin(); itr != m_instanceSaveById.end();)        {            if (itr->second->GetMapId() == mapid)                _ResetSave(itr);            else                ++itr;        }        // delete them from the DB, even if not loaded        SQLTransaction trans = CharacterDatabase.BeginTransaction();        PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_INSTANCE_BY_MAP_DIFF);        stmt->setUInt16(0, uint16(mapid));        trans->Append(stmt);        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GROUP_INSTANCE_BY_MAP_DIFF);        stmt->setUInt16(0, uint16(mapid));        trans->Append(stmt);        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_INSTANCE_BY_MAP_DIFF);        stmt->setUInt16(0, uint16(mapid));        trans->Append(stmt);        CharacterDatabase.CommitTransaction(trans);        // calculate the next reset time        uint32 diff = sWorld->getIntConfig(CONFIG_INSTANCE_RESET_TIME_HOUR) * HOUR;        uint32 period = uint32(((GetResetTimeFor(mapid) * sWorld->getRate(RATE_INSTANCE_RESET_TIME))/DAY) * DAY);        if (period < DAY)            period = DAY;        uint32 next_reset = uint32(((resetTime + MINUTE) / DAY * DAY) + period + diff);        SetResetTimeFor(mapid, next_reset);        ScheduleReset(true, time_t(next_reset-3600), InstResetEvent(1, mapid, 0));        // Update it in the DB        stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GLOBAL_INSTANCE_RESETTIME);        stmt->setUInt32(0, next_reset);        stmt->setUInt16(1, uint16(mapid));        CharacterDatabase.Execute(stmt);    }    // note: this isn't fast but it's meant to be executed very rarely    Map const* map = sMapMgr->CreateBaseMap(mapid);    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(now - resetTime);            ((InstanceMap*)map2)->SendResetWarnings(timeLeft);        }        else            ((InstanceMap*)map2)->Reset(INSTANCE_RESET_GLOBAL);    }    // TODO: delete creature/gameobject respawn times even if the maps are not loaded}

void InstanceResetScheduler::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 instances so those are skipped    typedef std::map<uint32, std::pair<uint32, time_t> > ResetTimeMapType;    ResetTimeMapType InstResetTime;    QueryResult *result = CharacterDatabase.Query("SELECT id, map, resettime FROM instance WHERE resettime > 0");    if( result )    {        do        {            if(time_t resettime = time_t((*result)[2].GetUInt64()))            {                uint32 id = (*result)[0].GetUInt32();                uint32 mapid = (*result)[1].GetUInt32();                InstResetTime[id] = std::pair<uint32, uint64>(mapid, resettime);            }        }        while (result->NextRow());        delete result;        // update reset time for normal instances with the max creature respawn time + X hours        result = WorldDatabase.Query("SELECT MAX(respawntime), instance FROM creature_respawn WHERE instance > 0 GROUP BY instance");        if( result )        {            do            {                Field *fields = result->Fetch();                uint32 instance = fields[1].GetUInt32();                time_t resettime = time_t(fields[0].GetUInt64() + 2 * HOUR);                ResetTimeMapType::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());            delete result;        }        // schedule the reset times        for(ResetTimeMapType::iterator itr = InstResetTime.begin(); itr != InstResetTime.end(); ++itr)            if(itr->second.second > now)                ScheduleReset(true, itr->second.second, InstanceResetEvent(RESET_EVENT_DUNGEON, itr->second.first, itr->first));    }    // load the global respawn times for raid instances    uint32 diff = sWorld.getConfig(CONFIG_UINT32_INSTANCE_RESET_TIME_HOUR) * HOUR;    m_resetTimeByMapId.resize(sMapStore.GetNumRows()+1);    result = CharacterDatabase.Query("SELECT mapid, resettime FROM instance_reset");    if(result)    {        do        {            Field *fields = result->Fetch();            uint32 mapid = fields[0].GetUInt32();            if(!ObjectMgr::GetInstanceTemplate(mapid))            {                sLog.outError("InstanceSaveManager::LoadResetTimes: invalid mapid %u in instance_reset!", mapid);                CharacterDatabase.DirectPExecute("DELETE FROM instance_reset WHERE mapid = '%u'", mapid);                continue;            }            // update the reset time if the hour in the configs changes            uint64 oldresettime = fields[1].GetUInt64();            uint64 newresettime = (oldresettime / DAY) * DAY + diff;            if(oldresettime != newresettime)                CharacterDatabase.DirectPExecute("UPDATE instance_reset SET resettime = '"UI64FMTD"' WHERE mapid = '%u'", newresettime, mapid);            m_resetTimeByMapId[mapid] = newresettime;        } while(result->NextRow());        delete result;    }    // clean expired instances, references to them will be deleted in CleanupInstances    // must be done before calculating new reset times    m_InstanceSaves._CleanupExpiredInstancesAtTime(now);    // 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(uint32 i = 0; i < sInstanceTemplate.MaxEntry; i++)    {        // only raid maps have a global reset time        InstanceTemplate const* temp = ObjectMgr::GetInstanceTemplate(i);        if(!temp || !temp->reset_delay)            continue;        uint32 period = GetMaxResetTimeFor(temp);        time_t t = GetResetTimeFor(temp->map);        if(!t)        {            // initialize the reset time//.........这里部分代码省略.........

//.........这里部分代码省略.........            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;    if (QueryResult result = CharacterDatabase.Query("SELECT mapid, difficulty, resettime FROM instance_reset"))    {        do        {            Field* fields = result->Fetch();            uint32 mapid = fields[0].GetUInt16();            Difficulty difficulty = Difficulty(fields[1].GetUInt8());            uint64 oldresettime = fields[2].GetUInt64();            MapDifficulty const* mapDiff = GetMapDifficultyData(mapid, difficulty);            if (!mapDiff)            {                TC_LOG_ERROR("misc", "InstanceSaveManager::LoadResetTimes: invalid mapid(%u)/difficulty(%u) pair in instance_reset!", mapid, difficulty);                PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GLOBAL_INSTANCE_RESETTIME);                stmt->setUInt16(0, uint16(mapid));                stmt->setUInt8(1, uint8(difficulty));                CharacterDatabase.DirectExecute(stmt);                continue;            }            // update the reset time if the hour in the configs changes            uint64 newresettime = (oldresettime / DAY) * DAY + diff;            if (oldresettime != newresettime)            {                PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GLOBAL_INSTANCE_RESETTIME);                stmt->setUInt64(0, uint64(newresettime));                stmt->setUInt16(1, uint16(mapid));                stmt->setUInt8(2, uint8(difficulty));                CharacterDatabase.DirectExecute(stmt);            }            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 (MapDifficultyMap::const_iterator itr = sMapDifficultyMap.begin(); itr != sMapDifficultyMap.end(); ++itr)    {        uint32 map_diff_pair = itr->first;        uint32 mapid = PAIR32_LOPART(map_diff_pair);        Difficulty difficulty = Difficulty(PAIR32_HIPART(map_diff_pair));        MapDifficulty const* mapDiff = &itr->second;        if (!mapDiff->resetTime)            continue;        // the reset_delay must be at least one day        uint32 period = uint32(((mapDiff->resetTime * 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;            PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_GLOBAL_INSTANCE_RESETTIME);            stmt->setUInt16(0, uint16(mapid));            stmt->setUInt8(1, uint8(difficulty));            stmt->setUInt64(2, uint64(t));            CharacterDatabase.DirectExecute(stmt);        }        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;            PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GLOBAL_INSTANCE_RESETTIME);            stmt->setUInt64(0, uint64(t));            stmt->setUInt16(1, uint16(mapid));            stmt->setUInt8(2, uint8(difficulty));            CharacterDatabase.DirectExecute(stmt);        }        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(map_diff_pair);        for (; range.first != range.second; ++range.first)            ScheduleReset(true, t - ResetTimeDelay[type-1], InstResetEvent(type, mapid, difficulty, range.first->second));    }}

//.........这里部分代码省略.........        {            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();            MapDifficulty const* mapDiff = GetMapDifficultyData(mapid, difficulty);            if (!mapDiff)            {                sLog->outError("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);            SetResetTimeFor(mapid, difficulty, newresettime);        } while (result->NextRow());    }    ResetTimeMapDiffInstances::const_iterator in_itr;    // 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 (MapDifficultyMap::const_iterator itr = sMapDifficultyMap.begin(); itr != sMapDifficultyMap.end(); ++itr)    {        uint32 map_diff_pair = itr->first;        uint32 mapid = PAIR32_LOPART(map_diff_pair);        Difficulty difficulty = Difficulty(PAIR32_HIPART(map_diff_pair));        MapDifficulty const* mapDiff = &itr->second;        if (!mapDiff->resetTime)            continue;        // the reset_delay must be at least one day        uint32 period = uint32(((mapDiff->resetTime * 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);        }        SetResetTimeFor(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));        for (in_itr = mapDiffResetInstances.lower_bound(map_diff_pair); in_itr != mapDiffResetInstances.upper_bound(map_diff_pair); ++in_itr)            ScheduleReset(true, t - ResetTimeDelay[type-1], InstResetEvent(type, mapid, difficulty, in_itr->second));    }}

//.........这里部分代码省略.........                {                    CharacterDatabase.DirectPExecute("UPDATE instance SET resettime = '" UI64FMTD "' WHERE id = '%u'", uint64(resettime), instance);                    itr->second.second = resettime;                }            }            while (result->NextRow());            delete result;        }        // schedule the reset times        for(InstResetTimeMapDiffType::iterator itr = instResetTime.begin(); itr != instResetTime.end(); ++itr)            if(itr->second.second > now)                ScheduleReset(true, itr->second.second, DungeonResetEvent(RESET_EVENT_NORMAL_DUNGEON, 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.getConfig(CONFIG_UINT32_INSTANCE_RESET_TIME_HOUR) * HOUR;    result = CharacterDatabase.Query("SELECT mapid, difficulty, resettime FROM instance_reset");    if(result)    {        do        {            Field* fields = result->Fetch();            time_t oldresettime;            uint32 mapid = fields[0].GetUInt32();            Difficulty difficulty = Difficulty(fields[1].GetUInt32());            uint64 _oldresettime = fields[2].GetUInt64();            if (_oldresettime > uint64(time(NULL) + INSTANCE_MAX_RESET_OFFSET))            {                MapDifficultyEntry const* mapDiff = GetMapDifficultyData(mapid,Difficulty(difficulty));                oldresettime = DungeonResetScheduler::CalculateNextResetTime(mapDiff);                sLog.outErrorDb("Wrong reset time in group_instance corrected to: %ld", oldresettime);            }            else                oldresettime = time_t(_oldresettime);            MapEntry const* mapEntry = sMapStore.LookupEntry(mapid);            if (!mapEntry || !mapEntry->IsDungeon() || !GetMapDifficultyData(mapid,difficulty))            {                sLog.outError("MapPersistentStateManager::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            time_t newresettime = (oldresettime / DAY) * DAY + diff;            if(oldresettime != newresettime && newresettime > now)                CharacterDatabase.DirectPExecute("UPDATE instance_reset SET resettime = '" UI64FMTD "' WHERE mapid = '%u' AND difficulty = '%u'", (uint64)newresettime, mapid, difficulty);            SetResetTimeFor(mapid,difficulty,newresettime);        } while(result->NextRow());        delete result;    }    // clean expired instances, references to them will be deleted in CleanupInstances    // must be done before calculating new reset times    m_InstanceSaves._CleanupExpiredInstancesAtTime(now);    // 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(MapDifficultyMap::const_iterator itr = sMapDifficultyMap.begin(); itr != sMapDifficultyMap.end(); ++itr)    {        uint32 map_diff_pair = itr->first;        uint32 mapid = PAIR32_LOPART(map_diff_pair);        Difficulty difficulty = Difficulty(PAIR32_HIPART(map_diff_pair));        MapDifficultyEntry const* mapDiff = itr->second;        // skip mapDiff without global reset time        if (!mapDiff->resetTime)            continue;        MapEntry const* mapEntry = sMapStore.LookupEntry(mapid);        if (!mapEntry || !mapEntry->IsDungeon())            continue;        //time_t period = GetMaxResetTimeFor(mapDiff);        time_t t = GetResetTimeFor(mapid,difficulty);        if (!t || t < now || t > nextWeek)        {            t = CalculateNextResetTime(mapDiff);            CharacterDatabase.DirectPExecute("REPLACE INTO instance_reset VALUES ('%u','%u','" UI64FMTD "')", mapid, difficulty, (uint64)t);        }        SetResetTimeFor(mapid,difficulty,t);        // schedule the global reset/warning        ResetEventType type = RESET_EVENT_INFORM_1;        for (; type < RESET_EVENT_INFORM_LAST; type = ResetEventType(type + 1))            if (t > time_t(now + resetEventTypeDelay[type]))                break;        ScheduleReset(true, t - resetEventTypeDelay[type], DungeonResetEvent(type, mapid, difficulty, 0));    }}