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

.github/workflows/test.yml

@@ -0,0 +1,38 @@
+name: Build
+
+on: [push]
+
+jobs:
+    build:
+        name: Test on ${{ matrix.platform }}
+        runs-on: ${{ matrix.os }}
+        strategy:
+            fail-fast: false
+            matrix:
+                include:
+                    - kind: linux
+                      os: ubuntu-latest
+                      platform: linux
+                    - kind: windows
+                      os: windows-latest
+                      platform: win
+                    - kind: mac
+                      os: macos-11
+                      platform: osx
+        steps:
+            - uses: actions/checkout@v3
+
+            - name: Set up Node
+              uses: actions/setup-node@v3
+              with:
+                  # The talk on the street says this might be a good version for building.
+                  node-version: 14.20.1
+                  cache: yarn
+
+            - name: Install Yarn dependencies
+              run: yarn install --frozen-lockfile
+
+            - name: Run tests
+              run: >
+                  node test/folder-structure-testing/populator.mjs &&
+                  yarn run test:unit:ci

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

@@ -13,9 +13,6 @@ import ConflictManagementProvider from "../providers/generic/installing/Conflict
 import PathResolver from "../r2mm/manager/PathResolver";
 import ZipProvider from "../providers/generic/zip/ZipProvider";
 
