Exterrata
1640 lines
67 KiB
C#
1640 lines
67 KiB
C#
using System.Collections.ObjectModel;
|
|
using System.Diagnostics;
|
|
using System.Text;
|
|
using System.Windows.Input;
|
|
using Avalonia.Threading;
|
|
using CVRManager.Models;
|
|
using CVRManager.Services;
|
|
|
|
namespace CVRManager.ViewModels;
|
|
|
|
public class MainViewModel : ObservableObject
|
|
{
|
|
readonly AppConfig cfg;
|
|
readonly GitHubService github;
|
|
readonly ModStore store;
|
|
readonly CvrmgService cvrmg = new();
|
|
readonly ModImportService importer;
|
|
readonly StringBuilder log = new();
|
|
CancellationTokenSource? cts;
|
|
|
|
bool busy;
|
|
string status = "Ready";
|
|
double progress;
|
|
bool indeterminate;
|
|
InstallVM? selectedInstall;
|
|
ModVM? selectedMod;
|
|
bool showNew;
|
|
string newName = "";
|
|
BranchChoice? newChoice;
|
|
string? newImportPath;
|
|
bool newMoveCache = true;
|
|
bool newDownload = true;
|
|
string addModRepo = "";
|
|
string cacheSize = "";
|
|
|
|
public Func<Task<string?>>? PickFolder { get; set; }
|
|
public Func<Task<IReadOnlyList<string>>>? PickFiles { get; set; }
|
|
public Func<string, Task<bool>>? Confirm { get; set; }
|
|
public Func<string, Task>? CopyImage { get; set; }
|
|
public GalleryViewModel Gallery { get; }
|
|
public void ReportStatus(string text) => Status = text;
|
|
|
|
public MainViewModel()
|
|
{
|
|
cfg = ConfigStore.Load();
|
|
ThemeService.Apply(cfg.Theme);
|
|
github = new GitHubService(() => cfg.GitHubToken);
|
|
store = new ModStore(github);
|
|
importer = new ModImportService(github, cvrmg);
|
|
Gallery = new GalleryViewModel(this);
|
|
|
|
foreach (var m in cfg.Mods) Mods.Add(new ModVM(this, m));
|
|
foreach (var h in cfg.Hooks) Hooks.Add(new HookVM(this, h));
|
|
foreach (var a in cfg.Accounts) Accounts.Add(new AccountVM(this, a));
|
|
RebuildAccountChoices();
|
|
foreach (var src in cfg.Sources) Sources.Add(new SourceVM(this, src));
|
|
AvailableMods = Mods.ToList();
|
|
selectedSource = Sources.FirstOrDefault();
|
|
Mods.CollectionChanged += (_, _) => RegroupMods();
|
|
RegroupMods();
|
|
foreach (var i in cfg.Installs) Installs.Add(new InstallVM(this, i));
|
|
RebuildChoices();
|
|
newChoice = BranchChoices.FirstOrDefault(c => c.Name == "public");
|
|
Installs.CollectionChanged += (_, _) => { Raise(nameof(NoInstalls)); Raise(nameof(ShowDetail)); };
|
|
selectedInstall = Installs.FirstOrDefault();
|
|
selectedMod = Mods.FirstOrDefault(m => m.Info.Id != ModDef.MelonLoaderId);
|
|
|
|
CreateInstallCommand = new RelayCommand(CreateInstallAsync);
|
|
ShowNewCommand = new RelayCommand(() => { ShowNew = true; NewImport = false; DetectExisting(); });
|
|
CancelNewCommand = new RelayCommand(() => ShowNew = false);
|
|
RefreshBranchesCommand = new RelayCommand(RefreshBranchesAsync);
|
|
CancelCommand = new RelayCommand(() => cts?.Cancel());
|
|
AddModCommand = new RelayCommand(AddModAsync);
|
|
AddLocalNewCommand = new RelayCommand(AddLocalFilesNewAsync);
|
|
RefreshAllModsCommand = new RelayCommand(RefreshAllModsAsync);
|
|
DedupeCommand = new RelayCommand(DedupeAllAsync);
|
|
ApplyLibraryRootCommand = new RelayCommand(ApplyLibraryRoot);
|
|
BrowseLibraryRootCommand = new RelayCommand(BrowseLibraryRootAsync);
|
|
BrowseImportCommand = new RelayCommand(BrowseImportAsync);
|
|
OpenLibraryCommand = new RelayCommand(() => Explorer(Paths.Root));
|
|
OpenCacheCommand = new RelayCommand(() => Explorer(Paths.SharedCache));
|
|
OpenModStoreCommand = new RelayCommand(() => Explorer(Paths.ModStore));
|
|
|
|
var timer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(1) };
|
|
timer.Tick += (_, _) => { if (IsInstallsPage) SelectedInstall?.RefreshLogs(); };
|
|
timer.Start();
|
|
|
|
Log($"Library: {Paths.Root}");
|
|
_ = StartupAsync();
|
|
}
|
|
|
|
public ObservableCollection<InstallVM> Installs { get; } = new();
|
|
public ObservableCollection<ModVM> Mods { get; } = new();
|
|
public ObservableCollection<HookVM> Hooks { get; } = new();
|
|
public ObservableCollection<AccountVM> Accounts { get; } = new();
|
|
public ObservableCollection<AccountChoice> AccountChoices { get; } = new();
|
|
public bool HasAccounts => Accounts.Count > 0;
|
|
string newAccountUser = "";
|
|
string newAccountKey = "";
|
|
|
|
public string NewAccountUser { get => newAccountUser; set => Set(ref newAccountUser, value); }
|
|
public string NewAccountKey { get => newAccountKey; set => Set(ref newAccountKey, value); }
|
|
|
|
public void RebuildAccountChoices()
|
|
{
|
|
AccountChoices.Clear();
|
|
AccountChoices.Add(new AccountChoice("", "Game login"));
|
|
foreach (var a in cfg.Accounts) AccountChoices.Add(new AccountChoice(a.Id, a.Name));
|
|
Raise(nameof(HasAccounts));
|
|
foreach (var i in Installs) i.RaiseAccount();
|
|
}
|
|
|
|
public void AccountsChanged()
|
|
{
|
|
Save();
|
|
RebuildAccountChoices();
|
|
}
|
|
|
|
GameAccount AddAccount(string name, string username, string userId, string key)
|
|
{
|
|
var a = new GameAccount { Name = name, Username = username, UserId = userId, AccessKey = TokenVault.Protect(key) };
|
|
cfg.Accounts.Add(a);
|
|
Accounts.Add(new AccountVM(this, a));
|
|
return a;
|
|
}
|
|
|
|
public ICommand AddAccountCommand => new RelayCommand(() =>
|
|
{
|
|
var user = NewAccountUser.Trim();
|
|
var key = NewAccountKey.Trim();
|
|
if (user.Length == 0 || key.Length == 0) { Status = "Enter a username and an access key."; return; }
|
|
AddAccount(user, user, "", key);
|
|
NewAccountUser = NewAccountKey = "";
|
|
AccountsChanged();
|
|
});
|
|
|
|
public ICommand ImportAccountsCommand => new RelayCommand(async () =>
|
|
{
|
|
var dirs = cfg.Installs.Select(Paths.GameDir).ToList();
|
|
var found = await Task.Run(() => AccountService.Scan(dirs).ToList());
|
|
var known = cfg.Accounts.Select(a => (a.Username, TokenVault.Unprotect(a.AccessKey))).ToHashSet();
|
|
var added = 0;
|
|
foreach (var f in found)
|
|
{
|
|
if (!known.Add((f.Username, f.AccessKey))) continue;
|
|
AddAccount(f.Name, f.Username, f.UserId, f.AccessKey);
|
|
added++;
|
|
}
|
|
Status = added == 0 ? "No new accounts found." : $"Imported {added} account{(added == 1 ? "" : "s")}.";
|
|
if (added > 0) AccountsChanged();
|
|
});
|
|
|
|
public async Task RemoveAccountAsync(AccountVM vm)
|
|
{
|
|
if (Confirm != null && !await Confirm($"Remove the account '{vm.Info.Name}'?")) return;
|
|
cfg.Accounts.Remove(vm.Info);
|
|
Accounts.Remove(vm);
|
|
foreach (var i in cfg.Installs.Where(i => i.AccountId == vm.Info.Id)) i.AccountId = "";
|
|
AccountsChanged();
|
|
}
|
|
public IEnumerable<HookDef> HookCatalog => cfg.Hooks;
|
|
string? hookWarning;
|
|
|
|
public void HooksChanged()
|
|
{
|
|
Save();
|
|
foreach (var i in Installs) i.RebuildHooks();
|
|
}
|
|
|
|
public ICommand AddHookCommand => new RelayCommand(() =>
|
|
{
|
|
var def = new HookDef { Name = "New hook" };
|
|
cfg.Hooks.Add(def);
|
|
Hooks.Add(new HookVM(this, def));
|
|
foreach (var i in Installs) if (def.DefaultOn) i.Info.HookIds.Add(def.Id);
|
|
HooksChanged();
|
|
});
|
|
|
|
public async Task RemoveHookAsync(HookVM vm)
|
|
{
|
|
if (!vm.CanRemove) return;
|
|
if (Confirm != null && !await Confirm($"Remove the hook '{vm.Info.Name}'?")) return;
|
|
cfg.Hooks.Remove(vm.Info);
|
|
Hooks.Remove(vm);
|
|
foreach (var i in Installs) i.Info.HookIds.Remove(vm.Info.Id);
|
|
HooksChanged();
|
|
}
|
|
|
|
public Task RunHookAsync(InstallVM vm, HookDef hook) => Run($"Running {hook.Name} on {vm.Info.Name}", async ct =>
|
|
{
|
|
if (!await HookService.RunAsync(hook, vm.Info, vm.InstalledBuild, Log, ct))
|
|
throw new InvalidOperationException($"{hook.Name} reported problems; see the activity log in Settings.");
|
|
});
|
|
|
|
async Task RunHooksAsync(InstallVM vm, string evt, CancellationToken ct)
|
|
{
|
|
var failed = await HookService.RunEventAsync(cfg.Hooks, vm.Info, evt, AppManifest.LocalBuildId(vm.Info), Log, ct);
|
|
if (failed.Count > 0) hookWarning = $"hook problems: {string.Join(", ", failed)} (see the activity log in Settings)";
|
|
}
|
|
public ObservableCollection<BranchInfo> Branches { get; } = new();
|
|
public ObservableCollection<BranchChoice> BranchChoices { get; } = new();
|
|
public ObservableCollection<string> DetectedInstalls { get; } = new();
|
|
public bool HasDetected => DetectedInstalls.Count > 0;
|
|
|
|
public IEnumerable<ModDef> ModCatalog => cfg.Mods;
|
|
public ModDef MelonLoader => cfg.Mods.First(m => m.Id == ModDef.MelonLoaderId);
|
|
|
|
public ICommand CreateInstallCommand { get; }
|
|
public ICommand ShowNewCommand { get; }
|
|
public ICommand CancelNewCommand { get; }
|
|
public ICommand RefreshBranchesCommand { get; }
|
|
public ICommand CancelCommand { get; }
|
|
public ICommand AddModCommand { get; }
|
|
public ICommand AddLocalNewCommand { get; }
|
|
public ICommand RefreshAllModsCommand { get; }
|
|
public ICommand DedupeCommand { get; }
|
|
public ICommand ApplyLibraryRootCommand { get; }
|
|
public ICommand BrowseLibraryRootCommand { get; }
|
|
public ICommand BrowseImportCommand { get; }
|
|
public ICommand OpenLibraryCommand { get; }
|
|
public ICommand OpenCacheCommand { get; }
|
|
public ICommand OpenModStoreCommand { get; }
|
|
|
|
string page = "installs";
|
|
public bool IsInstallsPage { get => page == "installs"; set { if (value) SetPage("installs"); } }
|
|
public bool IsModsPage { get => page == "mods"; set { if (value) SetPage("mods"); } }
|
|
public bool IsSettingsPage { get => page == "settings"; set { if (value) SetPage("settings"); } }
|
|
public bool IsGalleryPage
|
|
{
|
|
get => page == "gallery";
|
|
set
|
|
{
|
|
if (!value) return;
|
|
SetPage("gallery");
|
|
if (Gallery.Items.Count == 0) _ = Gallery.RefreshAsync();
|
|
}
|
|
}
|
|
|
|
void SetPage(string p)
|
|
{
|
|
if (page == p) return;
|
|
page = p;
|
|
Raise(nameof(IsInstallsPage));
|
|
Raise(nameof(IsModsPage));
|
|
Raise(nameof(IsSettingsPage));
|
|
Raise(nameof(IsGalleryPage));
|
|
}
|
|
|
|
public bool NoInstalls => Installs.Count == 0;
|
|
|
|
public bool IsBusy { get => busy; private set { if (Set(ref busy, value)) Raise(nameof(IsIdle)); } }
|
|
public bool IsIdle => !busy;
|
|
public string Status
|
|
{
|
|
get => status;
|
|
private set
|
|
{
|
|
status = value;
|
|
Raise();
|
|
ShowToast(value);
|
|
}
|
|
}
|
|
|
|
bool toastVisible;
|
|
bool toastError;
|
|
int toastToken;
|
|
public bool ToastVisible { get => toastVisible; private set => Set(ref toastVisible, value); }
|
|
public bool ToastError { get => toastError; private set => Set(ref toastError, value); }
|
|
|
|
void ShowToast(string text, bool error = false)
|
|
{
|
|
if (text == "Ready") return;
|
|
ToastError = error;
|
|
ToastVisible = true;
|
|
var token = ++toastToken;
|
|
if (error) return;
|
|
_ = Task.Run(async () =>
|
|
{
|
|
await Task.Delay(5000);
|
|
Dispatcher.UIThread.Post(() => { if (token == toastToken && !IsBusy) ToastVisible = false; });
|
|
});
|
|
}
|
|
|
|
public ICommand DismissToastCommand => new RelayCommand(() => ToastVisible = false);
|
|
|
|
bool showCode, codeBusy;
|
|
string codeText = "", codeError = "";
|
|
InstallVM? codeTarget;
|
|
public bool ShowCodeEntry { get => showCode; private set => Set(ref showCode, value); }
|
|
public string CodeText { get => codeText; set => Set(ref codeText, value); }
|
|
public string CodeError { get => codeError; private set { if (Set(ref codeError, value)) Raise(nameof(HasCodeError)); } }
|
|
public bool HasCodeError => codeError.Length > 0;
|
|
public bool CodeBusy { get => codeBusy; private set { if (Set(ref codeBusy, value)) Raise(nameof(CodeIdle)); } }
|
|
public bool CodeIdle => !codeBusy;
|
|
public string CodeIntro => codeTarget != null
|
|
? $"Unlocked branches are added and {codeTarget.Info.Name} switches to the first."
|
|
: "Unlocked branches are added and the first is selected.";
|
|
|
|
public void BeginCodeEntry(InstallVM? install = null)
|
|
{
|
|
codeTarget = install;
|
|
CodeText = "";
|
|
CodeError = "";
|
|
Raise(nameof(CodeIntro));
|
|
ShowCodeEntry = true;
|
|
}
|
|
|
|
public ICommand CancelCodeCommand => new RelayCommand(() => { if (!CodeBusy) ShowCodeEntry = false; });
|
|
public ICommand EnterCodeNewCommand => new RelayCommand(() => BeginCodeEntry());
|
|
public ICommand SubmitCodeCommand => new RelayCommand(async () =>
|
|
{
|
|
var code = CodeText.Trim();
|
|
if (CodeBusy) return;
|
|
if (code.Length == 0) { CodeError = "Type the access code first."; return; }
|
|
if (!SteamSignedIn) { CodeError = "Sign in to Steam in Settings first; Steam only checks codes for a signed-in account."; return; }
|
|
CodeError = "";
|
|
CodeBusy = true;
|
|
try
|
|
{
|
|
var names = await CheckCodeAsync(code);
|
|
ShowCodeEntry = false;
|
|
var pick = BranchChoices.FirstOrDefault(c => c.Name == names[0]);
|
|
if (pick == null) return;
|
|
if (codeTarget != null) codeTarget.BranchHint = pick;
|
|
else NewChoice = pick;
|
|
Status = names.Count == 1 ? $"Unlocked branch {names[0]}." : $"Unlocked {names.Count} branches; selected {names[0]}.";
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
CodeError = e.Message;
|
|
Log($"Access code check failed: {e.Message}");
|
|
}
|
|
finally { CodeBusy = false; }
|
|
});
|
|
|
|
bool showSignIn, signInNeedsCode;
|
|
string signInPassword = "", signInCode = "", signInPrompt = "";
|
|
TaskCompletionSource<string?>? signInReply;
|
|
public bool ShowSignIn { get => showSignIn; private set => Set(ref showSignIn, value); }
|
|
bool signInWaiting;
|
|
public bool SignInNeedsCode { get => signInNeedsCode; private set { if (Set(ref signInNeedsCode, value)) Raise(nameof(SignInNeedsPassword)); } }
|
|
public bool SignInWaiting { get => signInWaiting; private set { if (Set(ref signInWaiting, value)) { Raise(nameof(SignInNeedsPassword)); Raise(nameof(SignInCanContinue)); } } }
|
|
public bool SignInNeedsPassword => !signInNeedsCode && !signInWaiting;
|
|
public bool SignInCanContinue => !signInWaiting;
|
|
public string SignInUser { get => cfg.SteamUser; set { if (cfg.SteamUser != value) { cfg.SteamUser = value.Trim(); Raise(); Save(); } } }
|
|
public string SignInPassword { get => signInPassword; set => Set(ref signInPassword, value); }
|
|
public string SignInCode { get => signInCode; set => Set(ref signInCode, value); }
|
|
public string SignInPrompt { get => signInPrompt; private set => Set(ref signInPrompt, value); }
|
|
public bool SteamSignedIn => !string.IsNullOrEmpty(cfg.SteamToken);
|
|
public string SteamAccountText => SteamSignedIn ? $"Signed in as {cfg.SteamUser}." : "Not signed in.";
|
|
|
|
public ICommand SteamSignInCommand => new RelayCommand(async () =>
|
|
{
|
|
SignInPassword = "";
|
|
SignInCode = "";
|
|
SignInNeedsCode = false;
|
|
SignInWaiting = false;
|
|
SignInPrompt = "Steam sign-in";
|
|
ShowSignIn = true;
|
|
var pass = await WaitSignInAsync();
|
|
if (pass == null) { ShowSignIn = false; return; }
|
|
SignInPrompt = "Signing in...";
|
|
await Run("Steam sign-in", async ct =>
|
|
{
|
|
async Task<string> Ask(string prompt)
|
|
{
|
|
SignInCode = "";
|
|
SignInPrompt = prompt;
|
|
SignInNeedsCode = true;
|
|
ShowSignIn = true;
|
|
return await WaitSignInAsync() ?? throw new OperationCanceledException();
|
|
}
|
|
try
|
|
{
|
|
var token = await SteamLink.SignInAsync(cfg.SteamUser, pass,
|
|
() => Dispatcher.UIThread.Post(() =>
|
|
{
|
|
SignInPrompt = "Approve on your Steam mobile app.";
|
|
SignInWaiting = true;
|
|
ShowSignIn = true;
|
|
}),
|
|
wrong => Ask(wrong ? "That Steam Guard code was wrong. Enter the code from your Steam mobile app" : "Enter the Steam Guard code from your Steam mobile app"),
|
|
(mail, wrong) => Ask($"{(wrong ? "That code was wrong. " : "")}Enter the Steam Guard code emailed to {mail}"),
|
|
ct);
|
|
cfg.SteamToken = TokenVault.Protect(token);
|
|
Save();
|
|
Log($"Signed in to Steam as {cfg.SteamUser}.");
|
|
}
|
|
finally
|
|
{
|
|
ShowSignIn = false;
|
|
SignInNeedsCode = false;
|
|
SignInWaiting = false;
|
|
Raise(nameof(SteamSignedIn));
|
|
Raise(nameof(SteamAccountText));
|
|
}
|
|
});
|
|
SignInPassword = "";
|
|
});
|
|
|
|
Task<string?> WaitSignInAsync()
|
|
{
|
|
signInReply = new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
return signInReply.Task;
|
|
}
|
|
|
|
public ICommand SubmitSignInCommand => new RelayCommand(() =>
|
|
{
|
|
if (!SignInNeedsCode && !SignInWaiting && (string.IsNullOrWhiteSpace(cfg.SteamUser) || SignInPassword.Length == 0))
|
|
{
|
|
SignInPrompt = "Enter both your Steam username and password.";
|
|
return;
|
|
}
|
|
var reply = SignInNeedsCode ? SignInCode.Trim() : SignInPassword;
|
|
SignInPassword = "";
|
|
signInReply?.TrySetResult(reply);
|
|
});
|
|
|
|
public ICommand CancelSignInCommand => new RelayCommand(() => signInReply?.TrySetResult(null));
|
|
|
|
public ICommand SteamSignOutCommand => new RelayCommand(() =>
|
|
{
|
|
cfg.SteamToken = "";
|
|
Save();
|
|
Raise(nameof(SteamSignedIn));
|
|
Raise(nameof(SteamAccountText));
|
|
});
|
|
|
|
bool newImport;
|
|
bool NewImportDone;
|
|
public bool NewImport { get => newImport; set => Set(ref newImport, value); }
|
|
public double Progress { get => progress; private set => Set(ref progress, value); }
|
|
public bool Indeterminate { get => indeterminate; private set => Set(ref indeterminate, value); }
|
|
public string LogText { get { lock (logLock) return log.ToString(); } }
|
|
readonly object logLock = new();
|
|
bool logRaisePending;
|
|
|
|
public InstallVM? SelectedInstall
|
|
{
|
|
get => selectedInstall;
|
|
set { if (Set(ref selectedInstall, value)) { Raise(nameof(HasSelectedInstall)); ShowNew = false; NotifyAssignments(); } }
|
|
}
|
|
public bool HasSelectedInstall => selectedInstall != null;
|
|
|
|
public void RefreshModUsage()
|
|
{
|
|
foreach (var m in AvailableMods) m.RefreshUsedBy();
|
|
}
|
|
|
|
ModVM? managedMod;
|
|
public ModVM? ManagedMod { get => managedMod; set { if (Set(ref managedMod, value)) Raise(nameof(ShowManage)); } }
|
|
public bool ShowManage => managedMod != null;
|
|
public ICommand CloseManageCommand => new RelayCommand(() => ManagedMod = null);
|
|
|
|
public void NotifyAssignments()
|
|
{
|
|
foreach (var m in AvailableMods.Concat(Mods).Distinct().ToList()) m.NotifyInstall();
|
|
if (modFilter != "All mods") RegroupMods();
|
|
}
|
|
|
|
public ObservableCollection<object> ModRows { get; } = new();
|
|
public List<ModVM> AvailableMods { get; private set; } = new();
|
|
readonly Dictionary<string, ModVM> transientMods = new();
|
|
string availableStatus = "Loading mods from your sources...";
|
|
public string AvailableStatus { get => availableStatus; private set => Set(ref availableStatus, value); }
|
|
|
|
public bool IsInCatalog(ModDef def) => cfg.Mods.Contains(def);
|
|
|
|
public void EnsureInCatalog(ModVM vm)
|
|
{
|
|
if (cfg.Mods.Contains(vm.Info)) return;
|
|
cfg.Mods.Add(vm.Info);
|
|
Mods.Add(vm);
|
|
Save();
|
|
}
|
|
|
|
static bool Matches(ModDef d, AvailableEntry e)
|
|
{
|
|
if (d.CvrmgId > 0 && e.Cvrmg != null && e.Cvrmg.Id == d.CvrmgId) return true;
|
|
if (d.Source == "github" && d.AssetFilter.Length > 0 && e.Keys.Contains(ModImportService.Norm(d.AssetFilter.Replace(".dll", "", StringComparison.OrdinalIgnoreCase)))) return true;
|
|
if (d.FileName.Length > 0 && e.Keys.Contains(ModImportService.Norm(Path.GetFileNameWithoutExtension(d.FileName)))) return true;
|
|
return e.Keys.Contains(ModImportService.Norm(d.Name));
|
|
}
|
|
|
|
ModDef BuildDef(AvailableEntry e)
|
|
{
|
|
var def = new ModDef { Name = e.Name, Type = e.Cvrmg?.ModType ?? "Mods" };
|
|
if (e.Repos.FirstOrDefault() is { } o)
|
|
{
|
|
def.Source = "github";
|
|
def.Repo = o.Repo;
|
|
def.AssetFilter = o.Asset;
|
|
def.FileName = o.Asset;
|
|
def.SourceLink = $"https://github.com/{o.Repo}";
|
|
def.Releases = o.Releases;
|
|
}
|
|
else if (e.Cvrmg != null)
|
|
{
|
|
def.Source = "cvrmg";
|
|
def.FileName = Paths.Safe(e.Cvrmg.Name) + ".dll";
|
|
def.Releases = new List<ReleaseInfo> { CvrmgService.ToRelease(e.Cvrmg, def.FileName) };
|
|
}
|
|
if (e.Cvrmg != null) CvrmgService.ApplyMeta(def, e.Cvrmg);
|
|
if (def.Category.Length == 0) def.Category = "Not on CVRMG";
|
|
return def;
|
|
}
|
|
|
|
public async Task RefreshAvailableAsync(bool force, CancellationToken ct = default)
|
|
{
|
|
AvailableStatus = "Loading mods from your sources...";
|
|
List<AvailableEntry> entries;
|
|
try
|
|
{
|
|
entries = await AvailableModsService.BuildAsync(cvrmg, importer, cfg.Sources, force, Log, ct);
|
|
}
|
|
catch (Exception e) when (e is not OperationCanceledException)
|
|
{
|
|
AvailableStatus = "Could not load sources: " + e.Message;
|
|
entries = new();
|
|
}
|
|
|
|
var vms = new List<ModVM>();
|
|
var byEntry = new Dictionary<AvailableEntry, ModVM>();
|
|
var claimed = new HashSet<ModDef>();
|
|
foreach (var e in entries)
|
|
{
|
|
var existing = cfg.Mods.FirstOrDefault(d => d.Id != ModDef.MelonLoaderId && !claimed.Contains(d) && Matches(d, e));
|
|
if (existing != null)
|
|
{
|
|
claimed.Add(existing);
|
|
if (e.Cvrmg != null)
|
|
{
|
|
if (existing.CvrmgId == 0) existing.CvrmgId = e.Cvrmg.Id;
|
|
if (existing.Category.Length == 0 || existing.Category == "Not on CVRMG") existing.Category = e.Cvrmg.Category;
|
|
if (existing.Description.Length == 0) existing.Description = e.Cvrmg.Description;
|
|
if (existing.Author.Length == 0) existing.Author = e.Cvrmg.Author;
|
|
existing.Status = e.Cvrmg.StatusText;
|
|
existing.LatestVersion = e.Cvrmg.ModVersion;
|
|
}
|
|
if (existing.Source == "github" && e.Repos.FirstOrDefault(o => o.Repo.Equals(existing.Repo, StringComparison.OrdinalIgnoreCase)) is { } offer)
|
|
existing.SetReleases(ModImportService.FilterReleases(offer.Releases, existing.AssetFilter));
|
|
else if (existing.Source == "cvrmg" && e.Cvrmg != null)
|
|
existing.SetReleases(new List<ReleaseInfo> { CvrmgService.ToRelease(e.Cvrmg, existing.FileName.Length > 0 ? existing.FileName : Paths.Safe(e.Cvrmg.Name) + ".dll") });
|
|
var vm = Mods.FirstOrDefault(v => v.Info == existing);
|
|
if (vm != null) { vms.Add(vm); byEntry[e] = vm; }
|
|
continue;
|
|
}
|
|
if (e.Cvrmg is { ApprovalStatus: 3 }) continue;
|
|
if (!transientMods.TryGetValue(e.Key, out var t)) transientMods[e.Key] = t = new ModVM(this, BuildDef(e));
|
|
else
|
|
{
|
|
var fresh = BuildDef(e);
|
|
t.Info.Releases = fresh.Releases;
|
|
t.Info.Description = fresh.Description;
|
|
t.Info.LatestVersion = fresh.LatestVersion;
|
|
t.Info.Category = fresh.Category;
|
|
t.Info.Status = fresh.Status;
|
|
}
|
|
t.Rebuild();
|
|
vms.Add(t);
|
|
byEntry[e] = t;
|
|
}
|
|
foreach (var vm in Mods.Where(v => v.Info.Id != ModDef.MelonLoaderId && !claimed.Contains(v.Info))) vms.Add(vm);
|
|
|
|
foreach (var src in Sources)
|
|
{
|
|
var own = src.Info.Kind == "cvrmg"
|
|
? entries.Where(e => e.Cvrmg != null)
|
|
: entries.Where(e => e.Repos.Any(o => o.Repo.Equals(src.Info.Repo, StringComparison.OrdinalIgnoreCase)));
|
|
src.SetMods(own.Select(e => byEntry.GetValueOrDefault(e)).Where(v => v != null).Select(v => v!).Distinct()
|
|
.OrderBy(v => v.Info.Name, StringComparer.OrdinalIgnoreCase));
|
|
src.Count = src.Mods.Count;
|
|
}
|
|
|
|
AvailableMods = vms;
|
|
foreach (var vm in Mods) vm.Rebuild();
|
|
Save();
|
|
AvailableStatus = $"{vms.Count} mods from {Sources.Count} sources";
|
|
RegroupMods();
|
|
}
|
|
readonly HashSet<string> collapsedMods = new();
|
|
bool regroupQueued;
|
|
string modSearch = "";
|
|
string modFilter = "All mods";
|
|
public static string[] ModFilters { get; } = { "All mods", "Installed", "Updates available" };
|
|
|
|
public string ModSearch { get => modSearch; set { if (Set(ref modSearch, value)) RegroupMods(); } }
|
|
public string ModFilter { get => modFilter; set { if (value != null && Set(ref modFilter, value)) RegroupMods(); } }
|
|
|
|
public void RegroupMods()
|
|
{
|
|
if (regroupQueued) return;
|
|
regroupQueued = true;
|
|
Dispatcher.UIThread.Post(() =>
|
|
{
|
|
regroupQueued = false;
|
|
var keep = selectedMod;
|
|
var q = modSearch.Trim();
|
|
ModRows.Clear();
|
|
var visible = AvailableMods.Where(m => m.Info.Id != ModDef.MelonLoaderId)
|
|
.Where(m => q.Length == 0 || m.Name.Contains(q, StringComparison.OrdinalIgnoreCase) || m.Info.Author.Contains(q, StringComparison.OrdinalIgnoreCase) || m.CategoryText.Contains(q, StringComparison.OrdinalIgnoreCase) || m.Info.Description.Contains(q, StringComparison.OrdinalIgnoreCase))
|
|
.Where(m => modFilter switch { "Installed" => m.InstallUsed, "Updates available" => m.UpdateAvailable, _ => true })
|
|
.GroupBy(m => m.CategoryText)
|
|
.OrderBy(g => g.Key is "Uncategorized" or "Local files" ? 1 : 0)
|
|
.ThenBy(g => g.Key, StringComparer.OrdinalIgnoreCase);
|
|
foreach (var g in visible)
|
|
{
|
|
ModRows.Add(new GroupHeader(g.Key, g.Count(), !collapsedMods.Contains(g.Key), h => { if (!collapsedMods.Remove(h.Title)) collapsedMods.Add(h.Title); RegroupMods(); }));
|
|
if (collapsedMods.Contains(g.Key)) continue;
|
|
foreach (var m in g.OrderBy(m => m.Info.Name, StringComparer.OrdinalIgnoreCase)) ModRows.Add(m);
|
|
}
|
|
if (keep != null && ModRows.Contains(keep)) selectedMod = keep;
|
|
Raise(nameof(SelectedRow));
|
|
});
|
|
}
|
|
|
|
public object? SelectedRow
|
|
{
|
|
get => selectedMod;
|
|
set { if (value is ModVM m) SelectedMod = m; }
|
|
}
|
|
|
|
public ModVM? SelectedMod
|
|
{
|
|
get => selectedMod;
|
|
set { if (Set(ref selectedMod, value)) { Raise(nameof(HasSelectedMod)); Raise(nameof(SelectedRow)); selectedMod?.Rebuild(); } }
|
|
}
|
|
public bool HasSelectedMod => selectedMod != null;
|
|
|
|
public bool ShowNew { get => showNew; set { if (Set(ref showNew, value)) Raise(nameof(ShowDetail)); } }
|
|
public bool ShowDetail => Installs.Count > 0;
|
|
public string NewName { get => newName; set => Set(ref newName, value); }
|
|
public BranchChoice? NewChoice
|
|
{
|
|
get => newChoice;
|
|
set
|
|
{
|
|
if (value != null) Set(ref newChoice, value);
|
|
}
|
|
}
|
|
public string? NewImportPath { get => newImportPath; set => Set(ref newImportPath, value); }
|
|
public bool NewMoveCache { get => newMoveCache; set => Set(ref newMoveCache, value); }
|
|
public bool NewDownload { get => newDownload; set => Set(ref newDownload, value); }
|
|
|
|
public string? NewDetected
|
|
{
|
|
get => NewImportPath;
|
|
set
|
|
{
|
|
NewImportPath = value;
|
|
if (value == null) return;
|
|
var found = SteamIntegration.FindExistingInstalls().FirstOrDefault(x => x.GameDir == value);
|
|
if (found.Manifest == null) return;
|
|
try
|
|
{
|
|
var state = Vdf.ParseDocument(File.ReadAllText(found.Manifest)).Dict("AppState");
|
|
var branch = state?.Dict("UserConfig")?.Str("BetaKey");
|
|
if (!string.IsNullOrEmpty(branch)) NewChoice = BranchChoices.FirstOrDefault(c => c.Name == branch) ?? AddChoice(new BranchChoice(branch, ""));
|
|
}
|
|
catch { }
|
|
Raise();
|
|
}
|
|
}
|
|
|
|
public string AddModRepo { get => addModRepo; set => Set(ref addModRepo, value); }
|
|
public string CacheSize { get => cacheSize; private set => Set(ref cacheSize, value); }
|
|
|
|
public string LibraryRoot
|
|
{
|
|
get => cfg.LibraryRoot;
|
|
set { if (cfg.LibraryRoot != value) { cfg.LibraryRoot = value; Raise(); } }
|
|
}
|
|
|
|
public bool CanChangeRoot => cfg.Installs.Count == 0;
|
|
|
|
public string SteamUser
|
|
{
|
|
get => cfg.SteamUser;
|
|
set { if (cfg.SteamUser != value) { cfg.SteamUser = value; Raise(); Raise(nameof(SignInUser)); Save(); } }
|
|
}
|
|
|
|
public bool CheckUpdates
|
|
{
|
|
get => cfg.CheckUpdates;
|
|
set { if (cfg.CheckUpdates != value) { cfg.CheckUpdates = value; Raise(); Save(); } }
|
|
}
|
|
|
|
UpdateInfo? update;
|
|
string updateStatus = "";
|
|
public string VersionText => $"CVR Manager {UpdateService.Current.ToString(3)}";
|
|
public string UpdateStatus { get => updateStatus; private set => Set(ref updateStatus, value); }
|
|
public bool UpdateReady => update != null;
|
|
public string InstallUpdateText => update == null ? "" : $"Install {update.Tag}";
|
|
public ICommand CheckUpdateCommand => new RelayCommand(() => CheckForUpdateAsync(true));
|
|
public ICommand InstallUpdateCommand => new RelayCommand(InstallUpdateAsync);
|
|
|
|
async Task CheckForUpdateAsync(bool manual)
|
|
{
|
|
if (manual) UpdateStatus = "Checking...";
|
|
try
|
|
{
|
|
update = await UpdateService.CheckAsync(CancellationToken.None);
|
|
UpdateStatus = update != null ? $"{update.Tag} is available." : manual ? "Up to date." : "";
|
|
if (update != null && !manual) ShowToast($"CVR Manager {update.Tag} is available. Install it in Settings.");
|
|
}
|
|
catch (Exception e) when (e is HttpRequestException or TaskCanceledException or System.Text.Json.JsonException)
|
|
{
|
|
update = null;
|
|
UpdateStatus = manual ? $"Could not check: {e.Message}" : "";
|
|
}
|
|
Raise(nameof(UpdateReady));
|
|
Raise(nameof(InstallUpdateText));
|
|
}
|
|
|
|
Task InstallUpdateAsync()
|
|
{
|
|
var info = update;
|
|
if (info == null) return Task.CompletedTask;
|
|
if (!UpdateService.CanWriteAppDir())
|
|
{
|
|
UpdateStatus = "The app folder is read-only; move CVR Manager somewhere you can write to.";
|
|
return Task.CompletedTask;
|
|
}
|
|
return Run($"Updating to {info.Tag}", async ct =>
|
|
{
|
|
var staged = await UpdateService.DownloadAsync(info, SetProgress, ct);
|
|
Save();
|
|
UpdateService.ApplyAndRestart(staged);
|
|
Dispatcher.UIThread.Post(() => (Avalonia.Application.Current?.ApplicationLifetime as Avalonia.Controls.ApplicationLifetimes.IClassicDesktopStyleApplicationLifetime)?.Shutdown());
|
|
});
|
|
}
|
|
|
|
public bool CacheGuard
|
|
{
|
|
get => cfg.CacheGuard;
|
|
set { if (cfg.CacheGuard != value) { cfg.CacheGuard = value; Raise(); Save(); } }
|
|
}
|
|
|
|
public IEnumerable<string> ThemeNames => ThemeService.Names;
|
|
public string ThemeNote { get; private set; } = "";
|
|
|
|
public string Theme
|
|
{
|
|
get => cfg.Theme;
|
|
set
|
|
{
|
|
if (value == null || cfg.Theme == value) return;
|
|
cfg.Theme = value;
|
|
var ok = ThemeService.Apply(value);
|
|
ThemeNote = ok ? "" : "No saved in-game colours; using ChilloutVR.";
|
|
Raise();
|
|
Raise(nameof(ThemeNote));
|
|
Save();
|
|
}
|
|
}
|
|
|
|
public string GitHubToken
|
|
{
|
|
get => cfg.GitHubToken;
|
|
set { if (cfg.GitHubToken != value) { cfg.GitHubToken = value; Raise(); Save(); } }
|
|
}
|
|
|
|
public string SteamClientText => SteamIntegration.IsRunning
|
|
? "Steam is running."
|
|
: "Steam is started silently on launch.";
|
|
|
|
public void Save() => ConfigStore.Save(cfg);
|
|
|
|
public void Log(string line)
|
|
{
|
|
lock (logLock)
|
|
{
|
|
log.AppendLine(line);
|
|
if (log.Length > 60000) log.Remove(0, log.Length - 40000);
|
|
if (logRaisePending) return;
|
|
logRaisePending = true;
|
|
}
|
|
Dispatcher.UIThread.Post(async () =>
|
|
{
|
|
await Task.Delay(150);
|
|
lock (logLock) logRaisePending = false;
|
|
Raise(nameof(LogText));
|
|
});
|
|
}
|
|
|
|
void SetProgress(double p) => Dispatcher.UIThread.Post(() => { Indeterminate = false; Progress = p; });
|
|
|
|
async Task Run(string title, Func<CancellationToken, Task> work)
|
|
{
|
|
if (IsBusy) { ToastVisible = true; return; }
|
|
IsBusy = true;
|
|
Status = title;
|
|
Indeterminate = true;
|
|
cts = new CancellationTokenSource();
|
|
try
|
|
{
|
|
hookWarning = null;
|
|
await work(cts.Token);
|
|
if (hookWarning != null)
|
|
{
|
|
status = $"{title}: done, but {hookWarning}";
|
|
Raise(nameof(Status));
|
|
ShowToast(status, true);
|
|
}
|
|
else Status = $"{title}: done";
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
Status = $"{title}: cancelled";
|
|
Log(Status);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log($"ERROR: {e.Message}");
|
|
status = $"{title}: failed - {e.Message}";
|
|
Raise(nameof(Status));
|
|
ShowToast(status, true);
|
|
}
|
|
finally
|
|
{
|
|
Indeterminate = false;
|
|
Progress = 0;
|
|
IsBusy = false;
|
|
cts = null;
|
|
Save();
|
|
foreach (var i in Installs) i.Refresh();
|
|
foreach (var m in Mods) m.Rebuild();
|
|
Raise(nameof(CanChangeRoot));
|
|
}
|
|
}
|
|
|
|
async Task StartupAsync()
|
|
{
|
|
DetectExisting();
|
|
AdoptRunningGames();
|
|
_ = RefreshAvailableAsync(false);
|
|
var cached = ConfigStore.LoadBranches();
|
|
if (cached.Count > 0)
|
|
{
|
|
foreach (var b in cached) Branches.Add(b);
|
|
RebuildChoices();
|
|
}
|
|
_ = RefreshBranchesQuietAsync(CancellationToken.None);
|
|
_ = Task.Run(() => { try { Directory.Delete(Path.Combine(Paths.Root, "update"), true); } catch (Exception e) when (e is IOException or UnauthorizedAccessException) { } });
|
|
if (cfg.CheckUpdates) _ = CheckForUpdateAsync(false);
|
|
if (!IsBusy) await RefreshModCoreAsync(MelonLoader, quiet: true);
|
|
_ = Task.Run(() =>
|
|
{
|
|
var size = FileOps.FormatSize(CacheService.SizeOf(Paths.SharedCache));
|
|
Dispatcher.UIThread.Post(() => CacheSize = $"Shared cache size: {size}");
|
|
});
|
|
}
|
|
|
|
BranchChoice AddChoice(BranchChoice c)
|
|
{
|
|
BranchChoices.Add(c);
|
|
return c;
|
|
}
|
|
|
|
public void RebuildChoices()
|
|
{
|
|
var names = new List<BranchChoice> { new("public", "") };
|
|
names.AddRange(Branches.Where(b => !b.PasswordRequired && b.Name != "public").Select(b => new BranchChoice(b.Name, "")));
|
|
names.AddRange(cfg.Unlocked.Select(u => new BranchChoice(u.Name, u.Code)));
|
|
foreach (var i in cfg.Installs)
|
|
if (names.All(n => n.Name != i.Branch)) names.Add(new BranchChoice(i.Branch, i.BranchPassword));
|
|
var keepNew = NewChoice?.Name;
|
|
BranchChoices.Clear();
|
|
foreach (var n in names.DistinctBy(n => n.Name)) BranchChoices.Add(n);
|
|
newChoice = BranchChoices.FirstOrDefault(c => c.Name == keepNew) ?? BranchChoices.First();
|
|
Raise(nameof(NewChoice));
|
|
foreach (var i in Installs) i.Refresh();
|
|
}
|
|
|
|
async Task<List<string>> CheckCodeAsync(string code)
|
|
{
|
|
var keys = await BranchCodeService.ResolveAsync(code, cfg.SteamUser, SteamToken, CancellationToken.None);
|
|
if (keys.Count == 0) throw new InvalidOperationException("That code does not unlock any ChilloutVR branch.");
|
|
foreach (var (n, key) in keys)
|
|
{
|
|
cfg.Unlocked.RemoveAll(u => u.Name == n);
|
|
cfg.Unlocked.Add(new UnlockedBranch { Name = n, Code = code, Key = BranchCodeService.ProtectKey(key) });
|
|
}
|
|
Save();
|
|
RebuildChoices();
|
|
Log($"Access code unlocks: {string.Join(", ", keys.Keys)}");
|
|
_ = RefreshBranchesQuietAsync(CancellationToken.None);
|
|
return keys.Keys.ToList();
|
|
}
|
|
|
|
void DetectExisting()
|
|
{
|
|
DetectedInstalls.Clear();
|
|
foreach (var (game, _) in SteamIntegration.FindExistingInstalls()) DetectedInstalls.Add(game);
|
|
Raise(nameof(HasDetected));
|
|
}
|
|
|
|
public Task RefreshBranchesAsync() => Run("Refreshing branches", async ct =>
|
|
{
|
|
var list = await SteamDownloader.GetBranchesAsync(cfg.SteamUser, SteamToken, PrivateBranches(), StoreBranchKey, Log, ct);
|
|
Branches.Clear();
|
|
foreach (var b in list) Branches.Add(b);
|
|
ConfigStore.SaveBranches(list);
|
|
RebuildChoices();
|
|
Log($"Branches: {string.Join(", ", list.Select(b => b.Name + (b.PasswordRequired ? " (password)" : "")))}");
|
|
foreach (var i in Installs) i.Refresh();
|
|
});
|
|
|
|
string SteamToken => TokenVault.Unprotect(cfg.SteamToken);
|
|
|
|
void StoreBranchKey(string branch, byte[] key)
|
|
{
|
|
var entry = cfg.Unlocked.FirstOrDefault(u => u.Name == branch);
|
|
if (entry == null) return;
|
|
entry.Key = BranchCodeService.ProtectKey(key);
|
|
Dispatcher.UIThread.Post(Save);
|
|
}
|
|
|
|
List<SteamDownloader.PrivateBranch> PrivateBranches() =>
|
|
cfg.Unlocked.Where(u => u.Code.Length > 0).Select(u => new SteamDownloader.PrivateBranch(u.Name, u.Code, BranchCodeService.UnprotectKey(u.Key))).ToList();
|
|
|
|
Task InstallFilesAsync(InstallInfo info, bool validate, CancellationToken ct)
|
|
{
|
|
var key = BranchCodeService.UnprotectKey(cfg.Unlocked.FirstOrDefault(u => u.Name == info.Branch)?.Key ?? "");
|
|
return SteamDownloader.InstallAsync(Paths.GameDir(info), info.Branch, info.BranchPassword, key, StoreBranchKey,
|
|
cfg.SteamUser, SteamToken, validate, Log, SetProgress, ct);
|
|
}
|
|
|
|
async Task CreateInstallAsync()
|
|
{
|
|
var name = NewName.Trim();
|
|
if (name.Length == 0) { Status = "Give the install a name."; return; }
|
|
if (cfg.Installs.Any(i => i.Name.Equals(name, StringComparison.OrdinalIgnoreCase))) { Status = "An install with that name exists."; return; }
|
|
|
|
var info = new InstallInfo
|
|
{
|
|
Name = name,
|
|
Branch = NewChoice?.Name ?? "public",
|
|
BranchPassword = NewChoice?.Code ?? "",
|
|
};
|
|
info.Folder = InstallFolders.UniqueFolder(cfg.Installs, info, name);
|
|
info.HookIds = cfg.Hooks.Where(h => h.DefaultOn).Select(h => h.Id).ToList();
|
|
var import = NewImport ? NewImportPath : null;
|
|
if (NewImport && string.IsNullOrWhiteSpace(import)) { Status = "Choose the folder to import."; return; }
|
|
var moveCache = NewMoveCache;
|
|
var download = !NewImport;
|
|
NewImportDone = NewImport;
|
|
|
|
InstallVM? vm = null;
|
|
await Run($"Creating {name}", async ct =>
|
|
{
|
|
Directory.CreateDirectory(Paths.GameDir(info));
|
|
cfg.Installs.Add(info);
|
|
vm = new InstallVM(this, info);
|
|
Installs.Add(vm);
|
|
SelectedInstall = vm;
|
|
ShowNew = false;
|
|
Raise(nameof(CanChangeRoot));
|
|
|
|
if (!string.IsNullOrEmpty(import))
|
|
{
|
|
Log($"Mirroring {import} into this install. The original is only read, never changed...");
|
|
var cacheSrc = Path.Combine(import, "ChilloutVR_Data", "Cache");
|
|
await Task.Run(() => FileOps.CopyTree(import, Paths.GameDir(info),
|
|
p => string.Equals(p, cacheSrc, StringComparison.OrdinalIgnoreCase), Log, ct), ct);
|
|
|
|
var found = SteamIntegration.FindExistingInstalls().FirstOrDefault(x => x.GameDir == import);
|
|
if (found.Manifest != null)
|
|
{
|
|
Directory.CreateDirectory(Path.GetDirectoryName(Paths.Manifest(info))!);
|
|
File.Copy(found.Manifest, Paths.Manifest(info), true);
|
|
}
|
|
|
|
if (moveCache && Directory.Exists(cacheSrc))
|
|
{
|
|
Log("Copying the source cache into the shared cache (the original is left as it is)...");
|
|
await Task.Run(() => CacheService.CopyInto(cacheSrc, Paths.SharedCache, Log, ct), ct);
|
|
}
|
|
}
|
|
|
|
if (download) await InstallFilesAsync(info, true, ct);
|
|
if (Directory.Exists(Path.GetDirectoryName(Paths.CacheDir(info))!) || File.Exists(Paths.GameExe(info)))
|
|
await CacheService.LinkAsync(info, Log, ct);
|
|
if (NewImportDone) await ImportModsCoreAsync(info, ct);
|
|
if (File.Exists(Paths.GameExe(info))) await RunHooksAsync(vm, HookDef.AfterUpdateEvent, ct);
|
|
});
|
|
vm?.Refresh();
|
|
NewName = "";
|
|
NewImportPath = null;
|
|
}
|
|
|
|
public Task UpdateInstallAsync(InstallVM vm, bool validate) => Run($"Updating {vm.Info.Name}", async ct =>
|
|
{
|
|
await RunHooksAsync(vm, HookDef.BeforeUpdateEvent, ct);
|
|
await InstallFilesAsync(vm.Info, validate, ct);
|
|
await CacheService.LinkAsync(vm.Info, Log, ct);
|
|
if (vm.Info.Mods.Count > 0) await store.ApplyAsync(vm.Info, cfg.Mods, Log, ct);
|
|
vm.ClearPending();
|
|
await RunHooksAsync(vm, HookDef.AfterUpdateEvent, ct);
|
|
await RefreshBranchesQuietAsync(ct);
|
|
});
|
|
|
|
async Task RefreshBranchesQuietAsync(CancellationToken ct)
|
|
{
|
|
try
|
|
{
|
|
var list = await SteamDownloader.GetBranchesAsync(cfg.SteamUser, SteamToken, PrivateBranches(), StoreBranchKey, Log, ct);
|
|
Branches.Clear();
|
|
foreach (var b in list) Branches.Add(b);
|
|
ConfigStore.SaveBranches(list);
|
|
RebuildChoices();
|
|
}
|
|
catch (OperationCanceledException) { throw; }
|
|
catch (Exception e) { Log($"Branch refresh failed: {e.Message}"); }
|
|
}
|
|
|
|
public Task LinkCacheAsync(InstallVM vm) => Run("Linking cache", async ct =>
|
|
{
|
|
await CacheService.LinkAsync(vm.Info, Log, ct);
|
|
});
|
|
|
|
Task DedupeAllAsync() => Run("Deduplicating caches", async ct =>
|
|
{
|
|
foreach (var i in Installs.Where(i => CacheService.GetState(i.Info) != CacheState.Missing).ToList())
|
|
{
|
|
Log($"{i.Info.Name}: {CacheService.GetState(i.Info)}");
|
|
await CacheService.LinkAsync(i.Info, Log, ct);
|
|
}
|
|
var size = await Task.Run(() => CacheService.SizeOf(Paths.SharedCache), ct);
|
|
CacheSize = $"Shared cache size: {FileOps.FormatSize(size)}";
|
|
});
|
|
|
|
public void OpenFolder(InstallVM vm)
|
|
{
|
|
var path = Directory.Exists(Paths.GameDir(vm.Info)) ? Paths.GameDir(vm.Info) : Paths.InstallDir(vm.Info);
|
|
Directory.CreateDirectory(path);
|
|
Explorer(path);
|
|
}
|
|
|
|
static void Explorer(string path)
|
|
{
|
|
Directory.CreateDirectory(path);
|
|
Process.Start(new ProcessStartInfo("explorer.exe", $"\"{path}\"") { UseShellExecute = true });
|
|
}
|
|
|
|
public void MoveInstall(InstallVM vm, int to)
|
|
{
|
|
var from = Installs.IndexOf(vm);
|
|
if (from < 0 || to < 0 || to >= Installs.Count || from == to) return;
|
|
Installs.Move(from, to);
|
|
cfg.Installs.RemoveAt(from);
|
|
cfg.Installs.Insert(to, vm.Info);
|
|
if (selectedInstall == vm) Raise(nameof(SelectedInstall));
|
|
else SelectedInstall = vm;
|
|
}
|
|
|
|
public Task DuplicateInstallAsync(InstallVM src) => Run($"Duplicating {src.Info.Name}", async ct =>
|
|
{
|
|
var srcGame = Paths.GameDir(src.Info);
|
|
if (!Directory.Exists(srcGame) || !File.Exists(Paths.GameExe(src.Info)))
|
|
throw new InvalidOperationException("There is nothing to duplicate yet: this install has no game files.");
|
|
if (src.IsRunning || FindGameProcesses(src.Info).Count > 0)
|
|
throw new InvalidOperationException("Stop the game before duplicating its install.");
|
|
|
|
var name = $"{src.Info.Name} copy";
|
|
for (var n = 2; cfg.Installs.Any(i => i.Name.Equals(name, StringComparison.OrdinalIgnoreCase)); n++)
|
|
name = $"{src.Info.Name} copy {n}";
|
|
|
|
var info = new InstallInfo
|
|
{
|
|
Name = name,
|
|
Branch = src.Info.Branch,
|
|
BranchPassword = src.Info.BranchPassword,
|
|
LaunchArgs = src.Info.LaunchArgs,
|
|
LaunchMode = src.Info.LaunchMode,
|
|
AccountId = src.Info.AccountId,
|
|
HookIds = src.Info.HookIds.ToList(),
|
|
Mods = src.Info.Mods.Select(a => new ModAssignment { ModId = a.ModId, Version = a.Version, Enabled = a.Enabled }).ToList(),
|
|
Deployed = src.Info.Deployed.ToDictionary(kv => kv.Key, kv => kv.Value.ToList()),
|
|
};
|
|
info.Folder = InstallFolders.UniqueFolder(cfg.Installs, info, name);
|
|
|
|
var skip = new[]
|
|
{
|
|
Path.GetFullPath(Paths.CacheDir(src.Info)),
|
|
Path.GetFullPath(Path.Combine(srcGame, "MelonLoader", "Logs")),
|
|
Path.GetFullPath(Path.Combine(srcGame, "MelonLoader", "Latest.log")),
|
|
};
|
|
Log($"Copying {src.Info.Name} to {name} (cache and logs are not copied; the cache is shared)...");
|
|
try
|
|
{
|
|
await Task.Run(() => FileOps.CopyTree(srcGame, Paths.GameDir(info),
|
|
p => skip.Contains(Path.GetFullPath(p), StringComparer.OrdinalIgnoreCase), Log, ct), ct);
|
|
await CacheService.LinkAsync(info, Log, ct);
|
|
}
|
|
catch
|
|
{
|
|
await Task.Run(() => FileOps.DeleteDirectorySafe(Paths.InstallDir(info)));
|
|
throw;
|
|
}
|
|
|
|
cfg.Installs.Add(info);
|
|
var vm = new InstallVM(this, info);
|
|
Installs.Add(vm);
|
|
SelectedInstall = vm;
|
|
Raise(nameof(CanChangeRoot));
|
|
Log($"Created {name}.");
|
|
});
|
|
|
|
public async Task DeleteInstallAsync(InstallVM vm)
|
|
{
|
|
if (Confirm != null && !await Confirm($"Delete install '{vm.Info.Name}' and all its game files?\nThe shared cache and downloaded mods are kept.")) return;
|
|
await Run($"Deleting {vm.Info.Name}", async ct =>
|
|
{
|
|
await Task.Run(() =>
|
|
{
|
|
CacheService.RemoveLinkIfJunction(Paths.CacheDir(vm.Info));
|
|
FileOps.DeleteDirectorySafe(Paths.InstallDir(vm.Info));
|
|
}, ct);
|
|
cfg.Installs.Remove(vm.Info);
|
|
Installs.Remove(vm);
|
|
SelectedInstall = Installs.FirstOrDefault();
|
|
});
|
|
}
|
|
|
|
readonly HashSet<InstallVM> launching = new();
|
|
|
|
public async Task LaunchAsync(InstallVM vm, string? modeKey = null)
|
|
{
|
|
var exe = Paths.GameExe(vm.Info);
|
|
if (!File.Exists(exe)) { Status = "Nothing to launch: update this install first."; return; }
|
|
if (!launching.Add(vm)) return;
|
|
try { await LaunchCoreAsync(vm, exe, modeKey); }
|
|
finally { launching.Remove(vm); }
|
|
}
|
|
|
|
async Task LaunchCoreAsync(InstallVM vm, string exe, string? modeKey)
|
|
{
|
|
Status = $"Preparing {vm.Info.Name}...";
|
|
if (vm.Pending) await ApplyModsAsync(vm);
|
|
|
|
var hookFailures = await HookService.RunEventAsync(cfg.Hooks, vm.Info, HookDef.BeforeLaunchEvent, vm.InstalledBuild, Log, CancellationToken.None);
|
|
if (hookFailures.Count > 0) Log($"Launching anyway; hook problems: {string.Join(", ", hookFailures)}");
|
|
|
|
var steamOk = await SteamIntegration.EnsureRunningAsync(Log);
|
|
if (!steamOk) Log("WARNING: the Steam client is not running, so Steam will not count this session.");
|
|
|
|
var gameDir = Paths.GameDir(vm.Info);
|
|
await Task.Run(() =>
|
|
{
|
|
try { MultiInstance.Prepare(gameDir, Log); }
|
|
catch (Exception e) when (e is IOException or UnauthorizedAccessException) { Log($"Could not prepare the install for several instances: {e.Message}"); }
|
|
|
|
var appIdFile = Path.Combine(gameDir, "steam_appid.txt");
|
|
if (!File.Exists(appIdFile)) File.WriteAllText(appIdFile, Paths.AppId.ToString());
|
|
|
|
try
|
|
{
|
|
if (cfg.CacheGuard) CacheGuardService.Deploy(gameDir, Log);
|
|
else CacheGuardService.Remove(gameDir, Log);
|
|
}
|
|
catch (Exception e) { Log($"Cache guard step failed: {e.Message}"); }
|
|
});
|
|
|
|
var psi = new ProcessStartInfo(exe)
|
|
{
|
|
WorkingDirectory = Paths.GameDir(vm.Info),
|
|
UseShellExecute = false,
|
|
};
|
|
psi.Environment["SteamAppId"] = Paths.AppId.ToString();
|
|
psi.Environment["SteamGameId"] = Paths.AppId.ToString();
|
|
var mode = LaunchModeOption.Find(modeKey ?? vm.Info.LaunchMode);
|
|
var extra = SplitArgs(mode.Arguments).Concat(SplitArgs(vm.Info.LaunchArgs)).ToList();
|
|
var account = cfg.Accounts.FirstOrDefault(a => a.Id == vm.Info.AccountId);
|
|
if (account != null)
|
|
{
|
|
try { extra.Add("--profile=" + await Task.Run(() => AccountService.WriteProfile(gameDir, account))); }
|
|
catch (Exception e) when (e is IOException or UnauthorizedAccessException or InvalidOperationException) { Log($"ERROR: {e.Message}"); Status = e.Message; return; }
|
|
}
|
|
foreach (var arg in extra) psi.ArgumentList.Add(arg);
|
|
|
|
Process proc;
|
|
try { proc = await Task.Run(() => Process.Start(psi)!); }
|
|
catch (Exception e) { Log($"ERROR: could not start the game: {e.Message}"); return; }
|
|
|
|
var instanceNo = vm.InstanceCount + 1;
|
|
Status = instanceNo > 1 ? $"Launched another instance of {vm.Info.Name} ({instanceNo} running)" : $"Launched {vm.Info.Name}";
|
|
Log($"Launched {vm.Info.Name}, launch mode: {mode.Label}{(account != null ? $", account: {account.Name}" : "")} (pid {proc.Id}, instance {instanceNo}).");
|
|
_ = Task.Run(() => GameWindow.ApplyIconWhenReadyAsync(proc, exe));
|
|
Watch(vm, proc, checkSteam: true);
|
|
}
|
|
|
|
readonly HashSet<int> trackedPids = new();
|
|
|
|
void Watch(InstallVM vm, Process proc, bool checkSteam)
|
|
{
|
|
var pid = proc.Id;
|
|
trackedPids.Add(pid);
|
|
vm.InstanceStarted();
|
|
var wasRunning = SteamIntegration.IsAppRunning;
|
|
_ = Task.Run(async () =>
|
|
{
|
|
if (checkSteam)
|
|
{
|
|
for (var i = 0; i < 40 && !proc.HasExited && !SteamIntegration.IsAppRunning; i++) await Task.Delay(1000);
|
|
if (proc.HasExited) { }
|
|
else if (SteamIntegration.IsAppRunning)
|
|
Log(wasRunning ? "Steam already showed ChilloutVR as running before this launch." : "Steam registered the session as ChilloutVR; playtime is being counted.");
|
|
else
|
|
Log("Steam has not registered the game as running; playtime may not be counted.");
|
|
}
|
|
await proc.WaitForExitAsync();
|
|
Dispatcher.UIThread.Post(() =>
|
|
{
|
|
trackedPids.Remove(pid);
|
|
vm.InstanceEnded();
|
|
Log($"{vm.Info.Name} exited (pid {pid}).");
|
|
if (vm.InstanceCount == 0 && renamePending.Remove(vm)) TryRenameFolder(vm);
|
|
vm.Refresh();
|
|
});
|
|
});
|
|
}
|
|
|
|
static List<Process> FindGameProcesses(InstallInfo info)
|
|
{
|
|
var exe = Path.GetFullPath(Paths.GameExe(info));
|
|
var found = new List<Process>();
|
|
foreach (var p in Process.GetProcessesByName("ChilloutVR"))
|
|
{
|
|
try
|
|
{
|
|
if (string.Equals(p.MainModule?.FileName, exe, StringComparison.OrdinalIgnoreCase)) { found.Add(p); continue; }
|
|
}
|
|
catch (Exception e) when (e is System.ComponentModel.Win32Exception or InvalidOperationException) { }
|
|
p.Dispose();
|
|
}
|
|
return found;
|
|
}
|
|
|
|
readonly Dictionary<InstallVM, CancellationTokenSource> renameTimers = new();
|
|
readonly HashSet<InstallVM> renamePending = new();
|
|
|
|
bool TryRenameFolder(InstallVM vm)
|
|
{
|
|
var info = vm.Info;
|
|
var desired = InstallFolders.UniqueFolder(cfg.Installs, info, info.Name);
|
|
if (desired.Equals(info.Folder, StringComparison.Ordinal)) return true;
|
|
|
|
if (vm.IsRunning || FindGameProcesses(info).Count > 0)
|
|
{
|
|
renamePending.Add(vm);
|
|
return false;
|
|
}
|
|
var before = info.Folder;
|
|
try
|
|
{
|
|
InstallFolders.Rename(info, desired);
|
|
info.Folder = desired;
|
|
Save();
|
|
vm.Refresh();
|
|
Log($"Renamed the install folder '{before}' to '{desired}'.");
|
|
return true;
|
|
}
|
|
catch (Exception e) when (e is IOException or UnauthorizedAccessException)
|
|
{
|
|
Log($"Could not rename the folder of '{info.Name}' ({e.Message}).");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public void ScheduleFolderRename(InstallVM vm)
|
|
{
|
|
if (renameTimers.TryGetValue(vm, out var previous)) previous.Cancel();
|
|
var cts = renameTimers[vm] = new CancellationTokenSource();
|
|
var token = cts.Token;
|
|
_ = Task.Run(async () =>
|
|
{
|
|
try
|
|
{
|
|
await Task.Delay(1200, token);
|
|
while (IsBusy) await Task.Delay(1000, token);
|
|
}
|
|
catch (OperationCanceledException) { return; }
|
|
Dispatcher.UIThread.Post(() =>
|
|
{
|
|
if (token.IsCancellationRequested) return;
|
|
renameTimers.Remove(vm);
|
|
if (!TryRenameFolder(vm) && vm.IsRunning)
|
|
Status = $"The folder will be renamed after {vm.Info.Name} is closed.";
|
|
});
|
|
});
|
|
}
|
|
|
|
void AdoptRunningGames()
|
|
{
|
|
foreach (var vm in Installs)
|
|
{
|
|
foreach (var p in FindGameProcesses(vm.Info))
|
|
{
|
|
if (trackedPids.Contains(p.Id)) { p.Dispose(); continue; }
|
|
Log($"{vm.Info.Name} is already running (pid {p.Id}); adopted it.");
|
|
var adopted = p;
|
|
_ = Task.Run(() => GameWindow.ApplyIconWhenReadyAsync(adopted, Paths.GameExe(vm.Info)));
|
|
Watch(vm, p, checkSteam: false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public async Task StopAsync(InstallVM vm)
|
|
{
|
|
var targets = FindGameProcesses(vm.Info);
|
|
if (targets.Count == 0)
|
|
{
|
|
vm.ResetInstances();
|
|
Status = $"{vm.Info.Name} is not running.";
|
|
return;
|
|
}
|
|
Log($"Stopping {vm.Info.Name} ({targets.Count} instance{(targets.Count == 1 ? "" : "s")})...");
|
|
Status = $"Stopping {vm.Info.Name}...";
|
|
foreach (var p in targets)
|
|
{
|
|
try { p.CloseMainWindow(); } catch (InvalidOperationException) { }
|
|
}
|
|
var deadline = DateTime.UtcNow.AddSeconds(8);
|
|
while (DateTime.UtcNow < deadline && targets.Any(p => !p.HasExited)) await Task.Delay(250);
|
|
foreach (var p in targets.Where(p => !p.HasExited))
|
|
{
|
|
Log($"{vm.Info.Name} did not close in time; ending the process.");
|
|
try { p.Kill(true); } catch (Exception e) when (e is InvalidOperationException or System.ComponentModel.Win32Exception) { }
|
|
}
|
|
foreach (var p in targets) p.Dispose();
|
|
}
|
|
|
|
static IEnumerable<string> SplitArgs(string s)
|
|
{
|
|
var sb = new StringBuilder();
|
|
var quoted = false;
|
|
foreach (var c in s)
|
|
{
|
|
if (c == '"') quoted = !quoted;
|
|
else if (char.IsWhiteSpace(c) && !quoted)
|
|
{
|
|
if (sb.Length > 0) { yield return sb.ToString(); sb.Clear(); }
|
|
}
|
|
else sb.Append(c);
|
|
}
|
|
if (sb.Length > 0) yield return sb.ToString();
|
|
}
|
|
|
|
public Task ApplyModsAsync(InstallVM vm) => Run($"Applying mods to {vm.Info.Name}", async ct =>
|
|
{
|
|
await store.ApplyAsync(vm.Info, cfg.Mods, Log, ct);
|
|
vm.ClearPending();
|
|
});
|
|
|
|
public Task ToggleMelonLoaderAsync(InstallVM vm)
|
|
{
|
|
var game = Paths.GameDir(vm.Info);
|
|
var dll = Path.Combine(game, "version.dll");
|
|
var off = dll + ".off";
|
|
var a = vm.MlAssignment;
|
|
|
|
if (vm.MlPresent)
|
|
{
|
|
if (a != null) { a.Enabled = false; return ApplyModsAsync(vm); }
|
|
return Run("Disabling MelonLoader", _ => { File.Move(dll, off, true); return Task.CompletedTask; });
|
|
}
|
|
if (a != null) { a.Enabled = true; return ApplyModsAsync(vm); }
|
|
if (vm.MlOffPresent) return Run("Enabling MelonLoader", _ => { File.Move(off, dll, true); return Task.CompletedTask; });
|
|
return SetMelonLoaderVersionAsync(vm);
|
|
}
|
|
|
|
public Task SetMelonLoaderVersionAsync(InstallVM vm)
|
|
{
|
|
var tag = vm.MlVersionChoice;
|
|
if (tag == null) { Status = "Pick a MelonLoader version first (the app never guesses one)."; return Task.CompletedTask; }
|
|
var a = vm.MlAssignment;
|
|
if (a == null) vm.Info.Mods.Add(a = new ModAssignment { ModId = ModDef.MelonLoaderId });
|
|
a.Version = tag;
|
|
a.Enabled = true;
|
|
return Run("Installing MelonLoader", async ct =>
|
|
{
|
|
if (MelonLoader.Releases.Count == 0) await RefreshModCoreAsync(MelonLoader, true, ct);
|
|
await store.ApplyAsync(vm.Info, cfg.Mods, Log, ct);
|
|
vm.ClearPending();
|
|
});
|
|
}
|
|
|
|
async Task RefreshModCoreAsync(ModDef mod, bool quiet = false, CancellationToken ct = default)
|
|
{
|
|
if (mod.Source == "local" || mod.Local) return;
|
|
try
|
|
{
|
|
if (mod.Source == "cvrmg")
|
|
{
|
|
var all = await cvrmg.GetAllAsync(ct);
|
|
var m = all.FirstOrDefault(x => x.Id == mod.CvrmgId) ?? throw new InvalidOperationException("no longer listed on CVRMG");
|
|
CvrmgService.ApplyMeta(mod, m);
|
|
mod.SetReleases(new List<ReleaseInfo> { CvrmgService.ToRelease(m, mod.FileName.Length > 0 ? mod.FileName : Paths.Safe(m.Name) + ".dll") });
|
|
}
|
|
else
|
|
{
|
|
var fresh = await github.GetReleasesAsync(mod.Repo, ct);
|
|
var filtered = ModImportService.FilterReleases(fresh, mod.AssetFilter).ToList();
|
|
if (mod.Id == ModDef.MelonLoaderId)
|
|
{
|
|
try
|
|
{
|
|
if (await github.GetMelonLoaderNightlyAsync(ct) is { } nightly) filtered.Insert(0, nightly);
|
|
}
|
|
catch (Exception e) when (e is not OperationCanceledException) { Log($"MelonLoader nightly: could not look up ({e.Message})"); }
|
|
}
|
|
mod.SetReleases(filtered);
|
|
}
|
|
if (!quiet) Log($"{mod.Name}: {mod.Releases.Count} versions, latest {mod.LatestTag}");
|
|
}
|
|
catch (Exception e) when (quiet && e is not OperationCanceledException)
|
|
{
|
|
Log($"{mod.Name}: could not fetch versions ({e.Message})");
|
|
}
|
|
Dispatcher.UIThread.Post(() =>
|
|
{
|
|
Mods.FirstOrDefault(m => m.Info == mod)?.Rebuild();
|
|
foreach (var i in Installs) i.Refresh();
|
|
RegroupMods();
|
|
Save();
|
|
});
|
|
}
|
|
|
|
public async Task SwitchSourceAsync(ModVM vm, string source)
|
|
{
|
|
var def = vm.Info;
|
|
if (def.Source == source) return;
|
|
var previous = def.Source;
|
|
def.Source = source;
|
|
def.Releases = def.Releases.Where(r => r.Snapshot).ToList();
|
|
try
|
|
{
|
|
if (source == "cvrmg")
|
|
{
|
|
var m = (await cvrmg.GetAllAsync(CancellationToken.None)).FirstOrDefault(x => x.Id == def.CvrmgId)
|
|
?? throw new InvalidOperationException("this mod is not listed on CVRMG");
|
|
if (def.FileName.Length == 0) def.FileName = Paths.Safe(def.Name) + ".dll";
|
|
CvrmgService.ApplyMeta(def, m);
|
|
def.SetReleases(new List<ReleaseInfo> { CvrmgService.ToRelease(m, def.FileName) });
|
|
}
|
|
else
|
|
{
|
|
var releases = await importer.ReleasesAsync(def.Repo, Log, CancellationToken.None);
|
|
def.SetReleases(ModImportService.FilterReleases(releases, def.AssetFilter));
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log($"{def.Name}: could not switch to {source} ({e.Message})");
|
|
def.Source = previous;
|
|
}
|
|
|
|
foreach (var inst in Installs)
|
|
if (inst.Info.Mods.FirstOrDefault(a => a.ModId == def.Id) is { } a && a.Version != "latest" && def.Releases.All(r => r.Tag != a.Version))
|
|
a.Version = "latest";
|
|
|
|
vm.Rebuild();
|
|
if (cfg.Mods.Contains(def)) Save();
|
|
}
|
|
|
|
public Task RefreshModAsync(ModVM vm) => Run($"Refreshing {vm.Info.Name}", ct => RefreshModCoreAsync(vm.Info, ct: ct));
|
|
|
|
Task RefreshAllModsAsync() => Run("Refreshing mod sources", ct => RefreshAvailableAsync(true, ct));
|
|
|
|
async Task AddModAsync()
|
|
{
|
|
var repo = GitHubService.ParseRepo(AddModRepo);
|
|
if (repo == null) { Status = "Enter a GitHub repo as owner/repo or a github.com URL."; return; }
|
|
if (cfg.Mods.Any(m => m.Repo.Equals(repo, StringComparison.OrdinalIgnoreCase))) { Status = "That repo is already in the catalog."; return; }
|
|
var def = new ModDef { Name = repo.Split('/')[1], Repo = repo };
|
|
await Run($"Adding {repo}", async ct =>
|
|
{
|
|
await RefreshModCoreAsync(def, ct: ct);
|
|
cfg.Mods.Add(def);
|
|
var vm = new ModVM(this, def);
|
|
Mods.Add(vm);
|
|
SelectedMod = vm;
|
|
AddModRepo = "";
|
|
});
|
|
}
|
|
|
|
void SyncModList()
|
|
{
|
|
foreach (var def in cfg.Mods.Where(d => Mods.All(v => v.Info != d)).ToList()) Mods.Add(new ModVM(this, def));
|
|
foreach (var m in Mods) m.Rebuild();
|
|
_ = RefreshAvailableAsync(false);
|
|
}
|
|
|
|
async Task ImportModsCoreAsync(InstallInfo info, CancellationToken ct)
|
|
{
|
|
var found = await importer.IdentifyAsync(Paths.GameDir(info), cfg.Sources, Log, ct);
|
|
var added = await Task.Run(() => importer.Apply(cfg, info, found, Log), ct);
|
|
int Count(string k) => found.Count(f => f.Source == k);
|
|
Log($"Imported {added} mods: {Count("github")} from GitHub repos, {Count("cvrmg")} from CVRMG, {Count("local")} kept as local snapshots.");
|
|
SyncModList();
|
|
}
|
|
|
|
public Task ImportInstallModsAsync(InstallVM vm) => Run($"Importing mods from {vm.Info.Name}", async ct =>
|
|
{
|
|
await ImportModsCoreAsync(vm.Info, ct);
|
|
vm.Rebuild();
|
|
vm.ClearPending();
|
|
});
|
|
|
|
public ObservableCollection<SourceVM> Sources { get; } = new();
|
|
string addSourceRepo = "";
|
|
public string AddSourceRepo { get => addSourceRepo; set => Set(ref addSourceRepo, value); }
|
|
|
|
public ICommand ScanSteamInstallCommand => new RelayCommand(() => Run("Scanning your Steam install's mods", async ct =>
|
|
{
|
|
var dir = DetectedInstalls.FirstOrDefault() ?? throw new InvalidOperationException("No Steam install of ChilloutVR was found.");
|
|
var found = await importer.IdentifyAsync(dir, cfg.Sources, Log, ct);
|
|
var added = await Task.Run(() => importer.Apply(cfg, null, found, Log, dir), ct);
|
|
int Count(string k) => found.Count(f => f.Source == k);
|
|
Log($"Catalog updated from {dir}: {added} mods ({Count("github")} from GitHub repos, {Count("cvrmg")} from CVRMG, {Count("local")} local snapshots).");
|
|
SyncModList();
|
|
}));
|
|
|
|
public ICommand AddSourceCommand => new RelayCommand(() =>
|
|
{
|
|
var repo = GitHubService.ParseRepo(AddSourceRepo);
|
|
if (repo == null) { Status = "Enter a GitHub repo as owner/repo or a github.com URL."; return; }
|
|
if (cfg.Sources.Any(s => s.Repo.Equals(repo, StringComparison.OrdinalIgnoreCase))) { Status = "That source is already listed."; return; }
|
|
var def = new SourceDef { Name = repo.Split('/')[1], Kind = "github", Repo = repo };
|
|
cfg.Sources.Add(def);
|
|
var sv = new SourceVM(this, def);
|
|
Sources.Add(sv);
|
|
SelectedSource = sv;
|
|
AddSourceRepo = "";
|
|
Save();
|
|
_ = RefreshAvailableAsync(false);
|
|
});
|
|
|
|
public void RemoveSource(SourceVM vm)
|
|
{
|
|
if (!vm.CanRemove) return;
|
|
cfg.Sources.Remove(vm.Info);
|
|
Sources.Remove(vm);
|
|
if (SelectedSource == vm) SelectedSource = Sources.FirstOrDefault();
|
|
Save();
|
|
_ = RefreshAvailableAsync(false);
|
|
}
|
|
|
|
SourceVM? selectedSource;
|
|
public SourceVM? SelectedSource { get => selectedSource; set { if (Set(ref selectedSource, value)) Raise(nameof(HasSelectedSource)); } }
|
|
public bool HasSelectedSource => selectedSource != null;
|
|
|
|
public async Task AddLocalFilesAsync(ModVM? vm = null)
|
|
{
|
|
if (PickFiles == null) return;
|
|
var files = await PickFiles();
|
|
if (files.Count == 0) return;
|
|
await Run("Importing local mod", ct =>
|
|
{
|
|
var def = vm?.Info;
|
|
if (def == null)
|
|
{
|
|
def = new ModDef { Name = Path.GetFileNameWithoutExtension(files[0]), Local = true };
|
|
def.Releases.Add(new ReleaseInfo { Tag = "local", Published = DateTime.Now });
|
|
cfg.Mods.Add(def);
|
|
var nv = new ModVM(this, def);
|
|
Mods.Add(nv);
|
|
SelectedMod = nv;
|
|
}
|
|
store.ImportLocal(def, files);
|
|
return Task.CompletedTask;
|
|
});
|
|
}
|
|
|
|
public Task AddLocalFilesNewAsync() => AddLocalFilesAsync();
|
|
|
|
public Task DownloadModAsync(ModVM vm) => Run($"Downloading {vm.Info.Name}", async ct =>
|
|
{
|
|
var tag = vm.SelectedRelease?.Tag ?? vm.Info.LatestTag;
|
|
if (tag == null) throw new InvalidOperationException("No version selected; refresh versions first.");
|
|
await store.EnsureDownloadedAsync(vm.Info, tag, Log, ct);
|
|
});
|
|
|
|
public async Task DeleteModDownloadAsync(ModVM vm)
|
|
{
|
|
var tag = vm.SelectedRelease?.Tag;
|
|
if (tag == null) return;
|
|
await Run($"Deleting {vm.Info.Name} {tag}", _ => { ModStore.DeleteVersion(vm.Info, tag); return Task.CompletedTask; });
|
|
}
|
|
|
|
public async Task RemoveModAsync(ModVM vm)
|
|
{
|
|
if (vm.IsBuiltin) return;
|
|
var users = Installs.Where(i => i.Info.Mods.Any(a => a.ModId == vm.Info.Id)).ToList();
|
|
if (Confirm != null && !await Confirm(users.Count == 0
|
|
? $"Remove {vm.Info.Name} from the catalog and delete its downloads?"
|
|
: $"Remove {vm.Info.Name}? It is assigned to: {string.Join(", ", users.Select(u => u.Info.Name))}. Its files stay in those installs until you apply mods there.")) return;
|
|
await Run($"Removing {vm.Info.Name}", ct =>
|
|
{
|
|
foreach (var u in users)
|
|
{
|
|
u.Info.Mods.RemoveAll(a => a.ModId == vm.Info.Id);
|
|
u.Rebuild();
|
|
u.MarkPending();
|
|
}
|
|
cfg.Mods.Remove(vm.Info);
|
|
Mods.Remove(vm);
|
|
SelectedMod = Mods.FirstOrDefault();
|
|
_ = RefreshAvailableAsync(false);
|
|
var dir = Path.Combine(Paths.ModStore, vm.Info.Id);
|
|
if (Directory.Exists(dir)) Directory.Delete(dir, true);
|
|
return Task.CompletedTask;
|
|
});
|
|
}
|
|
|
|
async Task BrowseLibraryRootAsync()
|
|
{
|
|
if (PickFolder == null) return;
|
|
var p = await PickFolder();
|
|
if (p != null) LibraryRoot = p;
|
|
}
|
|
|
|
async Task BrowseImportAsync()
|
|
{
|
|
if (PickFolder == null) return;
|
|
var p = await PickFolder();
|
|
if (p != null) NewImportPath = p;
|
|
}
|
|
|
|
void ApplyLibraryRoot()
|
|
{
|
|
if (!CanChangeRoot) { Status = "Delete all installs before changing the library location."; return; }
|
|
Paths.Root = cfg.LibraryRoot;
|
|
Save();
|
|
Directory.CreateDirectory(Paths.Root);
|
|
Status = $"Library location set to {Paths.Root}";
|
|
}
|
|
}
|