- Bugfixes for deleting scaling mods without first disabling them.

- Retry for failure to write to DAT/Index due to file in use errors.

Author: Lunaretic

xivModdingFramework/Mods/Modding.cs

@@ -385,6 +385,9 @@ public async Task<bool> ToggleModUnsafe(bool enable, Mod mod, bool includeIntern
 
                         // And write that metadata to the actual constituent files.
                         await ItemMetadata.ApplyMetadata(meta, cachedIndex, cachedModlist);
+                    } else if(ext == ".rgsp")
+                    {
+                        await CMP.ApplyRgspFile(mod.fullPath, cachedIndex, cachedModlist);
                     }
                 }
             }
@@ -396,6 +399,18 @@ public async Task<bool> ToggleModUnsafe(bool enable, Mod mod, bool includeIntern
                     if (cachedIndex != null)
                     {
                         cachedIndex.SetDataOffset(mod.fullPath, 0);
+
+                        // This is a metadata entry being deleted, we'll need to restore the metadata entries back to default.
+                        if (mod.fullPath.EndsWith(".meta"))
+                        {
+                            var root = await XivCache.GetFirstRoot(mod.fullPath);
+                            await ItemMetadata.RestoreDefaultMetadata(root, cachedIndex, cachedModlist);
+                        }
+
+                        if (mod.fullPath.EndsWith(".rgsp"))
+                        {
+                            await CMP.RestoreDefaultScaling(mod.fullPath, cachedIndex, cachedModlist);
+                        }
                     }
                     else
                     {

xivModdingFramework/SqPack/FileTypes/Dat.cs

@@ -1553,11 +1553,31 @@ public async Task<uint> WriteToDat(byte[] importData, XivDataFile dataFile, long
                 var datPath = Path.Combine(_gameDirectory.FullName, $"{dataFile.GetDataFileName()}{DatExtension}{datNum}");
 
                 // Copy the data into the file.
-                using (var bw = new BinaryWriter(File.OpenWrite(datPath)))
+                BinaryWriter bw = null;
+
+                try
                 {
-                    if(targetOffset >= 2048) {
+                    try
+                    {
+                        bw = new BinaryWriter(File.OpenWrite(datPath));
+                    }
+                    catch
+                    {
+                        if(bw != null)
+                        {
+                            bw.Dispose();
+                        }
+
+                        // Wait just a bit and try again.
+                        await Task.Delay(100);
+                        bw = new BinaryWriter(File.OpenWrite(datPath));
+                    }
+
+                    if (targetOffset >= 2048)
+                    {
                         bw.BaseStream.Seek(seekPointer, SeekOrigin.Begin);
-                    } else
+                    }
+                    else
                     {
                         bw.BaseStream.Seek(0, SeekOrigin.End);
                     }
@@ -1579,6 +1599,13 @@ public async Task<uint> WriteToDat(byte[] importData, XivDataFile dataFile, long
                         bw.Write((byte)0);
                     }
                 }
+                finally
+                {
+                    if (bw != null)
+                    {
+                        bw.Dispose();
+                    }
+                }
 
                 var intFormat = (uint)(filePointer / 8);
                 uint datIdentifier = (uint)(datNum * 2);

xivModdingFramework/SqPack/FileTypes/Index.cs

@@ -794,12 +794,33 @@ public async Task SaveIndexFile(IndexFile index, bool alreadySemaphoreLocked = f
                     throw new Exception("Cannot write index files; files current in use.");
                 }
 
-                using (var index1Stream = new BinaryWriter(File.OpenWrite(index1Path)))
+                BinaryWriter index1Stream = null;
+                BinaryWriter index2Stream = null;
+                try
                 {
-                    using (var index2Stream = new BinaryWriter(File.OpenWrite(index2Path)))
+                    try
+                    {
+                        index1Stream = new BinaryWriter(File.OpenWrite(index1Path));
+                        index2Stream = new BinaryWriter(File.OpenWrite(index2Path));
+                    }
+                    catch
                     {
-                        index.Save(index1Stream, index2Stream);
+                        index1Stream?.Dispose();
+                        index2Stream?.Dispose();
+
+                        // Set a minor delay and try again, in case the user has some sort of locking issue.
+                        await Task.Delay(200);
+
+                        index1Stream = new BinaryWriter(File.OpenWrite(index1Path));
+                        index2Stream = new BinaryWriter(File.OpenWrite(index2Path));
                     }
+
+                    index.Save(index1Stream, index2Stream);
+                }
+                finally
+                {
+                    index1Stream?.Dispose();
+                    index2Stream?.Dispose();
                 }