Introduction of IMC Saving Backend Functions (Not available via UI)

Author: Lunaretic

xivModdingFramework/Cache/XivCache.cs

@@ -977,7 +977,7 @@ public string GetSql(bool includeWhere = true, bool skipJoin = true)
 
 
                     // [AND/OR] [COLUMN] [=/LIKE]
-                    if (Comparer == ComparisonType.Like)
+                    if (Comparer == ComparisonType.Equal)
                     {
                         result += " = ";
                     }

xivModdingFramework/Variants/DataContainers/XivImc.cs

@@ -14,6 +14,12 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+using HelixToolkit.SharpDX.Core;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using xivModdingFramework.Helpers;
+
 namespace xivModdingFramework.Variants.DataContainers
 {
     /// <summary>
@@ -43,5 +49,62 @@ public class XivImc
         /// Some examples would be any of the Lux weapons
         /// </remarks>
         public ushort Vfx { get; set; }
+
+        /// <summary>
+        /// Returns the raw bytes that make up this IMC entry.
+        /// </summary>
+        /// <returns></returns>
+        public byte[] GetBytes()
+        {
+            var bytes = new List<byte>();
+            bytes.AddRange(BitConverter.GetBytes(Variant));
+            bytes.AddRange(BitConverter.GetBytes(Mask));
+            bytes.AddRange(BitConverter.GetBytes(Vfx));
+            return bytes.ToArray();
+        }
+
+        /// <summary>
+        /// Shows a given attribute part
+        /// </summary>
+        /// <param name="part"></param>
+        public void ShowPart(char part)
+        {
+            var index = Helpers.Constants.Alphabet.ToList().IndexOf(part);
+            if(index < 0 || index > 9)
+            {
+                throw new NotSupportedException("Invalid IMC Part Letter.");
+            }
+
+            var bit = 1;
+            for(var i = 0; i < index; i++)
+            {
+                bit = bit << 1;
+            }
+
+            Mask = (ushort)(Mask | bit);
+        }
+
+        /// <summary>
+        /// Hides a given attribute part
+        /// </summary>
+        /// <param name="part"></param>
+        public void HidePart(char part)
+        {
+            var index = Helpers.Constants.Alphabet.ToList().IndexOf(part);
+            if (index < 0 || index > 9)
+            {
+                throw new NotSupportedException("Invalid IMC Part Letter.");
+            }
+
+            var bit = 1;
+            for (var i = 0; i < index; i++)
+            {
+                bit = bit << 1;
+            }
+
+            Mask = (ushort)(Mask & (~bit));
+
+        }
+
     }
 }

xivModdingFramework/Variants/FileTypes/Imc.cs

@@ -64,7 +64,8 @@ public async Task<XivImc> GetImcInfo(IItemModel item)
             var info = await GetFullImcInfo(item);
             var slot = item.GetItemSlotAbbreviation();
 
-            return info.GetEntry(item.ModelInfo.ImcSubsetID, slot);
+            var result = info.GetEntry(item.ModelInfo.ImcSubsetID, slot);
+            return result;
         }
 
         public async Task<FullImcInfo> GetFullImcInfo(IItemModel item)
@@ -79,14 +80,19 @@ public async Task<FullImcInfo> GetFullImcInfo(IItemModel item)
             {
                 // Some dual wield items don't have a second IMC, and just default to the first.
                 var gear = (XivGear)item;
-                if (gear != null && gear.PairedItem != null) {
-                    return await (GetFullImcInfo(gear.PairedItem));
+                if (gear != null && gear.PairedItem != null)
+                {
+                    var pair = gear.PairedItem;
+                    var imcPath = GetImcPath(pair);
+                    var path = imcPath.Folder + "/" + imcPath.File;
+                    return await (GetFullImcInfo(path));
                 }
             }
 
             return info;
         }
 
+
         /// <summary>
         /// Gets the full IMC information for a given item
         /// </summary>
@@ -185,6 +191,87 @@ public async Task<FullImcInfo> GetFullImcInfo(string path)
             });
         }
 
