vault 11.0.1

A parser for Company of Heroes replay files.
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

use crate::{
    command_type::CommandType,
    data::{ParserResult, Span},
};
use nom::{
    bytes::complete::take,
    combinator::{flat_map, map, peek, rest},
    multi::length_value,
    number::complete::{le_u16, le_u32, le_u8},
    sequence::tuple,
};

#[derive(Debug, Copy, Clone)]
pub enum CommandData {
    Empty,
    Pbgid(u32),
    SourcedPbgid(u32, u16),
    Sourced(u16),
    SourcedIndex(u16, u32),
    Unknown,
}

impl CommandData {
    pub fn parse_empty(input: Span) -> ParserResult<CommandData> {
        map(rest, |_| CommandData::Empty)(input)
    }

    pub fn parse_pbgid(input: Span) -> ParserResult<CommandData> {
        map(tuple((take(27u32), le_u32)), |(_, pbgid)| {
            CommandData::Pbgid(pbgid)
        })(input)
    }

    pub fn parse_sourced_pbgid(input: Span) -> ParserResult<CommandData> {
        map(
            tuple((take(22u32), le_u16, take(3u32), le_u32)),
            |(_, source_identifier, _, pbgid)| CommandData::SourcedPbgid(pbgid, source_identifier),
        )(input)
    }

    pub fn parse_sourced(input: Span) -> ParserResult<CommandData> {
        map(tuple((take(22u32), le_u16)), |(_, source_identifier)| {
            CommandData::Sourced(source_identifier)
        })(input)
    }

    pub fn parse_sourced_index(input: Span) -> ParserResult<CommandData> {
        map(
            tuple((take(22u32), le_u16, take(2u32), le_u32)),
            |(_, source_identifier, _, queue_index)| {
                CommandData::SourcedIndex(source_identifier, queue_index)
            },
        )(input)
    }

    pub fn parse_unknown(input: Span) -> ParserResult<CommandData> {
        map(rest, |_| CommandData::Unknown)(input)
    }

    pub fn parser_for_type(
        command_type: CommandType,
    ) -> impl FnMut(Span) -> ParserResult<CommandData> {
        match command_type {
            CommandType::PCMD_AIPlayer => Self::parse_empty,
            CommandType::PCMD_Ability
            | CommandType::PCMD_InstantUpgrade
            | CommandType::PCMD_TentativeUpgrade => Self::parse_pbgid,
            CommandType::CMD_BuildSquad | CommandType::CMD_Ability | CommandType::CMD_Upgrade => {
                Self::parse_sourced_pbgid
            }
            CommandType::CMD_CancelConstruction => Self::parse_sourced,
            CommandType::CMD_CancelProduction => Self::parse_sourced_index,
            _ => Self::parse_unknown,
        }
    }
}

#[derive(Debug, Clone)]
pub struct Command {
    pub action_type: CommandType,
    pub player_id: u8,
    pub index: u32,
    pub data: CommandData,
    #[cfg(feature = "raw")]
    pub bytes: Vec<u8>,
}

impl Command {
    pub fn parse(input: Span) -> ParserResult<Command> {
        map(
            length_value(
                peek(le_u16),
                tuple((le_u16, flat_map(CommandType::parse, Self::parse_type))),
            ),
            |(_length, command)| command,
        )(input)
    }

    #[cfg(not(feature = "raw"))]
    fn parse_type(action_type: CommandType) -> impl FnMut(Span) -> ParserResult<Command> {
        move |input: Span| {
            map(
                tuple((le_u8, le_u32, CommandData::parser_for_type(action_type))),
                |(player_id, index, data)| Command {
                    action_type,
                    player_id: player_id & 0b0111_1111, // bit mask to turn eg 0x87 into 0x7
                    index,
                    data,
                },
            )(input)
        }
    }

    #[cfg(feature = "raw")]
    fn parse_type(action_type: CommandType) -> impl FnMut(Span) -> ParserResult<Command> {
        use nom::{combinator::eof, multi::many_till};

        move |input: Span| {
            map(
                tuple((
                    peek(many_till(le_u8, eof)),
                    le_u8,
                    le_u32,
                    CommandData::parser_for_type(action_type),
                )),
                |((bytes, _), player_id, index, data)| Command {
                    action_type,
                    player_id: player_id & 0b0111_1111, // bit mask to turn eg 0x87 into 0x7,
                    index,
                    data,
                    bytes,
                },
            )(input)
        }
    }
}