rpgmxp_types/
event_page_condition.rs

Help
1use ruby_marshal::FromValue;
2use ruby_marshal::FromValueContext;
3use ruby_marshal::FromValueError;
4use ruby_marshal::IntoValue;
5use ruby_marshal::IntoValueError;
6use ruby_marshal::ObjectValue;
7use ruby_marshal::StringValue;
8use ruby_marshal::SymbolValue;
9use ruby_marshal::Value;
10use ruby_marshal::ValueArena;
11use ruby_marshal::ValueHandle;
12
13const OBJECT_NAME: &[u8] = b"RPG::Event::Page::Condition";
14
15const SWITCH2_VALID_FIELD: &[u8] = b"@switch2_valid";
16const SELF_SWITCH_CH_FIELD: &[u8] = b"@self_switch_ch";
17const SWITCH1_ID_FIELD: &[u8] = b"@switch1_id";
18const SWITCH1_VALID_FIELD: &[u8] = b"@switch1_valid";
19const VARIABLE_VALUE_FIELD: &[u8] = b"@variable_value";
20const SELF_SWITCH_VALID_FIELD: &[u8] = b"@self_switch_valid";
21const VARIABLE_ID_FIELD: &[u8] = b"@variable_id";
22const VARIABLE_VALID_FIELD: &[u8] = b"@variable_valid";
23const SWITCH2_ID_FIELD: &[u8] = b"@switch2_id";
24
25#[derive(Debug, serde::Deserialize, serde::Serialize)]
26pub struct EventPageCondition {
27    pub switch2_valid: bool,
28    pub self_switch_ch: String,
29    pub switch1_id: i32,
30    pub switch1_valid: bool,
31    pub variable_value: i32,
32    pub self_switch_valid: bool,
33    pub variable_id: i32,
34    pub variable_valid: bool,
35    pub switch2_id: i32,
36}
37
38impl<'a> FromValue<'a> for EventPageCondition {
39    fn from_value(ctx: &FromValueContext<'a>, value: &Value) -> Result<Self, FromValueError> {
40        let object: &ObjectValue = FromValue::from_value(ctx, value)?;
41        let name = object.name();
42        let name: &SymbolValue = ctx.from_value(name.into())?;
43        let name = name.value();
44        if name != OBJECT_NAME {
45            return Err(FromValueError::UnexpectedObjectName { name: name.into() });
46        }
47
48        let instance_variables = object.instance_variables();
49
50        let mut switch2_valid_field = None;
51        let mut self_switch_ch_field = None;
52        let mut switch1_id_field = None;
53        let mut switch1_valid_field = None;
54        let mut variable_value_field = None;
55        let mut self_switch_valid_field = None;
56        let mut variable_id_field = None;
57        let mut variable_valid_field = None;
58        let mut switch2_id_field = None;
59
60        for (key, value) in instance_variables.iter().copied() {
61            let key: &SymbolValue = ctx.from_value(key.into())?;
62            let key = key.value();
63
64            match key {
65                SWITCH2_VALID_FIELD => {
66                    if switch2_valid_field.is_some() {
67                        return Err(FromValueError::DuplicateInstanceVariable {
68                            name: SWITCH2_VALID_FIELD.into(),
69                        });
70                    }
71
72                    switch2_valid_field = Some(ctx.from_value(value)?);
73                }
74                SELF_SWITCH_CH_FIELD => {
75                    if self_switch_ch_field.is_some() {
76                        return Err(FromValueError::DuplicateInstanceVariable {
77                            name: SELF_SWITCH_CH_FIELD.into(),
78                        });
79                    }
80
81                    let value: &StringValue = ctx.from_value(value)?;
82                    self_switch_ch_field = Some(
83                        std::str::from_utf8(value.value())
84                            .map_err(FromValueError::new_other)?
85                            .into(),
86                    );
87                }
88                SWITCH1_ID_FIELD => {
89                    if switch1_id_field.is_some() {
90                        return Err(FromValueError::DuplicateInstanceVariable {
91                            name: SWITCH1_ID_FIELD.into(),
92                        });
93                    }
94
95                    switch1_id_field = Some(ctx.from_value(value)?);
96                }
97                SWITCH1_VALID_FIELD => {
98                    if switch1_valid_field.is_some() {
99                        return Err(FromValueError::DuplicateInstanceVariable {
100                            name: SWITCH1_VALID_FIELD.into(),
101                        });
102                    }
103
104                    switch1_valid_field = Some(ctx.from_value(value)?);
105                }
106                VARIABLE_VALUE_FIELD => {
107                    if variable_value_field.is_some() {
108                        return Err(FromValueError::DuplicateInstanceVariable {
109                            name: VARIABLE_VALUE_FIELD.into(),
110                        });
111                    }
112
113                    variable_value_field = Some(ctx.from_value(value)?);
114                }
115                SELF_SWITCH_VALID_FIELD => {
116                    if self_switch_valid_field.is_some() {
117                        return Err(FromValueError::DuplicateInstanceVariable {
118                            name: SELF_SWITCH_VALID_FIELD.into(),
119                        });
120                    }
121
122                    self_switch_valid_field = Some(ctx.from_value(value)?);
123                }
124                VARIABLE_ID_FIELD => {
125                    if variable_id_field.is_some() {
126                        return Err(FromValueError::DuplicateInstanceVariable {
127                            name: VARIABLE_ID_FIELD.into(),
128                        });
129                    }
130
131                    variable_id_field = Some(ctx.from_value(value)?);
132                }
133                VARIABLE_VALID_FIELD => {
134                    if variable_valid_field.is_some() {
135                        return Err(FromValueError::DuplicateInstanceVariable {
136                            name: VARIABLE_VALID_FIELD.into(),
137                        });
138                    }
139
140                    variable_valid_field = Some(ctx.from_value(value)?);
141                }
142                SWITCH2_ID_FIELD => {
143                    if switch2_id_field.is_some() {
144                        return Err(FromValueError::DuplicateInstanceVariable {
145                            name: SWITCH2_ID_FIELD.into(),
146                        });
147                    }
148
149                    switch2_id_field = Some(ctx.from_value(value)?);
150                }
151                _ => {
152                    return Err(FromValueError::UnknownInstanceVariable { name: key.into() });
153                }
154            }
155        }
156
157        let switch2_valid =
158            switch2_valid_field.ok_or_else(|| FromValueError::MissingInstanceVariable {
159                name: SWITCH2_VALID_FIELD.into(),
160            })?;
161        let self_switch_ch =
162            self_switch_ch_field.ok_or_else(|| FromValueError::MissingInstanceVariable {
163                name: SELF_SWITCH_CH_FIELD.into(),
164            })?;
165        let switch1_id =
166            switch1_id_field.ok_or_else(|| FromValueError::MissingInstanceVariable {
167                name: SWITCH1_ID_FIELD.into(),
168            })?;
169        let switch1_valid =
170            switch1_valid_field.ok_or_else(|| FromValueError::MissingInstanceVariable {
171                name: SWITCH1_VALID_FIELD.into(),
172            })?;
173        let variable_value =
174            variable_value_field.ok_or_else(|| FromValueError::MissingInstanceVariable {
175                name: VARIABLE_VALUE_FIELD.into(),
176            })?;
177        let self_switch_valid =
178            self_switch_valid_field.ok_or_else(|| FromValueError::MissingInstanceVariable {
179                name: SELF_SWITCH_VALID_FIELD.into(),
180            })?;
181        let variable_id =
182            variable_id_field.ok_or_else(|| FromValueError::MissingInstanceVariable {
183                name: VARIABLE_ID_FIELD.into(),
184            })?;
185        let variable_valid =
186            variable_valid_field.ok_or_else(|| FromValueError::MissingInstanceVariable {
187                name: VARIABLE_VALID_FIELD.into(),
188            })?;
189        let switch2_id =
190            switch2_id_field.ok_or_else(|| FromValueError::MissingInstanceVariable {
191                name: SWITCH2_ID_FIELD.into(),
192            })?;
193
194        Ok(Self {
195            switch2_valid,
196            self_switch_ch,
197            switch1_id,
198            switch1_valid,
199            variable_value,
200            self_switch_valid,
201            variable_id,
202            variable_valid,
203            switch2_id,
204        })
205    }
206}
207
208impl IntoValue for EventPageCondition {
209    fn into_value(self, arena: &mut ValueArena) -> Result<ValueHandle, IntoValueError> {
210        let object_name = arena.create_symbol(OBJECT_NAME.into());
211
212        let switch2_valid_field_key = arena.create_symbol(SWITCH2_VALID_FIELD.into());
213        let self_switch_ch_field_key = arena.create_symbol(SELF_SWITCH_CH_FIELD.into());
214        let switch1_id_field_key = arena.create_symbol(SWITCH1_ID_FIELD.into());
215        let switch1_valid_field_key = arena.create_symbol(SWITCH1_VALID_FIELD.into());
216        let variable_value_field_key = arena.create_symbol(VARIABLE_VALUE_FIELD.into());
217        let self_switch_valid_field_key = arena.create_symbol(SELF_SWITCH_VALID_FIELD.into());
218        let variable_id_field_key = arena.create_symbol(VARIABLE_ID_FIELD.into());
219        let variable_valid_field_key = arena.create_symbol(VARIABLE_VALID_FIELD.into());
220        let switch2_id_field_key = arena.create_symbol(SWITCH2_ID_FIELD.into());
221
222        let switch2_valid_field_value = self.switch2_valid.into_value(arena)?;
223        let self_switch_ch_field_value = arena.create_string(self.self_switch_ch.into()).into();
224        let switch1_id_field_value = self.switch1_id.into_value(arena)?;
225        let switch1_valid_field_value = self.switch1_valid.into_value(arena)?;
226        let variable_value_field_value = self.variable_value.into_value(arena)?;
227        let self_switch_valid_field_value = self.self_switch_valid.into_value(arena)?;
228        let variable_id_field_value = self.variable_id.into_value(arena)?;
229        let variable_valid_field_value = self.variable_valid.into_value(arena)?;
230        let switch2_id_field_value = self.switch2_id.into_value(arena)?;
231
232        let fields = vec![
233            (switch2_valid_field_key, switch2_valid_field_value),
234            (self_switch_ch_field_key, self_switch_ch_field_value),
235            (switch1_id_field_key, switch1_id_field_value),
236            (switch1_valid_field_key, switch1_valid_field_value),
237            (variable_value_field_key, variable_value_field_value),
238            (self_switch_valid_field_key, self_switch_valid_field_value),
239            (variable_id_field_key, variable_id_field_value),
240            (variable_valid_field_key, variable_valid_field_value),
241            (switch2_id_field_key, switch2_id_field_value),
242        ];
243
244        let object = arena.create_object(object_name, fields);
245
246        Ok(object.into())
247    }
248}
rpgmxp_types/event_page_condition.rs

rpgmxp_types/
event_page_condition.rs
