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

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use crate::byte_utils::parse_string;

/// Miscellaneous information on a WolfRPG Editor game
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(PartialEq)]
pub struct GameData {
    tile_size: u8,
    character_directions: u8,
    character_movements: u8,
    game_name: String,
    fonts: [String; 4]
}

impl GameData {
    pub fn parse(bytes: &[u8]) -> GameData {
        let mut offset: usize = 0;

        let tile_size: u8 = bytes[offset];
        offset += 1;

        let character_directions: u8 = bytes[offset];
        offset += 1;

        let character_movements: u8 = bytes[offset];
        offset += 1;

        offset += 23; // Unknown

        let (bytes_read, game_name): (usize, String) = parse_string(&bytes[offset..]);
        offset += bytes_read;

        // Unknown
        let (bytes_read, _): (usize, String) = parse_string(&bytes[offset..]);
        offset += bytes_read;

        // Unknown
        let (bytes_read, _): (usize, String) = parse_string(&bytes[offset..]);
        offset += bytes_read;

        let mut fonts: Vec<String> = Vec::with_capacity(4);
        for _ in 0..4 {
            let (bytes_read, font): (usize, String) = parse_string(&bytes[offset..]);
            offset += bytes_read;
            fonts.push(font);
        }

        let fonts: [String; 4] = fonts.try_into().unwrap();

        GameData {
            tile_size,
            character_directions,
            character_movements,
            game_name,
            fonts
        }
    }
    pub fn tile_size(&self) -> u8 {
        self.tile_size
    }

    pub fn tile_size_mut(&mut self) -> &mut u8 {
        &mut self.tile_size
    }

    pub fn character_directions(&self) -> u8 {
        self.character_directions
    }

    pub fn character_directions_mut(&mut self) -> &mut u8 {
        &mut self.character_directions
    }

    pub fn character_movements(&self) -> u8 {
        self.character_movements
    }

    pub fn character_movements_mut(&mut self) -> &mut u8 {
        &mut self.character_movements
    }

    pub fn game_name(&self) -> &str {
        &self.game_name
    }

    pub fn game_name_mut(&mut self) -> &mut String {
        &mut self.game_name
    }

    pub fn fonts(&self) -> &[String; 4] {
        &self.fonts
    }

    pub fn fonts_mut(&mut self) -> &mut [String; 4] {
        &mut self.fonts
    }
}