game version vs pin version

Frotty · Frotty · commit 2226644f32ad · 2026-06-01T12:14:13.000+02:00
diff --git a/de.peeeq.wurstscript/src/main/java/de/peeeq/wurstio/languageserver/ProjectConfigBuilder.java b/de.peeeq.wurstscript/src/main/java/de/peeeq/wurstio/languageserver/ProjectConfigBuilder.java
@@ -200,21 +200,29 @@ private static void applyBuildMapData(WurstProjectConfigData projectConfig, File
         try (FileInputStream inputStream = new FileInputStream(mapScript)) {
             StringWriter sw = new StringWriter();
 
-            if (w3data.getWc3PatchVersion().isPresent()) {
-                w3I.injectConfigsInJassScript(inputStream, sw, w3data.getWc3PatchVersion().get());
+            WurstBuildConfig buildConfig = buildConfigFromBuildDir(buildDir);
+            GameVersion version = effectiveConfigInjectionVersion(buildDir, w3data);
+            if (buildConfig.configuredGameVersion().isPresent()) {
+                WLogger.info("Using wurst.build patch target for map config injection: " + version);
+            } else if (w3data.getWc3PatchVersion().isPresent()) {
+                WLogger.info("Using detected game version for map config injection: " + version);
             } else {
-                GameVersion version = buildConfigFromBuildDir(buildDir).fallbackGameVersion();
-                WLogger.info(
-                    "Failed to determine installed game version. Falling back to wurst.build patch target: " + version
-                );
-                w3I.injectConfigsInJassScript(inputStream, sw, version);
+                WLogger.info("Failed to determine installed game version. Falling back to default patch target: " + version);
             }
+            w3I.injectConfigsInJassScript(inputStream, sw, version);
 
             byte[] scriptBytes = sw.toString().getBytes(StandardCharsets.UTF_8);
             Files.write(scriptBytes, result.script);
         }
     }
 
+    private static GameVersion effectiveConfigInjectionVersion(File buildDir, W3InstallationData w3data) {
+        WurstBuildConfig buildConfig = buildConfigFromBuildDir(buildDir);
+        return buildConfig.configuredGameVersion()
+            .or(() -> w3data.getWc3PatchVersion())
+            .orElseGet(buildConfig::fallbackGameVersion);
+    }
+
     private static WurstBuildConfig buildConfigFromBuildDir(File buildDir) {
         java.nio.file.Path projectRoot = buildDir.toPath().getParent();
         if (projectRoot == null) {
diff --git a/de.peeeq.wurstscript/src/main/java/de/peeeq/wurstio/languageserver/requests/MapRequest.java b/de.peeeq.wurstscript/src/main/java/de/peeeq/wurstio/languageserver/requests/MapRequest.java
@@ -108,7 +108,10 @@ public MapRequest(WurstLanguageServer langServer, Optional<File> map, List<Strin
         this.wc3Path = wc3Path;
         this.buildConfig = WurstBuildConfig.fromWorkspaceRoot(workspaceRoot);
         if (gameExePath.isPresent() && StringUtils.isNotBlank(gameExePath.get())) {
-            this.w3data = new W3InstallationData(Optional.of(new File(gameExePath.get())), buildConfig.configuredGameVersion());
+            Optional<GameVersion> configuredVersion = this instanceof RunMap
+                ? Optional.empty()
+                : buildConfig.configuredGameVersion();
+            this.w3data = new W3InstallationData(Optional.of(new File(gameExePath.get())), configuredVersion);
         } else {
             this.w3data = getBestW3InstallationData();
         }
@@ -945,17 +948,18 @@ private W3InstallationData getBestW3InstallationData() throws RequestFailedExcep
         if (!needsGameExe && configuredVersion.isPresent()) {
             return new W3InstallationData(Optional.empty(), configuredVersion);
         }
+        Optional<GameVersion> versionForDiscovery = needsGameExe ? Optional.empty() : configuredVersion;
         if (wc3Path.isPresent() && StringUtils.isNotBlank(wc3Path.get())) {
             W3InstallationData w3data = new W3InstallationData(langServer, new File(wc3Path.get()),
-                needsGameExe, configuredVersion);
+                needsGameExe, versionForDiscovery);
             if (w3data.getWc3PatchVersion().isEmpty() && !configuredVersion.isPresent()) {
                 WLogger.warning("Could not determine Warcraft III version at specified path: " + wc3Path
                     + ". Falling back to default launch behavior.");
             }
 
             return w3data;
         } else {
-            return new W3InstallationData(langServer, needsGameExe, configuredVersion);
+            return new W3InstallationData(langServer, needsGameExe, versionForDiscovery);
         }
     }
 
diff --git a/de.peeeq.wurstscript/src/main/java/de/peeeq/wurstio/languageserver/requests/RunMap.java b/de.peeeq.wurstscript/src/main/java/de/peeeq/wurstio/languageserver/requests/RunMap.java
@@ -7,7 +7,9 @@
 import de.peeeq.wurstio.gui.WurstGuiImpl;
 import de.peeeq.wurstio.languageserver.ModelManager;
 import de.peeeq.wurstio.languageserver.WFile;
+import de.peeeq.wurstio.languageserver.WurstBuildConfig;
 import de.peeeq.wurstio.languageserver.WurstLanguageServer;
+import de.peeeq.wurstio.utils.W3InstallationData;
 import de.peeeq.wurstscript.WLogger;
 import de.peeeq.wurstscript.attributes.CompileError;
 import de.peeeq.wurstscript.gui.WurstGui;
@@ -22,6 +24,7 @@
 
 import javax.swing.*;
 import javax.swing.filechooser.FileSystemView;
+import java.awt.GraphicsEnvironment;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
@@ -136,7 +139,11 @@ private void startGame(WurstGui gui, CompilationResult result) throws Exception
         gui.sendProgress("Starting Warcraft 3...");
 
         File mapCopy = cachedMapFile.get();
-        Optional<GameVersion> detectedGameVersion = w3data.getWc3PatchVersion();
+        W3InstallationData launchData = resolveLaunchData();
+        if (launchData == null) {
+            throw new RequestFailedException(MessageType.Info, "Run canceled.");
+        }
+        Optional<GameVersion> detectedGameVersion = launchData.getWc3PatchVersion();
         if (buildConfig.shouldCopyRunMapToWarcraftMapDir(detectedGameVersion)) {
             mapCopy = copyToWarcraftMapDir(cachedMapFile.get());
         }
@@ -153,7 +160,7 @@ private void startGame(WurstGui gui, CompilationResult result) throws Exception
 
         if (!path.isEmpty()) {
             // now start the map
-            File gameExe = w3data.getGameExe()
+            File gameExe = launchData.getGameExe()
                 .orElseThrow(() -> new RequestFailedException(MessageType.Error, wc3Path + " does not exist."));
             List<String> cmd = Lists.newArrayList(gameExe.getAbsolutePath());
             Optional<String> wc3RunArgs = langServer.getConfigProvider().getWc3RunArgs();
@@ -186,6 +193,104 @@ private void startGame(WurstGui gui, CompilationResult result) throws Exception
         }
     }
 
+    private W3InstallationData resolveLaunchData() {
+        W3InstallationData launchData = w3data;
+        while (shouldWarnClientPatchMismatch(launchData)) {
+            String projectTarget = buildConfig.wc3PatchName().orElse("configured patch");
+            String clientTarget = launchData.getWc3PatchVersion()
+                .map(RunMap::describeClientVersion)
+                .orElse("unknown Warcraft III version");
+            String message = "This project targets " + projectTarget + ", but the selected Warcraft III client looks like "
+                + clientTarget + ". The map may not start correctly.";
+            WLogger.warning(message);
+
+            MismatchChoice choice = chooseMismatchAction(message);
+            if (choice == MismatchChoice.CANCEL) {
+                return null;
+            }
+            if (choice == MismatchChoice.CONTINUE) {
+                return launchData;
+            }
+            Optional<W3InstallationData> selected = chooseAlternateGamePath();
+            if (selected.isEmpty()) {
+                return null;
+            }
+            launchData = selected.get();
+        }
+        if (buildConfig.wc3Patch().isPresent() && launchData.getWc3PatchVersion().isEmpty()) {
+            WLogger.warning("Could not determine Warcraft III client version. If the map does not start, select a matching Warcraft III installation.");
+        }
+        return launchData;
+    }
+
+    private boolean shouldWarnClientPatchMismatch(W3InstallationData launchData) {
+        Optional<WurstBuildConfig.Wc3Patch> projectKind = buildConfig.wc3Patch();
+        Optional<GameVersion> clientVersion = launchData.getWc3PatchVersion();
+        if (projectKind.isEmpty() || clientVersion.isEmpty()) {
+            return false;
+        }
+        return projectKind.get() != kindForVersion(clientVersion.get());
+    }
+
+    private static WurstBuildConfig.Wc3Patch kindForVersion(GameVersion version) {
+        if (version.compareTo(new GameVersion("1.29")) < 0) {
+            return WurstBuildConfig.Wc3Patch.PRE_129;
+        }
+        if (version.compareTo(GameVersion.VERSION_1_32) < 0) {
+            return WurstBuildConfig.Wc3Patch.CLASSIC;
+        }
+        return WurstBuildConfig.Wc3Patch.REFORGED;
+    }
+
+    private static String describeClientVersion(GameVersion version) {
+        return kindForVersion(version) + " (" + version + ")";
+    }
+
+    private MismatchChoice chooseMismatchAction(String message) {
+        if (GraphicsEnvironment.isHeadless()) {
+            return MismatchChoice.CONTINUE;
+        }
+        Object[] options = {"Continue", "Choose Warcraft III folder", "Cancel"};
+        int result = JOptionPane.showOptionDialog(
+            null,
+            message,
+            "Warcraft III version mismatch",
+            JOptionPane.DEFAULT_OPTION,
+            JOptionPane.WARNING_MESSAGE,
+            null,
+            options,
+            options[1]
+        );
+        if (result == 1) {
+            return MismatchChoice.CHOOSE_OTHER;
+        }
+        if (result == 2 || result == JOptionPane.CLOSED_OPTION) {
+            return MismatchChoice.CANCEL;
+        }
+        return MismatchChoice.CONTINUE;
+    }
+
+    private Optional<W3InstallationData> chooseAlternateGamePath() {
+        if (GraphicsEnvironment.isHeadless()) {
+            return Optional.empty();
+        }
+        JFileChooser fileChooser = new JFileChooser(FileSystemView.getFileSystemView().getHomeDirectory());
+        fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+        fileChooser.setDialogTitle("Select Warcraft III installation folder");
+        int result = fileChooser.showOpenDialog(null);
+        if (result != JFileChooser.APPROVE_OPTION) {
+            return Optional.empty();
+        }
+        File selectedFolder = fileChooser.getSelectedFile();
+        return Optional.of(new W3InstallationData(langServer, selectedFolder, true, Optional.empty()));
+    }
+
+    private enum MismatchChoice {
+        CONTINUE,
+        CHOOSE_OTHER,
+        CANCEL
+    }
+
 
     private void callJhcrUpdate(File mapScript) throws IOException, InterruptedException {
         File mapScriptFolder = mapScript.getParentFile();
diff --git a/de.peeeq.wurstscript/src/main/java/de/peeeq/wurstio/utils/W3InstallationData.java b/de.peeeq.wurstscript/src/main/java/de/peeeq/wurstio/utils/W3InstallationData.java
@@ -19,6 +19,8 @@ public class W3InstallationData {
 
     private Optional<GameVersion> version = Optional.empty();
 
+    private boolean versionHeuristic = false;
+
     private File selectedFolder;
 
     private boolean shouldAskForPath = false;
@@ -37,10 +39,12 @@ public W3InstallationData(Optional<File> gameExe, Optional<GameVersion> version)
         if (!this.version.isPresent() && this.gameExe.isPresent()) {
             try {
                 this.version = Optional.ofNullable(GameExe.getVersion(this.gameExe.get()));
+                this.versionHeuristic = false;
                 WLogger.info("Parsed game version from configured executable: " + this.version);
             } catch (IOException | RuntimeException e) {
                 WLogger.warning("Could not parse game version from configured executable. Continuing without detected game version.");
                 WLogger.debug("Game version parser failed: " + e);
+                inferVersionFromExecutablePath();
             }
         }
     }
@@ -128,9 +132,55 @@ private void loadFromPath(File wc3Path, boolean shouldParseVersion) {
 
             return Optional.empty();
         });
+        if (!version.isPresent()) {
+            inferVersionFromExecutablePath();
+        } else {
+            versionHeuristic = false;
+        }
         WLogger.info("Parsed custom game version from executable: " + version);
     }
 
