late-java-core 2.2.9

# Late Java Core - Rust


Una librería Rust para lanzar Minecraft Java Edition con soporte completo para mod loaders, autenticación Microsoft/Mojang/AZauth, y descarga automática de archivos.

## Características


- ✅ **Autenticación completa**: Microsoft, Mojang (legacy), y AZauth
- ✅ **Soporte para mod loaders**: Forge, NeoForge, Fabric, Legacy Fabric, Quilt
- ✅ **Descarga automática**: Java, librerías, assets, y archivos del juego
- ✅ **Verificación de integridad**: SHA-1 y SHA-256
- ✅ **Descarga concurrente**: Múltiples archivos simultáneamente
- ✅ **Soporte multiplataforma**: Windows, macOS, Linux
- ✅ **API asíncrona**: Basada en Tokio
- ✅ **Manejo de errores robusto**: Con tipos de error específicos

## Instalación


Agrega la siguiente línea a tu `Cargo.toml`:

```toml
[dependencies]
late-java-core = "2.2.9"
tokio = { version = "1.0", features = ["full"] }
```

## Uso Básico


```rust
use late_java_core::{Launch, MicrosoftAuth, LaunchOptions, MemoryOptions, init_logger};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    init_logger();

    // Autenticación Microsoft
    let auth = MicrosoftAuth::new("00000000402b5328".to_string());
    let auth_result = auth.authenticate().await?;
    
    // Configuración del launcher
    let options = LaunchOptions {
        path: "./minecraft".to_string(),
        version: "1.20.4".to_string(),
        authenticator: auth_result,
        memory: MemoryOptions {
            min: "2G".to_string(),
            max: "4G".to_string(),
        },
        ..Default::default()
    };
    
    // Lanzar Minecraft
    let launcher = Launch::new();
    launcher.launch(options).await?;
    
    Ok(())
}
```

## Autenticación


### Microsoft (Recomendado)


```rust
use late_java_core::MicrosoftAuth;

let auth = MicrosoftAuth::new("00000000402b5328".to_string());
let result = auth.authenticate().await?;

// Refrescar token si es necesario
let refreshed = auth.refresh(result).await?;
```

### Mojang (Legacy)


```rust
use late_java_core::MojangAuth;

let auth = MojangAuth::new();
let result = auth.authenticate("usuario", "contraseña").await?;

// Validar token
let is_valid = auth.validate(&result.access_token, &result.client_token).await?;
```

### AZauth (Servidor Personalizado)


```rust
use late_java_core::{AZauthAuth, AZauthUser};

let auth = AZauthAuth::new("https://authserver.example.com".to_string());

// Login básico
let result = auth.authenticate("usuario", "contraseña").await?;

// Login con 2FA
let result = auth.login("usuario@ejemplo.com", "contraseña", None).await?;
if let Some(true) = result.a2f {
    // Usuario necesita ingresar código 2FA
    let result = auth.login("usuario@ejemplo.com", "contraseña", Some("123456")).await?;
}

// Verificar sesión
let verified = auth.verify(&result).await?;

// Cerrar sesión
let signed_out = auth.signout(&result).await?;
```

## Configuración Avanzada


