// Saves of this game (Ocarina of Time, 0400486024DEC000), wherever they are (old setup/Saves.cs, Shell.Saves.cs): Triforce keeps // them in \user\save\ (Linux: ~/.local/share/hookshot/save/, host/hos_main.c saves_dir), emulators in their NAND // (Eden, yuzu, suyu, sudachi, citron, torzu, EvilOOT: nand\user\save\0000000000000000\\0400486024DEC000) or Ryujinx's // bis\user\save\\0, NX2navi in its game folder's profile (NaviSave). The files are the same everywhere (account.sav, // option.sav, slot_00..05\caption.sav + progress.sav), so bringing saves in or out is a copy, with what gets replaced backed up first. using System.Diagnostics; using System.Text.Json; using System.Text.RegularExpressions; namespace Triforce.Logic; /// A place that holds this game's saves (or, Empty, a place to copy them into). public sealed class SaveSet { public string Name { get; set; } = ""; public string Folder { get; set; } = ""; public int Slots { get; set; } public DateTime Last { get; set; } public bool Empty { get; set; } public override string ToString() => Name; } /// One of the six files of the game (slot_00..slot_05 = File 1..6). Caption: slot_0N\caption.sav, whose JPEG (from the first /// FF D8 FF to the last FF D9) the App decodes for the picture (DESIGN 7); Written: when it was last saved. public sealed record SaveSlot(int Index, string Folder, bool Used, string? Caption, DateTime? Written) { /// "File 4": the game's own numbering. public int FileNumber => Index + 1; } public sealed class SavesException : Exception { public SavesException(string message) : base(message) { } } public sealed class Saves { public const string TitleId = "0400486024DEC000"; /// Triforce's save folder name (host/nn_applet.c user_uid, host/nn_fs.c: save\<uid hi><uid lo>). public const string TriforceUid = "5a3c9e1f0b7d24680000000000000001"; public const int SlotCount = 6; static readonly string[] Emulators = { "eden", "EvilOOT", "yuzu", "suyu", "sudachi", "citron", "torzu", "eglantine", "Ryujinx" }; readonly TriforceContext ctx; public Saves(TriforceContext ctx) { this.ctx = ctx; } /// Triforce's save folder for a game folder. public string TriforceFolder(string game) => ctx.Platform.SaveFolder(game, TriforceUid); /// Triforce commits its save as a transaction (host/save_tx.h): a finished commit that could not be put in place yet /// (<user>\save-tx\<uid>\ready-<n>, the highest n) waits beside the save folder and is newer. The folder of that /// transaction for a save folder <user>\save\<uid>, or null when it is no such save folder. static string? TriforceTx(string save) { var parent = Path.GetDirectoryName(save.TrimEnd('\\', '/')); if (parent == null || !string.Equals(Path.GetFileName(parent), "save", StringComparison.OrdinalIgnoreCase)) return null; var user = Path.GetDirectoryName(parent); return user == null ? null : Path.Combine(user, "save-tx", Path.GetFileName(save.TrimEnd('\\', '/'))); } /// The save Triforce would load at its next start: a finished commit still waiting, else the save folder. public string TriforceNewest(string game) { var folder = TriforceFolder(game); try { var tx = TriforceTx(folder); if (tx != null && Directory.Exists(tx)) { var ready = Directory.GetDirectories(tx, "ready-*") .Select(d => (Dir: d, M: Regex.Match(Path.GetFileName(d), @"^ready-(\d{1,9})$"))) .Where(r => r.M.Success && IsSaveSet(r.Dir)) .OrderByDescending(r => int.Parse(r.M.Groups[1].Value)).FirstOrDefault(); if (ready.Dir != null) return ready.Dir; } } catch (Exception) { } return folder; } /// The six files of a game folder's save, as the game would load them (a waiting commit first). public IReadOnlyList Slots(string game) => SlotsIn(TriforceNewest(game)); /// The six files of any save folder. public static IReadOnlyList SlotsIn(string saveFolder) { var list = new List(); for (var i = 0; i < SlotCount; i++) { var dir = Path.Combine(saveFolder, "slot_" + i.ToString("00")); var progress = Path.Combine(dir, "progress.sav"); var caption = Path.Combine(dir, "caption.sav"); var used = File.Exists(progress); DateTime? written = null; try { var times = new[] { progress, caption }.Where(File.Exists).Select(File.GetLastWriteTime).ToList(); if (times.Count > 0) written = times.Max(); } catch (Exception) { } list.Add(new SaveSlot(i, dir, used, File.Exists(caption) ? caption : null, written)); } return list; } /// The file saved last: the one whose caption.sav was written last (DESIGN 7 "Newest save"), null when none is used. public SaveSlot? Newest(string game) => Slots(game).Where(s => s.Used).OrderByDescending(s => s.Caption != null ? File.GetLastWriteTime(s.Caption) : s.Written ?? DateTime.MinValue).FirstOrDefault(); /// A folder holding this game's saves. public static bool IsSaveSet(string dir) => Directory.Exists(dir) && (File.Exists(Path.Combine(dir, "option.sav")) || File.Exists(Path.Combine(dir, "slot_00", "progress.sav")) || File.Exists(Path.Combine(dir, "account.sav"))); public static SaveSet Describe(string name, string dir) { var s = new SaveSet { Name = name, Folder = dir }; if (!Directory.Exists(dir)) { s.Empty = true; return s; } s.Slots = Directory.GetDirectories(dir, "slot_*").Count(d => File.Exists(Path.Combine(d, "progress.sav"))); var files = Directory.GetFiles(dir, "*.sav", SearchOption.AllDirectories); s.Empty = files.Length == 0; s.Last = files.Length > 0 ? files.Max(f => File.GetLastWriteTime(f)) : DateTime.MinValue; return s; } /// The save an NX2navi game would load, given its game folder or that folder's profile folder. NX2navi keeps the save in /// <game>\profile\save\<account> (32 hex digits) and commits through <game>\profile\save-tx: a finished commit there /// (ready-<n>, the highest n) is newer than the account folder until the game's next start swaps it in. public static string? NaviSave(string dir) { try { foreach (var profile in new[] { Path.Combine(dir, "profile"), dir }) { var saves = Path.Combine(profile, "save"); if (!Directory.Exists(saves)) continue; var tx = Path.Combine(profile, "save-tx"); if (Directory.Exists(tx)) { // (the game names them with ten digits, ready-0000000001: its runtime/fs_host.c "ready-%010u", an unsigned 32-bit n) var ready = Directory.GetDirectories(tx, "ready-*") .Select(d => (Dir: d, M: Regex.Match(Path.GetFileName(d), @"^ready-(\d{1,10})$"))) .Where(r => r.M.Success && IsSaveSet(r.Dir)) .OrderByDescending(r => long.Parse(r.M.Groups[1].Value)).FirstOrDefault(); if (ready.Dir != null) return ready.Dir; } var account = Directory.GetDirectories(saves) .Where(d => Regex.IsMatch(Path.GetFileName(d), "^[0-9a-fA-F]{32}$") && IsSaveSet(d)) .OrderByDescending(d => Describe("", d).Last).FirstOrDefault(); if (account != null) return account; } } catch (Exception) { } return null; } /// The game folder NX2navi's launcher built into (<launcher>\data\launcher.json "game_dir"). static string? NaviGameDir(string launcher) { try { var file = Path.Combine(launcher, "data", "launcher.json"); if (!File.Exists(file)) return null; using var doc = JsonDocument.Parse(File.ReadAllText(file).TrimStart('')); return doc.RootElement.TryGetProperty("game_dir", out var g) && g.ValueKind == JsonValueKind.String && g.GetString() is { Length: > 0 } game ? game : null; } catch (Exception) { return null; } } /// Every save of this game found on this PC, newest first: the emulators' usual folders, the folders of programs the /// desktop and Start menu start (portable emulators keep a "user" folder beside them), Ryujinx's numbered saves, and NX2navi's /// games. A test run looks only in its own Roaming and Local folders (no drives, no shortcuts). public List FindEmulatorSaves() { var found = new List(); var seen = new HashSet(OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal); void Add(string name, string dir) { try { if (!IsSaveSet(dir)) return; var full = Path.GetFullPath(dir).TrimEnd('\\', '/'); if (seen.Add(full)) found.Add(Describe(name, full)); } catch (Exception) { } } void Nand(string name, string root) // (root\nand\user\save\0000000000000000\\) { var users = Path.Combine(root, "nand", "user", "save", "0000000000000000"); if (!Directory.Exists(users)) return; foreach (var u in SafeDirs(users)) Add(name, Path.Combine(u, TitleId)); } void Ryujinx(string name, string root) // (root\bis\user\save\<index>\0; the title is not checked) { var saves = Path.Combine(root, "bis", "user", "save"); if (!Directory.Exists(saves)) return; foreach (var s in SafeDirs(saves)) Add(name, Path.Combine(s, "0")); } void Navi(string game) { if (NaviSave(game) is { } save) Add("NX2navi", save); } void NaviLauncher(string launcher) { Navi(Path.Combine(launcher, "game")); if (NaviGameDir(launcher) is { } game) Navi(game); } var (roaming, local) = ctx.Platform.EmulatorDataRoots; if (ctx.IsWindows) { NaviLauncher(Path.Combine(local, "Programs", "NX2navi")); if (ctx.TestRoot == null) foreach (var drive in DriveInfo.GetDrives()) try { if (drive.DriveType == DriveType.Fixed && drive.IsReady) Navi(Path.Combine(drive.RootDirectory.FullName, "Games", "NX2navi")); } catch (Exception) { } foreach (var e in Emulators) { var root = Path.Combine(roaming, e); if (e == "Ryujinx") Ryujinx("Ryujinx", root); else Nand(Pretty(e), root); } // (portable copies: the programs the shortcuts start) foreach (var exe in ctx.TestRoot != null ? Enumerable.Empty<string>() : ShortcutTargets()) { var dir = Path.GetDirectoryName(exe); if (dir == null) continue; var name = Path.GetFileNameWithoutExtension(exe) + " (" + dir + ")"; Nand(name, Path.Combine(dir, "user")); Ryujinx(name, Path.Combine(dir, "portable")); Navi(dir); NaviLauncher(dir); } } else { // (Linux, docs/saves.md: ~/.local/share/<emu>, ~/.config/Ryujinx, the Flatpaks' own folders; NX2navi's AppImage builds // into ~/Games/Ocarina. Guess-level beyond docs/saves.md: check on a Deck) var home = ctx.TestRoot ?? Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); foreach (var e in Emulators.Where(e => e != "Ryujinx")) { Nand(Pretty(e), Path.Combine(roaming, e)); Nand(Pretty(e), Path.Combine(roaming, e.ToLowerInvariant())); } Ryujinx("Ryujinx", Path.Combine(local, "Ryujinx")); if (ctx.TestRoot == null) { var flat = Path.Combine(home, ".var", "app"); foreach (var (id, emu) in new[] { ("dev.eden_emu.eden", "eden"), ("org.yuzu_emu.yuzu", "yuzu"), ("org.suyu_emu.suyu", "suyu"), ("org.citron_emu.citron", "citron") }) Nand(Pretty(emu) + " (Flatpak)", Path.Combine(flat, id, "data", emu)); Ryujinx("Ryujinx (Flatpak)", Path.Combine(flat, "org.ryujinx.Ryujinx", "config", "Ryujinx")); } Navi(Path.Combine(home, "Games", "Ocarina")); } return found.OrderByDescending(s => s.Last).ToList(); } static string Pretty(string e) => e.ToLowerInvariant() switch { "eden" => "Eden", "yuzu" => "yuzu", "suyu" => "suyu", "sudachi" => "Sudachi", "citron" => "Citron", "torzu" => "torzu", "eglantine" => "Eglantine", "eviloot" => "EvilOOT", _ => e, }; static IEnumerable<string> SafeDirs(string d) { try { return Directory.GetDirectories(d); } catch (Exception) { return Array.Empty<string>(); } } /// <summary>The .exe files the desktop and Start menu shortcuts start (WScript.Shell reads the .lnk), at most 400 per folder.</summary> static IEnumerable<string> ShortcutTargets() { var exes = new HashSet<string>(StringComparer.OrdinalIgnoreCase); if (!OperatingSystem.IsWindows()) return exes; var places = new[] { Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), Environment.GetFolderPath(Environment.SpecialFolder.CommonDesktopDirectory), Environment.GetFolderPath(Environment.SpecialFolder.Programs), Environment.GetFolderPath(Environment.SpecialFolder.CommonPrograms), }; var type = Type.GetTypeFromProgID("WScript.Shell"); if (type == null) return exes; object? shell = null; try { shell = Activator.CreateInstance(type); foreach (var p in places.Where(p => p.Length > 0 && Directory.Exists(p))) { IEnumerable<string> links; try { links = Directory.GetFiles(p, "*.lnk", p.EndsWith("Programs", StringComparison.OrdinalIgnoreCase) ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly); } catch (Exception) { continue; } foreach (var l in links.Take(400)) { try { var lnk = type.InvokeMember("CreateShortcut", System.Reflection.BindingFlags.InvokeMethod, null, shell, new object[] { l })!; var target = lnk.GetType().InvokeMember("TargetPath", System.Reflection.BindingFlags.GetProperty, null, lnk, null) as string; System.Runtime.InteropServices.Marshal.FinalReleaseComObject(lnk); if (target != null && target.EndsWith(".exe", StringComparison.OrdinalIgnoreCase) && File.Exists(target)) exes.Add(target); } catch (Exception) { } } } } catch (Exception) { } finally { if (shell != null) System.Runtime.InteropServices.Marshal.FinalReleaseComObject(shell); } return exes; } /// <summary>A chosen folder: the save set it is, an NX2navi save inside it, or the first one inside it (breadth first, 7 levels, /// at most 4000 folders).</summary> public static string? FindIn(string dir) { if (IsSaveSet(dir)) return dir; if (NaviSave(dir) is { } navi) return navi; var queue = new Queue<(string, int)>(); queue.Enqueue((dir, 0)); var looked = 0; while (queue.Count > 0 && looked++ < 4000) { var (d, depth) = queue.Dequeue(); foreach (var s in SafeDirs(d)) { if (IsSaveSet(s)) return s; if (depth < 7) queue.Enqueue((s, depth + 1)); } } return null; } /// <summary>A game or emulator that has these saves open (it would write over the copy when it closes): its name, or null. /// In a test run only a program started from inside the test folder counts.</summary> public string? RunningGame() { // ("ocarina" is the program NX2navi builds) var names = new[] { "Triforce", "hookshot", "EvilOOT", "eden", "yuzu", "suyu", "sudachi", "citron", "torzu", "Ryujinx", "ocarina" }; foreach (var p in ctx.Platform.FindProcesses(names)) if (ctx.TestRoot == null || p.Exe != null && TriforceContext.Inside(ctx.TestRoot, p.Exe)) return p.Name == "ocarina" ? "NX2navi" : p.Name; return null; } /// <summary>Copies one save set over another: the destination's old files are copied to the backup folder first (nothing is /// merged slot by slot: the copy is exactly the source). Returns the backup folder, or null when there was nothing to back up. /// The games' save locks are held across all of it (SaveLock), and the copy is made as <save>.partial and swapped in once /// complete (Partial): a copy that fails or is cut off leaves the destination as it was. TRIFORCE_SAVE_LOCK=0: no lock.</summary> public string? Copy(string from, string to, string backupRoot, string label) { var src = Path.GetFullPath(from).TrimEnd('\\', '/'); var dst = Path.GetFullPath(to).TrimEnd('\\', '/'); ctx.Require(dst); if (TriforceContext.SamePath(src, dst)) throw new InvalidOperationException("That is the same save folder."); var locking = ctx.Env("TRIFORCE_SAVE_LOCK") != "0"; using var dstLock = locking ? SaveLock.Take(dst) : null; using var srcLock = locking && !string.Equals(SaveLock.PathOf(src), SaveLock.PathOf(dst), StringComparison.OrdinalIgnoreCase) ? SaveLock.Take(src) : null; var partial = new Partial(ctx.Platform); Partial.Recover(dst); var staged = partial.Stage(src, dst); string? backup = null; try { if (Directory.Exists(dst) && Directory.EnumerateFileSystemEntries(dst).Any()) { var safe = string.Concat(label.Select(c => Path.GetInvalidFileNameChars().Contains(c) || c == ' ' ? '-' : c)); backup = Path.Combine(backupRoot, DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss") + "_" + safe); Directory.CreateDirectory(backup); CopyTree(dst, backup); } } catch (Exception) { Partial.Remove(staged); throw; } partial.SwapIn(staged, dst); // (into Triforce: its working copy and any finished commit still waiting belong to the save that was replaced, and the game // would put such a commit over the copy at its next start) if (TriforceTx(dst) is { } tx && Directory.Exists(tx)) try { Directory.Delete(tx, true); } catch (Exception) { } return backup; } static void CopyTree(string from, string to) { Directory.CreateDirectory(to); foreach (var f in Directory.GetFiles(from)) File.Copy(f, Path.Combine(to, Path.GetFileName(f)), true); foreach (var d in Directory.GetDirectories(from)) CopyTree(d, Path.Combine(to, Path.GetFileName(d))); } void Refuse() { if (RunningGame() is { } running) throw new SavesException("Close " + running + " first: it would write its own saves back over the copy when it closes."); } /// <summary>Bring saves in: a found (or chosen) save set becomes Triforce's; Triforce's own are backed up first, into /// <install>\save-backups\<date>_Triforce-before-<name>. Refused while a game or emulator runs. Returns the backup folder.</summary> public Task<string?> ImportAsync(SaveSet from, string game) => Task.Run(() => { Refuse(); if (from.Empty || !IsSaveSet(from.Folder)) throw new SavesException("That folder has no saves to bring in."); var backup = Copy(from.Folder, TriforceFolder(game), ctx.SaveBackupsFolder, "Triforce before " + from.Name); ctx.Log.Write("saves: " + from.Folder + " -> Triforce" + (backup != null ? " (backup " + backup + ")" : "")); return backup; }); /// <summary>Copy saves out: Triforce's newest save becomes the target's; the target's are backed up first. Returns the backup folder.</summary> public Task<string?> ExportAsync(string game, SaveSet to) => Task.Run(() => { Refuse(); var source = TriforceNewest(game); if (!IsSaveSet(source)) throw new SavesException("Triforce has no saves yet to take out."); var backup = Copy(source, to.Folder, ctx.SaveBackupsFolder, to.Name + " before Triforce"); ctx.Log.Write("saves: Triforce -> " + to.Folder + (backup != null ? " (backup " + backup + ")" : "")); return backup; }); }