violet_crystal 0.1.1

Rust-powered addon development framework for Minecraft Bedrock
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
146
147
148

use askama::Template;

use super::Block;

#[derive(Clone)]
pub struct BlockRegistry<'a> {
    pub blocks: Vec<Block<'a>>,
    pub block_atlas: Vec<BlockAtlasEntry>,
    pub terrain_atlas: Vec<TerrainAtlasEntry>
}

#[derive(Template)]
#[template(
    path = "block_serialization/blocks.json.jinja2",
    escape = "none"
)]
pub struct BlockAtlasTemplate {
    pub content: String,
}

#[derive(Template)]
#[template(
    path = "block_serialization/terrain_texture.json.jinja2",
    escape = "none"
)]
pub struct TerrainAtlasTemplate {
    pub content: String,
    pub pack_name: String,
}

#[derive(Template)]
#[template(
    path = "block_serialization/block_atlas_entry.json.jinja2",
    escape = "none"
)]
struct BlockAtlasEntryTemplate {
    pub id: String,
    pub textures: String,
    pub sound: String,
}

#[derive(Clone)]
pub struct BlockAtlasEntry {
    pub id: String,
    pub path: String,
    pub textures: String,
    pub sound: String,
}

#[derive(Clone)]
pub struct TerrainAtlasEntry {
    pub id: String,
    pub texture_path: String,
}

impl TerrainAtlasEntry {
    fn serialize(&self) -> String {
        let id: String = (*self)
            .clone()
            .id
            .chars()
            .map(|x| if x == ':' { '_' } else { x })
            .collect();
        TerrainAtlasEntryTemplate {
            texture_path: format!("textures/blocks/{}", id),
            id
        }
            .render()
            .unwrap()
    }
}

#[derive(Template)]
#[template(
    path = "block_serialization/terrain_texture_entry.json.jinja2",
    escape = "none"
)]
struct TerrainAtlasEntryTemplate {
    pub id: String,
    pub texture_path: String,
}
impl BlockAtlasEntry {
    fn serialize(&self) -> String {
        BlockAtlasEntryTemplate {
            textures: self
                .clone()
                .id
                .chars()
                .map(|x| if x == ':' { '_' } else { x })
                .collect(),
            id: self
                .clone()
                .id,
            sound: self.clone().sound,
        }
        .render()
        .unwrap()
    }
}

pub fn serialize_block_atlas(atlas: &Vec<BlockAtlasEntry>) -> String {
    let mut atlas_string = String::new();
    for entry in atlas {
        atlas_string.push_str(&entry.serialize());
        atlas_string.push(',');
    }
    atlas_string.pop();
    atlas_string
}

pub fn serialize_terrain_atlas(atlas: &Vec<TerrainAtlasEntry>) -> String {
    let mut atlas_string = String::new();
    for entry in atlas {
        atlas_string.push_str(&entry.serialize());
        atlas_string.push(',');
    }
    atlas_string.pop();
    atlas_string
}

impl<'a> BlockRegistry<'a> {
    pub fn new() -> Self {
        Self {
            blocks: vec![],
            block_atlas: vec![],
            terrain_atlas: vec![]
        }
    }

    pub fn add_block(&mut self, block: Block<'a>) {
        self.blocks.push(block.clone());
        self.block_atlas.push(BlockAtlasEntry {
            id: block.clone().type_id.render(),
            path: block.clone().texture_set,
            textures: block
                .type_id.render()
                .chars()
                .into_iter()
                .map(|x| if x == ':' { '_' } else { x })
                .collect(),
            sound: block.clone().sound,
        });
        self.terrain_atlas.push(TerrainAtlasEntry {
            id: block.clone().type_id.render(),
            texture_path: block.clone().texture_set
        });
    }
}