halbu 0.3.0

Diablo II save file parsing library.
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

use halbu::{Save, Strictness};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Start from a known good file.
    let bytes = std::fs::read("assets/test/Joe.d2s")?;

    // Strict mode fails fast on invalid data.
    let strict = Save::parse(&bytes, Strictness::Strict)?;
    println!(
        "Strict parse OK: format={:?}, name={}",
        strict.save.format(),
        strict.save.character.name
    );

    // Validation is separate from parsing, so check the save on its own.
    let validation = strict.save.validate();
    println!("\nValidation issues: {}", validation.issues.len());
    for (index, issue) in validation.issues.iter().enumerate() {
        println!("#{index} [{:?}] {}", issue.code, issue.message);
    }

    // Break the payload on purpose so we can inspect non-fatal issues.
    // - byte 0 breaks signature
    // - truncation simulates a damaged or incomplete file
    let mut damaged = bytes.clone();
    damaged[0] = 0x00;
    damaged.truncate(220);

    // Lax mode keeps going and collects issues.
    let lax = Save::parse(&damaged, Strictness::Lax)?;
    println!("\nLax parse issues: {}", lax.issues.len());
    for (index, issue) in lax.issues.iter().enumerate() {
        println!(
            "#{index} [{:?}/{:?}] section={:?} offset={:?} expected={:?} found={:?}\n  {}",
            issue.severity,
            issue.kind,
            issue.section,
            issue.offset,
            issue.expected,
            issue.found,
            issue.message
        );
    }

    // Strict mode should reject the damaged payload.
    match Save::parse(&damaged, Strictness::Strict) {
        Ok(_) => println!("\nUnexpected: strict parse accepted damaged payload."),
        Err(error) => println!("\nStrict parse error: {error}"),
    }

    Ok(())
}