+        public async Task SaveImcInfo(XivImc info, IItemModel item)
+        {
+            var full = await GetFullImcInfo(item);
+            full.SetEntry(info, item.ModelInfo.ImcSubsetID, item.GetItemSlotAbbreviation());
+            await SaveFullImcInfo(full, item);
+        }
+
+        public async Task SaveImcInfo(XivImc info, string path, int subsetId = -1, string slot = "")
+        {
+            var full = await GetFullImcInfo(path);
+            full.SetEntry(info, subsetId, slot);
+            await SaveFullImcInfo(full, path);
+        }
+
+        public async Task SaveFullImcInfo(FullImcInfo info, IItemModel item)
+        {
+            try
+            {
+                var imcPath = GetImcPath(item);
+                var path = imcPath.Folder + "/" + imcPath.File;
+                await SaveFullImcInfo(info, path);
+            }
+            catch
+            {
+                // Some dual wield items don't have a second IMC, and just default to the first.
+                var gear = (XivGear)item;
+                if (gear != null && gear.PairedItem != null)
+                {
+                    var pair = gear.PairedItem;
+                    var imcPath = GetImcPath(pair);
+                    var path = imcPath.Folder + "/" + imcPath.File;
+                    await (SaveFullImcInfo(info, path));
+                }
+            }
+            return;
+
+        }
+
+        public async Task SaveFullImcInfo(FullImcInfo info, string path, string itemName = null, string category = null, string source = null)
+        {
+            var index = new Index(_gameDirectory);
+            var dat = new Dat(_gameDirectory);
+
+
+            var imcOffset = await index.GetDataOffset(path);
+
+            // No writing new IMC files.
+            if (imcOffset == 0)
+            {
+                throw new InvalidDataException($"Could not find offset for {path}");
+            }
+
+            var data = new List<byte>();
+
+            // 4 Header bytes.
+            data.AddRange(BitConverter.GetBytes(info.SubsetCount));
+            data.AddRange(BitConverter.GetBytes((short) info.TypeIdentifier));
+
+            // The rest of this is easy, it's literally just post all the sets in order.
+            foreach(var entry in info.DefaultSubset)
+            {
+                data.AddRange(entry.GetBytes());
+            }
+
+            foreach(var set in info.SubsetList)
+            {
+                foreach (var entry in set)
+                {
+                    data.AddRange(entry.GetBytes());
+                }
+            }
+
+            // That's it.
+
+            itemName ??= Path.GetFileName(path);
+            category ??= "Meta";
+            source ??= "Internal";
+
+            await dat.ImportType2Data(data.ToArray(), itemName, path, category, source);
+        }
+
         /// <summary>
         /// Gets the IMC internal path for the given model info
         /// </summary>
@@ -320,13 +407,42 @@ public XivImc GetEntry(int subsetID = -1, string slot = "")
 
                 // Get which offset the slot uses.
                 var idx = 0;
-                if(_slotOffsetDictionary.ContainsKey(slot))
+                if(_slotOffsetDictionary.ContainsKey(slot) && _slotOffsetDictionary[slot] < subset.Count)
                 {
                     idx = _slotOffsetDictionary[slot];
                 }
 
                 return subset[idx];
             }
+
+            public void SetEntry(XivImc info, int subsetID = -1, string slot = "")
+            {
+                // Variant IDs are 1 based, not 0 based.
+                var index = subsetID - 1;
+
+                // Invalid Index, return default.
+                if (index >= SubsetCount || index < 0)
+                {
+                    index = -1;
+                }
+
+                // Test for getting default set.
+                var subset = DefaultSubset;
+                if (index >= 0)
+                {
+                    subset = SubsetList[index];
+                }
+
+                // Get which offset the slot uses.
+                var idx = 0;
+                if (_slotOffsetDictionary.ContainsKey(slot) && _slotOffsetDictionary[slot] < subset.Count)
+                {
+                    idx = _slotOffsetDictionary[slot];
+                }
+
+                // Assign info.
+                subset[idx] = info;
+            }
         }
 
     }