-const basePackageFiles = ["manifest.json", "readme.md", "icon.png"];
-
-
 type InstallRuleArgs = {
     profile: Profile,
     coreRule: CoreRuleType,

src/installers/ShimloaderInstaller.ts

@@ -0,0 +1,87 @@
+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 } from "./InstallRuleInstaller";
+
+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);
+        }
+    }
+}
+
+export class ShimloaderPluginInstaller extends PackageInstaller {
+    readonly installer = new InstallRuleInstaller({
+        gameName: "none" as any,  // This isn't acutally used for actual installation but needs some value
+        rules: [
+            {
+                route: path.join("shimloader", "mod"),
+                isDefaultLocation: true,
+                defaultFileExtensions: [],
+                trackingMethod: "SUBDIR",
+                subRoutes: [],
+            },
+            {
+                route: path.join("shimloader", "pak"),
+                defaultFileExtensions: [],
+                trackingMethod: "SUBDIR",
+                subRoutes: [],
+            },
+            {
+                route: path.join("shimloader", "cfg"),
+                defaultFileExtensions: [],
+                trackingMethod: "NONE",
+                subRoutes: [],
+            }
+        ]
+    });
+
+    async install(args: InstallArgs) {
+        await this.installer.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://raw.githubusercontent.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"], "VotV",
+            "https://thunderstore.io/c/voices-of-the-void/api/v1/package/", "https://raw.githubusercontent.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://raw.githubusercontent.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/InstallationRules.ts

@@ -52,27 +52,15 @@ export default class InstallationRules {
     public static getAllManagedPaths(rules: RuleSubtype[], pathBuilder?: string): ManagedRule[] {
         const paths: ManagedRule[] = [];
         rules.forEach(value => {
-            if (pathBuilder === undefined) {
-                paths.push({
-                    route: value.route,
-                    trackingMethod: value.trackingMethod,
-                    extensions: value.defaultFileExtensions,
-                    isDefaultLocation: value.isDefaultLocation || false,
-                    ref: value
-                });
-            } else {
-                paths.push({
-                    route: path.join(pathBuilder, value.route),
-                    trackingMethod: value.trackingMethod,
-                    extensions: value.defaultFileExtensions,
-                    isDefaultLocation: value.isDefaultLocation || false,
-                    ref: value
-                });
-            }
-            let subPath = pathBuilder === undefined ? value.route : path.join(pathBuilder, value.route);
-            this.getAllManagedPaths(value.subRoutes, subPath).forEach(value1 => {
-                paths.push(value1);
+            const route = !pathBuilder ? value.route : path.join(pathBuilder, value.route);
+            paths.push({
+                route: route,
+                trackingMethod: value.trackingMethod,
+                extensions: value.defaultFileExtensions,
+                isDefaultLocation: value.isDefaultLocation || false,
+                ref: value
             });
+            this.getAllManagedPaths(value.subRoutes, route).forEach(x => paths.push(x));
         });
         return paths;
     }

src/r2mm/installing/profile_installers/GenericProfileInstaller.ts

@@ -16,14 +16,13 @@ import GameManager from '../../../model/game/GameManager';
 import { MOD_LOADER_VARIANTS } from '../../installing/profile_installers/ModLoaderVariantRecord';
 import FileWriteError from '../../../model/errors/FileWriteError';
 import FileUtils from '../../../utils/FileUtils';
-import { GetInstallerIdForLoader } from '../../../model/installing/PackageLoader';
+import { GetInstallerIdForLoader, GetInstallerIdForPlugin } from '../../../model/installing/PackageLoader';
 import ZipProvider from "../../../providers/generic/zip/ZipProvider";
-import { PackageInstallers } from "../../../installers/registry";
+import { PackageInstallerId, PackageInstallers } from "../../../installers/registry";
 import { InstallArgs } from "../../../installers/PackageInstaller";
 import { InstallRuleInstaller } from "../../../installers/InstallRuleInstaller";
 
 
-
 export default class GenericProfileInstaller extends ProfileInstallerProvider {
 
     private readonly rule: CoreRuleType;
@@ -156,9 +155,17 @@ export default class GenericProfileInstaller extends ProfileInstallerProvider {
 
         if (variant !== undefined) {
             return this.installModLoader(variant, args);
-        } else {
-            return this.installForManifestV2(args);
         }
+
+        const pluginInstaller = GetInstallerIdForPlugin(activeGame.packageLoader);
+
+        if (pluginInstaller !== null) {
+            await PackageInstallers[pluginInstaller].install(args);
+            return Promise.resolve(null);
+        }
+
+        // Revert to legacy install behavior.
+        return this.installForManifestV2(args);
     }
 
     async installModLoader(mapping: ModLoaderPackageMapping, args: InstallArgs): Promise<R2Error | null> {
@@ -215,8 +222,17 @@ export default class GenericProfileInstaller extends ProfileInstallerProvider {
                 );
             }
         }
-        const bepInExLocation: string = path.join(profile.getPathOfProfile(), 'BepInEx');
-        if (await fs.exists(bepInExLocation)) {
+
+        // BepInEx & shimloader plugin uninstall logic
+        // TODO: Move to work through the installer interface
+        const profilePath = profile.getPathOfProfile();
+        const searchLocations = ["BepInEx", "shimloader"];
+        for (const searchLocation of searchLocations) {
+            const bepInExLocation: string = path.join(profilePath, searchLocation);
+            if (!(await fs.exists(bepInExLocation))) {
+                continue
+            }
+
             try {
                 for (const file of (await fs.readdir(bepInExLocation))) {
                     if ((await fs.lstat(path.join(bepInExLocation, file))).isDirectory()) {

src/r2mm/installing/profile_installers/ModLoaderVariantRecord.ts

@@ -65,6 +65,8 @@ export const MODLOADER_PACKAGES = [
     new ModLoaderPackageMapping("BepInEx-BepInExPack_WizardWithAGun", "BepInExPack", PackageLoader.BEPINEX),
     new ModLoaderPackageMapping("SunkenlandModding-BepInExPack_Sunkenland", "BepInExPack_Sunkenland", PackageLoader.BEPINEX),
     new ModLoaderPackageMapping("BepInEx_Wormtown-BepInExPack", "BepInExPack", PackageLoader.BEPINEX),
+    new ModLoaderPackageMapping("0xFFF7-votv_shimloader", "", PackageLoader.SHIMLOADER),
+    new ModLoaderPackageMapping("Thunderstore-unreal_shimloader", "", PackageLoader.SHIMLOADER),
 ];
 
 
@@ -159,6 +161,8 @@ const VARIANTS = {
     MeepleStation: MODLOADER_PACKAGES,
     VoidCrew: MODLOADER_PACKAGES,
     Sailwind: MODLOADER_PACKAGES,
+    VotV: MODLOADER_PACKAGES,
+    Palworld: MODLOADER_PACKAGES,
 };
 // Exported separately from the definition in order to preserve the key names in the type definition.
 // Otherwise this would become [key: string] and we couldn't use the game names for type hinting elsewhere.

src/r2mm/launching/instructions/GameInstructions.ts

@@ -7,6 +7,7 @@ import Profile from '../../../model/Profile';
 import NorthstarGameInstructions from './instructions/loader/NorthstarGameInstructions';
 import { GodotMLGameInstructions } from "../../launching/instructions/instructions/loader/GodotMLGameInstructions";
 import { AncientVRGameInstructions } from "../../launching/instructions/instructions/loader/AncientVRGameInstructions";
+import ShimloaderGameInstructions from './instructions/loader/ShimloaderGameInstructions';
 
 export interface GameInstruction {
     moddedParameters: string,
@@ -22,6 +23,7 @@ export default class GameInstructions {
         [PackageLoader.NORTHSTAR, new NorthstarGameInstructions()],
         [PackageLoader.GODOT_ML, new GodotMLGameInstructions()],
         [PackageLoader.ANCIENT_DUNGEON_VR, new AncientVRGameInstructions()],
+        [PackageLoader.SHIMLOADER, new ShimloaderGameInstructions()]
     ]);
 
     public static async getInstructionsForGame(game: Game, profile: Profile): Promise<GameInstruction> {

src/r2mm/launching/instructions/instructions/loader/ShimloaderGameInstructions.ts

@@ -0,0 +1,21 @@
+import GameInstructionGenerator from '../GameInstructionGenerator';
+import { GameInstruction } from '../../GameInstructions';
+import Game from '../../../../../model/game/Game';
+import Profile from '../../../../../model/Profile';
+import * as path from 'path';
+
+export default class ShimloaderGameInstructions extends GameInstructionGenerator {
+
+    public async generate(game: Game, profile: Profile): Promise<GameInstruction> {
+        const shimloader = path.join(profile.getPathOfProfile(), "shimloader");
+
+        const luaDir = path.join(shimloader, "mod");
+        const pakDir = path.join(shimloader, "pak");
+        const cfgDir = path.join(shimloader, "cfg");
+
+        return {
+            moddedParameters: `--mod-dir "${luaDir}" --pak-dir "${pakDir}" --cfg-dir "${cfgDir}"`,
+            vanillaParameters: ""
+        }
+    }
+}