wolfrpg-map-parser 0.6.0

Parser for Wolf RPG Editor map 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
137
138
139
140
141
142
143
144
145

use crate::byte_utils::as_u32_le;
use crate::command::picture_command::colors::Colors;
use crate::command::picture_command::show::parsable_fields::ParsableFields;
use crate::command::picture_command::show::zoom_fields::ZoomFields;
#[cfg(feature = "serde")]
use serde::{Serialize, Deserialize};

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(PartialEq, Clone)]
pub struct FreeTransformFields {
    zoom_state: ZoomFields,
    top_right_x: u32,
    top_right_y: u32,
    bottom_left_x: u32,
    bottom_left_y: u32,
    bottom_right_x: u32,
    bottom_right_y: u32
}

impl FreeTransformFields {
    pub fn colors(&self) -> &Colors {
        self.zoom_state.colors()
    }

    pub fn colors_mut(&mut self) -> &mut Colors {
        self.zoom_state.colors_mut()
    }

    pub fn delay(&self) -> u32 {
        self.zoom_state.delay()
    }

    pub fn delay_mut(&mut self) -> &mut u32 {
        self.zoom_state.delay_mut()
    }

    pub fn range_count(&self) -> u32 {
        self.zoom_state.range_count()
    }

    pub fn range_count_mut(&mut self) -> &mut u32 {
        self.zoom_state.range_count_mut()
    }

    pub fn color_values(&self) -> &[u32; 3] {
        self.zoom_state.color_values()
    }

    pub fn color_values_mut(&mut self) -> &mut [u32; 3] {
        self.zoom_state.color_values_mut()
    }

    pub fn zoom_height(&self) -> u32 {
        self.zoom_state.zoom_height()
    }

    pub fn zoom_height_mut(&mut self) -> &mut u32 {
        self.zoom_state.zoom_height_mut()
    }

    pub fn top_right_x(&self) -> u32 {
        self.top_right_x
    }

    pub fn top_right_x_mut(&mut self) -> &mut u32 {
        &mut self.top_right_x
    }

    pub fn top_right_y(&self) -> u32 {
        self.top_right_y
    }

    pub fn top_right_y_mut(&mut self) -> &mut u32 {
        &mut self.top_right_y
    }

    pub fn bottom_left_x(&self) -> u32 {
        self.bottom_left_x
    }

    pub fn bottom_left_x_mut(&mut self) -> &mut u32 {
        &mut self.bottom_left_x
    }

    pub fn bottom_left_y(&self) -> u32 {
        self.bottom_left_y
    }

    pub fn bottom_left_y_mut(&mut self) -> &mut u32 {
        &mut self.bottom_left_y
    }

    pub fn bottom_right_x(&self) -> u32 {
        self.bottom_right_x
    }

    pub fn bottom_right_x_mut(&mut self) -> &mut u32 {
        &mut self.bottom_right_x
    }

    pub fn bottom_right_y(&self) -> u32 {
        self.bottom_right_y
    }

    pub fn bottom_right_y_mut(&mut self) -> &mut u32 {
        &mut self.bottom_right_y
    }
}

impl ParsableFields<FreeTransformFields> for FreeTransformFields {
    fn parse(bytes: &[u8]) -> (usize, Self) {
        let mut offset: usize = 0;

        let (bytes_read, zoom_state): (usize, ZoomFields) = ZoomFields::parse(bytes);
        offset += bytes_read;

        let top_right_x: u32 = as_u32_le(&bytes[offset..offset+4]);
        offset += 4;

        let top_right_y: u32 = as_u32_le(&bytes[offset..offset+4]);
        offset += 4;

        let bottom_left_x: u32 = as_u32_le(&bytes[offset..offset+4]);
        offset += 4;

        let bottom_left_y: u32 = as_u32_le(&bytes[offset..offset+4]);
        offset += 4;

        let bottom_right_x: u32 = as_u32_le(&bytes[offset..offset+4]);
        offset += 4;

        let bottom_right_y: u32 = as_u32_le(&bytes[offset..offset+4]);
        offset += 4;

        (offset, Self {
            zoom_state,
            top_right_x,
            top_right_y,
            bottom_left_x,
            bottom_left_y,
            bottom_right_x,
            bottom_right_y
        })
    }
}