gawdl3y / resolute Goto Github PK

It is annoying needing to click each arrow manually to expand the categories

The app should have a mechanism to detect mods that were manually installed or installed by Resolute before #12 was implemented.

Blocked by #12.

As title, environments with unstable connections are entirely unable to download mods with Resolute.
Due to a temporary situation, my average latency times are quite high, and Resolute seems to not like that, as I get timeout errors as the image below.

it is to note that regular downloads of the files via browsers, download managers and such are possible.

I'm aware that this is most likely not a priority, but a more robust download system would definitely be of benefit. Or at least a way to set a manual timeout value that is not as strict.

The app should have its own custom update dialog rather than using the default Tauri one.
This will allow proper display of the markdown changelogs.

there is a crate called steamloacte (https://crates.io/crates/steamlocate/) which can easily find steam library folders, and even a specific app like resonite, though this library has some known bugs in it's current latest release and I'd probably wait until they release 2.0.0 (which they probably will soon, considering there is already a beta version)

The app should allow users to select a specific version of a mod to install in case they don't just want the latest version.

Mod artifact downloads done by the Resolute library code should be atomic (download to a temporary file then moved/renamed), thus being much less error-prone in the event of networking issues or other problems encountered. Any errors encountered while downloading an artifact should result in no further artifacts being downloaded, any already-downloaded ones deleted, and the user should be alerted to the failure.

A warning should be displayed whenever the Resonite directory isn't configured or doesn't seem to exist on the filesystem.

Looks like any file that contains dll is located and listed, notably .dll.old and .dll.disabled. These will add additional 'Unrecognized' entries.

When updating, the .dll.old file will also be picked up and show as another entry, even if the hash matches an existing hash of a known mod
These two entries are for the same mod, one of which is ending in '.dll.old' but they have the same hash

This could be optional maybe

Text styles are currently used inconsistently throughout the UI - some are unspecified, some headers are used, and the body text classes are mostly unused. Ideally, every bit of text should have a proper text style applied if it isn't already by a Vuetify component.

The application should forward all internal logging to a log file (or multiple) in one of its directories.
This will greatly increase the transparency of its operation and allow for much easier debugging of production builds in the future.

When selecting the Resonite directory with a native Linux build of the game, the UI always warns that it wasn't able to find the Resonite executable. This is due to the UI only looking for Resonite.exe, whereas the native Linux build's executable is Resonite.x86_64.

I think there should be a standalone exe download, as I like to put the resonite folder to have everything in one place

Being able to search the contents of name + tag/description/etc in the same query separated by spaces would be beneficial especially as partial matches. I'm not sure how much partial matching it currently allows as it seems to include spaces in the search

Searching for "No " should still find NoTankControls but doesn't as the mod name doesn't have a space and the description doesn't include it either.

I'd love to see the DLL version info be tried to be parsed and be shown similarly as mods from the manifest. Though I'd except the unknown mods to keep the blue question mark to indicate that they aren't actually from the manifest, and the details are just provided by the file metadata :P

I do realize this is most likely a low priority feature request, so I did play around with the idea of making a PR but for now I ran out of time 😅

fn get_assembly_version<P: AsRef<Path>>(path: &P) -> Option<semver::Version> {
	use pelite::FileMap;
	use pelite::pe32::{Pe, PeFile};

    let Some(file_map) = FileMap::open(path).ok() else { return None;};
    let Some(file) = PeFile::from_bytes(file_map.as_ref()).ok() else { return None;};
		let Some(resources) = file.resources().ok() else { return None;};
		let Some(version_info) = resources.version_info().ok() else { return None;};
		let Some(fixed_info) = version_info.fixed() else { return None;};
    Some(semver::Version {
			major: fixed_info.dwFileVersion.Major as u64,
			minor: fixed_info.dwFileVersion.Minor as u64,
			patch: fixed_info.dwFileVersion.Patch as u64,
			pre: Default::default(),
			build: semver::BuildMetadata::new(&fixed_info.dwFileVersion.Build.to_string()).unwrap_or_default(),
		})
}

The ProductName could be gotten in a similar way for the hypothetically correct GUIDs to show.

There should be two easily-noticeable warnings present for mods on the mod list:

• When a mod has the "deprecated" flag
• When a mod doesn't list the current platform as one of the supported platforms

The app should offer a way for it to auto-detect possible Resonite installation paths and should automatically run this procedure on startup when the setting is unset. The main focus for now should be locating a Steam installation and going off of that, as Resonite doesn't currently have any official standalone releases. It's also probably not worth trying to locate secondary Steam libraries.

Known details:

• Windows:
  • Usually %programfiles(x86)%\Steam
  • Can be detected from the registry (HKCU\Software\Valve\Steam\SteamPath)
• Linux
  • Traditional: ~/.steam/steam/
  • Flatpak:
    • Usually ~/.var/app/com.valvesoftware.Steam/.local/share/Steam
    • Can be detected via flatpak info --show-location com.valvesoftware.Steam and ascending two directories from the returned path

Once a Steam installation is located, the game's installation folder can be extra confirmed by checking for and reading Resonite's ACF (should be $STEAM/steamapps/common/appmanifest_2519830.acf), though this is likely unnecessary.
It's probably safe to assume that the path is always going to be $STEAM/steamapps/common/Resonite.

The app should have some kind of UI to present additional mod details, such as the author(s), source location, icon, etc.

Users should be able to uninstall a mod after they have installed it.

Blocked by #12

Changes to settings should be logged as they are saved.

The app should have a method to display notifications temporarily on-screen before they then go into a separate notifications list.
Any existing message boxes should be updated to use this system:

• Mod installed
• Mod failed to install

The app's current version number should be displayed somewhere so that it can be easily checked.

Currently, when installing a mod, the first version entry from the manifest is used. These version entries may not be guaranteed to be sorted in descending order, which means installing a mod may end up using an old version.
The newest version should always be installed by default. This can be achieved by sorting the versions (either before handing them to the UI or done within the UI layer) upon loading them.

Trojan:Script/Wacatac.B!ml

Currently some users, especially those less versed in github or other types of programs/executables are experiencing confusion when trying to find the download for the program. Ideally a simplified list of 2-3 options on the readme to link for each platform download with additional builds in the release tab as normal. Then people can be presented a small few options instead of 17 things they could download. (Current total count of assets)

Somewhat related to #58

Users should be able to override the manifest URL that gets downloaded and parsed for the mod listing.

Once a mod is installed, the user should be able to toggle whether it is enabled or disabled without fully uninstalling it.

Blocked by #12

The app should track what mods it has installed and show indication that they are installed, as well as which version is installed.

The app should support multiple languages, especially given the diverse community that Resonite serves as home to.

Error messages from external crates on the backend are out-of-scope, as that would be nearly impossible to achieve with any consistency.

Error messages from Resolute's own code in the backend are doable since nearly all errors are already their own type and thus can be sent to the frontend via error codes rather than raw strings.

Currently, the tags on a mod are not searched against when filtering the mod list. Ideally, these should be taken into account whenever filtering.

The installation .exe fails installing webview2 when I run it. My assumption is that this is because I've removed Edge via https://github.com/AveYo/fox

I'm assuming WebView is a dependency for the app? If so, it may be a good idea to add that info to the readme, as It's not too uncommon for folk to remove webview and edge together.

Currently web requests have no UserAgent. Tested with the custom manifest url.

It would be nice to be able to see these mods even if there would be no update tracking.

The app should have a page to view all internal logging output of the current execution in a convenient way within the UI.
This is friendlier to the average user than a log file, but also generally more convenient to quickly check what happened behind the scenes for an action.

Ideally, the app should be able to detect and display mods that artifacts are present for that aren't in the manifest.

The mod list table should be both searchable and filterable by columns.

In order to accommodate for scripting/automation, the major functions (installing/uninstalling/updating/listing mods) should be available via a CLI in the app.

It is currently 8:10pm on 4/16 but looking at this log it is a bit odd to know the time these occurred as they are all set as UTC 0 instead of being shown in my timezone.

Just a small enhancement to consider.

Currently, the app is hard-coded to dark mode.
Users of the app should have a choice between dark mode, light mode, and following their system theme, with following the system theme being the default.

As title mentions the all mods list scroll bar doesn't reach the bottom when more than a couple categories are expanded

I don't need an installer for a single self-contained exe file

Resolute should display warnings whenever mods are installed/active that have unresolved dependencies or conflicts with other mods.

When installing a mod, if the version has any dependencies, Resolute should offer to install those automatically alongside the original mod being installed.

With installed mod state tracking implemented, the UI should have a dedicated Installed mods page that only displays mods that are currently installed. It should still retrieve the latest manifest info for it in order to display the correct latest version information.

There should be buttons/links to open important directories in the OS file explorer. Examples of such directories:

• Resonite path
• Resonite logs path
• Resonite cache path
• Resonite DB path
• RML mods path
• RML libs path
• RML config path

On first launch (and maybe upon demand with a button hidden away somewhere), an introduction and setup guide experience should be presented to the user. This should walk the user through:

• Installing RML
• Installing Harmony
• Setting the Steam launch parameter (-LoadAssembly Libraries/ResoniteModLoader.dll)

When artifacts are downloaded, they should be hashed and verified against the checksum listed in the manifest.

When an update is found and the user chooses to install it in the dialog, if an error is encountered during the update installation, the dialog gets stuck open in a loading state perpetually.

The UI should display loading indicators and have relevant success/failure notifications for the following:

• Clicking an install button (needs loading indicator)
• Clicking the refresh button (needs loading indicator and failure notification)
• Manifest loading on startup (needs failure indication)