bevy_entitiles 0.2.2

A tilemap library for bevy. With many algorithms built in.
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

use std::{
    fs::{create_dir_all, File},
    io::Write,
};

use bevy::{
    ecs::{
        component::Component,
        entity::Entity,
        system::{Commands, Query},
    },
    utils::HashMap,
};
use serde::Serialize;

use crate::tilemap::{map::Tilemap, tile::Tile};

use super::{SerializedTile, SerializedTilemap, TilemapLayer, PATH_TILES, TILEMAP_META, TILES};

pub struct TilemapSaverBuilder {
    path: String,
    map_name: String,
    texture_path: Option<String>,
    layers: u32,
    remove_map_after_done: bool,
}

impl TilemapSaverBuilder {
    pub fn new(path: String, map_name: String) -> Self {
        TilemapSaverBuilder {
            path,
            map_name,
            texture_path: None,
            layers: 0,
            remove_map_after_done: false,
        }
    }

    /// Set which layers to save. By default, only the texture layer is saved.
    /// If there's async algorithms performing when saving, you should save them.
    pub fn with_layer(mut self, layer: TilemapLayer) -> Self {
        self.layers |= layer as u32;
        self
    }

    /// Set the texture path to save.
    pub fn with_texture(mut self, texture_path: String) -> Self {
        self.texture_path = Some(texture_path);
        self
    }

    /// Despawn the tilemap after saving.
    pub fn remove_map_after_done(mut self) -> Self {
        self.remove_map_after_done = true;
        self
    }

    pub fn build(self, commands: &mut Commands, target: Entity) {
        commands.entity(target).insert(TilemapSaver {
            path: self.path,
            map_name: self.map_name,
            texture_path: self.texture_path,
            layers: self.layers,
            remove_map_after_done: self.remove_map_after_done,
        });
    }
}

#[derive(Component)]
pub struct TilemapSaver {
    pub(crate) path: String,
    pub(crate) map_name: String,
    pub(crate) texture_path: Option<String>,
    pub(crate) layers: u32,
    pub(crate) remove_map_after_done: bool,
}

pub fn save(
    mut commands: Commands,
    tilemaps_query: Query<(Entity, &Tilemap, &TilemapSaver)>,
    tiles_query: Query<&Tile>,
    #[cfg(feature = "algorithm")] path_tilemaps_query: Query<
        &crate::tilemap::algorithm::path::PathTilemap,
    >,
) {
    for (entity, tilemap, saver) in tilemaps_query.iter() {
        let map_path = saver.path.clone() + &saver.map_name + "\\";

        let serialized_tilemap = SerializedTilemap::from_tilemap(tilemap, saver);
        save_object(&map_path, TILEMAP_META, &serialized_tilemap);

        // texture
        if saver.layers & 1 != 0 {
            let serialized_tiles: Vec<Option<SerializedTile>> = tilemap
                .tiles
                .iter()
                .map(|e| {
                    if let Some(tile) = e {
                        Some(tiles_query.get(tile.clone()).unwrap().clone().into())
                    } else {
                        None
                    }
                })
                .collect::<Vec<_>>();

            save_object(&map_path, TILES, &serialized_tiles);
        }

        // algorithm
        #[cfg(feature = "algorithm")]
        if saver.layers & (1 << 1) != 0 {
            if let Ok(path_tilemap) = path_tilemaps_query.get(entity) {
                let serialized_path_map = super::SerializedPathTilemap {
                    tiles: path_tilemap
                        .tiles
                        .iter()
                        .map(|(index, tile)| {
                            (*index, super::SerializedPathTile { cost: tile.cost })
                        })
                        .collect::<HashMap<_, _>>(),
                };

                save_object(&map_path, PATH_TILES, &serialized_path_map);
            }
        }

        if saver.remove_map_after_done {
            commands.entity(entity).despawn();
        }

        commands.entity(entity).remove::<TilemapSaver>();
    }
}

pub fn save_object<T: Serialize>(path: &str, file_name: &str, object: &T) {
    let _ = create_dir_all(path);
    let _ = File::create(path.to_owned() + file_name)
        .unwrap_or(File::open(path.to_owned() + file_name).unwrap())
        .write(ron::to_string(object).unwrap().as_bytes());
}