Add Palworld + Voices of the Void support, initial Unreal engine support

src/components/config-components/ConfigSelectionLayout.vue

@@ -127,6 +127,14 @@ import ProfileModList from '../../r2mm/mods/ProfileModList';
                     this.configFiles.push(new ConfigFile(file.substring(configLocation.length + 1), file, fileStat.mtime));
                 }
             }
+
+            // HACK: Force the UE4SS-settings.ini file for shimloader mod installs to be visible.
+            const ue4ssSettingsPath = tree.getFiles().find(x => x.toLowerCase().endsWith("ue4ss-settings.ini"));
+            if (ue4ssSettingsPath) {
+                const lstat = await fs.lstat(ue4ssSettingsPath);
+                this.configFiles.push(new ConfigFile("UE4SS-settings.ini", ue4ssSettingsPath, lstat.mtime));
+            }
+
             this.shownConfigFiles = [...this.configFiles];
         }
 

src/installers/InstallRuleInstaller.ts

@@ -115,6 +115,51 @@ async function installSubDirNoFlatten(profile: Profile, rule: ManagedRule, insta
     }
 }
 
+async function installSubDirTracked(profile: Profile, rule: ManagedRule, installSources: string[], mod: ManifestV2) {
+    const fs = FsProvider.instance;
+    const subDir = path.join(profile.getPathOfProfile(), rule.route, mod.getName());
+    await FileUtils.ensureDirectory(subDir);
+
+    const relocations = new Map<string, string>();
+
+    let makeProfilePath = (input: string): string => {
+        const match = installSources.find((x) => input.startsWith(x));
+        if (match === undefined) {
+            return input;
+        }
+
+        return path.join(subDir, input.replace(match, ""));
+    }
+
+    const sources = [...installSources];
+    let source: string | undefined;
+
+    while ((source = sources.pop()) !== undefined) {
+        const lstat = await fs.lstat(source);
+
+        if (lstat.isFile()) {
+            const dest = makeProfilePath(source);
+            const destDir = path.dirname(dest);
+
+            if (!(await fs.exists(destDir))) {
+                await fs.mkdirs(destDir);
+            }
+
+            fs.copyFile(source, dest);
+
+            const profileRel = dest.replace(profile.getPathOfProfile(), "").substring(1);
+            relocations.set(source, profileRel);
+
+            continue;
+        }
+
+        const contents = (await fs.readdir(source)).map((x) => path.join(source as string, x));
+        sources.push(...contents);
+    }
+
+    await addToStateFile(mod, relocations, profile);
+}
+
 async function buildInstallForRuleSubtype(
     rule: CoreRuleType,
     location: string,
@@ -266,6 +311,7 @@ export class InstallRuleInstaller extends PackageInstaller {
                 case 'NONE': await installUntracked(profile, managedRule, files, mod); break;
                 case 'SUBDIR_NO_FLATTEN': await installSubDirNoFlatten(profile, managedRule, files, mod); break;
                 case 'PACKAGE_ZIP': await installPackageZip(profile, managedRule, files, mod); break;
+                case 'SUBDIR_TRACKED': await installSubDirTracked(profile, managedRule, files, mod); break;
             }
         }
         return Promise.resolve(undefined);

src/installers/ShimloaderInstaller.ts

@@ -0,0 +1,69 @@
+import { InstallArgs, PackageInstaller } from "./PackageInstaller";
+import path from "path";
+import FsProvider from "../providers/generic/file/FsProvider";
+import FileTree from "../model/file/FileTree";
+import FileUtils from "../utils/FileUtils";
+import R2Error from "../model/errors/R2Error";
+import { InstallRuleInstaller, addToStateFile } from "./InstallRuleInstaller";
+import InstallationRules from "../r2mm/installing/InstallationRules";
+import GameManager from "../model/game/GameManager";
+
+export class ShimloaderInstaller extends PackageInstaller {
+    /**
+     * Handle installation of unreal-shimloader
+     */
+    async install(args: InstallArgs) {
+        const {
+            mod,
+            packagePath,
+            profile,
+        } = args;
+
+        const fs = FsProvider.instance;
+        const fileRelocations = new Map<string, string>();
+
+        const targets = [
+            ["dwmapi.dll", "dwmapi.dll"],
+            ["UE4SS/ue4ss.dll", "ue4ss.dll"],
+            ["UE4SS/UE4SS-settings.ini", "UE4SS-settings.ini"],
+        ];
+
+        const ue4ssTree = await FileTree.buildFromLocation(path.join(packagePath, "UE4SS/Mods"));
+        if (ue4ssTree instanceof R2Error) {
+            throw ue4ssTree;
+        }
+
+        for (const subFile of ue4ssTree.getRecursiveFiles()) {
+            const relSrc = path.relative(path.join(packagePath, "UE4SS/Mods"), subFile);
+
+            targets.push([path.join("UE4SS/Mods", relSrc), path.join("shimloader/mod", relSrc)]);
+        }
+
+        for (const targetPath of targets) {
+            const absSrc = path.join(packagePath, targetPath[0]);
+            const absDest = path.join(profile.getPathOfProfile(), targetPath[1]);
+
+            await FileUtils.ensureDirectory(path.dirname(absDest));
+            await fs.copyFile(absSrc, absDest);
+
+            fileRelocations.set(absSrc, targetPath[1]);
+        }
+
+        // The config subdir needs to be created for shimloader (it will get cranky if it's not there).
+        const configDir = path.join(profile.getPathOfProfile(), "shimloader", "cfg");
+        if (!await fs.exists(configDir)) {
+            await fs.mkdirs(configDir);
+        }
+
+        await addToStateFile(mod, fileRelocations, profile);
+    }
+}
+
+export class ShimloaderPluginInstaller extends PackageInstaller {
+    async install(args: InstallArgs) {
+        const rule = InstallationRules.RULES.find(value => value.gameName === GameManager.activeGame.internalFolderName)!;
+
+        const legacyInstaller = new InstallRuleInstaller(rule);
+        await legacyInstaller.install(args);
+    }
+}

