late-java-core 2.2.9

A Rust library for launching Minecraft Java Edition
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

use late_java_core::{Launch, MicrosoftAuth, LaunchOptions, MemoryOptions, LoaderOptions, JavaOptions, ScreenOptions, init_logger};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    init_logger();
    
    println!("=== Late Java Core - Ejemplo Básico ===");
    
    // Crear autenticador Microsoft
    let auth = MicrosoftAuth::new("00000000402b5328".to_string());
    
    // En un ejemplo real, esto abriría una ventana de autenticación
    println!("Nota: En un ejemplo real, esto abriría la autenticación Microsoft");
    
    // Crear respuesta de autenticación simulada
    let auth_result = late_java_core::auth::AuthResponse {
        access_token: "simulated_token".to_string(),
        client_token: "simulated_client_token".to_string(),
        uuid: "simulated_uuid".to_string(),
        name: "TestUser".to_string(),
        refresh_token: Some("simulated_refresh_token".to_string()),
        user_properties: "{}".to_string(),
        meta: late_java_core::auth::AuthMeta {
            auth_type: "Xbox".to_string(),
            access_token_expires_in: chrono::Utc::now().timestamp() as u64 + 3600,
            demo: false,
        },
        xbox_account: None,
        profile: None,
    };
    
    // Configurar opciones de lanzamiento - 100% compatible con la API original de TypeScript
    let options = LaunchOptions {
        url: None,
        headers: None,
        token: None,
        authenticator: auth_result,
        timeout: Some(10000),
        path: ".Minecraft".to_string(),
        version: "1.20.4".to_string(),
        instance: None,
        detached: Some(false),
        download_file_multiple: Some(5),
        bypass_offline: Some(false),
        intel_enabled_mac: Some(false),
        loader: LoaderOptions {
            path: Some("./loader".to_string()),
            r#type: None,
            build: Some("latest".to_string()),
            enable: false,
        },
        mcp: None,
        verify: Some(false),
        ignored: vec![],
        jvm_args: vec![],
        game_args: vec![],
        java: JavaOptions {
            path: None,
            version: None,
            r#type: "jre".to_string(),
        },
        screen: ScreenOptions {
            width: None,
            height: None,
            fullscreen: None,
        },
        memory: MemoryOptions {
            min: Some("2G".to_string()),
            max: Some("4G".to_string()),
        },
    };
    
    // Crear launcher
    let mut launcher = Launch::new();
    let mut event_receiver = launcher.subscribe();
    
    // Escuchar eventos en un hilo separado
    let event_handle = tokio::spawn(async move {
        while let Ok(event) = event_receiver.recv().await {
            match event {
                late_java_core::LaunchEvent::Progress { downloaded, total, element } => {
                    let percentage = if total > 0 { (downloaded * 100) / total } else { 0 };
                    println!("Progreso: {}% - {}", percentage, element);
                }
                late_java_core::LaunchEvent::Data(data) => {
                    println!("Minecraft: {}", data);
                }
                late_java_core::LaunchEvent::Close(msg) => {
                    println!("{}", msg);
                    break;
                }
                late_java_core::LaunchEvent::Error(err) => {
                    println!("Error: {}", err);
                    break;
                }
                _ => {}
            }
        }
    });
    
    // Lanzar Minecraft
    println!("Lanzando Minecraft...");
    launcher.launch(options).await?;
    
    // Esperar a que termine el evento handler
    event_handle.abort();
    
    println!("¡Ejemplo completado!");
    Ok(())
}