Method generate

src/resources.rs:75–141

(world: &mut World, map_width: usize, map_height: usize)

impl Map {
    pub fn generate(world: &mut World, map_width: usize, map_height: usize) -> Map {
        const MAX_ROOMS: usize = 20;
        const MAX_ATTEMPTS: usize = 200;
        const MIN_SIZE: usize = 5;
        const MAX_SIZE: usize = 15;

        let mut map = Map {
            tiles: vec![MapTile::WALL; map_width * map_height],
            width: map_width,
        };

        let mut rng = rand::thread_rng();

        let mut rooms = vec![];

        'attempt: for _ in 0..MAX_ATTEMPTS {
            let x = rng.gen_range(1..map_width - 1);
            let y = rng.gen_range(1..map_height - 1);

            let width = usize::min(rng.gen_range(MIN_SIZE..MAX_SIZE), map_width - 1 - x);
            let height = usize::min(rng.gen_range(MIN_SIZE..MAX_SIZE), map_height - 1 - y);

            if width < MIN_SIZE || height < MIN_SIZE {
                continue;
            }

            let room = Room {
                x,
                y,
                width,
                height,
            };

            for existing in &rooms {
                if room.intersects(existing) {
                    continue 'attempt;
                }
            }

            map.carve_room(&room);

            rooms.push(room);

            if rooms.len() == MAX_ROOMS {
                break;
            }
        }

        for pair in rooms.windows(2) {
            let (ax, ay) = pair[0].centre();
            let (bx, by) = pair[1].centre();

            if rng.gen_bool(0.5) {
                map.carve_h_corridor(ax, bx, ay);
                map.carve_v_corridor(bx, ay, by);
            } else {
                map.carve_v_corridor(ax, ay, by);
                map.carve_h_corridor(ax, bx, by);