refactors mapgen into chained builders

src/map_builders/simple_map.rs

@@ -1,107 +1,59 @@
-use super::{
-    apply_horizontal_tunnel, apply_room_to_map, apply_vertical_tunnel, spawner, Map, MapBuilder, Position, Rect,
-    TileType, SHOW_MAPGEN,
-};
+use super::{apply_horizontal_tunnel, apply_room_to_map, apply_vertical_tunnel, BuilderMap, InitialMapBuilder, Rect};
 use rltk::RandomNumberGenerator;
 
-pub struct SimpleMapBuilder {
-    map: Map,
-    starting_position: Position,
-    depth: i32,
-    rooms: Vec<Rect>,
-    history: Vec<Map>,
-    spawn_list: Vec<(usize, String)>,
-}
+pub struct SimpleMapBuilder {}
 
-impl MapBuilder for SimpleMapBuilder {
-    fn build_map(&mut self, rng: &mut RandomNumberGenerator) {
-        return self.rooms_and_corridors(rng);
-    }
-    //  Getters
-    fn get_map(&mut self) -> Map {
-        return self.map.clone();
-    }
-    fn get_starting_pos(&mut self) -> Position {
-        return self.starting_position.clone();
-    }
-    fn get_spawn_list(&self) -> &Vec<(usize, String)> {
-        return &self.spawn_list;
-    }
-    // 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 InitialMapBuilder for SimpleMapBuilder {
+    #[allow(dead_code)]
+    fn build_map(&mut self, rng: &mut rltk::RandomNumberGenerator, build_data: &mut BuilderMap) {
+        self.rooms_and_corridors(rng, build_data);
     }
 }
 
 impl SimpleMapBuilder {
     #[allow(dead_code)]
-    pub fn new(new_depth: i32) -> SimpleMapBuilder {
-        SimpleMapBuilder {
-            map: Map::new(new_depth),
-            starting_position: Position { x: 0, y: 0 },
-            depth: new_depth,
-            rooms: Vec::new(),
-            history: Vec::new(),
-            spawn_list: Vec::new(),
-        }
+    pub fn new() -> Box<SimpleMapBuilder> {
+        Box::new(SimpleMapBuilder {})
     }
 
-    fn rooms_and_corridors(&mut self, rng: &mut RandomNumberGenerator) {
+    fn rooms_and_corridors(&mut self, rng: &mut RandomNumberGenerator, build_data: &mut BuilderMap) {
         const MAX_ROOMS: i32 = 30;
         const MIN_SIZE: i32 = 6;
         const MAX_SIZE: i32 = 10;
+        let mut rooms: Vec<Rect> = Vec::new();
 
         for _i in 0..MAX_ROOMS {
             let w = rng.range(MIN_SIZE, MAX_SIZE);
             let h = rng.range(MIN_SIZE, MAX_SIZE);
-            let x = rng.roll_dice(1, self.map.width - w - 1) - 1;
-            let y = rng.roll_dice(1, self.map.height - h - 1) - 1;
+            let x = rng.roll_dice(1, build_data.map.width - w - 1) - 1;
+            let y = rng.roll_dice(1, build_data.map.height - h - 1) - 1;
             let new_room = Rect::new(x, y, w, h);
             let mut ok = true;
-            for other_room in self.rooms.iter() {
+            for other_room in rooms.iter() {
                 if new_room.intersect(other_room) {
                     ok = false
                 }
             }
             if ok {
-                apply_room_to_map(&mut self.map, &new_room);
+                apply_room_to_map(&mut build_data.map, &new_room);
+                build_data.take_snapshot();
 
-                if !self.rooms.is_empty() {
+                if !rooms.is_empty() {
                     let (new_x, new_y) = new_room.centre();
-                    let (prev_x, prev_y) = self.rooms[self.rooms.len() - 1].centre();
+                    let (prev_x, prev_y) = rooms[rooms.len() - 1].centre();
                     if rng.range(0, 2) == 1 {
-                        apply_horizontal_tunnel(&mut self.map, prev_x, new_x, prev_y);
-                        apply_vertical_tunnel(&mut self.map, prev_y, new_y, new_x);
+                        apply_horizontal_tunnel(&mut build_data.map, prev_x, new_x, prev_y);
+                        apply_vertical_tunnel(&mut build_data.map, prev_y, new_y, new_x);
                     } else {
-                        apply_vertical_tunnel(&mut self.map, prev_y, new_y, prev_x);
-                        apply_horizontal_tunnel(&mut self.map, prev_x, new_x, new_y);
+                        apply_vertical_tunnel(&mut build_data.map, prev_y, new_y, prev_x);
+                        apply_horizontal_tunnel(&mut build_data.map, prev_x, new_x, new_y);
                     }
                 }
 
-                self.rooms.push(new_room);
-                self.take_snapshot();
+                rooms.push(new_room);
+                build_data.take_snapshot();
             }
         }
-
-        let stairs_position = self.rooms[self.rooms.len() - 1].centre();
-        let stairs_idx = self.map.xy_idx(stairs_position.0, stairs_position.1);
-        self.map.tiles[stairs_idx] = TileType::DownStair;
-
-        let start_pos = self.rooms[0].centre();
-        self.starting_position = Position { x: start_pos.0, y: start_pos.1 };
-
-        // Spawn entities
-        for room in self.rooms.iter().skip(1) {
-            spawner::spawn_room(&self.map, rng, room, self.depth, &mut self.spawn_list);
-        }
+        build_data.rooms = Some(rooms);
     }
 }