prefabs from ascii

src/map_builders/prefab_builder/mod.rs

@@ -0,0 +1,175 @@
+use super::{
+    remove_unreachable_areas_returning_most_distant, spawner, Map, MapBuilder, Position, TileType, SHOW_MAPGEN,
+};
+use rltk::RandomNumberGenerator;
+use specs::prelude::*;
+mod prefab_levels;
+
+#[allow(dead_code)]
+#[derive(PartialEq, Clone)]
+pub enum PrefabMode {
+    RexLevel { template: &'static str },
+    Constant { level: prefab_levels::PrefabLevel },
+}
+
+pub struct PrefabBuilder {
+    map: Map,
+    starting_position: Position,
+    depth: i32,
+    history: Vec<Map>,
+    mode: PrefabMode,
+    spawns: Vec<(usize, String)>,
+}
+
+impl MapBuilder for PrefabBuilder {
+    fn build_map(&mut self, rng: &mut RandomNumberGenerator) {
+        return self.build(rng);
+    }
+    fn spawn_entities(&mut self, ecs: &mut World) {
+        for entity in self.spawns.iter() {
+            spawner::spawn_entity(ecs, &(&entity.0, &entity.1));
+        }
+    }
+    //  Getters
+    fn get_map(&mut self) -> Map {
+        return self.map.clone();
+    }
+    fn get_starting_pos(&mut self) -> Position {
+        return self.starting_position.clone();
+    }
+    // Mapgen visualisation stuff
+    fn get_snapshot_history(&self) -> Vec<Map> {
+        return self.history.clone();
+    }
+    fn take_snapshot(&mut self) {
+        if SHOW_MAPGEN {
+            let mut snapshot = self.map.clone();
+            for v in snapshot.revealed_tiles.iter_mut() {
+                *v = true;
+            }
+            self.history.push(snapshot);
+        }
+    }
+}
+
+impl PrefabBuilder {
+    #[allow(dead_code)]
+    pub fn new(new_depth: i32) -> PrefabBuilder {
+        PrefabBuilder {
+            map: Map::new(new_depth),
+            starting_position: Position { x: 0, y: 0 },
+            depth: new_depth,
+            history: Vec::new(),
+            mode: PrefabMode::Constant { level: prefab_levels::WFC_POPULATED },
+            spawns: Vec::new(),
+        }
+    }
+
+    fn build(&mut self, rng: &mut RandomNumberGenerator) {
+        match self.mode {
+            PrefabMode::RexLevel { template } => self.load_rex_map(&template),
+            PrefabMode::Constant { level } => self.load_ascii_map(&level),
+        }
+        self.take_snapshot();
+
+        // Find starting pos by starting at middle and walking left until finding a floor tile
+        if self.starting_position.x == 0 {
+            self.starting_position = Position { x: self.map.width / 2, y: self.map.height / 2 };
+            let mut start_idx = self.map.xy_idx(self.starting_position.x, self.starting_position.y);
+            while self.map.tiles[start_idx] != TileType::Floor {
+                self.starting_position.x -= 1;
+                start_idx = self.map.xy_idx(self.starting_position.x, self.starting_position.y);
+            }
+            self.take_snapshot();
+
+            // Find all tiles we can reach from the starting point
+            let exit_tile = remove_unreachable_areas_returning_most_distant(&mut self.map, start_idx);
+            self.take_snapshot();
+
+            // Place the stairs
+            self.map.tiles[exit_tile] = TileType::DownStair;
+            self.take_snapshot();
+        }
+    }
+
+    fn char_to_map(&mut self, ch: char, idx: usize) {
+        match ch {
+            ' ' => self.map.tiles[idx] = TileType::Floor,
+            '#' => self.map.tiles[idx] = TileType::Wall,
+            '>' => self.map.tiles[idx] = TileType::DownStair,
+            '@' => {
+                let x = idx as i32 % self.map.width;
+                let y = idx as i32 / self.map.width;
+                self.map.tiles[idx] = TileType::Floor;
+                self.starting_position = Position { x: x as i32, y: y as i32 };
+            }
+            'g' => {
+                self.map.tiles[idx] = TileType::Floor;
+                self.spawns.push((idx, "Goblin".to_string()));
+            }
+            'o' => {
+                self.map.tiles[idx] = TileType::Floor;
+                self.spawns.push((idx, "Orc".to_string()));
+            }
+            '^' => {
+                self.map.tiles[idx] = TileType::Floor;
+                self.spawns.push((idx, "Bear Trap".to_string()));
+            }
+            '%' => {
+                self.map.tiles[idx] = TileType::Floor;
+                self.spawns.push((idx, "Rations".to_string()));
+            }
+            '!' => {
+                self.map.tiles[idx] = TileType::Floor;
+                self.spawns.push((idx, "Health Potion".to_string()));
+            }
+            _ => {
+                rltk::console::log(format!("Unknown glyph loading map: {}", (ch as u8) as char));
+            }
+        }
+    }
+
+    #[allow(dead_code)]
+    fn load_rex_map(&mut self, path: &str) {
+        let xp_file = rltk::rex::XpFile::from_resource(path).unwrap();
+
+        for layer in &xp_file.layers {
+            for y in 0..layer.height {
+                for x in 0..layer.width {
+                    let cell = layer.get(x, y).unwrap();
+                    if x < self.map.width as usize && y < self.map.height as usize {
+                        let idx = self.map.xy_idx(x as i32, y as i32);
+                        // We're doing some nasty casting to make it easier to type things like '#' in the match
+                        self.char_to_map(cell.ch as u8 as char, idx);
+                    }
+                }
+            }
+        }
+    }
+
+    fn read_ascii_to_vec(template: &str) -> Vec<char> {
+        let mut string_vec: Vec<char> = template.chars().filter(|a| *a != '\r' && *a != '\n').collect();
+        for c in string_vec.iter_mut() {
+            if *c as u8 == 160u8 {
+                *c = ' ';
+            }
+        }
+        return string_vec;
+    }
+
+    #[allow(dead_code)]
+    fn load_ascii_map(&mut self, level: &prefab_levels::PrefabLevel) {
+        let string_vec = PrefabBuilder::read_ascii_to_vec(level.template);
+
+        let mut i = 0;
+        for y in 0..level.height {
+            for x in 0..level.width {
+                if x < self.map.width as usize && y < self.map.height as usize {
+                    let idx = self.map.xy_idx(x as i32, y as i32);
+                    self.char_to_map(string_vec[i], idx);
+                }
+                i += 1;
+            }
+        }
+    }
+}