src/game/InstanceSaveMgr.cpp

   1 /*
   2  * Copyright (C) 2005,2006,2007 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "Common.h"
  20 #include "Database/SQLStorage.h"
  21
  22 #include "Player.h"
  23 #include "GridNotifiers.h"
  24 #include "Log.h"
  25 #include "GridStates.h"
  26 #include "CellImpl.h"
  27 #include "Map.h"
  28 #include "MapManager.h"
  29 #include "MapInstanced.h"
  30 #include "InstanceSaveMgr.h"
  31 #include "Timer.h"
  32 #include "GridNotifiersImpl.h"
  33 #include "Config/ConfigEnv.h"
  34 #include "Transports.h"
  35 #include "ObjectMgr.h"
  36 #include "World.h"
  37 #include "Group.h"
  38 #include "InstanceData.h"
  39 #include "ProgressBar.h"
  40
  41 INSTANTIATE_SINGLETON_1( InstanceSaveManager );
  42
  43 InstanceSaveManager::InstanceSaveManager() : lock_instLists(false)
  44 {
  45 }
  46
  47 InstanceSaveManager::~InstanceSaveManager()
  48 {
  49     // it is undefined whether this or objectmgr will be unloaded first
  50     // so we must be prepared for both cases
  51     lock_instLists = true;
  52     for (InstanceSaveHashMap::iterator itr = m_instanceSaveById.begin(); itr != m_instanceSaveById.end(); ++itr)
  53     {
  54         InstanceSave *save = itr->second;
  55         for(InstanceSave::PlayerListType::iterator itr2 = save->m_playerList.begin(), next = itr2; itr2 != save->m_playerList.end(); itr2 = next)
  56         {
  57             ++next;
  58             (*itr2)->UnbindInstance(save->GetMapId(), save->GetDifficulty(), true);
  59         }
  60         save->m_playerList.clear();
  61         for(InstanceSave::GroupListType::iterator itr2 = save->m_groupList.begin(), next = itr2; itr2 != save->m_groupList.end(); itr2 = next)
  62         {
  63             ++next;
  64             (*itr2)->UnbindInstance(save->GetMapId(), save->GetDifficulty(), true);
  65         }
  66         save->m_groupList.clear();
  67         delete save;
  68     }
  69 }
  70
  71 /*
  72 - adding instance into manager
  73 - called from InstanceMap::Add, _LoadBoundInstances, LoadGroups
  74 */
  75 InstanceSave* InstanceSaveManager::AddInstanceSave(uint32 mapId, uint32 instanceId, uint8 difficulty, time_t resetTime, bool canReset, bool load)
  76 {
  77     InstanceSave *save = GetInstanceSave(instanceId);
  78     if(save) return save;
  79
  80     const MapEntry* entry = sMapStore.LookupEntry(mapId);
  81     if(!entry || instanceId == 0)
  82     {
  83         sLog.outError("InstanceSaveManager::AddInstanceSave: mapid = %d, instanceid = %d!", mapId, instanceId);
  84         return NULL;
  85     }
  86
  87     if(!resetTime)
  88     {
  89         // initialize reset time
  90         // for normal instances if no creatures are killed the instance will reset in two hours
  91         if(entry->map_type == MAP_RAID || difficulty == DIFFICULTY_HEROIC)
  92             resetTime = GetResetTimeFor(mapId);
  93         else
  94         {
  95             resetTime = time(NULL) + 2 * HOUR;
  96             // normally this will be removed soon after in InstanceMap::Add, prevent error
  97             ScheduleReset(true, resetTime, InstResetEvent(0, mapId, instanceId));
  98         }
  99     }
 100
 101     sLog.outDebug("InstanceSaveManager::AddInstanceSave: mapid = %d, instanceid = %d", mapId, instanceId);
 102
 103     save = new InstanceSave(mapId, instanceId, difficulty, resetTime, canReset);
 104     if(!load) save->SaveToDB();
 105
 106     m_instanceSaveById[instanceId] = save;
 107     return save;
 108 }
 109
 110 InstanceSave *InstanceSaveManager::GetInstanceSave(uint32 InstanceId)
 111 {
 112     InstanceSaveHashMap::iterator itr = m_instanceSaveById.find(InstanceId);
 113     return itr != m_instanceSaveById.end() ? itr->second : NULL;
 114 }
 115
 116 void InstanceSaveManager::DeleteInstanceFromDB(uint32 instanceid)
 117 {
 118     CharacterDatabase.BeginTransaction();
 119     CharacterDatabase.PExecute("DELETE FROM instance WHERE id = '%u'", instanceid);
 120     CharacterDatabase.PExecute("DELETE FROM character_instance WHERE instance = '%u'", instanceid);
 121     CharacterDatabase.PExecute("DELETE FROM group_instance WHERE instance = '%u'", instanceid);
 122     CharacterDatabase.CommitTransaction();
 123     // respawn times should be deleted only when the map gets unloaded
 124 }
 125
 126 void InstanceSaveManager::RemoveInstanceSave(uint32 InstanceId)
 127 {
 128     InstanceSaveHashMap::iterator itr = m_instanceSaveById.find( InstanceId );
 129     if(itr != m_instanceSaveById.end())
 130     {
 131         // save the resettime for normal instances only when they get unloaded
 132         if(time_t resettime = itr->second->GetResetTimeForDB())
 133             CharacterDatabase.PExecute("UPDATE instance SET resettime = '"UI64FMTD"' WHERE id = '%u'", (uint64)resettime, InstanceId);
 134         delete itr->second;
 135         m_instanceSaveById.erase(itr);
 136     }
 137 }
 138
 139 InstanceSave::InstanceSave(uint16 MapId, uint32 InstanceId, uint8 difficulty, time_t resetTime, bool canReset)
 140 : m_resetTime(resetTime), m_instanceid(InstanceId), m_mapid(MapId),
 141   m_difficulty(difficulty), m_canReset(canReset)
 142 {
 143 }
 144
 145 InstanceSave::~InstanceSave()
 146 {
 147     // the players and groups must be unbound before deleting the save
 148     assert(m_playerList.empty() && m_groupList.empty());
 149 }
 150
 151 /*
 152     Called from AddInstanceSave
 153 */
 154 void InstanceSave::SaveToDB()
 155 {
 156     // save instance data too
 157     std::string data;
 158
 159     Map *map = MapManager::Instance().FindMap(GetMapId(),m_instanceid);
 160     if(map)
 161     {
 162         assert(map->IsDungeon());
 163         InstanceData *iData = ((InstanceMap *)map)->GetInstanceData();
 164         if(iData && iData->Save())
 165         {
 166             data = iData->Save();
 167             CharacterDatabase.escape_string(data);
 168         }
 169     }
 170
 171     CharacterDatabase.PExecute("INSERT INTO instance VALUES ('%u', '%u', '"UI64FMTD"', '%u', '%s')", m_instanceid, GetMapId(), (uint64)GetResetTimeForDB(), GetDifficulty(), data.c_str());
 172 }
 173
 174 time_t InstanceSave::GetResetTimeForDB()
 175 {
 176     // only save the reset time for normal instances
 177     const MapEntry *entry = sMapStore.LookupEntry(GetMapId());
 178     if(!entry || entry->map_type == MAP_RAID || GetDifficulty() == DIFFICULTY_HEROIC)
 179         return 0;
 180     else
 181         return GetResetTime();
 182 }
 183
 184 // to cache or not to cache, that is the question
 185 InstanceTemplate const* InstanceSave::GetTemplate()
 186 {
 187     return objmgr.GetInstanceTemplate(m_mapid);
 188 }
 189
 190 MapEntry const* InstanceSave::GetMapEntry()
 191 {
 192     return sMapStore.LookupEntry(m_mapid);
 193 }
 194
 195 void InstanceSave::DeleteFromDB()
 196 {
 197     InstanceSaveManager::DeleteInstanceFromDB(GetInstanceId());
 198 }
 199
 200 /* true if the instance save is still valid */
 201 bool InstanceSave::UnloadIfEmpty()
 202 {
 203     if(m_playerList.empty() && m_groupList.empty())
 204     {
 205         if(!sInstanceSaveManager.lock_instLists)
 206             sInstanceSaveManager.RemoveInstanceSave(GetInstanceId());
 207         return false;
 208     }
 209     else
 210         return true;
 211 }
 212
 213 void InstanceSaveManager::_DelHelper(DatabaseType &db, const char *fields, const char *table, const char *queryTail,...)
 214 {
 215     Tokens fieldTokens = StrSplit(fields, ", ");
 216     assert(fieldTokens.size() != 0);
 217
 218     va_list ap;
 219     char szQueryTail [MAX_QUERY_LEN];
 220     va_start(ap, queryTail);
 221     vsnprintf( szQueryTail, MAX_QUERY_LEN, queryTail, ap );
 222     va_end(ap);
 223
 224     QueryResult *result = db.PQuery("SELECT %s FROM %s %s", fields, table, szQueryTail);
 225     if(result)
 226     {
 227         do
 228         {
 229             Field *fields = result->Fetch();
 230             std::ostringstream ss;
 231             for(size_t i = 0; i < fieldTokens.size(); i++)
 232             {
 233                 std::string fieldValue = fields[i].GetCppString();
 234                 db.escape_string(fieldValue);
 235                 ss << (i != 0 ? " AND " : "") << fieldTokens[i] << " = '" << fieldValue << "'";
 236             }
 237             db.DirectPExecute("DELETE FROM %s WHERE %s", table, ss.str().c_str());
 238         } while (result->NextRow());
 239         delete result;
 240     }
 241 }
 242
 243 void InstanceSaveManager::CleanupInstances()
 244 {
 245     barGoLink bar(2);
 246     bar.step();
 247
 248     // load reset times and clean expired instances
 249     sInstanceSaveManager.LoadResetTimes();
 250
 251     // clean character/group - instance binds with invalid group/characters
 252     _DelHelper(CharacterDatabase, "character_instance.guid, instance", "character_instance", "LEFT JOIN characters ON character_instance.guid = characters.guid WHERE characters.guid IS NULL");
 253     _DelHelper(CharacterDatabase, "group_instance.leaderGuid, instance", "group_instance", "LEFT JOIN characters ON group_instance.leaderGuid = characters.guid LEFT JOIN groups ON group_instance.leaderGuid = groups.leaderGuid WHERE characters.guid IS NULL OR groups.leaderGuid IS NULL");
 254
 255     // clean instances that do not have any players or groups bound to them
 256     _DelHelper(CharacterDatabase, "id, map, difficulty", "instance", "LEFT JOIN character_instance ON character_instance.instance = id LEFT JOIN group_instance ON group_instance.instance = id WHERE character_instance.instance IS NULL AND group_instance.instance IS NULL");
 257
 258     // clean invalid instance references in other tables
 259     _DelHelper(CharacterDatabase, "character_instance.guid, instance", "character_instance", "LEFT JOIN instance ON character_instance.instance = instance.id WHERE instance.id IS NULL");
 260     _DelHelper(CharacterDatabase, "group_instance.leaderGuid, instance", "group_instance", "LEFT JOIN instance ON group_instance.instance = instance.id WHERE instance.id IS NULL");
 261
 262     // creature_respawn and gameobject_respawn are in another database
 263     // first, obtain total instance set
 264     std::set<uint32> InstanceSet;
 265     QueryResult *result = CharacterDatabase.Query("SELECT id FROM instance");
 266     if( result )
 267     {
 268         do
 269         {
 270             Field *fields = result->Fetch();
 271             InstanceSet.insert(fields[0].GetUInt32());
 272         }
 273         while (result->NextRow());
 274         delete result;
 275     }
 276
 277     // creature_respawn
 278     result = WorldDatabase.Query("SELECT DISTINCT(instance) FROM creature_respawn WHERE instance <> 0");
 279     if( result )
 280     {
 281         do
 282         {
 283             Field *fields = result->Fetch();
 284             if(InstanceSet.find(fields[0].GetUInt32()) == InstanceSet.end())
 285                 WorldDatabase.DirectPExecute("DELETE FROM creature_respawn WHERE instance = '%u'", fields[0].GetUInt32());
 286         }
 287         while (result->NextRow());
 288         delete result;
 289     }
 290
 291     // gameobject_respawn
 292     result = WorldDatabase.Query("SELECT DISTINCT(instance) FROM gameobject_respawn WHERE instance <> 0");
 293     if( result )
 294     {
 295         do
 296         {
 297             Field *fields = result->Fetch();
 298             if(InstanceSet.find(fields[0].GetUInt32()) == InstanceSet.end())
 299                 WorldDatabase.DirectPExecute("DELETE FROM gameobject_respawn WHERE instance = '%u'", fields[0].GetUInt32());
 300         }
 301         while (result->NextRow());
 302         delete result;
 303     }
 304
 305     bar.step();
 306     sLog.outString();
 307     sLog.outString( ">> Initialized %u instances", (uint32)InstanceSet.size());
 308 }
 309
 310 void InstanceSaveManager::PackInstances()
 311 {
 312     // this routine renumbers player instance associations in such a way so they start from 1 and go up
 313     // TODO: this can be done a LOT more efficiently
 314
 315     // obtain set of all associations
 316     std::set<uint32> InstanceSet;
 317
 318     // all valid ids are in the instance table
 319     // any associations to ids not in this table are assumed to be
 320     // cleaned already in CleanupInstances
 321     QueryResult *result = CharacterDatabase.Query("SELECT id FROM instance");
 322     if( result )
 323     {
 324         do
 325         {
 326             Field *fields = result->Fetch();
 327             InstanceSet.insert(fields[0].GetUInt32());
 328         }
 329         while (result->NextRow());
 330         delete result;
 331     }
 332
 333     barGoLink bar( InstanceSet.size() + 1);
 334     bar.step();
 335
 336     uint32 InstanceNumber = 1;
 337     // we do assume std::set is sorted properly on integer value
 338     for (std::set<uint32>::iterator i = InstanceSet.begin(); i != InstanceSet.end(); ++i)
 339     {
 340         if (*i != InstanceNumber)
 341         {
 342             // remap instance id
 343             WorldDatabase.PExecute("UPDATE creature_respawn SET instance = '%u' WHERE instance = '%u'", InstanceNumber, *i);
 344             WorldDatabase.PExecute("UPDATE gameobject_respawn SET instance = '%u' WHERE instance = '%u'", InstanceNumber, *i);
 345             CharacterDatabase.PExecute("UPDATE corpse SET instance = '%u' WHERE instance = '%u'", InstanceNumber, *i);
 346             CharacterDatabase.PExecute("UPDATE character_instance SET instance = '%u' WHERE instance = '%u'", InstanceNumber, *i);
 347             CharacterDatabase.PExecute("UPDATE instance SET id = '%u' WHERE id = '%u'", InstanceNumber, *i);
 348             CharacterDatabase.PExecute("UPDATE group_instance SET instance = '%u' WHERE instance = '%u'", InstanceNumber, *i);
 349         }
 350
 351         ++InstanceNumber;
 352         bar.step();
 353     }
 354
 355     sLog.outString( ">> Instance numbers remapped, next instance id is %u", InstanceNumber );
 356     sLog.outString();
 357 }
 358
 359 void InstanceSaveManager::LoadResetTimes()
 360 {
 361     time_t now = time(NULL);
 362     time_t today = (now / DAY) * DAY;
 363
 364     // NOTE: Use DirectPExecute for tables that will be queried later
 365
 366     // get the current reset times for normal instances (these may need to be updated)
 367     // these are only kept in memory for InstanceSaves that are loaded later
 368     // resettime = 0 in the DB for raid/heroic instances so those are skipped
 369     typedef std::map<uint32, std::pair<uint32, time_t> > ResetTimeMapType;
 370     ResetTimeMapType InstResetTime;
 371     QueryResult *result = CharacterDatabase.Query("SELECT id, map, resettime FROM instance WHERE resettime > 0");
 372     if( result )
 373     {
 374         do
 375         {
 376             if(time_t resettime = time_t((*result)[2].GetUInt64()))
 377             {
 378                 uint32 id = (*result)[0].GetUInt32();
 379                 uint32 mapid = (*result)[1].GetUInt32();
 380                 InstResetTime[id] = std::pair<uint32, uint64>(mapid, resettime);
 381             }
 382         }
 383         while (result->NextRow());
 384         delete result;
 385
 386         // update reset time for normal instances with the max creature respawn time + X hours
 387         result = WorldDatabase.Query("SELECT MAX(respawntime), instance FROM creature_respawn WHERE instance > 0 GROUP BY instance");
 388         if( result )
 389         {
 390             do
 391             {
 392                 Field *fields = result->Fetch();
 393                 uint32 instance = fields[1].GetUInt32();
 394                 time_t resettime = time_t(fields[0].GetUInt64() + 2 * HOUR);
 395                 ResetTimeMapType::iterator itr = InstResetTime.find(instance);
 396                 if(itr != InstResetTime.end() && itr->second.second != resettime)
 397                 {
 398                     CharacterDatabase.DirectPExecute("UPDATE instance SET resettime = '"UI64FMTD"' WHERE id = '%u'", uint64(resettime), instance);
 399                     itr->second.second = resettime;
 400                 }
 401             }
 402             while (result->NextRow());
 403             delete result;
 404         }
 405
 406         // schedule the reset times
 407         for(ResetTimeMapType::iterator itr = InstResetTime.begin(); itr != InstResetTime.end(); ++itr)
 408             if(itr->second.second > now)
 409                 ScheduleReset(true, itr->second.second, InstResetEvent(0, itr->second.first, itr->first));
 410     }
 411
 412     // load the global respawn times for raid/heroic instances
 413     uint32 diff = sWorld.getConfig(CONFIG_INSTANCE_RESET_TIME_HOUR) * HOUR;
 414     m_resetTimeByMapId.resize(sMapStore.GetNumRows()+1);
 415     result = CharacterDatabase.Query("SELECT mapid, resettime FROM instance_reset");
 416     if(result)
 417     {
 418         do
 419         {
 420             Field *fields = result->Fetch();
 421             uint32 mapid = fields[0].GetUInt32();
 422             if(!objmgr.GetInstanceTemplate(mapid))
 423             {
 424                 sLog.outError("InstanceSaveManager::LoadResetTimes: invalid mapid %u in instance_reset!", mapid);
 425                 CharacterDatabase.DirectPExecute("DELETE FROM instance_reset WHERE mapid = '%u'", mapid);
 426                 continue;
 427             }
 428
 429             // update the reset time if the hour in the configs changes
 430             uint64 oldresettime = fields[1].GetUInt64();
 431             uint64 newresettime = (oldresettime / DAY) * DAY + diff;
 432             if(oldresettime != newresettime)
 433                 CharacterDatabase.DirectPExecute("UPDATE instance_reset SET resettime = '"UI64FMTD"' WHERE mapid = '%u'", newresettime, mapid);
 434
 435             m_resetTimeByMapId[mapid] = newresettime;
 436         } while(result->NextRow());
 437         delete result;
 438     }
 439
 440     // clean expired instances, references to them will be deleted in CleanupInstances
 441     // must be done before calculating new reset times
 442     _DelHelper(CharacterDatabase, "id, map, difficulty", "instance", "LEFT JOIN instance_reset ON mapid = map WHERE (instance.resettime < '"UI64FMTD"' AND instance.resettime > '0') OR (NOT instance_reset.resettime IS NULL AND instance_reset.resettime < '"UI64FMTD"')",  (uint64)now, (uint64)now);
 443
 444     // calculate new global reset times for expired instances and those that have never been reset yet
 445     // add the global reset times to the priority queue
 446     for(uint32 i = 0; i < sInstanceTemplate.MaxEntry; i++)
 447     {
 448         InstanceTemplate const* temp = objmgr.GetInstanceTemplate(i);
 449         if(!temp) continue;
 450         // only raid/heroic maps have a global reset time
 451         const MapEntry* entry = sMapStore.LookupEntry(temp->map);
 452         if(!entry || !entry->HasResetTime())
 453             continue;
 454
 455         uint32 period = temp->reset_delay * DAY;
 456         assert(period != 0);
 457         time_t t = m_resetTimeByMapId[temp->map];
 458         if(!t)
 459         {
 460             // initialize the reset time
 461             t = today + period + diff;
 462             CharacterDatabase.DirectPExecute("INSERT INTO instance_reset VALUES ('%u','"UI64FMTD"')", i, (uint64)t);
 463         }
 464
 465         if(t < now)
 466         {
 467             // assume that expired instances have already been cleaned
 468             // calculate the next reset time
 469             t = (t / DAY) * DAY;
 470             t += ((today - t) / period + 1) * period + diff;
 471             CharacterDatabase.DirectPExecute("UPDATE instance_reset SET resettime = '"UI64FMTD"' WHERE mapid = '%u'", (uint64)t, i);
 472         }
 473
 474         m_resetTimeByMapId[temp->map] = t;
 475
 476         // schedule the global reset/warning
 477         uint8 type = 1;
 478         static int tim[4] = {3600, 900, 300, 60};
 479         for(; type < 4; type++)
 480             if(t - tim[type-1] > now) break;
 481         ScheduleReset(true, t - tim[type-1], InstResetEvent(type, i));
 482     }
 483 }
 484
 485 void InstanceSaveManager::ScheduleReset(bool add, time_t time, InstResetEvent event)
 486 {
 487     if(add) m_resetTimeQueue.insert(std::pair<time_t, InstResetEvent>(time, event));
 488     else
 489     {
 490         // find the event in the queue and remove it
 491         ResetTimeQueue::iterator itr;
 492         std::pair<ResetTimeQueue::iterator, ResetTimeQueue::iterator> range;
 493         range = m_resetTimeQueue.equal_range(time);
 494         for(itr = range.first; itr != range.second; ++itr)
 495             if(itr->second == event) { m_resetTimeQueue.erase(itr); return; }
 496         // in case the reset time changed (should happen very rarely), we search the whole queue
 497         if(itr == range.second)
 498         {
 499             for(itr = m_resetTimeQueue.begin(); itr != m_resetTimeQueue.end(); ++itr)
 500                 if(itr->second == event) { m_resetTimeQueue.erase(itr); return; }
 501             if(itr == m_resetTimeQueue.end())
 502                 sLog.outError("InstanceSaveManager::ScheduleReset: cannot cancel the reset, the event(%d,%d,%d) was not found!", event.type, event.mapid, event.instanceId);
 503         }
 504     }
 505 }
 506
 507 void InstanceSaveManager::Update()
 508 {
 509     time_t now = time(NULL), t;
 510     while(!m_resetTimeQueue.empty() && (t = m_resetTimeQueue.begin()->first) < now)
 511     {
 512         InstResetEvent &event = m_resetTimeQueue.begin()->second;
 513         if(event.type == 0)
 514         {
 515             // for individual normal instances, max creature respawn + X hours
 516             _ResetInstance(event.mapid, event.instanceId);
 517             m_resetTimeQueue.erase(m_resetTimeQueue.begin());
 518         }
 519         else
 520         {
 521             // global reset/warning for a certain map
 522             time_t resetTime = GetResetTimeFor(event.mapid);
 523             _ResetOrWarnAll(event.mapid, event.type != 4, resetTime - now);
 524             if(event.type != 4)
 525             {
 526                 // schedule the next warning/reset
 527                 event.type++;
 528                 static int tim[4] = {3600, 900, 300, 60};
 529                 ScheduleReset(true, resetTime - tim[event.type-1], event);
 530             }
 531             m_resetTimeQueue.erase(m_resetTimeQueue.begin());
 532         }
 533     }
 534 }
 535
 536 void InstanceSaveManager::_ResetSave(InstanceSaveHashMap::iterator &itr)
 537 {
 538     // unbind all players bound to the instance
 539     // do not allow UnbindInstance to automatically unload the InstanceSaves
 540     lock_instLists = true;
 541     InstanceSave::PlayerListType &pList = itr->second->m_playerList;
 542     while(!pList.empty())
 543     {
 544         Player *player = *(pList.begin());
 545         player->UnbindInstance(itr->second->GetMapId(), itr->second->GetDifficulty(), true);
 546     }
 547     InstanceSave::GroupListType &gList = itr->second->m_groupList;
 548     while(!gList.empty())
 549     {
 550         Group *group = *(gList.begin());
 551         group->UnbindInstance(itr->second->GetMapId(), itr->second->GetDifficulty(), true);
 552     }
 553     delete itr->second;
 554     m_instanceSaveById.erase(itr++);
 555     lock_instLists = false;
 556 }
 557
 558 void InstanceSaveManager::_ResetInstance(uint32 mapid, uint32 instanceId)
 559 {
 560     sLog.outDebug("InstanceSaveMgr::_ResetInstance %u, %u", mapid, instanceId);
 561     Map *map = (MapInstanced*)MapManager::Instance().CreateBaseMap(mapid);
 562     if(!map->Instanceable())
 563         return;
 564
 565     InstanceSaveHashMap::iterator itr = m_instanceSaveById.find(instanceId);
 566     if(itr != m_instanceSaveById.end()) _ResetSave(itr);
 567     DeleteInstanceFromDB(instanceId);                       // even if save not loaded
 568
 569     Map* iMap = ((MapInstanced*)map)->FindMap(instanceId);
 570     if(iMap && iMap->IsDungeon()) ((InstanceMap*)iMap)->Reset(INSTANCE_RESET_RESPAWN_DELAY);
 571     else objmgr.DeleteRespawnTimeForInstance(instanceId);   // even if map is not loaded
 572 }
 573
 574 void InstanceSaveManager::_ResetOrWarnAll(uint32 mapid, bool warn, uint32 timeLeft)
 575 {
 576     // global reset for all instances of the given map
 577     // note: this isn't fast but it's meant to be executed very rarely
 578     Map const *map = MapManager::Instance().CreateBaseMap(mapid);
 579     if(!map->Instanceable())
 580         return;
 581     uint64 now = (uint64)time(NULL);
 582
 583     if(!warn)
 584     {
 585         // this is called one minute before the reset time
 586         InstanceTemplate const* temp = objmgr.GetInstanceTemplate(mapid);
 587         if(!temp || !temp->reset_delay)
 588         {
 589             sLog.outError("InstanceSaveManager::ResetOrWarnAll: no instance template or reset delay for map %d", mapid);
 590             return;
 591         }
 592
 593         // remove all binds to instances of the given map
 594         for(InstanceSaveHashMap::iterator itr = m_instanceSaveById.begin(); itr != m_instanceSaveById.end();)
 595         {
 596             if(itr->second->GetMapId() == mapid)
 597                 _ResetSave(itr);
 598             else
 599                 ++itr;
 600         }
 601
 602         // delete them from the DB, even if not loaded
 603         CharacterDatabase.BeginTransaction();
 604         CharacterDatabase.PExecute("DELETE FROM character_instance USING character_instance LEFT JOIN instance ON character_instance.instance = id WHERE map = '%u'", mapid);
 605         CharacterDatabase.PExecute("DELETE FROM group_instance USING group_instance LEFT JOIN instance ON group_instance.instance = id WHERE map = '%u'", mapid);
 606         CharacterDatabase.PExecute("DELETE FROM instance WHERE map = '%u'", mapid);
 607         CharacterDatabase.CommitTransaction();
 608
 609         // calculate the next reset time
 610         uint32 diff = sWorld.getConfig(CONFIG_INSTANCE_RESET_TIME_HOUR) * HOUR;
 611         uint32 period = temp->reset_delay * DAY;
 612         uint64 next_reset = ((now + timeLeft + MINUTE) / DAY * DAY) + period + diff;
 613         // update it in the DB
 614         CharacterDatabase.PExecute("UPDATE instance_reset SET resettime = '"UI64FMTD"' WHERE mapid = '%d'", next_reset, mapid);
 615     }
 616
 617     MapInstanced::InstancedMaps &instMaps = ((MapInstanced*)map)->GetInstancedMaps();
 618     MapInstanced::InstancedMaps::iterator mitr;
 619     for(mitr = instMaps.begin(); mitr != instMaps.end(); ++mitr)
 620     {
 621         Map *map2 = mitr->second;
 622         if(!map2->IsDungeon()) continue;
 623         if(warn) ((InstanceMap*)map2)->SendResetWarnings(timeLeft);
 624         else ((InstanceMap*)map2)->Reset(INSTANCE_RESET_GLOBAL);
 625     }
 626
 627     // TODO: delete creature/gameobject respawn times even if the maps are not loaded
 628 }
 629
 630 uint32 InstanceSaveManager::GetNumBoundPlayersTotal()
 631 {
 632     uint32 ret = 0;
 633     for(InstanceSaveHashMap::iterator itr = m_instanceSaveById.begin(); itr != m_instanceSaveById.end(); ++itr)
 634         ret += itr->second->GetPlayerCount();
 635     return ret;
 636 }
 637
 638 uint32 InstanceSaveManager::GetNumBoundGroupsTotal()
 639 {
 640     uint32 ret = 0;
 641     for(InstanceSaveHashMap::iterator itr = m_instanceSaveById.begin(); itr != m_instanceSaveById.end(); ++itr)
 642         ret += itr->second->GetGroupCount();
 643     return ret;
 644 }