Handle loading and unloading modules at runtime

Author: MaximDude

Managers/ModuleMan.cpp

@@ -18,6 +18,7 @@ namespace RTE {
 
 	void ModuleMan::Clear() {
 		m_LoadedDataModules.clear();
+		m_UnloadedDataModules.clear();
 		m_DisabledDataModuleNames.clear();
 	}
 
@@ -27,6 +28,9 @@ namespace RTE {
 		for (const auto &[moduleID, dataModule] : m_LoadedDataModules) {
 			delete dataModule;
 		}
+		for (const auto &[moduleID, dataModule] : m_UnloadedDataModules) {
+			delete dataModule;
+		}
 		Clear();
 	}
 
@@ -147,8 +151,20 @@ namespace RTE {
 			return false;
 		}
 
+		// First check that we aren't trying to load another module with the same name. If not, check the unloaded map and load from there if it exists.
 		if (const DataModule *dataModule = GetDataModule(GetModuleID(moduleName)); dataModule) {
 			return true;
+		} else if (moduleType == DataModule::DataModuleType::Unofficial) {
+			auto unloadedModulesItr = std::find_if(m_UnloadedDataModules.begin(), m_UnloadedDataModules.end(),
+				[&moduleName](const auto &unloadedModuleEntry) {
+					return unloadedModuleEntry.second->GetFileName() == moduleName;
+				}
+			);
+			if (unloadedModulesItr != m_UnloadedDataModules.end()) {
+				m_LoadedDataModules.emplace(*unloadedModulesItr);
+				m_UnloadedDataModules.erase(unloadedModulesItr);
+				return true;
+			}
 		}
 
 		// Only instantiate it here, because it needs to be in the lists of this before being created.
@@ -165,6 +181,27 @@ namespace RTE {
 		return true;
 	}
 
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	bool ModuleMan::UnloadDataModule(const std::string &moduleName) {
+		if (!IsModuleOfficial(moduleName) && !IsModuleUserdata(moduleName)) {
+			auto loadedModulesItr = std::find_if(m_LoadedDataModules.begin(), m_LoadedDataModules.end(),
+				[&moduleName](const auto &loadedModuleEntry) {
+					return loadedModuleEntry.second->GetFileName() == moduleName;
+				}
+			);
+
+			if (loadedModulesItr != m_LoadedDataModules.end()) {
+				m_UnloadedDataModules.emplace(*loadedModulesItr);
+				m_LoadedDataModules.erase(loadedModulesItr);
+				return true;
+			}
+		} else {
+			g_ConsoleMan.PrintString("Official and Userdata modules cannot be unloaded!");
+		}
+		return false;
+	}
+
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	bool ModuleMan::LoadAllDataModules() {

Managers/ModuleMan.h

@@ -141,20 +141,26 @@ namespace RTE {
 		/// <returns>Whether the DataModule was read and added correctly.</returns>
 		bool LoadDataModule(const std::string &moduleName, DataModule::DataModuleType moduleType, const ProgressCallback &progressCallback = nullptr);
 
+		/// <summary>
+		/// Unloads a DataModule by removing it from the loaded modules list. Does not actually erase it from memory.
+		/// </summary>
+		/// <param name="moduleName">The DataModule name to unload.</param>
+		/// <returns>Whether the DataModule was successfully unloaded.</returns>
+		bool UnloadDataModule(const std::string &moduleName);
+
 		/// <summary>
 		/// Loads all the official data modules individually with LoadDataModule, then proceeds to look for any non-official modules and loads them as well.
 		/// </summary>
 		bool LoadAllDataModules();
 #pragma endregion
 
-
-
 	private:
 
 		static const std::array<std::string, 10> c_OfficialModules; //!< Array storing the names of all the official modules.
 		static const std::array<std::pair<std::string, std::string>, 3> c_UserdataModules; //!< Array storing the names of all the userdata modules.
 
 		std::unordered_map<int, DataModule *> m_LoadedDataModules; //!< Map of all loaded DataModules by their ID. Owned by this.
+		std::unordered_map<int, DataModule *> m_UnloadedDataModules; //!< Map of DataModules that are loaded but disabled through the Mod Manager GUI. Treated as not loaded at all.
 
 		std::unordered_set<std::string> m_DisabledDataModuleNames; //!< The DataModule names that are disabled and should not be loaded at startup.
 		std::string m_SingleModuleToLoad; //!< Name of the single module to load after the official modules.

Menus/ModManagerGUI.cpp

@@ -117,9 +117,11 @@ namespace RTE {
 			if (modRecord.Enabled) {
 				m_ToggleModButton->SetText("Disable Mod");
 				disabledModsList.erase(disabledModsList.find(modRecord.ModulePath));
+				g_ModuleMan.LoadDataModule(modRecord.ModulePath, DataModule::DataModuleType::Unofficial, nullptr);
 			} else {
 				m_ToggleModButton->SetText("Enable Mod");
 				disabledModsList.emplace(modRecord.ModulePath);
+				g_ModuleMan.UnloadDataModule(modRecord.ModulePath);
 			}
 			selectedItem->m_Name = modRecord.GetDisplayString();
 			m_ModsListBox->SetSelectedIndex(index);