wolfrpg_map_parser/command/common_event_command/
event.rs

1use crate::byte_utils::{as_u32_le, as_u32_vec, parse_string_vec};
2use crate::common::u32_or_string::U32OrString;
3use crate::command::common_event_command::argument_count::ArgumentCount;
4use crate::command::common_event_command::options::Options;
5#[cfg(feature = "serde")]
6use serde::{Serialize, Deserialize};
7use std::cmp::max;
8use std::collections::VecDeque;
9
10#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
11#[derive(PartialEq, Clone)]
12pub struct Event {
13    target: u32,
14    argument_count: ArgumentCount,
15    options: Options,
16    number_arguments: Vec<u32>,
17    string_arguments: Vec<U32OrString>,
18    return_variable: Option<u32>,
19    event_name: Option<String>,
20}
21
22impl Event {
23    pub(crate) fn parse(bytes: &[u8]) -> (usize, Self) {
24        let mut offset: usize = 0;
25
26        let target: u32 = as_u32_le(&bytes[offset..offset+4]);
27        offset += 4;
28
29        let argument_count: u8 = bytes[offset];
30        let argument_count: ArgumentCount = ArgumentCount::new(argument_count);
31        offset += 1;
32
33        let options: [u8; 3] = bytes[offset..offset+3].try_into().unwrap();
34        let options: Options = Options::new(options);
35        offset += 3;
36
37        let (bytes_read, number_arguments): (usize, Vec<u32>)
38            = Self::parse_u32_vec(bytes, offset, argument_count.number_arguments() as usize);
39        offset += bytes_read;
40
41        let (bytes_read, string_arguments_variables): (usize, Vec<u32>)
42            = Self::parse_u32_vec(bytes, offset, argument_count.string_arguments() as usize);
43        offset += bytes_read;
44
45        let return_variable: Option<u32> = if options.has_return_value() {
46            let ret: u32 = as_u32_le(&bytes[offset..offset+4]);
47            offset += 4;
48
49            Some(ret)
50        } else {
51            None
52        };
53
54        offset += 1; // padding
55
56        let string_count: u8 = bytes[offset];
57        offset += 1;
58
59        let (bytes_read, strings): (usize, Vec<String>)
60            = parse_string_vec(&bytes[offset..], string_count as usize);
61        offset += bytes_read;
62
63        let (event_name, string_arguments): (Option<String>, Vec<U32OrString>)
64            = Self::convert_strings(string_arguments_variables, strings,
65                                    argument_count.string_arguments() as usize, &options);
66
67        offset += 1;
68
69        (offset, Self {
70            target,
71            argument_count,
72            options,
73            number_arguments,
74            string_arguments,
75            return_variable,
76            event_name,
77        })
78    }
79
80    fn parse_u32_vec(bytes: &[u8], offset: usize, count: usize) -> (usize, Vec<u32>) {
81        (count*4, as_u32_vec(&bytes[offset..offset + count*4]))
82    }
83
84    fn convert_strings(variables: Vec<u32>, strings: Vec<String>, count: usize, options: &Options)
85        -> (Option<String>, Vec<U32OrString>) {
86        let mut count: usize = max(count, strings.len());
87        let mut string_arguments: Vec<U32OrString> = Vec::with_capacity(count);
88        let mut strings: VecDeque<String> = strings.into_iter().collect();
89
90        let event_name: Option<String> = if options.string_argument_count() < count as u8 {
91            count -= 1;
92            strings.pop_front()
93        } else {
94            None
95        };
96
97        for i in 0..count.max(variables.len()) {
98            let arg: U32OrString = if options.is_arg_string((i+1) as u8) {
99                U32OrString::String(strings[i].clone())
100            } else {
101                U32OrString::U32(variables[i])
102            };
103
104            string_arguments.push(arg);
105        }
106
107        (event_name, string_arguments)
108    }
109
110    pub fn target(&self) -> u32 {
111        self.target
112    }
113
114    pub fn target_mut(&mut self) -> &mut u32 {
115        &mut self.target
116    }
117
118    pub fn argument_count(&self) -> &ArgumentCount {
119        &self.argument_count
120    }
121
122    pub fn argument_count_mut(&mut self) -> &mut ArgumentCount {
123        &mut self.argument_count
124    }
125
126    pub fn options(&self) -> &Options {
127        &self.options
128    }
129
130    pub fn options_mut(&mut self) -> &mut Options {
131        &mut self.options
132    }
133
134    pub fn number_arguments(&self) -> &Vec<u32> {
135        &self.number_arguments
136    }
137
138    pub fn number_arguments_mut(&mut self) -> &mut Vec<u32> {
139        &mut self.number_arguments
140    }
141
142    pub fn string_arguments(&self) -> &Vec<U32OrString> {
143        &self.string_arguments
144    }
145
146    pub fn string_arguments_mut(&mut self) -> &mut Vec<U32OrString> {
147        &mut self.string_arguments
148    }
149
150    pub fn return_variable(&self) -> Option<u32> {
151        self.return_variable
152    }
153
154    pub fn return_variable_mut(&mut self) -> &mut Option<u32> {
155        &mut self.return_variable
156    }
157
158    pub fn event_name(&self) -> &Option<String> {
159        &self.event_name
160    }
161
162    pub fn event_name_mut(&mut self) -> &mut Option<String> {
163        &mut self.event_name
164    }
165}
wolfrpg_map_parser/command/common_event_command/event.rs

wolfrpg_map_parser/command/common_event_command/
event.rs
