Allowed saving to be done synchronously and swapped metagame to do synchronous saving to hopefully avoid problems with this stupid mess of code

Author: garethyr

Entities/SLTerrain.cpp

@@ -257,13 +257,13 @@ namespace RTE {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	int SLTerrain::SaveData(const std::string &pathBase) {
+	int SLTerrain::SaveData(const std::string &pathBase, bool doAsyncSaves) {
 		if (pathBase.empty()) {
 			return -1;
 		}
-		SceneLayer::SaveData(pathBase + " Mat.png");
-		m_FGColorLayer->SaveData(pathBase + " FG.png");
-		m_BGColorLayer->SaveData(pathBase + " BG.png");
+		SceneLayer::SaveData(pathBase + " Mat.png", doAsyncSaves);
+		m_FGColorLayer->SaveData(pathBase + " FG.png", doAsyncSaves);
+		m_BGColorLayer->SaveData(pathBase + " BG.png", doAsyncSaves);
 		return 0;
 	}
 

Entities/SLTerrain.h

@@ -77,8 +77,9 @@ namespace RTE {
 		/// Saves bitmap data currently in memory to disk.
 		/// </summary>
 		/// <param name="pathBase">The filepath base to the where to save the Bitmap data. This means everything up to the extension. "FG" and "Mat" etc will be added.</param>
+		/// <param name="doAsyncSaves">Whether or not to save asynchronously.</param>
 		/// <returns>An error return value signaling success or any particular failure. Anything below 0 is an error signal.</returns>
-		int SaveData(const std::string &pathBase) override;
+		int SaveData(const std::string &pathBase, bool doAsyncSaves = true) override;
 
 		/// <summary>
 		/// Clears out any previously loaded bitmap data from memory.

Entities/Scene.cpp

@@ -1029,7 +1029,7 @@ int Scene::ExpandAIPlanAssemblySchemes()
 //////////////////////////////////////////////////////////////////////////////////////////
 // Description:     Saves currently loaded bitmap data in memory to disk.
 
-int Scene::SaveData(std::string pathBase)
+int Scene::SaveData(std::string pathBase, bool doAsyncSaves)
 {
     const std::string fullPathBase = g_PresetMan.GetFullModulePath(pathBase);
     if (fullPathBase.empty())
@@ -1039,7 +1039,7 @@ int Scene::SaveData(std::string pathBase)
         return 0;
 
     // Save Terrain's data
-    if (m_pTerrain->SaveData(fullPathBase) < 0)
+    if (m_pTerrain->SaveData(fullPathBase, doAsyncSaves) < 0)
     {
         RTEAbort("Saving Terrain " + m_pTerrain->GetPresetName() + "\'s data failed!");
         return -1;
@@ -1055,7 +1055,7 @@ int Scene::SaveData(std::string pathBase)
         {
             std::snprintf(str, sizeof(str), "T%d", team);
             // Save unseen layer data to disk
-            if (m_apUnseenLayer[team]->SaveData(fullPathBase + " US" + str + ".png") < 0)
+            if (m_apUnseenLayer[team]->SaveData(fullPathBase + " US" + str + ".png", doAsyncSaves) < 0)
             {
                 g_ConsoleMan.PrintString("ERROR: Saving unseen layer " + m_apUnseenLayer[team]->GetPresetName() + "\'s data failed!");
                 return -1;

Entities/Scene.h

@@ -391,10 +391,11 @@ EntityAllocation(Scene)
 // Description:     Saves data currently in memory to disk.
 // Arguments:       The filepath base to the where to save the Bitmap data. This means
 //                  everything up to the extension. "FG" and "Mat" etc will be added.
+//					Whether or not to save asynchronously.
 // Return value:    An error return value signaling success or any particular failure.
 //                  Anything below 0 is an error signal.
 
-	int SaveData(std::string pathBase);
+	int SaveData(std::string pathBase, bool doAsyncSaves = true);
 
 
 //////////////////////////////////////////////////////////////////////////////////////////

Entities/SceneLayer.cpp

@@ -200,28 +200,37 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	template <bool TRACK_DRAWINGS>
-	int SceneLayerImpl<TRACK_DRAWINGS>::SaveData(const std::string &bitmapPath) {
+	int SceneLayerImpl<TRACK_DRAWINGS>::SaveData(const std::string &bitmapPath, bool doAsyncSaves) {
 		if (bitmapPath.empty()) {
 			return -1;
 		}
-		g_ActivityMan.IncrementSavingThreadCount();
+		if (doAsyncSaves) {
+			g_ActivityMan.IncrementSavingThreadCount();
+		}
 		if (m_MainBitmap) {
 			// Make a copy of the bitmap to pass to the thread because the bitmap may be offloaded mid thread and everything will be on fire.
 			BITMAP *outputBitmap = create_bitmap_ex(bitmap_color_depth(m_MainBitmap), m_MainBitmap->w, m_MainBitmap->h);
 			blit(m_MainBitmap, outputBitmap, 0, 0, 0, 0, m_MainBitmap->w, m_MainBitmap->h);
 
-			auto saveLayerBitmap = [bitmapPath](BITMAP *bitmapToSave) {
+			auto saveLayerBitmap = [bitmapPath, doAsyncSaves](BITMAP *bitmapToSave) {
 				PALETTE palette;
 				get_palette(palette);
 				if (save_png(bitmapPath.c_str(), bitmapToSave, palette) != 0) {
 					RTEAbort(std::string("Failed to save SceneLayerImpl bitmap to path and name: " + bitmapPath));
 				}
 				destroy_bitmap(bitmapToSave);
-				g_ActivityMan.DecrementSavingThreadCount();
+				if (doAsyncSaves) {
+					g_ActivityMan.DecrementSavingThreadCount();
+				}
 			};
-			std::thread saveThread(saveLayerBitmap, outputBitmap);
+
 			m_BitmapFile.SetDataPath(bitmapPath);
-			saveThread.detach();
+			if (doAsyncSaves) {
+				std::thread saveThread(saveLayerBitmap, outputBitmap);
+				saveThread.detach();
+			} else {
+				saveLayerBitmap(outputBitmap);
+			}
 		}
 		return 0;
 	}

Entities/SceneLayer.h

@@ -103,8 +103,9 @@ namespace RTE {
 		/// Saves data currently in memory to disk.
 		/// </summary>
 		/// <param name="bitmapPath">The filepath to the where to save the bitmap data.</param>
+		/// <param name="doAsyncSaves">Whether or not to save asynchronously.</param>
 		/// <returns>An error return value signaling success or any particular failure. Anything below 0 is an error signal.</returns>
-		virtual int SaveData(const std::string &bitmapPath);
+		virtual int SaveData(const std::string &bitmapPath, bool doAsyncSaves = true);
 
 		/// <summary>
 		/// Clears out any previously loaded bitmap data from memory.

Managers/MetaMan.cpp

@@ -370,7 +370,7 @@ int MetaMan::Save(Writer &writer) const {
 	for (const Scene *metaScene : m_Scenes) {
 		// Save the scene data to a good unique prefix for the Scene's layers' bitmap files as they are saved
 		// This should be handled separately from any .ini writing
-		//(*sItr)->SaveData(writer.GetFolderPath() + m_GameName + " - " + (*sItr)->GetPresetName());
+		//(*sItr)->SaveData(writer.GetFolderPath() + m_GameName + " - " + (*sItr)->GetPresetName(), false);
 		writer.NewPropertyWithValue("AddScene", metaScene);
 	}
 
@@ -403,7 +403,7 @@ int MetaMan::SaveSceneData(std::string pathBase)
         if ((*sItr)->IsRevealed() && (*sItr)->GetTerrain() && (*sItr)->GetTerrain()->IsLoadedFromDisk())
         {
             // Save the scene data to a good unique prefix for the Scene's layers' bitmap files as they are saved
-            if ((*sItr)->SaveData(pathBase + " - " + (*sItr)->GetPresetName()) < 0)
+            if ((*sItr)->SaveData(pathBase + " - " + (*sItr)->GetPresetName(), false) < 0)
                 return -1;
         }
     }

Menus/MetagameGUI.cpp

@@ -2963,7 +2963,7 @@ void MetagameGUI::CompletedActivity()
             // However, don't suck up actors of any non-winning team, and don't save the brains if we autoresolved, because that took care of placing the resident brains already
             pAlteredScene->RetrieveSceneObjects(true, winningTeam, autoResolved);
             // Save out the altered scene before clearing out its data from memory
-            pAlteredScene->SaveData(METASAVEPATH + std::string(AUTOSAVENAME) + " - " + pAlteredScene->GetPresetName());
+            pAlteredScene->SaveData(METASAVEPATH + std::string(AUTOSAVENAME) + " - " + pAlteredScene->GetPresetName(), false);
             // Clear the bitmap data etc of the altered scene, we don't need to copy that over
             pAlteredScene->ClearData();