open_launcher 1.5.2

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
106
107
108
109
110
111
112
113
114
115
116

use crate::utils::{try_download_file, LauncherError};
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(&mut self) -> Result<(), Box<dyn Error + Send + Sync>> {
        if self.version.profile.is_null() {
            return Err(Box::from(LauncherError(
                "Please install a version before installing assets".to_string(),
            )));
        }

        self.emit_progress("checking_assets", "", 0, 0);

        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?;
        fs::create_dir_all(&objects_dir).await?;

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

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

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

        let mut readdir = fs::read_dir(&objects_dir).await?;
        while let Some(file) = readdir.next_entry().await? {
            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?)) != hash
                {
                    fs::remove_file(&path).await?;
                }
            }
        }

        let mut total: u64 = 0;
        let mut current: u64 = 0;
        let mut objects_to_download = vec![];

        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() {
                total += object["size"].as_u64().unwrap();
                objects_to_download.push({
                    let mut object = object.clone();
                    object.insert(
                        "name".to_string(),
                        serde_json::Value::String(name.to_string()),
                    );
                    object
                });
            }
        }

        if !objects_to_download.is_empty() {
            self.emit_progress("downloading_assets", "", total, 0);
        }

        for object in objects_to_download {
            let name = object["name"].as_str().unwrap();
            let hash = object["hash"].as_str().unwrap().to_string();
            let object_path = objects_dir.join(&hash[..2]).join(&hash);

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

            let object_url = format!(
                "https://resources.download.minecraft.net/{}",
                hash[..2].to_string() + "/" + &hash
            );

            try_download_file(&object_url, &object_path, &hash, 3).await?;

            current += object["size"].as_u64().unwrap();
            self.emit_progress("downloading_assets", name, total, current);

            // 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(object["name"].as_str().unwrap());
                fs::create_dir_all(resources_path.parent().unwrap()).await?;
                fs::copy(&object_path, &resources_path).await?;
            }
        }

        Ok(())
    }
}