From 6ebf452632fde316d970ec174ca4bb672973e986 Mon Sep 17 00:00:00 2001
From: Ethan O'Brien <ethan.a.obrien@gmail.com>
Date: Sat, 6 Jun 2026 15:39:23 -0500
Subject: [PATCH] Cleanup asset table

---
 src/options.rs       |  3 +++
 src/router/global.rs | 53 +++++++++++++++++++++++++-------------------
 2 files changed, 33 insertions(+), 23 deletions(-)

diff --git a/src/options.rs b/src/options.rs
index 481e459..13d4a4f 100644
--- a/src/options.rs
+++ b/src/options.rs
@@ -59,6 +59,9 @@ pub struct Args {
     #[arg(long, default_value = "", help = "Asset hash for JP Android client.")]
     pub jp_android_asset_hash: String,
 
+    #[arg(long, default_value = "", help = "Asset hash for windows client.")]
+    pub windows_asset_hash: String,
+
     #[arg(long, default_value = "", help = "Path to image assets.")]
     pub image_asset_path: String,
 
diff --git a/src/router/global.rs b/src/router/global.rs
index d4a00f7..06cae1b 100644
--- a/src/router/global.rs
+++ b/src/router/global.rs
@@ -16,6 +16,7 @@ struct AssetHashes {
     version:  &'static str,
     android:  &'static str,
     ios:      &'static str,
+    windows:  &'static str,
 }
 
 static ASSET_TABLE: &[(&str, AssetHashes)] = &[
@@ -23,14 +24,39 @@ static ASSET_TABLE: &[(&str, AssetHashes)] = &[
         version: "4c921d2443335e574a82e04ec9ea243c",
         android: "67f8f261c16b3cca63e520a25aad6c1c",
         ios:     "b8975be8300013a168d061d3fdcd4a16",
+        windows: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
     }),
     ("GL", AssetHashes {
         version: "5260ff15dff8ba0c00ad91400f515f55",
         android: "d210b28037885f3ef56b8f8aa45ac95b",
         ios:     "dd7175e4bcdab476f38c33c7f34b5e4d",
+        windows: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
     }),
 ];
 
+impl AssetHashes {
+    fn resolve(&self, platform: &str, region: &str, easter_hash: Option<&str>) -> Option<String> {
+        let args = crate::get_args();
+
+        let (base, override_hash) = match (region, platform) {
+            ("JP", "Android") => (self.android, args.jp_android_asset_hash.as_str()),
+            ("JP", "iOS")     => (self.ios,     args.jp_ios_asset_hash.as_str()),
+            ("JP", "Windows") => (self.windows, args.windows_asset_hash.as_str()),
+            ("GL", "Android") => (self.android, args.en_android_asset_hash.as_str()),
+            ("GL", "iOS")     => (self.ios,     args.en_ios_asset_hash.as_str()),
+            _                 => return None,
+        };
+
+        Some(if !override_hash.is_empty() {
+            override_hash
+        } else if let Some(easter) = easter_hash {
+            easter
+        } else {
+            base
+        }.to_string())
+    }
+}
+
 static EASTER_HASHES: &[(&str, &str)] = &[
     ("JP", "eac0cad61c82bf2e31fc596555747d11"),
     ("GL", "da7ae831381c3f29337caa9891db7e6a"),
@@ -54,36 +80,17 @@ pub fn parse_platform(header: &str) -> &str {
 }
 
 pub fn get_asset_hash(asset_version: &str, platform: &str) -> Option<String> {
-    let args = crate::get_args();
     let easter = get_easter_mode();
 
     let (region, hashes) = ASSET_TABLE
         .iter()
         .find(|(_, h)| h.version == asset_version)?;
 
-    let (android_override, ios_override) = match *region {
-        "JP" => (&args.jp_android_asset_hash, &args.jp_ios_asset_hash),
-        "GL" => (&args.en_android_asset_hash, &args.en_ios_asset_hash),
-        _    => (&String::new(), &String::new()),
-    };
+    let easter_hash = easter
+        .then(|| EASTER_HASHES.iter().find(|(r, _)| r == region).map(|(_, h)| *h))
+        .flatten();
 
-    let hash = match platform {
-        "Android" => {
-            if !android_override.is_empty() {
-                android_override.as_str()
-            } else if easter {
-                EASTER_HASHES.iter().find(|(r, _)| r == region).map(|(_, h)| *h).unwrap_or(hashes.android)
-            } else {
-                hashes.android
-            }
-        }
-        "iOS" => {
-            if !ios_override.is_empty() { ios_override.as_str() } else { hashes.ios }
-        }
-        _ => return None,
-    };
-
-    Some(hash.to_string())
+    hashes.resolve(platform, region, easter_hash)
 }
 
 pub fn create_token() -> String {