+    private void inferVersionFromExecutablePath() {
+        if (!gameExe.isPresent()) {
+            return;
+        }
+        Optional<GameVersion> inferred = inferVersionFromExecutablePath(gameExe.get());
+        if (inferred.isPresent()) {
+            version = inferred;
+            versionHeuristic = true;
+            WLogger.info("Inferred Warcraft III client family from executable path: " + version.get());
+        }
+    }
+
+    public static Optional<GameVersion> inferVersionFromExecutablePath(File exe) {
+        if (exe == null) {
+            return Optional.empty();
+        }
+        String normalized = exe.getAbsolutePath().replace('\\', '/').toLowerCase();
+        String fileName = exe.getName().toLowerCase();
+        if (normalized.contains("/_retail_/") || normalized.contains("/_ptr_/")) {
+            return Optional.of(GameVersion.VERSION_1_32);
+        }
+        if (fileName.equals("war3.exe") || fileName.equals("frozen throne.exe")) {
+            return Optional.of(new GameVersion("1.28"));
+        }
+        if (fileName.equals("warcraft iii.exe")) {
+            File parent = exe.getParentFile();
+            if (parent != null) {
+                String parentName = parent.getName().toLowerCase();
+                if (parentName.equals("x86") || parentName.equals("x86_64")) {
+                    File installDir = parent.getParentFile();
+                    if (installDir != null && new File(installDir, "_retail_").exists()) {
+                        return Optional.of(GameVersion.VERSION_1_32);
+                    }
+                    return Optional.of(GameVersion.VERSION_1_31);
+                }
+            }
+            return Optional.of(new GameVersion("1.29"));
+        }
+        return Optional.empty();
+    }
+
     private void discoverExePath() {
         try {
             gameExe = Optional.ofNullable(new StdGameExeFinder().get());
@@ -178,6 +228,7 @@ private void showFileChooser() {
     private void discoverVersion() {
         try {
             version = Optional.ofNullable(new StdGameVersionFinder().get());
+            versionHeuristic = false;
             WLogger.info("Parsed game version: " + version);
         } catch (NotFoundException e) {
             WLogger.warning("Game version detection failed. Pin wc3Patch in wurst.build if launch arguments look wrong.");
@@ -194,6 +245,10 @@ public Optional<GameVersion> getWc3PatchVersion() {
         return version;
     }
 
+    public boolean isVersionHeuristic() {
+        return versionHeuristic;
+    }
+
     /**
      * @return The wc3 path or empty if none has been found
      */
diff --git a/de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/MapRequestPatchTargetTests.java b/de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/MapRequestPatchTargetTests.java
@@ -60,10 +60,32 @@ public void pinnedRunMapUsesPatchVersionWithoutParsingExecutable() throws Except
 
         TestRunMap request = new TestRunMap(project, fakeExe.toString());
 
-        assertEquals(request.detectedVersion().orElseThrow(), new GameVersion("1.27"));
+        assertFalse(request.detectedVersion().isPresent());
         assertEquals(request.gameExe().orElseThrow().getAbsoluteFile(), fakeExe.toFile().getAbsoluteFile());
     }
 
+    @Test
+    public void runMapInfersReforgedClientFromRetailExecutablePath() throws Exception {
+        Path project = projectWithPatch("v1.27b");
+        Path install = Files.createTempDirectory("warcraft-reforged");
+        Path exe = Files.createDirectories(install.resolve("_retail_").resolve("x86_64")).resolve("Warcraft III.exe");
+        Files.writeString(exe, "not a PE file");
+
+        TestRunMap request = new TestRunMap(project, exe.toString());
+
+        assertEquals(request.detectedVersion().orElseThrow(), GameVersion.VERSION_1_32);
+    }
+
+    @Test
+    public void runMapInfersClassicClientFromWar3ExecutablePath() throws Exception {
+        Path project = projectWithPatch("v2.0");
+        Path exe = Files.writeString(Files.createTempDirectory("warcraft-classic").resolve("war3.exe"), "not a PE file");
+
+        TestRunMap request = new TestRunMap(project, exe.toString());
+
+        assertEquals(request.detectedVersion().orElseThrow(), new GameVersion("1.28"));
+    }
+
     @Test
     public void configuredVersionSurvivesManualPathLoad() throws Exception {
         W3InstallationData data = new W3InstallationData(Optional.empty(), Optional.of(new GameVersion("2.0")));
diff --git a/de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/WurstBuildConfigTests.java b/de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/WurstBuildConfigTests.java
