Beta 2.3.2.2

Author: Lunaretic

xivModdingFramework/Cache/XivDependencyGraph.cs

@@ -132,9 +132,6 @@ public enum XivDependencyFileType
         invalid,
         root,
         meta,
-        eqp,
-        eqdp,
-        imc,
         mdl,
         mtrl,
         tex
@@ -787,16 +784,6 @@ public async Task<List<string>> GetImcEntryPaths()
             return imcEntries;
         }
 
-        private static readonly Dictionary<XivItemType, string> EqdpFolder= new Dictionary<XivItemType, string>()
-        {
-            { XivItemType.equipment, "chara/xls/charadb/equipmentdeformerparameter/" },
-            { XivItemType.accessory, "chara/xls/charadb/accessorydeformerparameter/" }
-        };
-
-        private static readonly Dictionary<XivItemType, string> EqpPaths = new Dictionary<XivItemType, string>()
-        {
-            { XivItemType.equipment, "chara/xls/equipmentparameter/equipmentparameter.eqp" }
-        };
 
 
 
@@ -1010,7 +997,7 @@ internal static class XivDependencyGraph
          *  
          * 
          * ROOT     - [SET AND SLOT] - Theoretical/Just a number/prefix, no associated file.
-         * META     - [EQP/EQDP/IMC] - Binary entries. - Not all of these entries are available for all types, but at least one always is.
+         * META     - [META] - Binary entries.
          * MODEL    - [MDL] - Files for each racial model.
          * MATERIAL - [MTRL] - Files for each Racial Model x Material Variant, roughly.
          * TEXTURE  - [TEX] - Files For each Material. May be used by multiple.
