Merge pull request #23 from HsiangNianian/hotfix/fix-high-edition-could-not-launch-bug

3 files changed, 37 insertions, 2 deletions

diff --git a/src-tauri/src/core/game_version.rs b/src-tauri/src/core/game_version.rs
index 572882f..31477a9 100644
--- a/src-tauri/src/core/game_version.rs
+++ b/src-tauri/src/core/game_version.rs
@@ -52,6 +52,7 @@ pub struct Library {
 pub struct Rule {
     pub action: String, // "allow" or "disallow"
     pub os: Option<OsRule>,
+    pub features: Option<serde_json::Value>, // Feature-based rules (e.g., is_demo_user, has_quick_plays_support)
 }
 
 #[derive(Debug, Deserialize)]
diff --git a/src-tauri/src/core/rules.rs b/src-tauri/src/core/rules.rs
index 877982a..71abda5 100644
--- a/src-tauri/src/core/rules.rs
+++ b/src-tauri/src/core/rules.rs
@@ -47,6 +47,13 @@ pub fn is_library_allowed(rules: &Option<Vec<Rule>>) -> bool {
 }
 
 fn rule_matches(rule: &Rule) -> bool {
+    // Feature-based rules (e.g., is_demo_user, has_quick_plays_support, is_quick_play_singleplayer)
+    // are not implemented in this launcher, so we return false for any rule that has features.
+    // This prevents adding arguments like --demo, --quickPlayPath, --quickPlaySingleplayer, etc.
+    if rule.features.is_some() {
+        return false;
+    }
+
     match &rule.os {
         None => true, // No OS condition means it applies to all
         Some(os_rule) => {
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index ae74a03..a24510e 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -40,6 +40,27 @@ impl MsRefreshTokenState {
     }
 }
 
+/// Check if a string contains unresolved placeholders in the form ${...}
+/// 
+/// After the replacement phase, if a string still contains ${...}, it means
+/// that placeholder variable was not found in the replacements map and is
+/// therefore unresolved. We should skip adding such arguments to avoid
+/// passing malformed arguments to the game launcher.
+fn has_unresolved_placeholder(s: &str) -> bool {
+    // Look for the opening sequence
+    if let Some(start_pos) = s.find("${") {
+        // Check if there's a closing brace after the opening sequence
+        if s[start_pos + 2..].find('}').is_some() {
+            // Found a complete ${...} pattern - this is an unresolved placeholder
+            return true;
+        }
+        // Found ${ but no closing } - also treat as unresolved/malformed
+        return true;
+    }
+    // No ${ found - the string is fully resolved
+    false
+}
+
 #[tauri::command]
 async fn start_game(
     window: Window,
@@ -449,7 +470,10 @@ async fn start_game(
                                     for (key, replacement) in &replacements {
                                         arg = arg.replace(key, replacement);
                                     }
-                                    args.push(arg);
+                                    // Skip arguments with unresolved placeholders
+                                    if !has_unresolved_placeholder(&arg) {
+                                        args.push(arg);
+                                    }
                                 } else if let Some(arr) = val.as_array() {
                                     for sub in arr {
                                         if let Some(s) = sub.as_str() {
@@ -457,7 +481,10 @@ async fn start_game(
                                             for (key, replacement) in &replacements {
                                                 arg = arg.replace(key, replacement);
                                             }
-                                            args.push(arg);
+                                            // Skip arguments with unresolved placeholders
+                                            if !has_unresolved_placeholder(&arg) {
+                                                args.push(arg);
+                                            }
                                         }
                                     }
                                 }