fix failing to launch 1.16.5

2 files changed, 25 insertions, 49 deletions

diff --git a/src/launcher.rs b/src/launcher.rs
index 8c798e1..c3c954e 100644
--- a/src/launcher.rs
+++ b/src/launcher.rs
@@ -357,20 +357,25 @@ impl Launcher {
         
         info!("Resolved launch version {}!", ver.id);
 
-        let mut libs = Vec::new();
         let mut extract_jobs = Vec::new();
         let mut downloads = IndexMap::new();
 
-        for lib in ver.libraries.values() {
+        for lib in ver.libraries.iter() {
             if lib.rules_apply(&self.system_info, &feature_matcher).is_err() {
+                trace!("Skipping library {}, compatibility rules failed", lib.name);
                 continue;
             }
 
-            libs.push(lib);
-            if let Some(dl) = self.libraries.create_download(lib, self.choose_lib_classifier(lib)) {
+            let classifier = self.choose_lib_classifier(lib);
+
+            if let Some(dl) = self.libraries.create_download(lib, classifier) {
                 let canon_name = lib.get_canonical_name();
-                if downloads.contains_key(&canon_name) { continue; }
+                if downloads.contains_key(&canon_name) {
+                    debug!("Skipping library {}, we already have another version of that library.", lib.name);
+                    continue;
+                }
 
+                trace!("Using library {} ({})", lib.name, classifier.unwrap_or("None"));
                 dl.make_dirs().await.map_err(|e| LaunchError::LibraryDirError(dl.get_path().to_path_buf(), e))?;
 
                 if lib.natives.is_some() {
@@ -381,6 +386,8 @@ impl Launcher {
                 }
 
                 downloads.insert(canon_name, dl);
+            } else {
+                trace!("Skipping library {} ({}), no download", lib.name, classifier.unwrap_or("None"));
             }
         }
 
@@ -699,7 +706,7 @@ impl LibraryRepository {
             for job in libs {
                 debug!("Extracting natives for {}", job.source.display());
                 tally += extract::extract_zip(&job.source, &natives_dir, |name|
-                    job.rule.as_ref().is_some_and(|rules|
+                    job.rule.as_ref().is_none_or(|rules|
                         rules.exclude.iter().filter(|ex|
                             name.starts_with(ex.as_str())).next().is_none()))?;
             }
diff --git a/src/version.rs b/src/version.rs
index 462ba3b..b844f23 100644
--- a/src/version.rs
+++ b/src/version.rs
@@ -214,7 +214,7 @@ pub struct Library {
 
 impl Library {
     pub fn get_canonical_name(&self) -> String {
-        canonicalize_library_name(self.name.as_str())
+        canonicalize_library_name(self.name.as_str(), self.natives.as_ref().map_or(None, |_| Some("__ozone_natives")))
     }
 }
 
@@ -258,8 +258,8 @@ pub struct CompleteVersion {
     #[serde(default)]
     pub downloads: BTreeMap<DownloadType, DownloadInfo>,
 
-    #[serde(default, deserialize_with = "deserialize_libraries")]
-    pub libraries: IndexMap<String, Library>,
+    #[serde(default)]
+    pub libraries: Vec<Library>,
 
     pub id: String,
     pub jar: Option<String>, // used as the jar filename if specified? (no longer used officially)
@@ -321,9 +321,7 @@ impl CompleteVersion {
             self.downloads.entry(*dltype).or_insert_with(|| dl.clone());
         }
 
-        for (name, lib) in other.libraries.iter().by_ref() {
-            self.libraries.entry(name.to_owned()).or_insert_with(|| lib.clone());
-        }
+        self.libraries.splice(0..0, other.libraries.iter().cloned());
 
         replace_missing!(logging);
         replace_missing!(main_class);
@@ -344,11 +342,12 @@ impl CompleteVersion {
     }
 }
 
-fn canonicalize_library_name(name: &str) -> String {
+fn canonicalize_library_name(name: &str, suffix: Option<&str>) -> String {
     name.split(':')
         .enumerate()
         .filter(|(i, _)| *i != 2)
         .map(|(_, s)| s.to_ascii_lowercase())
+        .chain(suffix.into_iter().map(|s| s.to_owned()))
         .collect::<Vec<_>>()
         .join(":")
 }
@@ -387,37 +386,6 @@ where
     deserializer.deserialize_str(DateTimeVisitor)
 }
 
-fn deserialize_libraries<'de, D>(deserializer: D) -> Result<IndexMap<String, Library>, D::Error>
-where
-    D: Deserializer<'de>
-{
-    struct LibrariesVisitor;
-
-    impl<'de> Visitor<'de> for LibrariesVisitor {
-        type Value = IndexMap<String, Library>;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str("an array of libraries")
-        }
-
-        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-        where
-            A: SeqAccess<'de>,
-        {
-            let mut map = IndexMap::new();
-
-            while let Some(lib) = seq.next_element::<Library>()? {
-                //map.insert(canonicalize_library_name(lib.name.as_str()), lib);
-                map.insert(lib.name.as_str().to_owned(), lib);
-            }
-
-            Ok(map)
-        }
-    }
-
-    deserializer.deserialize_seq(LibrariesVisitor)
-}
-
 // https://serde.rs/string-or-struct.html
 fn string_or_struct<'de, T, D>(deserializer: D) -> Result<T, D::Error>
 where
@@ -511,10 +479,11 @@ mod tests {
 
     #[test]
     fn test_it3() {
-        assert_eq!(canonicalize_library_name("group:artifact:version"), String::from("group:artifact"));
-        assert_eq!(canonicalize_library_name("group:artifact:version:specifier"), String::from("group:artifact:specifier"));
-        assert_eq!(canonicalize_library_name("not_enough:fields"), String::from("not_enough:fields"));
-        assert_eq!(canonicalize_library_name("word"), String::from("word"));
-        assert_eq!(canonicalize_library_name(""), String::from(""));
+        assert_eq!(canonicalize_library_name("group:artifact:version", None), String::from("group:artifact"));
+        assert_eq!(canonicalize_library_name("group:artifact:version:specifier", None), String::from("group:artifact:specifier"));
+        assert_eq!(canonicalize_library_name("not_enough:fields", None), String::from("not_enough:fields"));
+        assert_eq!(canonicalize_library_name("word", None), String::from("word"));
+        assert_eq!(canonicalize_library_name("", None), String::from(""));
+        assert_eq!(canonicalize_library_name("group:artifact:version", Some("suffix")), String::from("group:artifact:suffix"));
     }
 }