poe_data_tools 1.0.0

A library for working with Path of Exile game data
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
114
115
116

use std::fmt::Display;

use anyhow::{Result, anyhow};
use winnow::{
    Parser,
    binary::{le_u32, le_u64},
    combinator::{repeat, seq},
    token::take,
};

use super::types::*;
use crate::file_parsers::shared::winnow::WinnowParser;

#[derive(Debug)]
enum BundleError {
    InvalidEncoding(u32),
}
impl Display for BundleError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            BundleError::InvalidEncoding(x) => write!(f, "Invalid encoding identifier: {x}"),
        }
    }
}

impl std::error::Error for BundleError {}

fn first_file_encode<'a>() -> impl WinnowParser<&'a [u8], FirstFileEncode> {
    winnow::trace!(
        "first_file_encode",
        le_u32.try_map(|x| {
            use FirstFileEncode::*;
            let ffe = match x {
                8 => Kraken6,
                9 => MermaidA,
                12 => Bitknit,
                13 => LeviathanC,
                x => {
                    return Err(BundleError::InvalidEncoding(x));
                }
            };

            Ok(ffe)
        })
    )
}

fn head_payload<'a>() -> impl WinnowParser<&'a [u8], (HeadPayload, u32)> {
    winnow::trace!(
        "head_payload",
        seq!((
            _: take(12_usize),
            first_file_encode(),
            _: take(4_usize),
            le_u64,
            le_u64,
            le_u32,
            le_u32,
            _: take(16_usize),
        ))
        .map(
            |(
                first_file_encode,
                uncompressed_size,
                total_payload_size,
                block_count,
                uncompressed_block_granularity,
            )| {
                let head_payload = HeadPayload {
                    first_file_encode,
                    uncompressed_size,
                    total_payload_size,
                    uncompressed_block_granularity,
                };

                (head_payload, block_count)
            },
        )
    )
}

fn blocks<'a>(block_count: u32) -> impl WinnowParser<&'a [u8], Vec<Vec<u8>>> {
    let parser = move |input: &mut &[u8]| -> winnow::Result<_> {
        let block_sizes: Vec<_> = repeat(block_count as usize, le_u32).parse_next(input)?;

        let mut blocks = vec![];
        for size in block_sizes {
            let block = take(size).parse_next(input)?;
            blocks.push(block.to_vec());
        }

        Ok(blocks)
    };

    winnow::trace!("blocks", parser)
}

pub fn bundle<'a>() -> impl WinnowParser<&'a [u8], BundleFile> {
    let parser = |input: &mut &[u8]| {
        let (head, block_count) = head_payload().parse_next(input)?;

        let blocks = blocks(block_count).parse_next(input)?;

        let bundle = BundleFile { head, blocks };

        Ok(bundle)
    };

    winnow::trace!("bundle", parser)
}

pub fn parse_bundle_bytes(contents: &[u8]) -> Result<BundleFile> {
    bundle()
        .parse(contents)
        .map_err(|e| anyhow!("Failed to parse file: {e:?}"))
}