src/installers/registry.ts

@@ -3,13 +3,16 @@ import { GodotMLInstaller } from "./GodotMLInstaller";
 import { MelonLoaderInstaller } from "./MelonLoaderInstaller";
 import { PackageInstaller } from "./PackageInstaller";
 import { InstallRuleInstaller } from "./InstallRuleInstaller";
+import { ShimloaderInstaller, ShimloaderPluginInstaller } from "./ShimloaderInstaller";
 
 
 const _PackageInstallers = {
     // "legacy": new InstallRuleInstaller(),  // TODO: Enable
     "bepinex": new BepInExInstaller(),
     "godotml": new GodotMLInstaller(),
     "melonloader": new MelonLoaderInstaller(),
+    "shimloader": new ShimloaderInstaller(),
+    "shimloader-plugin": new ShimloaderPluginInstaller(),
 }
 
 export type PackageInstallerId = keyof typeof _PackageInstallers;

src/model/game/GameManager.ts

@@ -562,6 +562,19 @@ export default class GameManager {
             "https://thunderstore.io/c/sailwind/api/v1/package/", "https://github.com/ebkr/r2modmanPlus/master/modExclusions.md",
             [new StorePlatformMetadata(StorePlatform.STEAM, "1764530")], "Sailwind.png",
             GameSelectionDisplayMode.VISIBLE, GameInstanceType.GAME, PackageLoader.BEPINEX, []),
+        new Game(
+            "Voices of the Void", "VotV", "VotV",
+            "", ["VotV-Win64-Shipping.exe"], "",
+            "https://thunderstore.io/c/voices-of-the-void/api/v1/package/", "https://github.com/ebkr/r2modmanPlus/master/modExclusions.md",
+            [new StorePlatformMetadata(StorePlatform.OTHER)], "VotV.png",
+            GameSelectionDisplayMode.VISIBLE, GameInstanceType.GAME, PackageLoader.SHIMLOADER, ["votv"]),
+
+        new Game(
+            "Palworld", "Palworld", "Palworld",
+            "Palworld", ["Palworld.exe"], "Pal",
+            "https://thunderstore.io/c/palworld/api/v1/package/", "https://github.com/ebkr/r2modmanPlus/master/modExclusions.md",
+            [new StorePlatformMetadata(StorePlatform.STEAM, "1623730")], "Palworld.png",
+            GameSelectionDisplayMode.VISIBLE, GameInstanceType.GAME, PackageLoader.SHIMLOADER, ["palworld"])
     ];
 
     static get activeGame(): Game {

src/model/installing/PackageLoader.ts

@@ -1,11 +1,13 @@
 import { PackageInstallerId, PackageInstallers } from "../../installers/registry";
+import Game from "../game/Game";
 
 export enum PackageLoader {
     BEPINEX,
     MELON_LOADER,
     NORTHSTAR,
     GODOT_ML,
     ANCIENT_DUNGEON_VR,
+    SHIMLOADER,
 }
 
 export function GetInstallerIdForLoader(loader: PackageLoader): PackageInstallerId | null {
@@ -16,6 +18,15 @@ export function GetInstallerIdForLoader(loader: PackageLoader): PackageInstaller
         case PackageLoader.MELON_LOADER: return "melonloader";
         case PackageLoader.GODOT_ML: return "godotml";
         case PackageLoader.NORTHSTAR: return "bepinex";
+        case PackageLoader.SHIMLOADER: return "shimloader";
         case PackageLoader.ANCIENT_DUNGEON_VR: return null;
     }
 }
+
+export function GetInstallerIdForPlugin(loader: PackageLoader): PackageInstallerId | null {
+    switch (loader) {
+        case PackageLoader.SHIMLOADER: return "shimloader-plugin";
+    }
+
+    return null;
+}

src/providers/generic/game/platform_interceptor/PlatformInterceptorImpl.ts

@@ -63,6 +63,7 @@ function buildRunners(runners: PlatformRunnersType): LoaderRunnersType {
         [PackageLoader.NORTHSTAR]: runners,
         [PackageLoader.ANCIENT_DUNGEON_VR]: runners,
         [PackageLoader.GODOT_ML]: runners,
+        [PackageLoader.SHIMLOADER]: runners,
     }
 }
 

