open_launcher 1.3.0

Open Launcher is a package to install and launch modded and vanilla Minecraft instances totally automatically with Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use crate::utils::{try_download_file, InstallError};
use crate::Launcher;
use sha1::Digest;
use std::error::Error;
use tokio::fs;

impl Launcher {
    /// Install assets for the current version
    pub async fn install_assets(&self) -> Result<(), Box<dyn Error + Send>> {
        if self.version.profile.is_null() {
            return Err(Box::from(InstallError(
                "Please install a version before installing assets".to_string(),
            )));
        }

        println!("Checking assets");

        let assets_dir = self.game_dir.join("assets");
        let indexes_dir = assets_dir.join("indexes");
        let objects_dir = assets_dir.join("objects");

        fs::create_dir_all(&indexes_dir).await.unwrap();
        fs::create_dir_all(&objects_dir).await.unwrap();

        let index_path = indexes_dir.join(&format!(
            "{}.json",
            self.version.profile["assets"].as_str().unwrap()
        ));

        if !index_path.exists() {
            println!("Downloading asset index");

            let index_url = self.version.profile["assetIndex"]["url"].as_str().unwrap();
            let index_data = reqwest::get(index_url).await.unwrap().text().await.unwrap();
            fs::write(&index_path, index_data).await.unwrap();
        }

        let index: serde_json::Value =
            serde_json::from_str(&fs::read_to_string(&index_path).await.unwrap()).unwrap();

        let mut tasks = Vec::new();

        let mut readdir = fs::read_dir(&objects_dir).await.unwrap();
        while let Some(file) = readdir.next_entry().await.unwrap() {
            let path = file.path();
            if path.is_file() {
                let hash = path.file_name().unwrap().to_str().unwrap().to_string();

                if !index["objects"]
                    .as_object()
                    .unwrap()
                    .values()
                    .any(|object| object["hash"].as_str().unwrap() == &hash)
                    || format!("{:x}", sha1::Sha1::digest(&fs::read(&path).await.unwrap())) != hash
                {
                    println!("Removing outdated asset {}", hash);
                    fs::remove_file(&path).await.unwrap();
                }
            }
        }

        for (name, object) in index["objects"].as_object().unwrap() {
            let object = object.as_object().unwrap();
            let hash = object["hash"].as_str().unwrap().to_string();

            let object_path = objects_dir.join(&hash[..2]).join(&hash);

            if !object_path.exists() {
                println!("Downloading assets/{}", name);

                fs::create_dir_all(object_path.parent().unwrap())
                    .await
                    .unwrap();

                let object_url = format!(
                    "https://resources.download.minecraft.net/{}",
                    hash[..2].to_string() + "/" + &hash
                );
                let download_task = async move {
                    try_download_file(&object_url, &object_path, &hash, 3).await?;

                    // Legacy assets
                    if self.version.profile["assets"].as_str().unwrap() == "legacy"
                        || self.version.profile["assets"].as_str().unwrap() == "pre-1.6"
                    {
                        let resources_path = self.game_dir.join("resources").join(name);
                        fs::create_dir_all(resources_path.parent().unwrap())
                            .await
                            .unwrap();
                        fs::copy(&object_path, &resources_path).await.unwrap();
                    }

                    Ok::<_, Box<dyn Error + Send>>(())
                };
                tasks.push(download_task);
            }
        }

        for task in tasks {
            task.await?;
        }

        Ok(())
    }
}