bl4 0.8.5

Borderlands 4 save editor library - encryption, decryption, and parsing
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

use bl4::serial::Token;
use bl4::ItemSerial;
use std::io::{self, BufRead};

fn main() {
    let stdin = io::stdin();

    for line in stdin.lock().lines() {
        let line = line.unwrap();
        let serial = line.trim();
        if serial.is_empty() || !serial.starts_with("@Ug") {
            continue;
        }

        let Ok(item) = ItemSerial::decode(serial) else {
            println!("{}\tDECODE_FAILED", serial);
            continue;
        };

        // Full token stream
        let token_strs: Vec<String> = item
            .tokens
            .iter()
            .map(|t| match t {
                Token::Var {
                    val: v,
                    encoding: bl4::serial::VarEncoding::Int,
                } => format!("VI({})", v),
                Token::Var {
                    val: v,
                    encoding: bl4::serial::VarEncoding::Bit,
                } => format!("VB({})", v),
                Token::Separator => "SEP".to_string(),
                Token::SoftSeparator => "SOFT".to_string(),
                Token::Part { index, values, .. } => {
                    if values.is_empty() {
                        format!("P({})", index)
                    } else {
                        let vs: Vec<String> = values.iter().map(|v| v.to_string()).collect();
                        format!("P({}:{})", index, vs.join(","))
                    }
                }
                Token::String(s) => format!("S(len={})", s.len()),
            })
            .collect();

        // Extract all VarInts and VarBits in order
        let header_vals: Vec<String> = item
            .tokens
            .iter()
            .take_while(|t| !matches!(t, Token::Separator))
            .map(|t| match t {
                Token::Var {
                    val: v,
                    encoding: bl4::serial::VarEncoding::Int,
                } => format!("vi={}", v),
                Token::Var {
                    val: v,
                    encoding: bl4::serial::VarEncoding::Bit,
                } => format!("vb={}", v),
                Token::SoftSeparator => "soft".to_string(),
                _ => "?".to_string(),
            })
            .collect();

        println!(
            "{}\theader=[{}]\ttokens={}",
            serial,
            header_vals.join(", "),
            token_strs.join(" ")
        );
    }
}