```rust
use late_java_core::{LaunchOptions, LoaderOptions, ScreenOptions, JavaOptions};
use std::collections::HashMap;

let mut custom_headers = HashMap::new();
custom_headers.insert("User-Agent".to_string(), "MiLauncher/1.0".to_string());

let options = LaunchOptions {
    // Configuración básica
    path: "./minecraft".to_string(),
    version: "1.20.4".to_string(),
    authenticator: auth_result,
    
    // Configuración de red
    url: Some("https://launchermeta.mojang.com".to_string()),
    headers: Some(custom_headers),
    timeout: Some(30000),
    
    // Configuración de instancia
    instance: Some("modded".to_string()),
    detached: Some(false),
    download_file_multiple: Some(10),
    bypass_offline: Some(false),
    
    // Configuración de memoria
    memory: MemoryOptions {
        min: "4G".to_string(),
        max: "8G".to_string(),
    },
    
    // Configuración de pantalla
    screen: ScreenOptions {
        width: Some(1920),
        height: Some(1080),
        fullscreen: false,
    },
    
    // Configuración de Java
    java: JavaOptions {
        path: None, // Usar Java del sistema
        version: Some("17".to_string()),
        java_type: "jre".to_string(),
    },
    
    // Configuración del loader
    loader: LoaderOptions {
        path: Some("./loader".to_string()),
        loader_type: Some("fabric".to_string()),
        build: Some("0.15.9".to_string()),
        enable: true,
    },
    
    // Verificación de archivos
    verify: Some(true),
    ignored: vec!["saves".to_string(), "screenshots".to_string()],
    
    // Argumentos personalizados
    jvm_args: vec![
        "-XX:+UseG1GC".to_string(),
        "-XX:+ParallelRefProcEnabled".to_string(),
    ],
    game_args: vec![
        "--quickPlaySingleplayer".to_string(),
        "world_name".to_string(),
    ],
    
    ..Default::default()
};
```

## Mod Loaders Soportados


### Fabric


```rust
let options = LaunchOptions {
    // ... otras opciones
    loader: LoaderOptions {
        loader_type: Some("fabric".to_string()),
        build: Some("0.15.9".to_string()),
        enable: true,
        ..Default::default()
    },
    ..Default::default()
};
```

### Forge


```rust
let options = LaunchOptions {
    // ... otras opciones
    loader: LoaderOptions {
        loader_type: Some("forge".to_string()),
        build: Some("41.0.63".to_string()),
        enable: true,
        ..Default::default()
    },
    ..Default::default()
};
```

### NeoForge


```rust
let options = LaunchOptions {
    // ... otras opciones
    loader: LoaderOptions {
        loader_type: Some("neoforge".to_string()),
        build: Some("20.1.0-beta".to_string()),
        enable: true,
        ..Default::default()
    },
    ..Default::default()
};
```

### Quilt


```rust
let options = LaunchOptions {
    // ... otras opciones
    loader: LoaderOptions {
        loader_type: Some("quilt".to_string()),
        build: Some("0.20.0".to_string()),
        enable: true,
        ..Default::default()
    },
    ..Default::default()
};
```

## Obtener Versiones Disponibles


```rust
use late_java_core::VersionManifest;

let manifest = VersionManifest::fetch().await?;
println!("Última release: {}", manifest.latest.release);
println!("Última snapshot: {}", manifest.latest.snapshot);

for version in &manifest.versions[..5] {
    println!("Versión: {} ({})", version.id, version.r#type);
}
```

## Descarga de Archivos


```rust
use late_java_core::{Downloader, DownloadOptions};
use std::collections::HashMap;

let mut headers = HashMap::new();
headers.insert("User-Agent".to_string(), "MiApp/1.0".to_string());

let downloader = Downloader::with_headers(headers);

// Descargar un archivo único
downloader.download_file(
    "https://example.com/file.jar",
    "./downloads",
    "file.jar"
).await?;

// Descargar múltiples archivos
let files = vec![
    DownloadOptions {
        url: "https://example.com/file1.jar".to_string(),
        path: "./downloads/file1.jar".to_string(),
        folder: "./downloads".to_string(),
        length: Some(1024),
        r#type: Some("Library".to_string()),
    },
    // ... más archivos
];

downloader.download_file_multiple(&files, 2048, 5, 10000).await?;
```

## Manejo de Errores


