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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use anyhow::anyhow;
use winnow::{
    Parser,
    ascii::{dec_uint, float, space1},
    combinator::{
        alt, delimited, dispatch, empty, eof, opt, preceded as P, repeat, separated_pair,
        terminated,
    },
    token::{literal, rest},
};

use super::types::*;
use crate::file_parsers::{
    VersionedResult, VersionedResultExt,
    shared::{
        lift::{SliceParser, lift},
        winnow::{WinnowParser, filename, parse_bool, quoted, unquoted, version_line},
    },
};

fn headers_v2<'a>() -> impl WinnowParser<&'a str, HeadersV2> {
    winnow::trace!(
        "headers_v2",
        (
            float, //
            P(space1, float),
            P(space1, parse_bool),
            P(space1, parse_bool),
            opt(P(space1, dec_uint)),
            opt(P(space1, dec_uint)),
            opt(P(space1, dec_uint)),
            opt(P(space1, float)),
            opt(P(space1, dec_uint)),
            opt(P(space1, float)),
        )
            .map(
                |(
                    scale_min,
                    scale_max,
                    allow_waving,
                    allow_on_blocking,
                    max_rotation,
                    uint1,
                    uint2,
                    float1,
                    audio_type,
                    float2,
                )| HeadersV2 {
                    scale_min,
                    scale_max,
                    allow_waving,
                    allow_on_blocking,
                    max_rotation,
                    uint1,
                    uint2,
                    float1,
                    audio_type,
                    float2,
                },
            )
    )
}

fn headers_v3<'a>() -> impl SliceParser<'a, &'a str, HeadersV3> {
    winnow::trace!("headers_v3", repeat(
        0..,
        lift(P(
            (literal('-'), space1),
            dispatch! {
                terminated(unquoted(), opt(space1));
                "RandomScale" => separated_pair(float, space1, float).map(|(min, max)| Header::RandomScale { min, max }),
                "AllowWaving" => eof.value(Header::AllowWaving),
                "AllowOnBlocking" => eof.value(Header::AllowOnBlocking),
                "MaxRotation" => dec_uint.map(Header::MaxRotation),
                "MinEdgeScale" => float.map(Header::MinEdgeScale),
                "AudioType" => dec_uint.map(Header::AudioType),
                "DelayMultiplier" => float.map(Header::DelayMultiplier),
                "TimeMultiplier" => float.map(Header::TimeMultiplier),
                "SizeMultiplier" => float.map(Header::SizeMultiplier),
                "Seed" => dec_uint.map(Header::Seed),
                key => rest.map(move |rest: &str| Header::Other { key: key.to_string(), rest: rest.to_string() }),
            },
        )),
    )
    .map(HeadersV3))
}

fn entry<'a>() -> impl WinnowParser<&'a str, Entry> {
    winnow::trace!(
        "entry",
        (
            quoted('"').and_then(filename("fmt")), //
            P(space1, float),
            repeat(
                0..,
                P(
                    space1,
                    alt((
                        delimited(
                            literal('('),
                            separated_pair(float, literal(','), float),
                            literal(')'),
                        ),
                        delimited(
                            literal('['),
                            separated_pair(float, space1, float),
                            literal(']'),
                        ),
                    )),
                ),
            ),
        )
            .map(|(fmt_file, float, points)| Entry {
                fmt_file,
                float,
                points,
            })
    )
}

pub fn parse_dlp_str(contents: &str) -> VersionedResult<DLPFile> {
    let lines = contents
        .lines()
        .map(|l| l.trim())
        .filter(|l| !l.is_empty())
        .collect::<Vec<_>>();
    let mut lines = lines.as_slice();

    let version = opt(lift(version_line()))
        .parse_next(&mut lines)
        .map_err(|e| anyhow!("Failed to parse file: {e:?}"))?;

    let mut parser = (
        dispatch! {
            empty.value(version.unwrap_or(0));
            ..3 => lift(headers_v2()).map(Headers::V2),
            3.. => headers_v3().map(Headers::V3),
        },
        repeat(0.., lift(entry())),
    )
        .map(|(headers, entries)| DLPFile {
            version,
            headers,
            entries,
        });

    parser
        .parse(lines)
        .map_err(|e| anyhow!("Failed to parse file: {e:?}"))
        .with_version(version)
}