mclr 3.1.4

run mc in 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

pub mod deserialize;
pub mod mc;
pub mod utils;

mod tests {
    use std::{fs, path::Path};

    use crate::{
        mc::{
            self, get_compatible_java,
            utils::command_builder::{
                CommandAssetsConfig, CommandRamConfig, CommandResourcesConfig, CommandUserConfig,
                RunType,
            },
        },
        utils::{HandleEvent, manifest::manifest},
    };

    #[test]
    fn main() {
        env_logger::init();

        if !Path::new("versions").exists() {
            fs::create_dir("versions").expect("Cannot create versions")
        }
        //CONSOLE_HISTORY.push("downloading...".to_string());
        let b = manifest();
        let versions = b.get("1.20.1").unwrap();

        if !Path::new(format!("versions/{}", versions.id).as_str()).exists() {
            fs::create_dir(format!("versions/{}", &versions.id))
                .expect("Cannot create versions dir")
        }
        let version = &versions
            .save_and_load(format!("versions/{}/{}.json", &versions.id, &versions.id).as_str());
        // json_version::load("versions/quilt-loader-0.26.3-1.21.1/quilt-loader-0.26.3-1.21.1.json");

        println!("{:?}", version);

        let java_home = get_compatible_java("dest", &version.java_version);
        // paths and parameters
        let jar_path = format!("versions/{}/{}.jar", &version.id, &version.id);
        let libs_path = format!("versions/{}/libraries", &version.id);
        let binary_path = format!("versions/{}/bin", &version.id);
        let libs = &version.clone().libraries;

        //while !mc::utils::libs_utils::verify(&*libs_path.clone(), json_version::load("versions/1.8.9/1.8.9.json").libraries) {
        mc::utils::libs_utils::find(
            &libs_path.clone(),
            binary_path.as_str(),
            &libs.clone(),
            HandleEvent::new(move |_| {
                //println!("{}", e.percent());
            }),
        )
        .expect("TODO: panic message")
        .start();

        //mc::utils::libs_utils::get_libs(&libs_path.clone(), binary_path.as_str(), &version.clone().libraries, HandleEvent::new(move |e| {}));
        //println!("{}", mc::utils::libs_utils::verify(&libs_path.clone(), libs.clone(), HandleEvent::new(move |e| {})));

        mc::download(&jar_path, &version);

        mc::utils::assets_utils::find(
            "assets",
            &version,
            HandleEvent::new(|_| {
                //println!("{}", e.percent())
            }),
        )
        .start();
        println!("{}", jar_path.as_str());
        
        if let Some(logg) = &version.clone().logging {
            mc::get_config_logger(logg, "assets/log/log4j.xml");
        }

        println!("Running");

        mc::utils::command_builder::Command {
            resources: CommandResourcesConfig {
                libraries: libs_path.clone().to_string(),
                jar_file: jar_path.to_string(),
                bin: binary_path.to_string(),
                logger: "assets/log/log4j.xml".to_string(),
            },
            java_home: java_home.to_string(),
            game_dir: ".min".to_string(),
            assets: CommandAssetsConfig {
                assets_dir: "assets/".to_string(),
                assets_index: version.assets.clone().to_string(),
            },
            user: CommandUserConfig {
                user_type: "user".to_string(),
                client_id: "0".to_string(),
                uuid: "d0db8a3d-c392-4ae7-96e5-9365de33ab52".to_string(),
                xuid: "0".to_string(),
                access_token: "0".to_string(),
                user_name: "tuser".to_string(),
            },
            version: version.command_conf(),
            ram: CommandRamConfig { xmx: 4, xms: 2 },
            event: |_s: String| {
                println!("{}", _s);
            },
            err_event: |e: String| {
                println!("{}", e);
            },
            args: vec![],
        }
        .run(RunType::SERVER("oblision.es".to_string()));
    }
}