```rust
use late_java_core::{LateJavaCoreError, Result};

async fn launch_minecraft() -> Result<()> {
    match launcher.launch(options).await {
        Ok(_) => println!("Minecraft lanzado exitosamente"),
        Err(LateJavaCoreError::Auth(msg)) => {
            eprintln!("Error de autenticación: {}", msg);
        }
        Err(LateJavaCoreError::Network(err)) => {
            eprintln!("Error de red: {}", err);
        }
        Err(LateJavaCoreError::Minecraft(msg)) => {
            eprintln!("Error de Minecraft: {}", msg);
        }
        Err(err) => {
            eprintln!("Error inesperado: {}", err);
        }
    }
    Ok(())
}
```

## Ejemplos


El proyecto incluye varios ejemplos en la carpeta `examples/`:

- `basic_launcher.rs` - Ejemplo básico de uso
- `advanced_launcher.rs` - Configuración avanzada
- `complete_example.rs` - Ejemplo completo con todas las funcionalidades
- `complete_azauth_example.rs` - Ejemplo completo con AZauth y 2FA

Para ejecutar los ejemplos:

```bash
cargo run --example basic_launcher
cargo run --example advanced_launcher
cargo run --example complete_example
cargo run --example complete_azauth_example
```

## Ping de Servidores


```rust
use late_java_core::{StatusClient, ping_server};

// Hacer ping a un servidor
let result = ping_server("mc.hypixel.net", 25565).await?;
println!("Servidor: {}", result.server_info.description.text);
println!("Jugadores: {}/{}", result.server_info.players.online, result.server_info.players.max);
println!("Latencia: {}ms", result.latency);
```

## Eventos del Launcher


```rust
use late_java_core::{Launch, LaunchEvent};

let mut launcher = Launch::new();
let mut event_receiver = launcher.subscribe();

// Escuchar eventos
while let Ok(event) = event_receiver.recv().await {
    match event {
        LaunchEvent::Progress { downloaded, total, element } => {
            let percentage = (downloaded * 100) / total;
            println!("Progreso: {}% - {:?}", percentage, element);
        }
        LaunchEvent::Speed(speed) => {
            println!("Velocidad: {:.2} KB/s", speed / 1024.0);
        }
        LaunchEvent::Data(data) => {
            println!("Minecraft: {}", data);
        }
        LaunchEvent::Close(msg) => {
            println!("{}", msg);
            break;
        }
        LaunchEvent::Error(err) => {
            println!("Error: {}", err);
            break;
        }
        _ => {}
    }
}
```

## API Completa


### Autenticación


- `MicrosoftAuth` - Autenticación Microsoft OAuth2
- `MojangAuth` - Autenticación Mojang legacy
- `AZauthAuth` - Autenticación AZauth personalizada

### Launcher


- `Launch` - Clase principal del launcher
- `LaunchOptions` - Opciones de configuración
- `LoaderOptions` - Configuración de mod loaders
- `MemoryOptions` - Configuración de memoria
- `ScreenOptions` - Configuración de pantalla
- `JavaOptions` - Configuración de Java

### Minecraft


- `VersionManifest` - Manifest de versiones
- `VersionInfo` - Información de versión
- `MinecraftArguments` - Constructor de argumentos
- `MinecraftAssets` - Manejo de assets
- `MinecraftLibraries` - Manejo de librerías
- `JavaDownloader` - Descarga de Java

### Utilidades


- `Downloader` - Descargador de archivos
- `Unzipper` - Descompresor de archivos
- Funciones de utilidad para hashing, validación, etc.

## Requisitos del Sistema


- Rust 1.70+
- Tokio runtime
- Conexión a internet para descargas
- Java 8+ (se descarga automáticamente si no está disponible)

## Licencia


Creative Commons Attribution-NonCommercial 4.0 International

## Contribuciones


Las contribuciones son bienvenidas. Por favor, abre un issue o pull request en el repositorio.

## Soporte


Para soporte y preguntas:
- Abre un issue en GitHub
- Únete al Discord de la comunidad
- Revisa la documentación completa

---

**Nota**: Esta es una migración completa de la librería TypeScript original a Rust, manteniendo toda la funcionalidad y agregando mejoras de rendimiento y seguridad.