drop latest game engine constant / latest game version

src/main/config/default-versions.ts

@@ -6,7 +6,5 @@
  * In the future these values should probably be set and fetched from the master server, so we don't need to deploy a new lobby release every time.
  */
 
-export const DEFAULT_ENGINE_VERSION = "2025.01.3";
 export const LATEST = "LATEST";
-
 export const LATEST_GAME_VERSION = "byar:test";

src/main/content/engine/engine-content.ts

@@ -43,6 +43,14 @@ export class EngineContentAPI extends AbstractContentAPI<EngineVersion> {
         return this.installedVersions.values().some((installedVersion) => installedVersion.id === id);
     }
 
+    public getLatestInstalledVersion() {
+        return this.installedVersions
+            .values()
+            .toArray()
+            .sort((a, b) => a.id.localeCompare(b.id))
+            .pop();
+    }
+
     protected async getLatestTagName() {
         const { data } = await this.ocotokit.rest.repos.getLatestRelease({
             owner: contentSources.engineGitHub.owner,

src/main/content/pr-downloader.ts

@@ -1,5 +1,4 @@
 import { spawn } from "child_process";
-import { lastInArray } from "$/jaz-ts-utils/object";
 import os from "os";
 import path from "path";
 
@@ -8,7 +7,6 @@ import { AbstractContentAPI } from "./abstract-content";
 import { engineContentAPI } from "./engine/engine-content";
 import { logger } from "@main/utils/logger";
 import { CONTENT_PATH } from "@main/config/app";
-import { DEFAULT_ENGINE_VERSION } from "@main/config/default-versions";
 
 const log = logger("pr-downloader.ts");
 
@@ -37,9 +35,11 @@ export abstract class PrDownloaderAPI<T> extends AbstractContentAPI<T> {
     protected downloadContent(type: "game" | "map", name: string) {
         return new Promise<DownloadInfo>((resolve) => {
             log.debug(`Downloading ${name}...`);
-            const latestEngine = lastInArray(engineContentAPI.installedVersions)?.id || DEFAULT_ENGINE_VERSION;
+            const latestEngine = engineContentAPI.getLatestInstalledVersion();
+            if (!latestEngine) throw new Error("No engine version found");
+
             const binaryName = process.platform === "win32" ? "pr-downloader.exe" : "pr-downloader";
-            const prBinaryPath = path.join(CONTENT_PATH, "engine", latestEngine, binaryName);
+            const prBinaryPath = path.join(CONTENT_PATH, "engine", latestEngine.id, binaryName);
             const downloadArg = type === "game" ? "--download-game" : "--download-map";
             const prdProcess = spawn(`${prBinaryPath}`, ["--filesystem-writepath", CONTENT_PATH, downloadArg, name], {
                 env: {

src/main/game/game.ts

@@ -8,11 +8,12 @@ import { engineContentAPI } from "@main/content/engine/engine-content";
 
 import { Replay } from "@main/content/replays/replay";
 import { startScriptConverter } from "@main/utils/start-script-converter";
-import { DEFAULT_ENGINE_VERSION, LATEST_GAME_VERSION } from "@main/config/default-versions";
+import { LATEST_GAME_VERSION } from "@main/config/default-versions";
 import { logger } from "@main/utils/logger";
 import { gameContentAPI } from "@main/content/game/game-content";
 import { CONTENT_PATH, REPLAYS_PATH } from "@main/config/app";
 import { BattleWithMetadata } from "@main/game/battle/battle-types";
+import engineService from "@main/services/engine.service";
 
 const log = logger("main/game/game.ts");
 const engineLogger = logger("[RECOIL ENGINE]", { separator: "\n", level: "info" });
@@ -56,21 +57,21 @@ export class GameAPI {
         const scriptPath = path.join(CONTENT_PATH, this.springName);
         await fs.promises.writeFile(scriptPath, script);
         await this.launch({
-            engineVersion: DEFAULT_ENGINE_VERSION,
+            engineVersion: engineContentAPI.getLatestInstalledVersion().id,
             gameVersion,
             launchArg: scriptPath,
         });
     }
 
-    public async launchMultiplayerString(springString: string) {
+    public async launchMultiplayer(springString: string) {
         return this.launch({
-            engineVersion: DEFAULT_ENGINE_VERSION,
+            engineVersion: engineContentAPI.getLatestInstalledVersion().id, //TODO: replace this with the engine version from the server
             gameVersion: LATEST_GAME_VERSION,
             launchArg: springString,
         });
     }
 
-    public async launch({ engineVersion = DEFAULT_ENGINE_VERSION, gameVersion, launchArg }: { engineVersion: string; gameVersion: string; launchArg: string }): Promise<void> {
+    public async launch({ engineVersion, gameVersion, launchArg }: { engineVersion: string; gameVersion: string; launchArg: string }): Promise<void> {
         try {
             log.info(`Launching game with engine: ${engineVersion}, game: ${gameVersion}`);
             await this.fetchMissingContent(engineVersion, gameVersion);

src/main/services/tachyon.service.ts

@@ -14,7 +14,9 @@ function registerIpcHandlers(mainWindow: Electron.BrowserWindow) {
             const { ip, port, username, password } = data;
             mainWindow.webContents.send("tachyon:battleStart", data);
             const springString = `spring://${username}:${password}@${ip}:${port}`;
-            await gameAPI.launchMultiplayerString(springString);
+
+            //TODO ideally we should get an engine version from the server to pass to launchMultiplayerString
+            await gameAPI.launchMultiplayer(springString);
             return {
                 status: "success",
             };

vendor/jaz-ts-utils/object.ts

@@ -2,10 +2,6 @@ export function randomFromArray<T>(arr: T[]): T | undefined {
     return arr[Math.floor(Math.random() * arr.length)];
 }
 
-export function lastInArray<T>(target: T[]): T | undefined {
-    return target[target.length - 1];
-}
-
 export function removeFromArray<T>(target: T[], item: T): T[] {
     const index = target.indexOf(item);
     if (index > -1) {