@@ -1044,7 +1031,7 @@ internal static class XivDependencyGraph
         /// </summary>
         public static readonly Dictionary<XivDependencyLevel, List<XivDependencyFileType>> DependencyLevelGroups = new Dictionary<XivDependencyLevel, List<XivDependencyFileType>>()
         {
-            { XivDependencyLevel.Root, new List<XivDependencyFileType>() { XivDependencyFileType.root, XivDependencyFileType.meta, XivDependencyFileType.eqp, XivDependencyFileType.eqdp, XivDependencyFileType.imc } },
+            { XivDependencyLevel.Root, new List<XivDependencyFileType>() { XivDependencyFileType.root, XivDependencyFileType.meta } },
             { XivDependencyLevel.Model, new List<XivDependencyFileType>() { XivDependencyFileType.mdl } },
             { XivDependencyLevel.Material, new List<XivDependencyFileType>() { XivDependencyFileType.mtrl } },
             { XivDependencyLevel.Texture, new List<XivDependencyFileType>() { XivDependencyFileType.tex} },
@@ -1071,12 +1058,6 @@ internal static class XivDependencyGraph
         // Captures the binary offset of a file.
         private static readonly Regex _binaryOffsetRegex = new Regex(Constants.BinaryOffsetMarker + "([0-9]+)$");
 
-        // Regex for identifying EQP files and extracting the offset.
-        private static readonly Regex EqpRegex = new Regex("^chara\\/xls\\/equipmentparameter\\/equipmentparameter\\.eqp" + Constants.BinaryOffsetMarker + "([0-9]+)$");
-
-        // Regex for identifying EQDP files and extracting the type and offset.
-        private static readonly Regex EqdpRegex = new Regex("^chara\\/xls\\/charadb\\/(equipment|accessory)deformerparameter\\/c[0-9]{4}\\.eqdp" + Constants.BinaryOffsetMarker + "([0-9]+)$");
-
         private static readonly Regex MtrlRegex = new Regex("^.*\\.mtrl$");
 
         // Group 0 == Full File path
@@ -1303,19 +1284,6 @@ public static XivDependencyFileType GetDependencyFileType(string internalFilePat
                     return XivDependencyFileType.root;
                 case "meta":
                     return XivDependencyFileType.meta;
-                case "imc":
-                    // Do not allow dependency crawling for meta files that do not have proper binary offsets.
-                    if (!internalFilePath.Contains(Constants.BinaryOffsetMarker))
-                        return XivDependencyFileType.invalid;
-                    return XivDependencyFileType.imc;
-                case "eqp":
-                    if (!internalFilePath.Contains(Constants.BinaryOffsetMarker))
-                        return XivDependencyFileType.invalid;
-                    return XivDependencyFileType.eqp;
-                case "eqdp":
-                    if (!internalFilePath.Contains(Constants.BinaryOffsetMarker))
-                        return XivDependencyFileType.invalid;
-                    return XivDependencyFileType.eqdp;
                 case "mdl":
                     return XivDependencyFileType.mdl;
                 case "mtrl":
@@ -1559,106 +1527,33 @@ public static async Task<List<XivDependencyRoot>> GetDependencyRoots(string inte
         {
             var roots = new HashSet<XivDependencyRoot>();
 
+
+            // First root should always be the path-extracted root.
+            var info = ExtractRootInfo(internalFilePath);
+            var root = CreateDependencyRoot(info);
+            if(root != null)
+            {
+                roots.Add(root);
+            }
+
             // Tex files require special handling, because they can be referenced by modded items
             // outside of their own dependency chain potentially.
             var match = _extensionRegex.Match(internalFilePath);
             var suffix = "";
-            if(match.Success)
+            if (match.Success)
             {
                 suffix = match.Groups[1].Value;
             }
-            if(suffix == "tex")
+            if (suffix == "tex")
             {
                 // Oh boy.  Here we have to scrape the cache to find any custom modded roots(plural) we may have.
                 var customRoots = await GetModdedRoots(internalFilePath);
-                foreach(var r in customRoots)
+                foreach (var r in customRoots)
                 {
                     roots.Add(r);
                 }
             }
 
-            var info = ExtractRootInfo(internalFilePath);
-            var root = CreateDependencyRoot(info);
-            if(root != null)
-            {
-                roots.Add(root);
-            }
-
-
-            if(roots.Count == 0)
-            {
-                // See if this is a binary offset file.
-                match = _binaryOffsetRegex.Match(internalFilePath);
-                if(match.Success)
-                {
-                    long offset = Int64.Parse(match.Groups[1].Value);
-
-                    if (suffix == "imc")
-                    {
-                        // IMCs mostly parse out correctly above, but need to have slot information pulled from their binary offset.
-                        const int ImcHeaderSize = 4;
-                        const int ImcSubEntrySize = 6;
-                        const int IMcFullEntrySize = 30;
-
-                        offset /= 8;
-                        offset -= ImcHeaderSize;
-                        offset = offset % IMcFullEntrySize;
-                        var index = offset / ImcSubEntrySize;
-                        if (info.PrimaryType == XivItemType.equipment || info.PrimaryType == XivItemType.demihuman)
-                        {
-                            info.Slot = Imc.EquipmentSlotOffsetDictionary.First(x => x.Value == index).Key;
-                        }
-                        else  // accesory
-                        {
-                            info.Slot = Imc.AccessorySlotOffsetDictionary.First(x => x.Value == index).Key;
-                        }
-
-                        root = CreateDependencyRoot(info);
-                        if (root != null)
-                        {
-                            roots.Add(root);
-                        }
-                    }
-                    else if (suffix == "eqp")
-                    {
-                        var entrySize = Eqp.EquipmentParameterEntrySize * 8;
-                        var setId = (int)(offset / entrySize);
-
-                        var subOffset = (offset % entrySize) / 8;
-                        var slot = EquipmentParameterSet.EntryOffsets.First(x => x.Value == subOffset).Key;
-
-                        root = CreateDependencyRoot(XivItemType.equipment, setId, null, null, slot);
-                        if (root != null)
-                        {
-                            roots.Add(root);
-                        }
-
-                    } else if(suffix == "eqdp")
-                    {
-                        // For EQDPs, this is 16 bits per set, then within that, we can determine the slot based on the offset internally within the full set.
-                        match = EqdpRegex.Match(internalFilePath);
-                        if (match.Success)
-                        {
-                            var type = (XivItemType)Enum.Parse(typeof(XivItemType), match.Groups[1].Value);
-                            var entrySize = Eqp.EquipmentDeformerParameterEntrySize * 8;
-                            var setId = (int)(offset / entrySize);
-
-
-                            var slotOffset = offset % entrySize;
-                            var slotIndex = (int)(slotOffset / 2); // 2 Bits per slot.
-
-                            var slots = EquipmentDeformationParameterSet.SlotsAsList(type == XivItemType.accessory);
-                            var slot = slots[slotIndex];
-
-                            // Ok, now we have everything we need to create the root object.
-                            return new List<XivDependencyRoot>() { CreateDependencyRoot(type, setId, null, null, slot) };
-
-                        }
-
-                    }
-
-                }
-            }
 
             return roots.ToList();
         }

xivModdingFramework/Items/DataContainers/XivCharacter.cs

@@ -94,6 +94,23 @@ internal static IItemModel FromDependencyRoot(XivDependencyRoot root)
             return item;
         }
 
+        /// <summary>
+        /// Gets the item's name as it should be written to the modlist/modpack files.
+        /// </summary>
+        /// <returns></returns>
+        public string GetModlistItemName()
+        {
+            return SecondaryCategory != null ? SecondaryCategory : "Unknown";
+        }
+
+        /// <summary>
+        /// Gets the item's category as it should be written to the modlist/modpack files.
+        /// </summary>
+        /// <returns></returns>
+        public string GetModlistItemCategory()
+        {
+            return XivStrings.Character;
+        }
 
         public int CompareTo(object obj)
         {

xivModdingFramework/Items/DataContainers/XivFurniture.cs

@@ -87,6 +87,24 @@ internal static IItemModel FromDependencyRoot(XivDependencyRoot root)
             return item;
         }
 
+        /// <summary>
+        /// Gets the item's name as it should be written to the modlist/modpack files.
+        /// </summary>
+        /// <returns></returns>
+        public string GetModlistItemName()
+        {
+            return Name != null ? Name : "Unknown Furniture";
+        }
+
+        /// <summary>
+        /// Gets the item's category as it should be written to the modlist/modpack files.
+        /// </summary>
+        /// <returns></returns>
+        public string GetModlistItemCategory()
+        {
+            return SecondaryCategory != null ? SecondaryCategory : XivStrings.Housing;
+        }
+
         public int CompareTo(object obj)
         {
             return string.Compare(Name, ((XivFurniture)obj).Name, StringComparison.Ordinal);

xivModdingFramework/Items/DataContainers/XivGear.cs

@@ -92,6 +92,23 @@ public class XivGear : IItemModel
         /// </summary>
         public XivGear PairedItem { get; set; }
 
+        /// <summary>
+        /// Gets the item's name as it should be written to the modlist/modpack files.
+        /// </summary>
+        /// <returns></returns>
+        public string GetModlistItemName()
+        {
+            return Name != null ? Name : "Unknown Gear";
+        }
+
+        /// <summary>
+        /// Gets the item's category as it should be written to the modlist/modpack files.
+        /// </summary>
+        /// <returns></returns>
+        public string GetModlistItemCategory()
+        {
+            return SecondaryCategory != null ? SecondaryCategory : XivStrings.Gear;
+        }
         internal static IItemModel FromDependencyRoot(XivDependencyRoot root, int imcSubset)
         {
             var item = new XivGear();

xivModdingFramework/Items/DataContainers/XivGenericItemModel.cs

@@ -57,6 +57,23 @@ public class XivGenericItemModel : IItemModel
         /// </summary>
         public XivModelInfo ModelInfo { get; set; }
 
+        /// <summary>
+        /// Gets the item's name as it should be written to the modlist/modpack files.
+        /// </summary>
+        /// <returns></returns>
+        public string GetModlistItemName()
+        {
+            return Name != null ? Name : "Unknown Item";
+        }
+
+        /// <summary>
+        /// Gets the item's category as it should be written to the modlist/modpack files.
+        /// </summary>
+        /// <returns></returns>
+        public string GetModlistItemCategory()
+        {
+            return SecondaryCategory != null ? SecondaryCategory : "Unknown";
+        }
         internal static IItemModel FromDependencyRoot(XivDependencyRoot root, int imcSubset)
         {
             var item = new XivGenericItemModel();

xivModdingFramework/Items/DataContainers/XivMinion.cs

@@ -17,6 +17,7 @@
 using System;
 using xivModdingFramework.General.Enums;
 using xivModdingFramework.Items.Interfaces;
+using xivModdingFramework.Resources;
 
 namespace xivModdingFramework.Items.DataContainers
 {
@@ -67,6 +68,23 @@ public class XivMinion : IItemModel
         /// </summary>
         public XivModelInfo ModelInfo { get; set; }
 
+        /// <summary>
+        /// Gets the item's name as it should be written to the modlist/modpack files.
+        /// </summary>
+        /// <returns></returns>
+        public string GetModlistItemName()
+        {
+            return Name != null ? Name : "Unknown Minion";
+        }
+
+        /// <summary>
+        /// Gets the item's category as it should be written to the modlist/modpack files.
+        /// </summary>
+        /// <returns></returns>
+        public string GetModlistItemCategory()
+        {
+            return SecondaryCategory != null ? SecondaryCategory : XivStrings.Minions;
+        }
         public int CompareTo(object obj)
         {
             return string.Compare(Name, ((XivMinion)obj).Name, StringComparison.Ordinal);

xivModdingFramework/Items/DataContainers/XivMount.cs

@@ -71,6 +71,23 @@ public class XivMount : IItemModel
         /// </summary>
         public XivModelInfo ModelInfo { get; set; }
 
+        /// <summary>
+        /// Gets the item's name as it should be written to the modlist/modpack files.
+        /// </summary>
+        /// <returns></returns>
+        public string GetModlistItemName()
+        {
+            return Name != null ? Name : "Unknown Mount";
+        }
+
+        /// <summary>
+        /// Gets the item's category as it should be written to the modlist/modpack files.
+        /// </summary>
+        /// <returns></returns>
+        public string GetModlistItemCategory()
+        {
+            return SecondaryCategory != null ? SecondaryCategory : XivStrings.Mounts;
+        }
         internal static IItemModel FromDependencyRoot(XivDependencyRoot root, int imcSubset)
         {
             var item = new XivMount();

xivModdingFramework/Items/DataContainers/XivPet.cs

@@ -17,6 +17,7 @@
 using System;
 using xivModdingFramework.General.Enums;
 using xivModdingFramework.Items.Interfaces;
+using xivModdingFramework.Resources;
 
 namespace xivModdingFramework.Items.DataContainers
 {
@@ -67,6 +68,23 @@ public class XivPet : IItemModel
         /// </summary>
         public XivModelInfo ModelInfo { get; set; }
 
+        /// <summary>
+        /// Gets the item's name as it should be written to the modlist/modpack files.
+        /// </summary>
+        /// <returns></returns>
+        public string GetModlistItemName()
+        {
+            return Name != null ? Name : "Unknown Pet";
+        }
+
+        /// <summary>
+        /// Gets the item's category as it should be written to the modlist/modpack files.
+        /// </summary>
+        /// <returns></returns>
+        public string GetModlistItemCategory()
+        {
+            return SecondaryCategory != null ? SecondaryCategory : XivStrings.Pets;
+        }
         public int CompareTo(object obj)
         {
             return string.Compare(Name, ((XivPet)obj).Name, StringComparison.Ordinal);