truegrf 2.1.0

TrueGRF YAML to GRF compiler
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

use super::{Action, ActionTrait, Output, vec_list, write_special};


pub struct ActionFName<'a> {
    pub probability: u8,
    pub name: &'a String,
}

pub struct ActionFId {
    pub probability: u8,
    pub id: u8,
}

pub enum ActionFNameOrId<'a> {
    Name(ActionFName<'a>),
    Id(ActionFId),
}

impl<'a> From<ActionFName<'a>> for ActionFNameOrId<'a> {
    fn from(item: ActionFName<'a>) -> Self {
        ActionFNameOrId::Name(item)
    }
}
impl From<ActionFId> for ActionFNameOrId<'_> {
    fn from(item: ActionFId) -> Self {
        ActionFNameOrId::Id(item)
    }
}

pub struct ActionFPart<'a> {
    pub firstbit: u8,
    pub bitcount: u8,

    pub names: Vec<ActionFNameOrId<'a>>
}

pub enum ActionF<'a> {
    Style { id: u8, name: Option<&'a String>, parts: &'a Vec<ActionFPart<'a>> },
}

impl<'a> ActionTrait for ActionF<'a> {
    fn write(&self, output: &mut Output) {
        match self {
            ActionF::Style { id, name, parts } => {
                let mut name_data = Vec::new();
                let id = match *name {
                    Some(name) => {
                        name_data.extend([0x7f]);
                        name_data.extend(&*name.as_bytes());
                        name_data.extend([0x00]);
                        name_data.extend([0x00]);
                        *id | 0x80
                    },
                    None => {
                        *id
                    }
                };

                let mut data = Vec::new();
                for part in *parts {
                    data.extend([
                        part.names.len() as u8,
                        part.firstbit,
                        part.bitcount,
                    ]);

                    for name in &part.names {
                        match name {
                            ActionFNameOrId::Name(item) => {
                                data.extend([item.probability]);
                                data.extend(&*item.name.as_bytes());
                                data.extend([0x00]);
                            },
                            ActionFNameOrId::Id(item) => {
                                data.extend([item.probability | 0x80]);
                                data.extend([item.id]);
                            },
                        }
                    }
                }

                write_special(output, Action::ActionF, &vec_list!(
                    [id],
                    name_data,
                    [parts.len() as u8],
                    data
                ));
            }
        }
    }
}