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

use anyhow::{Result, anyhow};
use winnow::{
    Parser,
    ascii::{dec_uint as U, space1},
    combinator::{alt, opt, preceded as P, separated_pair},
    stream::AsChar,
    token::{literal, take_while},
};

use super::types::*;
use crate::file_parsers::shared::{
    lift::{SliceParser, lift},
    winnow::{
        WinnowParser, filename, parse_bool, quoted, repeat_array, separated_array, unquoted,
        unquoted_str,
    },
};

fn name_hex<'a>() -> impl WinnowParser<&'a str, (String, Option<String>)> {
    let hex_parser = P(literal("#"), take_while(1.., AsChar::is_hex_digit)).map(String::from);

    winnow::trace!("name_hex", (unquoted_str, opt(P(space1, hex_parser))))
}

fn gt_files<'a>() -> impl SliceParser<'a, &'a str, [GTFile; 2]> {
    winnow::trace!(
        "gt_files",
        repeat_array(lift(
            alt((
                quoted('"'), //
                unquoted(),
            ))
            .and_then(alt((
                literal("wildcard").map(|_| GTFile::Wildcard),
                filename("gt").map(GTFile::Path),
            ))),
        ))
    )
}

fn num_line<'a>() -> impl WinnowParser<&'a str, NumLine> {
    winnow::trace!(
        "num_line",
        (
            U,
            P(space1, U),
            P(space1, parse_bool),
            opt(P(space1, parse_bool)),
            opt(P(space1, parse_bool)),
            opt(P(space1, parse_bool)),
        )
            .map(|(uint1, uint2, bool1, bool2, bool3, bool4)| NumLine {
                uint1,
                uint2,
                bool1,
                bool2,
                bool3,
                bool4,
            })
    )
}

fn virtual_et_file<'a>() -> impl WinnowParser<&'a str, VirtualETFile> {
    winnow::trace!(
        "virtual_et_file",
        separated_pair(
            unquoted().and_then(filename("et")), //
            space1,
            parse_bool,
        )
        .map(|(path, bool1)| VirtualETFile { path, bool1 })
    )
}

fn virtual_section<'a>() -> impl SliceParser<'a, &'a str, VirtualSection> {
    winnow::trace!(
        "virtual_section",
        (
            lift(literal("virtual")),
            repeat_array(lift(virtual_et_file())),
            lift(separated_array(space1, U)),
        )
            .map(
                |(_virtual_tag, virtual_et_files, virtual_rotations)| VirtualSection {
                    virtual_et_files,
                    virtual_rotations,
                },
            )
    )
}

pub fn parse_et_str(contents: &str) -> Result<ETFile> {
    let lines = contents
        .lines()
        .map(|l| l.trim())
        .filter(|l| !l.is_empty())
        .collect::<Vec<_>>();

    let mut parser = (
        lift(name_hex()),
        gt_files(),
        opt(lift(num_line())),
        opt(lift(unquoted().and_then(filename("gt")))),
        opt(virtual_section()),
    )
        .map(
            |((name, hex), gt_files, num_line, gt_file2, virtual_section)| ETFile {
                name,
                hex,
                gt_files,
                num_line,
                virtual_section,
                gt_file2,
            },
        );

    let et_file = parser
        .parse(&lines)
        .map_err(|e| anyhow!("Failed to parse file: {e:?}"))?;

    Ok(et_file)
}