Instanced Projects, AssetLocator, ParamBank, FMGBank

src/StudioCore/AssetUtils.cs

@@ -0,0 +1,216 @@
+using SoulsFormats;
+using StudioCore.Editor;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace StudioCore;
+
+/// <summary>
+///     Helper functions and statics for Project/Assetlocator
+/// </summary>
+public class AssetUtils
+{
+    public static readonly string GameExecutableFilter;
+    public static readonly string ProjectJsonFilter;
+    public static readonly string RegulationBinFilter;
+    public static readonly string Data0Filter;
+    public static readonly string ParamBndDcxFilter;
+    public static readonly string ParamBndFilter;
+    public static readonly string EncRegulationFilter;
+    public static readonly string ParamLooseFilter;
+    public static readonly string CsvFilter;
+    public static readonly string TxtFilter;
+    public static readonly string FmgJsonFilter;
+
+    static AssetUtils()
+    {
+        // These patterns are meant to be passed directly into PlatformUtils.
+        // Everything about their handling should be done there.
+
+        // Game Executable (.EXE, EBOOT.BIN)|*.EXE*;*EBOOT.BIN*
+        // Windows executable (*.EXE)|*.EXE*
+        // Playstation executable (*.BIN)|*.BIN*
+        GameExecutableFilter = "exe,bin";
+        // Project file (project.json)|PROJECT.JSON
+        ProjectJsonFilter = "json";
+        // Regulation file (regulation.bin)|REGULATION.BIN
+        RegulationBinFilter = "bin";
+        // Data file (Data0.bdt)|DATA0.BDT
+        Data0Filter = "bdt";
+        // ParamBndDcx (gameparam.parambnd.dcx)|GAMEPARAM.PARAMBND.DCX
+        ParamBndDcxFilter = "parambnd.dcx";
+        // ParamBnd (gameparam.parambnd)|GAMEPARAM.PARAMBND
+        ParamBndFilter = "parambnd";
+        // Enc_RegBndDcx (enc_regulation.bnd.dcx)|ENC_REGULATION.BND.DCX
+        EncRegulationFilter = "bnd.dcx";
+        // Loose Param file (*.Param)|*.Param
+        ParamLooseFilter = "param";
+        // CSV file (*.csv)|*.csv
+        CsvFilter = "csv";
+        // Text file (*.txt)|*.txt
+        TxtFilter = "txt";
+        // Exported FMGs (*.fmg.json)|*.fmg.json
+        FmgJsonFilter = "fmg.json";
+        // All file filter is implicitly added by NFD. Ideally this is used explicitly.
+        // All files|*.*
+    }
+    public static GameType GetGameTypeForExePath(string exePath)
+    {
+        var type = GameType.Undefined;
+        if (exePath.ToLower().Contains("darksouls.exe"))
+        {
+            type = GameType.DarkSoulsPTDE;
+        }
+        else if (exePath.ToLower().Contains("darksoulsremastered.exe"))
+        {
+            type = GameType.DarkSoulsRemastered;
+        }
+        else if (exePath.ToLower().Contains("darksoulsii.exe"))
+        {
+            type = GameType.DarkSoulsIISOTFS;
+        }
+        else if (exePath.ToLower().Contains("darksoulsiii.exe"))
+        {
+            type = GameType.DarkSoulsIII;
+        }
+        else if (exePath.ToLower().Contains("eboot.bin"))
+        {
+            var path = Path.GetDirectoryName(exePath);
+            if (Directory.Exists($@"{path}\dvdroot_ps4"))
+            {
+                type = GameType.Bloodborne;
+            }
+            else
+            {
+                type = GameType.DemonsSouls;
+            }
+        }
+        else if (exePath.ToLower().Contains("sekiro.exe"))
+        {
+            type = GameType.Sekiro;
+        }
+        else if (exePath.ToLower().Contains("eldenring.exe"))
+        {
+            type = GameType.EldenRing;
+        }
+        else if (exePath.ToLower().Contains("armoredcore6.exe"))
+        {
+            type = GameType.ArmoredCoreVI;
+        }
+
+        return type;
+    }
+
+    public static bool CheckFilesExpanded(string gamepath, GameType game)
+    {
+        if (game == GameType.EldenRing)
+        {
+            if (!Directory.Exists($@"{gamepath}\map"))
+            {
+                return false;
+            }
+
+            if (!Directory.Exists($@"{gamepath}\asset"))
+            {
+                return false;
+            }
+        }
+
+        if (game is GameType.DarkSoulsPTDE or GameType.DarkSoulsIII or GameType.Sekiro)
+        {
+            if (!Directory.Exists($@"{gamepath}\map"))
+            {
+                return false;
+            }
+
+            if (!Directory.Exists($@"{gamepath}\obj"))
+            {
+                return false;
+            }
+        }
+
+        if (game == GameType.DarkSoulsIISOTFS)
+        {
+            if (!Directory.Exists($@"{gamepath}\map"))
+            {
+                return false;
+            }
+
+            if (!Directory.Exists($@"{gamepath}\model\obj"))
+            {
+                return false;
+            }
+        }
+
+        if (game == GameType.ArmoredCoreVI)
+        {
+            if (!Directory.Exists($@"{gamepath}\map"))
+            {
+                return false;
+            }
+
+            if (!Directory.Exists($@"{gamepath}\asset"))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public static string GetGameIDForDir(GameType Type)
+    {
+        switch (Type)
+        {
+            case GameType.DemonsSouls:
+                return "DES";
+            case GameType.DarkSoulsPTDE:
+                return "DS1";
+            case GameType.DarkSoulsRemastered:
+                return "DS1R";
+            case GameType.DarkSoulsIISOTFS:
+                return "DS2S";
+            case GameType.Bloodborne:
+                return "BB";
+            case GameType.DarkSoulsIII:
+                return "DS3";
+            case GameType.Sekiro:
+                return "SDT";
+            case GameType.EldenRing:
+                return "ER";
+            case GameType.ArmoredCoreVI:
+                return "AC6";
+            default:
+                throw new Exception("Game type not set");
+        }
+    }
+
+    public static AssetDescription GetNullAsset()
+    {
+        AssetDescription ret = new();
+        ret.AssetPath = "null";
+        ret.AssetName = "null";
+        ret.AssetArchiveVirtualPath = "null";
+        ret.AssetVirtualPath = "null";
+        return ret;
+    }
+
+    public static string GetBinderVirtualPath(string virtualPathToBinder, string binderFilePath)
+    {
+        var filename = Path.GetFileNameWithoutExtension($@"{binderFilePath}.blah");
+        if (filename.Length > 0)
+        {
+            filename = $@"{virtualPathToBinder}/{filename}";
+        }
+        else
+        {
+            filename = virtualPathToBinder;
+        }
+
+        return filename;
+    }
+}

src/StudioCore/Editor/Action.cs

@@ -309,10 +309,10 @@ public override ActionEvent Undo()
 
 public class DuplicateFMGEntryAction : EditorAction
 {
-    private readonly FMGBank.EntryGroup EntryGroup;
-    private FMGBank.EntryGroup NewEntryGroup;
+    private readonly FMGEntryGroup EntryGroup;
+    private FMGEntryGroup NewEntryGroup;
 
-    public DuplicateFMGEntryAction(FMGBank.EntryGroup entryGroup)
+    public DuplicateFMGEntryAction(FMGEntryGroup entryGroup)
     {
         EntryGroup = entryGroup;
     }
@@ -333,10 +333,10 @@ public override ActionEvent Undo()
 
 public class DeleteFMGEntryAction : EditorAction
 {
-    private FMGBank.EntryGroup BackupEntryGroup = new();
-    private FMGBank.EntryGroup EntryGroup;
+    private FMGEntryGroup BackupEntryGroup = new();
+    private FMGEntryGroup EntryGroup;
 
-    public DeleteFMGEntryAction(FMGBank.EntryGroup entryGroup)
+    public DeleteFMGEntryAction(FMGEntryGroup entryGroup)
     {
         EntryGroup = entryGroup;
     }

src/StudioCore/Editor/EditorDecorations.cs

@@ -259,21 +259,21 @@ public static void ParamRefsSelectables(ParamBank bank, List<ParamRef> paramRefs
         return rows;
     }
 
-    private static List<(string, FMGBank.EntryGroup)> resolveFMGRefs(List<FMGRef> fmgRefs, Param.Row context,
+    private static List<(string, FMGEntryGroup)> resolveFMGRefs(List<FMGRef> fmgRefs, Param.Row context,
         dynamic oldval)
     {
-        if (!FMGBank.IsLoaded)
+        if (!Locator.ActiveProject.FMGBank.IsLoaded)
         {
-            return new List<(string, FMGBank.EntryGroup)>();
+            return new List<(string, FMGEntryGroup)>();
         }
 
         return fmgRefs.Where(rf =>
             {
                 Param.Cell? c = context?[rf.conditionField];
                 return context == null || c == null || Convert.ToInt32(c.Value.Value) == rf.conditionValue;
-            }).Select(rf => FMGBank.FmgInfoBank.Find(x => x.Name == rf.fmg))
+            }).Select(rf => Locator.ActiveProject.FMGBank.FmgInfoBank.FirstOrDefault(x => x.Name == rf.fmg))
             .Where(fmgi => fmgi != null)
-            .Select(fmgi => (fmgi.Name, FMGBank.GenerateEntryGroup((int)oldval, fmgi)))
+            .Select(fmgi => (fmgi.Name, Locator.ActiveProject.FMGBank.GenerateEntryGroup((int)oldval, fmgi)))
             .ToList();
     }
 
@@ -282,11 +282,11 @@ public static void FmgRefSelectable(EditorScreen ownerScreen, List<FMGRef> fmgNa
     {
         List<string> textsToPrint = UICache.GetCached(ownerScreen, (int)oldval, "PARAM META FMGREF", () =>
         {
-            List<(string, FMGBank.EntryGroup)> refs = resolveFMGRefs(fmgNames, context, oldval);
+            List<(string, FMGEntryGroup)> refs = resolveFMGRefs(fmgNames, context, oldval);
             return refs.Where(x => x.Item2 != null)
                 .Select(x =>
                 {
-                    FMGBank.EntryGroup group = x.Item2;
+                    FMGEntryGroup group = x.Item2;
                     var toPrint = "";
                     if (!string.IsNullOrWhiteSpace(group.Title?.Text))
                     {
@@ -379,7 +379,7 @@ public static void VirtualParamRefSelectables(ParamBank bank, string virtualRefN
             {
                 List<string> matchedExtRefPath =
                     currentRef.paths.Select(x => string.Format(x, searchValue)).ToList();
-                AssetLocator al = ParamBank.PrimaryBank.AssetLocator;
+                AssetLocator al = Locator.AssetLocator;
                 ExtRefItem(context, fieldName, $"modded {currentRef.name}", matchedExtRefPath, al.GameModDirectory,
                     cacheOwner);
                 ExtRefItem(context, fieldName, $"vanilla {currentRef.name}", matchedExtRefPath,
@@ -464,7 +464,7 @@ public static void ParamRefEnumQuickLink(ParamBank bank, object oldval, List<Par
             }
             else if (fmgRefs != null)
             {
-                (string, FMGBank.EntryGroup)? primaryRef =
+                (string, FMGEntryGroup)? primaryRef =
                     resolveFMGRefs(fmgRefs, context, oldval)?.FirstOrDefault();
                 if (primaryRef?.Item2 != null)
                 {
@@ -599,9 +599,9 @@ public static void PropertyRowFMGRefsContextItems(List<FMGRef> reftypes, Param.R
         ActionManager executor)
     {
         // Add Goto statements
-        List<(string, FMGBank.EntryGroup)> refs = resolveFMGRefs(reftypes, context, oldval);
+        List<(string, FMGEntryGroup)> refs = resolveFMGRefs(reftypes, context, oldval);
         var ctrlDown = InputTracker.GetKey(Key.ControlLeft) || InputTracker.GetKey(Key.ControlRight);
-        foreach ((var name, FMGBank.EntryGroup group) in refs)
+        foreach ((var name, FMGEntryGroup group) in refs)
         {
             if (ImGui.Selectable($@"Goto {name} Text"))
             {

src/StudioCore/Editor/ProjectSettings.cs

@@ -1,4 +1,5 @@
-using StudioCore.Platform;
+using Silk.NET.Core;
+using StudioCore.Platform;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -39,8 +40,6 @@ public class ProjectSettings
     /// </summary>
     public bool UseLooseParams { get; set; } = false;
 
-    public bool PartialParams { get; set; } = false;
-
     // FMG editor
     public string LastFmgLanguageUsed { get; set; } = "";
 
@@ -79,6 +78,24 @@ public static ProjectSettings Deserialize(string path)
             return null;
         }
     }
+
+    internal ProjectSettings CopyAndAssumeFromModDir(string moddir)
+    {
+        ProjectSettings newProj = new();
+        newProj.ProjectName = Path.GetFileName(Path.GetDirectoryName(moddir));
+        newProj.GameRoot = GameRoot;
+        newProj.GameType = GameType;
+        switch (newProj.GameType)
+        {
+            case GameType.DarkSoulsIISOTFS:
+                newProj.UseLooseParams = File.Exists($@"{moddir}\Param\AreaParam.param");
+                break;
+            case GameType.DarkSoulsIII:
+                newProj.UseLooseParams = File.Exists($@"{moddir}\param\gameparam\gameparam_dlc2.parambnd.dcx");
+                break;
+        }
+        return newProj;
+    }
 }
 
 public class NewProjectOptions

src/StudioCore/Interface/AliasUtils.cs

@@ -231,9 +231,9 @@ public static string FindPlayerCharacterName(Entity e, string modelName)
                         var term = c.Value.ToParamEditorString();
                         var result = term;
 
-                        if (FMGBank.IsLoaded)
+                        if (Locator.ActiveProject.FMGBank.IsLoaded)
                         {
-                            var matchingFmgInfo = FMGBank.FmgInfoBank.Find(x => x.Name.Contains("Character"));
+                            var matchingFmgInfo = Locator.ActiveProject.FMGBank.FmgInfoBank.First(x => x.Name.Contains("Character"));
 
                             if (matchingFmgInfo != null)
                             {