src/r2mm/installing/ConflictManagementProviderImpl.ts

@@ -54,7 +54,10 @@ export default class ConflictManagementProviderImpl extends ConflictManagementPr
             }
             const modState: ModFileTracker = yaml.parse(stateFileContents);
             modState.files.forEach(([key, value]) => {
-                if (mod.isEnabled()) {
+                // HACK: Never reset UE4SS-settings.ini, ever. Seriously. It should always be enabled.
+                if (value.toLocaleLowerCase() == "ue4ss-settings.ini") {
+                    overallState.set(value, mod.getName());
+                } else if (mod.isEnabled()) {
                     overallState.set(value, mod.getName());
                 } else {
                     overallState.set(value + ".manager.disabled", mod.getName());
@@ -80,6 +83,15 @@ export default class ConflictManagementProviderImpl extends ConflictManagementPr
                 for (const [key, value] of modFiles.files) {
                     if (value === file) {
                         await FileUtils.ensureDirectory(path.dirname(path.join(profile.getPathOfProfile(), file)));
+
+                        // HACK: Check if UE4SS-settings.ini exists and, if it doesn't, add it. If it does exist, DONT TOUCH.
+                        if (file.toLocaleLowerCase() == "ue4ss-settings.ini") {
+                            if (!await FsProvider.instance.exists(path.join(profile.getPathOfProfile(), file))) {
+                                await FsProvider.instance.copyFile(key, path.join(profile.getPathOfProfile(), file));
+                            }
+
+                            break;
+                        }
                         if (await FsProvider.instance.exists(path.join(profile.getPathOfProfile(), file))) {
                             await FsProvider.instance.unlink(path.join(profile.getPathOfProfile(), file));
                         }

src/r2mm/installing/InstallationRules.ts

@@ -10,7 +10,7 @@ export type CoreRuleType = {
 
 export type RuleSubtype = {
     route: string,
-    trackingMethod: "SUBDIR" | "STATE" | "NONE" | "SUBDIR_NO_FLATTEN" | "PACKAGE_ZIP",
+    trackingMethod: "SUBDIR" | "STATE" | "NONE" | "SUBDIR_NO_FLATTEN" | "PACKAGE_ZIP" | "SUBDIR_TRACKED",
     subRoutes: RuleSubtype[],
     defaultFileExtensions: string[],
     isDefaultLocation?: boolean

src/r2mm/installing/default_installation_rules/InstallationRuleApplicator.ts

@@ -10,6 +10,7 @@ import InstallRules_Subnautica from '../default_installation_rules/game_rules/In
 import InstallRules_SubnauticaBZ from '../default_installation_rules/game_rules/InstallRules_SubnauticaBZ';
 import InstallRules_Titanfall2 from '../default_installation_rules/game_rules/InstallRules_Titanfall2';
 import InstallRules_BONELAB from '../default_installation_rules/game_rules/InstallRules_BONELAB';
+import { buildShimloaderRules } from './game_rules/InstallRules_Shimloader';
 import { buildBepInExRules } from '../default_installation_rules/game_rules/InstallRules_BepInex';
 import * as path from 'path';
 import { buildGodotMLRules } from "../default_installation_rules/game_rules/InstallRules_GodotML";
@@ -119,6 +120,8 @@ export default class InstallationRuleApplicator {
             buildBepInExRules("MeepleStation"),
             buildBepInExRules("VoidCrew"),
             buildBepInExRules("Sailwind"),
+            buildShimloaderRules("VotV"),
+            buildShimloaderRules("Palworld"),
         ]
     }
 }

src/r2mm/installing/default_installation_rules/game_rules/InstallRules_Shimloader.ts

@@ -0,0 +1,38 @@
+import type { CoreRuleType } from '../../InstallationRules';
+import * as path from 'path';
+import { GAME_NAME } from '../../profile_installers/ModLoaderVariantRecord';
+import { RuleSubtype } from "../../InstallationRules";
+
+export function buildShimloaderRules(gameName: GAME_NAME, extraRules?: RuleSubtype[]): CoreRuleType {
+    return {
+        gameName: gameName,
+        relativeFileExclusions: ["manifest.json", "README.md", "icon.png", "LICENCE"],
+        rules: [
+            {
+                route: path.join("shimloader/mod"),
+                defaultFileExtensions: [".lua"],
+                trackingMethod: "SUBDIR_TRACKED",
+                subRoutes: [
+                    {
+                        route: "dll",
+                        defaultFileExtensions: [".dll"],
+                        trackingMethod: "SUBDIR_TRACKED",
+                        subRoutes: [],
+                    }
+                ]
+            },
+            {
+                route: path.join("shimloader/pak"),
+                defaultFileExtensions: [".pak"],
+                trackingMethod: "SUBDIR_TRACKED",
+                subRoutes: [],
+            },
+            {
+                route: path.join("shimloader/cfg"),
+                defaultFileExtensions: [".cfg"],
+                trackingMethod: "NONE",
+                subRoutes: [],
+            }
+        ]
+    }
+}