cleanup

.gitignore

@@ -1 +1,2 @@
 /target
+*.profraw

coverage.md

@@ -0,0 +1,10 @@
+```
+cargo install grcov
+rustup component add llvm-tools-preview
+```
+
+```
+RUSTFLAGS="-Cinstrument-coverage" cargo clean
+RUSTFLAGS="-Cinstrument-coverage" cargo test
+grcov . --binary-path ./target/debug/deps/ -s . -t html --branch --ignore-not-existing --ignore '../*' --ignore "/*" -o target/coverage/html
+```

macros/src/lib.rs

@@ -3,7 +3,6 @@ extern crate proc_macro;
 use proc_macro::TokenStream;
 use quote::quote;
 
-
 #[proc_macro_derive(CreateMonsters)]
 pub fn create_monsters(input: TokenStream) -> TokenStream {
     let input = syn::parse_macro_input!(input as syn::File);

src/constants.rs

@@ -2,9 +2,8 @@ use std::{collections::HashMap, ops::RangeInclusive};
 
 use crate::{monster::MonsterTypes, room::RoomType};
 
-
 /// the number of rooms in vertical direction
-pub const ROOMS_HORIZONAL: usize = 8;
+pub const ROOMS_HORIZONTAL: usize = 8;
 /// the number of rooms in horizontal direction
 pub const ROOMS_VERTICAL: usize = 7;
 
@@ -13,8 +12,14 @@ pub const ROOM_WIDTH: usize = 9;
 /// the height of a room in the grid of rooms (number of characters)
 pub const ROOM_HEIGHT: usize = 6;
 
+// the minmal width of a room
+pub const ROOM_MIN_WIDTH: usize = 4;
+
+// the minmal height of a room
+pub const ROOM_MIN_HEIGHT: usize = 4;
+
 /// How many levels does the dungeon have?
-pub const LEVELS: usize = 2;
+pub const LEVELS: usize = 4;
 
 /// length of a game frame in ms
 pub const FRAME_LENGTH: u64 = 100;
@@ -25,7 +30,7 @@ pub const MIN_WIDTH: u16 = 120;
 pub const MIN_HEIGHT: u16 = LEVEL_HEIGHT as u16;
 
 /// the calculated width of a level
-pub const LEVEL_WIDTH: usize = 1 + ROOMS_HORIZONAL * ROOM_WIDTH;
+pub const LEVEL_WIDTH: usize = 1 + ROOMS_HORIZONTAL * ROOM_WIDTH;
 /// the calculated height of a level
 pub const LEVEL_HEIGHT: usize = 1 + ROOMS_VERTICAL * ROOM_HEIGHT;
 
@@ -41,6 +46,12 @@ pub fn get_monsters_per_level() -> Vec<HashMap<MonsterTypes, std::ops::RangeIncl
             (MonsterTypes::Skeleton, 33),
             (MonsterTypes::Snake, 33),
         ],
+        // level 4
+        vec![
+            (MonsterTypes::Orc, 34),
+            (MonsterTypes::Skeleton, 33),
+            (MonsterTypes::Snake, 33),
+        ],
     ];
     if tmp.len() < LEVELS {
         panic!(
@@ -74,8 +85,8 @@ pub fn get_room_type_per_level() -> Vec<HashMap<RoomType, std::ops::RangeInclusi
         // level 1
         vec![
             (RoomType::EmptyRoom, 50),
-            (RoomType::ArtifactRoom, 25),
+            (RoomType::ArtifactRoom, 10),
-            (RoomType::MonsterRoom, 5),
+            (RoomType::MonsterRoom, 20),
             (RoomType::BasicRoom, 20),
         ],
         // level 2
@@ -86,7 +97,17 @@ pub fn get_room_type_per_level() -> Vec<HashMap<RoomType, std::ops::RangeInclusi
             (RoomType::ArtifactRoom, 13),
         ],
         // level 3
-        vec![(RoomType::EmptyRoom, 50), (RoomType::MonsterRoom, 50)],
+        vec![
+            (RoomType::EmptyRoom, 50),
+            (RoomType::BasicRoom, 25),
+            (RoomType::MonsterRoom, 25),
+        ],
+        // level 4
+        vec![
+            (RoomType::BasicRoom, 33),
+            (RoomType::MonsterRoom, 33),
+            (RoomType::ArtifactRoom, 34),
+        ],
     ];
     if tmp.len() < LEVELS {
         panic!(

src/level.rs

@@ -57,7 +57,7 @@ impl Level {
             return (None, None, None);
         }
         if !self.discovered[x][y] {
-            #[cfg(test)]
+            // #[cfg(test)]
             return (Some(StructureElement::Unknown), None, None);
         }
         let search_pos = &Position::new(self.level, x, y);

src/level_generator.rs

@@ -1,5 +1,6 @@
 use petgraph::algo::min_spanning_tree;
 use petgraph::data::*;
+use petgraph::graph::Edge;
 use petgraph::graph::Graph;
 use petgraph::graph::UnGraph;
 
@@ -18,15 +19,16 @@ use crate::position::Position;
 use crate::room::Connection;
 use crate::{
     constants::{
-        get_room_type_per_level, LEVEL_HEIGHT, LEVEL_WIDTH, ROOMS_HORIZONAL, ROOMS_VERTICAL,
+        get_room_type_per_level, LEVEL_HEIGHT, LEVEL_WIDTH, ROOMS_HORIZONTAL, ROOMS_VERTICAL,
     },
     level::{Level, StructureElement},
     room::{Room, RoomType},
 };
 
+type GeneratorGraph = Graph<(usize, usize), usize, petgraph::Undirected>;
 pub struct LevelGenerator {
     level: usize,
-    rooms: [[Room; ROOMS_VERTICAL]; ROOMS_HORIZONAL],
+    rooms: [[Room; ROOMS_VERTICAL]; ROOMS_HORIZONTAL],
     rng: ThreadRng,
 }
 enum Direction {
@@ -35,58 +37,67 @@ enum Direction {
 }
 
 impl LevelGenerator {
-    pub fn generate(level: usize, first: bool, last: bool) -> Self {
+    fn generate_rooms_to_place(
-        let mut rng = rand::thread_rng();
+        rng: &mut ThreadRng,
-        let mut rooms = [[Room::new(&mut rng); ROOMS_VERTICAL]; ROOMS_HORIZONAL];
+        level: usize,
+        first: bool,
+        last: bool,
+    ) -> Vec<Room> {
+        let mut rooms_to_place: Vec<Room> = Vec::with_capacity(ROOMS_VERTICAL * ROOMS_HORIZONTAL);
 
-        /*
+        let mut start_room = Room::new(rng);
-           Fill grid with unconnected rooms
-        */
-
-        let mut rooms_to_place: Vec<Room> = Vec::with_capacity(ROOMS_VERTICAL * ROOMS_HORIZONAL);
-
-        let mut start_room = Room::new(&mut rng);
         if first {
             start_room.kind = RoomType::Start;
         } else {
             start_room.kind = RoomType::StairUp;
         }
         rooms_to_place.push(start_room);
-        let mut end_room = Room::new(&mut rng);
+        for _ in 2..ROOMS_HORIZONTAL * ROOMS_VERTICAL {
+            let mut room = Room::new(rng);
+            room.kind = LevelGenerator::select_room_type(level, rng);
+            if room.kind != RoomType::EmptyRoom {
+                rooms_to_place.push(room);
+            }
+        }
+        let mut end_room = Room::new(rng);
         if last {
             end_room.kind = RoomType::End;
         } else {
             end_room.kind = RoomType::StairDown;
         }
         rooms_to_place.push(end_room);
-        for _ in 2..ROOMS_HORIZONAL * ROOMS_VERTICAL {
+        rooms_to_place
-            let mut room = Room::new(&mut rng);
-            room.kind = LevelGenerator::select_room_type(level, &mut rng);
-            if room.kind != RoomType::EmptyRoom {
-                rooms_to_place.push(room);
     }
-        }
+
-        let mut room_row = rng.gen_range(1..ROOMS_VERTICAL);
+    fn place_rooms(
-        let mut room_col = rng.gen_range(1..ROOMS_HORIZONAL);
+        rng: &mut ThreadRng,
+        rooms_to_place: &mut Vec<Room>,
+    ) -> [[Room; ROOMS_VERTICAL]; ROOMS_HORIZONTAL] {
+        let mut rooms: [[Room; 7]; 8] = [[Room::new(rng); ROOMS_VERTICAL]; ROOMS_HORIZONTAL];
+        let mut room_row = rng.gen_range(0..ROOMS_VERTICAL);
+        let mut room_col = rng.gen_range(0..ROOMS_HORIZONTAL);
         rooms[room_col][room_row] = rooms_to_place.pop().unwrap();
         while let Some(room) = rooms_to_place.pop() {
+            let mut placed = false;
+            // randomize going horizontal or vertical
             let mut directions_to_try = vec![Direction::Horizontal, Direction::Vertical];
-            directions_to_try.shuffle(&mut rng);
+            directions_to_try.shuffle(rng);
             while !directions_to_try.is_empty() {
                 match directions_to_try.pop().unwrap() {
                     Direction::Horizontal => {
                         let mut free_cols: Vec<usize> = vec![];
-                        for col in 0..ROOMS_HORIZONAL {
+                        for (col, room_col) in rooms.iter().enumerate().take(ROOMS_HORIZONTAL) {
-                            if rooms[col][room_row].kind == RoomType::EmptyRoom {
+                            if room_col[room_row].kind == RoomType::EmptyRoom {
                                 free_cols.push(col);
                             }
                         }
                         if free_cols.is_empty() {
                             continue;
                         }
-                        free_cols.shuffle(&mut rng);
+                        free_cols.shuffle(rng);
                         room_col = *free_cols.first().unwrap();
                         rooms[room_col][room_row] = room;
+                        placed = true;
                         break;
                     }
                     Direction::Vertical => {
@@ -99,59 +110,67 @@ impl LevelGenerator {
                         if free_rows.is_empty() {
                             continue;
                         }
-                        free_rows.shuffle(&mut rng);
+                        free_rows.shuffle(rng);
                         room_row = *free_rows.first().unwrap();
                         rooms[room_col][room_row] = room;
+                        placed = true;
                         break;
                     }
                 }
             }
+
+            // all fields in the row/column was full so we can place it at any empty position
+            if !placed {
+                let mut free_pos: Vec<(usize, usize)> = vec![];
+                for (col, room_col) in rooms.iter().enumerate().take(ROOMS_HORIZONTAL) {
+                    for (row, room) in room_col.iter().enumerate().take(ROOMS_VERTICAL) {
+                        if room.kind == RoomType::EmptyRoom {
+                            free_pos.push((col, row));
+                        }
+                    }
+                }
+                let selected_pos = free_pos[rng.gen_range(0..free_pos.len())];
+                rooms[selected_pos.0][selected_pos.1] = room;
+            }
+        }
+        rooms
     }
 
-        // debug print a text view of the dungeon
+    fn create_mst(rooms: &[[Room; ROOMS_VERTICAL]; ROOMS_HORIZONTAL]) -> GeneratorGraph {
-        println!("  0 1 2 3 4 5 6 7");
+        // calculate the weight of an edge
-        for r in 0..ROOMS_VERTICAL {
+        fn calc_edge_weight(delta: usize) -> usize {
-            print!("{} ", r);
+            delta * delta
-            for c in 0..ROOMS_HORIZONAL {
-                match rooms[c][r].kind {
-                    RoomType::Start => print!("S "),
-                    RoomType::End => print!("E "),
-                    RoomType::StairUp => print!("< "),
-                    RoomType::StairDown => print!("> "),
-                    RoomType::BasicRoom => print!("B "),
-                    RoomType::ArtifactRoom => print!("A "),
-                    RoomType::MonsterRoom => print!("M "),
-                    RoomType::EmptyRoom => print!("  "),
-                };
-            }
-            println!();
         }
 
-        /*
+        let mut graph: GeneratorGraph = UnGraph::<(usize, usize), usize>::default();
-           Construct a graph from the unconnected rooms and make a minum spanning tree of it
+        for (col, tgt_col) in rooms.iter().enumerate().take(ROOMS_HORIZONTAL) {
-        */
+            for (row, room) in tgt_col.iter().enumerate().take(ROOMS_VERTICAL) {
-        let mut graph = UnGraph::<(usize, usize), u16>::default();
+                if room.kind != RoomType::EmptyRoom {
-        // collect nodes
-        for col in 0..ROOMS_HORIZONAL {
-            for row in 0..ROOMS_VERTICAL {
-                if rooms[col][row].kind != RoomType::EmptyRoom {
                     graph.add_node((col, row));
                 }
             }
         }
-        // collect edges between nodes, each right and down till we find the next room
+        for col in 0..ROOMS_HORIZONTAL {
-        for col in 0..ROOMS_HORIZONAL {
             for row in 0..ROOMS_VERTICAL {
                 if rooms[col][row].kind == RoomType::EmptyRoom {
                     continue;
                 }
                 if let Some(src_index) = graph.node_indices().find(|i| graph[*i] == (col, row)) {
-                    for col_1 in col + 1..ROOMS_HORIZONAL {
+                    for (col_1, tgt_col) in rooms
-                        if rooms[col_1][row].kind != RoomType::EmptyRoom {
+                        .iter()
+                        .enumerate()
+                        .take(ROOMS_HORIZONTAL)
+                        .skip(col + 1)
+                    {
+                        if tgt_col[row].kind != RoomType::EmptyRoom {
                             if let Some(tgt_index) =
                                 graph.node_indices().find(|i| graph[*i] == (col_1, row))
                             {
-                                graph.add_edge(src_index, tgt_index, 1);
+                                graph.add_edge(
+                                    src_index,
+                                    tgt_index,
+                                    calc_edge_weight(col.abs_diff(col_1)),
+                                );
                                 break;
                             }
                         }
@@ -161,7 +180,11 @@ impl LevelGenerator {
                             if let Some(tgt_index) =
                                 graph.node_indices().find(|i| graph[*i] == (col, row_1))
                             {
-                                graph.add_edge(src_index, tgt_index, 1);
+                                graph.add_edge(
+                                    src_index,
+                                    tgt_index,
+                                    calc_edge_weight(row.abs_diff(row_1)),
+                                );
                                 break;
                             }
                         }
@@ -169,42 +192,88 @@ impl LevelGenerator {
                 }
             }
         }
-        let mst: Graph<(usize, usize), u16, petgraph::Undirected> =
+        let mut mst: GeneratorGraph = Graph::from_elements(min_spanning_tree(&graph));
-            Graph::from_elements(min_spanning_tree(&graph));
+
+        // readd some of the short edges that were remove (all between a weight of 1 to 10)
+        let initial_edges = graph.raw_edges();
+        let minimal_edges = mst.raw_edges();
+        let mut extra_edges: Vec<Edge<usize>> = vec![];
+        for init_edge in initial_edges {
+            let start_node = init_edge.source();
+            let end_node = init_edge.target();
+            let mut found = false;
+            for min_edge in minimal_edges {
+                if min_edge.source() == start_node && min_edge.target() == end_node {
+                    found = true;
+                    break;
+                }
+            }
+            if !found {
+                extra_edges.push(init_edge.clone());
+            }
+        }
+        extra_edges.sort_by(|a, b| a.weight.cmp(&b.weight));
+        for e in extra_edges
+            .iter()
+            .filter(|x| x.weight > 1)
+            .filter(|x| x.weight < 7)
+        {
+            mst.add_edge(e.source(), e.target(), e.weight);
+        }
+        mst
+    }
+
+    fn create_connections(
+        rooms: &mut [[Room; ROOMS_VERTICAL]; ROOMS_HORIZONTAL],
+        mst: &GeneratorGraph,
+    ) {
         for edge in mst.raw_edges() {
             // the tuples are (col, row)
             let (src_node_col, src_node_row) = mst[edge.source()];
             let (tgt_node_col, tgt_node_row) = mst[edge.target()];
-            // println!("MST Edge from {:?} to {:?}", (src_node_col, src_node_row), (tgt_node_col, tgt_node_row));
+            let src_room = rooms[src_node_col][src_node_row];
+            let tgt_room = rooms[tgt_node_col][tgt_node_row];
 
             if src_node_col == tgt_node_col {
-                // println!("Down");
+                // Right
-                let start_col = src_node_col * ROOM_WIDTH + ROOM_WIDTH / 2;
+                let start_col =
-                let start_row = src_node_row * ROOM_HEIGHT + ROOM_HEIGHT;
+                    src_node_col * ROOM_WIDTH + src_room.offset_x + (src_room.width + 1) / 2;
-                let end_col = tgt_node_col * ROOM_WIDTH + ROOM_WIDTH / 2;
+                let start_row =
-                let end_row = tgt_node_row * ROOM_HEIGHT;
+                    src_node_row * ROOM_HEIGHT + src_room.offset_y + src_room.height + 1;
+                let end_col =
+                    tgt_node_col * ROOM_WIDTH + tgt_room.offset_x + (tgt_room.width + 1) / 2;
+                let end_row = 1 + tgt_node_row * ROOM_HEIGHT - 1 + tgt_room.offset_y;
                 rooms[src_node_col][src_node_row].connection_down = Some(Connection {
                     start_pos: (start_col, start_row),
                     end_pos: (end_col, end_row),
                 });
             } else {
-                // println!("Right");
+                // Down
-                let start_col = src_node_col * ROOM_WIDTH + ROOM_WIDTH;
+                let start_col =
-                let start_row = src_node_row * ROOM_HEIGHT + ROOM_HEIGHT / 2;
+                    1 + (src_node_col * ROOM_WIDTH) + src_room.offset_x + src_room.width;
-                let end_col = tgt_node_col * ROOM_WIDTH;
+                let start_row =
-                let end_row = tgt_node_row * ROOM_HEIGHT + ROOM_HEIGHT / 2;
+                    1 + src_node_row * ROOM_HEIGHT + src_room.offset_y + (src_room.height - 1) / 2;
+                let end_col = 1 + tgt_node_col * ROOM_WIDTH - 1 + tgt_room.offset_x;
+                let end_row =
+                    1 + tgt_node_row * ROOM_HEIGHT + tgt_room.offset_y + (tgt_room.height - 1) / 2;
                 rooms[src_node_col][src_node_row].connection_right = Some(Connection {
                     start_pos: (start_col, start_row),
                     end_pos: (end_col, end_row),
                 });
             }
         }
-
-        LevelGenerator {
-            level,
-            rooms,
-            rng,
     }
+
+    pub fn generate(level: usize, first: bool, last: bool) -> Self {
+        let mut rng = rand::thread_rng();
+
+        let mut rooms_to_place: Vec<Room> =
+            LevelGenerator::generate_rooms_to_place(&mut rng, level, first, last);
+        let mut rooms: [[Room; 7]; 8] = LevelGenerator::place_rooms(&mut rng, &mut rooms_to_place);
+
+        let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
+        LevelGenerator::create_connections(&mut rooms, &mst);
+        LevelGenerator { level, rooms, rng }
     }
 
     fn select_monster(position: Position, rng: &mut ThreadRng) -> Box<dyn Monster> {
@@ -242,47 +311,49 @@ impl LevelGenerator {
         let mut end_pos = (0, 0);
         let mut monsters: Vec<Box<dyn Monster>> = Vec::with_capacity(10);
         let mut artifacts: Vec<Box<dyn Artifact>> = Vec::with_capacity(10);
-        for col in 0..ROOMS_HORIZONAL {
+        for col in 0..ROOMS_HORIZONTAL {
             for row in 0..ROOMS_VERTICAL {
                 let room = self.rooms[col][row];
                 let position = room.render(&mut structure, col, row);
                 match room.kind {
-                    RoomType::Start => {start_pos=position},
+                    RoomType::Start => start_pos = position,
-                    RoomType::End => {end_pos=position},
+                    RoomType::End => end_pos = position,
-                    RoomType::StairUp => {start_pos=position},
+                    RoomType::StairUp => start_pos = position,
-                    RoomType::StairDown => {end_pos=position},
+                    RoomType::StairDown => end_pos = position,
-                    RoomType::BasicRoom => {},
+                    RoomType::BasicRoom => {}
                     RoomType::ArtifactRoom => {
                         match self.rng.gen_range(1..=100) {
                             1..=50 => {
-                                artifacts
+                                artifacts.push(Box::new(Chest::new(Position::new(
-                                    .push(Box::new(Chest::new(Position::new(self.level, position.0, position.1))));
+                                    self.level, position.0, position.1,
+                                ))));
                             }
                             _ => {
-                                artifacts
+                                artifacts.push(Box::new(Potion::new(Position::new(
-                                    .push(Box::new(Potion::new(Position::new(self.level, position.0, position.1))));
+                                    self.level, position.0, position.1,
+                                ))));
                             }
                         };
-                    },
+                    }
                     RoomType::MonsterRoom => {
                         monsters.push(LevelGenerator::select_monster(
                             Position::new(self.level, position.0, position.1),
                             &mut self.rng,
                         ));
-                    },
+                    }
-                    RoomType::EmptyRoom => {},
+                    RoomType::EmptyRoom => {}
                 }
             }
         }
-        for col in 0..ROOMS_HORIZONAL {
+        for col in 0..ROOMS_HORIZONTAL {
             for row in 0..ROOMS_VERTICAL {
                 if let Some(connection) = self.rooms[col][row].connection_down {
                     // println!("down");
-                    connection.render(&mut structure);
+                    connection.render(&mut self.rng, &mut structure);
                 }
                 if let Some(connection) = self.rooms[col][row].connection_right {
                     // println!("right");
-                    connection.render(&mut structure);
+                    connection.render(&mut self.rng, &mut structure);
                 }
             }
         }
@@ -313,3 +384,571 @@ fn test_level_gen_respects_level() {
     let level = LevelGenerator::generate(1, true, false).render();
     assert_eq!(1, level.level);
 }
+
+#[cfg(test)]
+fn find_room_types(rooms: &Vec<Room>) -> (bool, bool, bool, bool) {
+    let mut start_found = false;
+    let mut end_found: bool = false;
+    let mut down_found: bool = false;
+    let mut up_found: bool = false;
+    for room in rooms {
+        if room.kind == RoomType::Start {
+            start_found = true;
+        }
+        if room.kind == RoomType::End {
+            end_found = true;
+        }
+        if room.kind == RoomType::StairDown {
+            down_found = true;
+        }
+        if room.kind == RoomType::StairUp {
+            up_found = true;
+        }
+    }
+    (start_found, up_found, down_found, end_found)
+}
+#[test]
+fn test_rooms_to_place_first_level() {
+    let mut rng = rand::thread_rng();
+    let res = LevelGenerator::generate_rooms_to_place(&mut rng, 0, true, false);
+    assert!(
+        res.len() <= ROOMS_HORIZONTAL * ROOMS_VERTICAL,
+        "too many rooms created"
+    );
+    assert!(0 < res.len(), "too many rooms created");
+
+    let (start_found, up_found, down_found, end_found) = find_room_types(&res);
+    assert!(start_found);
+    assert!(!end_found);
+    assert!(down_found);
+    assert!(!up_found);
+}
+
+#[test]
+fn test_rooms_to_place_middle_level() {
+    let mut rng = rand::thread_rng();
+    let res = LevelGenerator::generate_rooms_to_place(&mut rng, 1, false, false);
+    assert!(
+        res.len() <= ROOMS_HORIZONTAL * ROOMS_VERTICAL,
+        "too many rooms created"
+    );
+    assert!(0 < res.len(), "too many rooms created");
+
+    let (start_found, up_found, down_found, end_found) = find_room_types(&res);
+    assert!(!start_found);
+    assert!(!end_found);
+    assert!(down_found);
+    assert!(up_found);
+}
+
+#[test]
+fn test_rooms_to_place_last_level() {
+    let mut rng = rand::thread_rng();
+    let res = LevelGenerator::generate_rooms_to_place(&mut rng, 2, false, true);
+    assert!(
+        res.len() <= ROOMS_HORIZONTAL * ROOMS_VERTICAL,
+        "too many rooms created"
+    );
+    assert!(0 < res.len(), "too many rooms created");
+
+    let (start_found, up_found, down_found, end_found) = find_room_types(&res);
+    assert!(!start_found);
+    assert!(end_found);
+    assert!(!down_found);
+    assert!(up_found);
+}
+
+#[cfg(test)]
+fn check_valid_placement(rooms: &[[Room; ROOMS_VERTICAL]; ROOMS_HORIZONTAL]) -> bool {
+    for col in 0..ROOMS_HORIZONTAL {
+        for row in 0..ROOMS_VERTICAL {
+            if rooms[col][row].kind != RoomType::EmptyRoom {
+                let mut count = 0;
+                for test_col in 0..ROOMS_HORIZONTAL {
+                    if rooms[test_col][row].kind != RoomType::EmptyRoom {
+                        count += 1;
+                    }
+                }
+                for test_row in 0..ROOMS_VERTICAL {
+                    if rooms[col][test_row].kind != RoomType::EmptyRoom {
+                        count += 1;
+                    }
+                }
+                if count < 3 {
+                    return false;
+                }
+            }
+        }
+    }
+    true
+}
+
+#[cfg(test)]
+fn count_rooms(rooms: &[[Room; ROOMS_VERTICAL]; ROOMS_HORIZONTAL]) -> usize {
+    let mut res = 0;
+    for col in 0..ROOMS_HORIZONTAL {
+        for row in 0..ROOMS_VERTICAL {
+            if rooms[col][row].kind != RoomType::EmptyRoom {
+                res += 1;
+            }
+        }
+    }
+    res
+}
+
+#[test]
+fn test_place_rooms() {
+    let mut rng = rand::thread_rng();
+    for count in 2..ROOMS_HORIZONTAL * ROOMS_VERTICAL {
+        let mut rooms: Vec<Room> = vec![Room::new(&mut rng), Room::new(&mut rng)];
+        rooms[0].kind = RoomType::Start;
+        rooms[1].kind = RoomType::End;
+        for t in 2..count {
+            rooms.push(Room::new(&mut rng));
+            rooms[t].kind = RoomType::BasicRoom;
+        }
+        let res = LevelGenerator::place_rooms(&mut rng, &mut rooms);
+
+        assert_eq!(count_rooms(&res), count, "counting {}", count);
+        assert!(check_valid_placement(&res));
+    }
+}
+
+#[test]
+fn test_create_mst() {
+    let mut rng = rand::thread_rng();
+    let mut rooms = [[Room::new(&mut rng); ROOMS_VERTICAL]; ROOMS_HORIZONTAL];
+    let res: GeneratorGraph = LevelGenerator::create_mst(&rooms);
+    assert_eq!(res.node_count(), 0);
+    assert_eq!(res.edge_count(), 0);
+
+    rooms[1][1].kind = RoomType::BasicRoom;
+    let res = LevelGenerator::create_mst(&rooms);
+    assert_eq!(res.node_count(), 1);
+    assert_eq!(res.edge_count(), 0);
+
+    rooms[1][3].kind = RoomType::BasicRoom;
+    let res = LevelGenerator::create_mst(&rooms);
+    assert_eq!(res.node_count(), 2);
+    assert_eq!(res.edge_count(), 1);
+
+    rooms[3][1].kind = RoomType::BasicRoom;
+    let res = LevelGenerator::create_mst(&rooms);
+    assert_eq!(res.node_count(), 3);
+    assert_eq!(res.edge_count(), 2);
+
+    rooms[3][3].kind = RoomType::BasicRoom;
+    let res = LevelGenerator::create_mst(&rooms);
+    assert_eq!(res.node_count(), 4);
+    assert_eq!(res.edge_count(), 3);
+
+    rooms[3][5].kind = RoomType::BasicRoom;
+    let res = LevelGenerator::create_mst(&rooms);
+    assert_eq!(res.node_count(), 5);
+    assert_eq!(res.edge_count(), 4);
+}
+
+#[test]
+fn test_create_connections() {
+    let mut rng = rand::thread_rng();
+    let mut rooms = [[Room::new(&mut rng); ROOMS_VERTICAL]; ROOMS_HORIZONTAL];
+    rooms[1][0].width = ROOM_WIDTH - 1;
+    rooms[1][0].offset_x = 0;
+    rooms[1][0].height = ROOM_HEIGHT - 1;
+    rooms[1][0].offset_y = 0;
+    rooms[1][0].kind = RoomType::BasicRoom;
+
+    rooms[3][0].width = ROOM_WIDTH - 1;
+    rooms[3][0].offset_x = 0;
+    rooms[3][0].height = ROOM_HEIGHT - 1;
+    rooms[3][0].offset_y = 0;
+    rooms[3][0].kind = RoomType::BasicRoom;
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
+    println!("{:?}", mst);
+    LevelGenerator::create_connections(&mut rooms, &mst);
+
+    assert!(rooms[1][0].connection_right.is_some());
+    assert_eq!(
+        rooms[1][0].connection_right.unwrap().start_pos,
+        (18, 3),
+        "wrong start"
+    );
+    assert_eq!(
+        rooms[1][0].connection_right.unwrap().end_pos,
+        (27, 3),
+        "wrong end"
+    );
+    assert!(rooms[1][0].connection_down.is_none());
+    assert!(rooms[3][0].connection_down.is_none());
+    assert!(rooms[3][0].connection_right.is_none());
+}
+
+#[test]
+fn test_create_connections_2() {
+    let mut rng = rand::thread_rng();
+    let mut rooms = [[Room::new(&mut rng); ROOMS_VERTICAL]; ROOMS_HORIZONTAL];
+    rooms[1][0].width = ROOM_WIDTH - 1;
+    rooms[1][0].offset_x = 0;
+    rooms[1][0].height = ROOM_HEIGHT - 1;
+    rooms[1][0].offset_y = 0;
+    rooms[1][0].kind = RoomType::BasicRoom;
+
+    rooms[3][0].width = ROOM_WIDTH - 2;
+    rooms[3][0].offset_x = 1;
+    rooms[3][0].height = ROOM_HEIGHT - 1;
+    rooms[3][0].offset_y = 0;
+    rooms[3][0].kind = RoomType::BasicRoom;
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
+    LevelGenerator::create_connections(&mut rooms, &mst);
+
+    assert!(rooms[1][0].connection_right.is_some());
+    assert_eq!(
+        rooms[1][0].connection_right.unwrap().start_pos,
+        (18, 3),
+        "wrong start"
+    );
+    assert_eq!(
+        rooms[1][0].connection_right.unwrap().end_pos,
+        (28, 3),
+        "wrong end"
+    );
+    assert!(rooms[1][0].connection_down.is_none());
+    assert!(rooms[3][0].connection_down.is_none());
+    assert!(rooms[3][0].connection_right.is_none());
+}
+
+#[test]
+fn test_create_connections_d_1() {
+    let mut rng = rand::thread_rng();
+    let mut rooms = [[Room::new(&mut rng); ROOMS_VERTICAL]; ROOMS_HORIZONTAL];
+    rooms[0][1].width = ROOM_WIDTH - 1;
+    rooms[0][1].offset_x = 0;
+    rooms[0][1].height = ROOM_HEIGHT - 1;
+    rooms[0][1].offset_y = 0;
+    rooms[0][1].kind = RoomType::BasicRoom;
+
+    rooms[0][3].width = ROOM_WIDTH - 1;
+    rooms[0][3].offset_x = 0;
+    rooms[0][3].height = ROOM_HEIGHT - 1;
+    rooms[0][3].offset_y = 0;
+    rooms[0][3].kind = RoomType::BasicRoom;
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
+    println!("{:?}", mst);
+    LevelGenerator::create_connections(&mut rooms, &mst);
+
+    assert!(rooms[0][1].connection_down.is_some());
+    assert!(rooms[0][1].connection_right.is_none());
+    assert!(rooms[0][3].connection_down.is_none());
+    assert!(rooms[0][3].connection_right.is_none());
+
+    assert_eq!(
+        rooms[0][1].connection_down.unwrap().start_pos,
+        (4, 12),
+        "wrong start"
+    );
+    assert_eq!(
+        rooms[0][1].connection_down.unwrap().end_pos,
+        (4, 18),
+        "wrong end"
+    );
+}
+
+#[test]
+fn test_create_connections_d_2() {
+    // test full sized rooms for downwards connection
+    let mut rng = rand::thread_rng();
+    let mut rooms = [[Room::new(&mut rng); ROOMS_VERTICAL]; ROOMS_HORIZONTAL];
+    rooms[1][1].width = ROOM_WIDTH - 1;
+    rooms[1][1].offset_x = 0;
+    rooms[1][1].height = ROOM_HEIGHT - 1;
+    rooms[1][1].offset_y = 0;
+    rooms[1][1].kind = RoomType::BasicRoom;
+
+    rooms[1][3].width = ROOM_WIDTH - 1;
+    rooms[1][3].offset_x = 0;
+    rooms[1][3].height = ROOM_HEIGHT - 1;
+    rooms[1][3].offset_y = 0;
+    rooms[1][3].kind = RoomType::BasicRoom;
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
+    LevelGenerator::create_connections(&mut rooms, &mst);
+
+    assert!(rooms[1][1].connection_down.is_some());
+    assert_eq!(
+        rooms[1][1].connection_down.unwrap().start_pos,
+        (13, 12),
+        "wrong start"
+    );
+    assert_eq!(
+        rooms[1][1].connection_down.unwrap().end_pos,
+        (13, 18),
+        "wrong end"
+    );
+    assert!(rooms[1][1].connection_right.is_none());
+    assert!(rooms[1][2].connection_down.is_none());
+    assert!(rooms[1][2].connection_right.is_none());
+}
+
+#[test]
+fn test_create_connections_d_3() {
+    // test reduced width rooms (with overlap) for downwards connection
+    let mut rng = rand::thread_rng();
+    let mut rooms = [[Room::new(&mut rng); ROOMS_VERTICAL]; ROOMS_HORIZONTAL];
+    rooms[1][1].width = 5;
+    rooms[1][1].offset_x = 0;
+    rooms[1][1].height = ROOM_HEIGHT - 1;
+    rooms[1][1].offset_y = 0;
+    rooms[1][1].kind = RoomType::BasicRoom;
+
+    rooms[1][3].width = 5;
+    rooms[1][3].offset_x = 4;
+    rooms[1][3].height = ROOM_HEIGHT - 1;
+    rooms[1][3].offset_y = 0;
+    rooms[1][3].kind = RoomType::BasicRoom;
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
+    LevelGenerator::create_connections(&mut rooms, &mst);
+
+    assert!(rooms[1][1].connection_down.is_some());
+    assert_eq!(
+        rooms[1][1].connection_down.unwrap().start_pos,
+        (ROOM_WIDTH + 3, ROOM_HEIGHT * 2),
+        "wrong start"
+    );
+    assert_eq!(
+        rooms[1][1].connection_down.unwrap().end_pos,
+        (ROOM_WIDTH + 7, ROOM_HEIGHT * 3),
+        "wrong end"
+    );
+    assert!(rooms[1][1].connection_right.is_none());
+    assert!(rooms[1][3].connection_down.is_none());
+    assert!(rooms[1][3].connection_right.is_none());
+}
+
+#[test]
+fn test_create_connections_d_4() {
+    // test reduced width rooms (with NO overlap) for downwards connection
+    let mut rng = rand::thread_rng();
+    let mut rooms = [[Room::new(&mut rng); ROOMS_VERTICAL]; ROOMS_HORIZONTAL];
+    rooms[1][1].width = 3;
+    rooms[1][1].offset_x = 0;
+    rooms[1][1].height = ROOM_HEIGHT - 1;
+    rooms[1][1].offset_y = 0;
+    rooms[1][1].kind = RoomType::BasicRoom;
+
+    rooms[1][3].width = 3;
+    rooms[1][3].offset_x = 5;
+    rooms[1][3].height = ROOM_HEIGHT - 1;
+    rooms[1][3].offset_y = 0;
+    rooms[1][3].kind = RoomType::BasicRoom;
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
+    LevelGenerator::create_connections(&mut rooms, &mst);
+
+    assert!(rooms[1][1].connection_down.is_some());
+    assert_eq!(
+        rooms[1][1].connection_down.unwrap().start_pos,
+        (ROOM_WIDTH + 2, ROOM_HEIGHT * 2),
+        "wrong start"
+    );
+    assert_eq!(
+        rooms[1][1].connection_down.unwrap().end_pos,
+        (ROOM_WIDTH + 7, ROOM_HEIGHT * 3),
+        "wrong end"
+    );
+    assert!(rooms[1][1].connection_right.is_none());
+    assert!(rooms[1][3].connection_down.is_none());
+    assert!(rooms[1][3].connection_right.is_none());
+}
+
+#[test]
+fn test_create_connections_d_5() {
+    // test reduced and moved width rooms (with NO overlap) for downwards connection
+    let mut rng = rand::thread_rng();
+    let mut rooms = [[Room::new(&mut rng); ROOMS_VERTICAL]; ROOMS_HORIZONTAL];
+    rooms[1][1].width = 3;
+    rooms[1][1].offset_x = 0;
+    rooms[1][1].height = 4;
+    rooms[1][1].offset_y = 0;
+    rooms[1][1].kind = RoomType::BasicRoom;
+
+    rooms[1][3].width = 3;
+    rooms[1][3].offset_x = 5;
+    rooms[1][3].height = 4;
+    rooms[1][3].offset_y = 1;
+    rooms[1][3].kind = RoomType::BasicRoom;
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
+    LevelGenerator::create_connections(&mut rooms, &mst);
+
+    assert!(rooms[1][1].connection_down.is_some());
+    assert_eq!(
+        rooms[1][1].connection_down.unwrap().start_pos,
+        (11, 11),
+        "wrong start"
+    );
+    assert_eq!(
+        rooms[1][1].connection_down.unwrap().end_pos,
+        (16, 19),
+        "wrong end"
+    );
+    assert!(rooms[1][1].connection_right.is_none());
+    assert!(rooms[1][3].connection_down.is_none());
+    assert!(rooms[1][3].connection_right.is_none());
+}
+
+#[test]
+fn test_create_connections_right_1() {
+    let mut rng = rand::thread_rng();
+    let mut rooms = [[Room::new(&mut rng); ROOMS_VERTICAL]; ROOMS_HORIZONTAL];
+    rooms[1][1].width = ROOM_WIDTH - 1;
+    rooms[1][1].offset_x = 0;
+    rooms[1][1].height = ROOM_HEIGHT - 1;
+    rooms[1][1].offset_y = 0;
+    rooms[1][1].kind = RoomType::BasicRoom;
+
+    rooms[3][1].width = ROOM_WIDTH - 1;
+    rooms[3][1].offset_x = 0;
+    rooms[3][1].height = ROOM_HEIGHT - 1;
+    rooms[3][1].offset_y = 0;
+    rooms[3][1].kind = RoomType::BasicRoom;
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
+    LevelGenerator::create_connections(&mut rooms, &mst);
+
+    assert!(rooms[1][1].connection_down.is_none());
+    assert!(rooms[1][1].connection_right.is_some());
+    assert_eq!(
+        rooms[1][1].connection_right.unwrap().start_pos,
+        (18, 9),
+        "wrong start"
+    );
+    assert_eq!(
+        rooms[1][1].connection_right.unwrap().end_pos,
+        (27, 9),
+        "wrong end"
+    );
+    assert!(rooms[3][1].connection_down.is_none());
+    assert!(rooms[3][1].connection_right.is_none());
+}
+
+#[test]
+fn test_create_connections_right_2() {
+    // test reduced width rooms (with overlap) for downwards connection
+    let mut rng = rand::thread_rng();
+    let mut rooms = [[Room::new(&mut rng); ROOMS_VERTICAL]; ROOMS_HORIZONTAL];
+    rooms[1][1].width = ROOM_WIDTH - 1;
+    rooms[1][1].offset_x = 0;
+    rooms[1][1].height = 4;
+    rooms[1][1].offset_y = 0;
+    rooms[1][1].kind = RoomType::BasicRoom;
+
+    rooms[3][1].width = ROOM_WIDTH - 1;
+    rooms[3][1].offset_x = 0;
+    rooms[3][1].height = 4;
+    rooms[3][1].offset_y = 2;
+    rooms[3][1].kind = RoomType::BasicRoom;
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
+    LevelGenerator::create_connections(&mut rooms, &mst);
+
+    assert!(rooms[1][1].connection_down.is_none());
+    assert!(rooms[1][1].connection_right.is_some());
+    assert_eq!(
+        rooms[1][1].connection_right.unwrap().start_pos,
+        (18, 8),
+        "wrong start"
+    );
+    assert_eq!(
+        rooms[1][1].connection_right.unwrap().end_pos,
+        (27, 10),
+        "wrong end"
+    );
+    assert!(rooms[1][2].connection_down.is_none());
+    assert!(rooms[1][2].connection_right.is_none());
+}
+
+#[test]
+fn test_create_connections_right_3() {
+    // test reduced width rooms (with NO overlap) for downwards connection
+    let mut rng = rand::thread_rng();
+    let mut rooms = [[Room::new(&mut rng); ROOMS_VERTICAL]; ROOMS_HORIZONTAL];
+    rooms[1][1].width = ROOM_WIDTH - 1;
+    rooms[1][1].offset_x = 0;
+    rooms[1][1].height = 2;
+    rooms[1][1].offset_y = 0;
+    rooms[1][1].kind = RoomType::BasicRoom;
+
+    rooms[3][1].width = ROOM_WIDTH - 1;
+    rooms[3][1].offset_x = 0;
+    rooms[3][1].height = 2;
+    rooms[3][1].offset_y = 4;
+    rooms[3][1].kind = RoomType::BasicRoom;
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
+    LevelGenerator::create_connections(&mut rooms, &mst);
+
+    assert!(rooms[1][1].connection_down.is_none());
+    assert!(rooms[1][1].connection_right.is_some());
+    assert_eq!(
+        rooms[1][1].connection_right.unwrap().start_pos,
+        (18, 7),
+        "wrong start"
+    );
+    assert_eq!(
+        rooms[1][1].connection_right.unwrap().end_pos,
+        (27, 11),
+        "wrong end"
+    );
+    assert!(rooms[1][3].connection_down.is_none());
+    assert!(rooms[1][3].connection_right.is_none());
+}
+
+#[test]
+fn test_create_connections_right_4() {
+    // test reduced width rooms (with NO overlap) for downwards connection
+    let mut rng = rand::thread_rng();
+    let mut rooms = [[Room::new(&mut rng); ROOMS_VERTICAL]; ROOMS_HORIZONTAL];
+    rooms[1][1].width = 4;
+    rooms[1][1].offset_x = 3;
+    rooms[1][1].height = 2;
+    rooms[1][1].offset_y = 0;
+    rooms[1][1].kind = RoomType::BasicRoom;
+
+    rooms[3][1].width = 3;
+    rooms[3][1].offset_x = 3;
+    rooms[3][1].height = 2;
+    rooms[3][1].offset_y = 4;
+    rooms[3][1].kind = RoomType::BasicRoom;
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
+    LevelGenerator::create_connections(&mut rooms, &mst);
+
+    assert!(rooms[1][1].connection_down.is_none());
+    assert!(rooms[1][1].connection_right.is_some());
+    assert_eq!(
+        rooms[1][1].connection_right.unwrap().start_pos,
+        (17, 7),
+        "wrong start"
+    );
+    assert_eq!(
+        rooms[1][1].connection_right.unwrap().end_pos,
+        (30, 11),
+        "wrong end"
+    );
+    assert!(rooms[1][3].connection_down.is_none());
+    assert!(rooms[1][3].connection_right.is_none());
+}
+
+// /*
+//        println!("  0 1 2 3 4 5 6 7");
+//        for r in 0..ROOMS_VERTICAL {
+//            print!("{} ", r);
+//            for c in 0..ROOMS_HORIZONTAL {
+//                match res[c][r].kind {
+//                    RoomType::Start => print!("S "),
+//                    RoomType::End => print!("E "),
+//                    RoomType::StairUp => print!("< "),
+//                    RoomType::StairDown => print!("> "),
+//                    RoomType::BasicRoom => print!("_ "),
+//                    RoomType::ArtifactRoom => print!("A "),
+//                    RoomType::MonsterRoom => print!("M "),
+//                    RoomType::EmptyRoom => print!("  "),
+//                };
+//            }
+//            println!();
+//        }
+//        println!();
+// */

src/level_widget.rs

@@ -17,7 +17,11 @@ impl LevelWidget {
         buf[(x, y)].set_symbol(symbol).set_bg(bg).set_fg(fg);
     }
     fn set_bold_cell(&self, buf: &mut Buffer, x: u16, y: u16, symbol: &str, fg: Color, bg: Color) {
-        buf[(x, y)].set_symbol(symbol).set_bg(bg).set_fg(fg).set_style(Style::new().add_modifier(Modifier::BOLD));
+        buf[(x, y)]
+            .set_symbol(symbol)
+            .set_bg(bg)
+            .set_fg(fg)
+            .set_style(Style::new().add_modifier(Modifier::BOLD));
     }
 }
 

src/monster.rs

@@ -45,7 +45,7 @@ create_monster!(
     name:"rat".to_string(),
     life: 2,
     symbol: String::from("r"),
-    color: Color::Black,
+    color: Color::White,
     experience_gain: 5,
     ticks_between_steps: 5,
     damage_range: 1..=2,
@@ -56,7 +56,7 @@ create_monster!(
     name:"spider".to_string(),
     life: 3,
     symbol: String::from("s"),
-    color: Color::Blue,
+    color: Color::Yellow,
     experience_gain: 7,
     ticks_between_steps: 7,
     damage_range: 2..=3,
@@ -67,7 +67,7 @@ create_monster!(
     name: "orc".to_string(),
     life: 4,
     symbol: String::from("O"),
-    color: Color::DarkGray,
+    color: Color::Gray,
     experience_gain: 10,
     ticks_between_steps: 10,
     damage_range: 2..=3,
@@ -78,7 +78,7 @@ create_monster!(
     name: "snake".to_string(),
     life: 3,
     symbol: String::from("s"),
-    color: Color::Black,
+    color: Color::White,
     experience_gain: 10,
     ticks_between_steps: 20,
     damage_range: 1..=4,
@@ -89,7 +89,7 @@ create_monster!(
     name: "skeleton".to_string(),
     life: 3,
     symbol: String::from("S"),
-    color: Color::DarkGray,
+    color: Color::Gray,
     experience_gain: 20,
     ticks_between_steps: 10,
     damage_range: 1..=5,

src/room.rs

@@ -1,10 +1,12 @@
 use std::{
     cmp::{max, min},
-    ops::Range,
+    ops::RangeInclusive,
 };
 
 use crate::{
-    constants::{LEVEL_HEIGHT, LEVEL_WIDTH, ROOM_HEIGHT, ROOM_WIDTH},
+    constants::{
+        LEVEL_HEIGHT, LEVEL_WIDTH, ROOM_HEIGHT, ROOM_MIN_HEIGHT, ROOM_MIN_WIDTH, ROOM_WIDTH,
+    },
     level::StructureElement,
 };
 use rand::rngs::ThreadRng;
@@ -29,23 +31,78 @@ pub struct Connection {
 }
 
 impl Connection {
-    pub fn render(&self, tgt: &mut [[StructureElement; LEVEL_HEIGHT]; LEVEL_WIDTH]) {
+    pub fn render(
+        &self,
+        rng: &mut ThreadRng,
+        tgt: &mut [[StructureElement; LEVEL_HEIGHT]; LEVEL_WIDTH],
+    ) {
+        fn calc_range(a: usize, b: usize) -> RangeInclusive<usize> {
+            if a > b {
+                b..=a
+            } else {
+                a..=b
+            }
+        }
         // the tuples are (col, row)
-        println!("{:?} -> {:?}",self.start_pos, self.end_pos);
+        let abs_d_col =
-        let d_col = max(self.start_pos.0, self.end_pos.0) - min(self.start_pos.0, self.end_pos.0);
+            max(self.start_pos.0, self.end_pos.0) - min(self.start_pos.0, self.end_pos.0);
 
-        let d_row = max(self.start_pos.1, self.end_pos.1) - min(self.start_pos.1, self.end_pos.1);
+        let abs_d_row =
+            max(self.start_pos.1, self.end_pos.1) - min(self.start_pos.1, self.end_pos.1);
 
-        if d_col == 0 {
+        if abs_d_col == 0 {
-            for row in self.start_pos.1..=self.end_pos.1 {
+            for row in calc_range(self.end_pos.1, self.start_pos.1) {
                 tgt[self.end_pos.0][row] = StructureElement::Floor;
             }
-        } 
+        } else if abs_d_row == 0 {
-        if d_row == 0 {
+            for col in calc_range(self.end_pos.0, self.start_pos.0) {
-            for col in self.start_pos.0..=self.end_pos.0 {
                 tgt[col][self.end_pos.1] = StructureElement::Floor;
             }
-
+        } else {
+            let d_row = self.end_pos.1 as i32 - self.start_pos.1 as i32;
+            if d_row > 0 {
+                // more up/down
+                let d_row = self.end_pos.1 - self.start_pos.1;
+                let vert_offset = if d_row > 3 {
+                    rng.gen_range(1..=d_row - 1)
+                } else {
+                    d_row / 2
+                };
+                for r in self.start_pos.1..=(self.start_pos.1 + vert_offset) {
+                    tgt[self.start_pos.0][r] = StructureElement::Floor;
+                }
+                for c in calc_range(self.end_pos.0, self.start_pos.0) {
+                    tgt[c][self.start_pos.1 + vert_offset] = StructureElement::Floor;
+                }
+                for r in (self.start_pos.1 + vert_offset)..=self.end_pos.1 {
+                    tgt[self.end_pos.0][r] = StructureElement::Floor;
+                }
+            } else {
+                // more left/right
+                let d_col = self.end_pos.0 - self.start_pos.0;
+                let horizont_offset = if d_col > 3 {
+                    rng.gen_range(1..=d_col - 1)
+                } else {
+                    d_col / 2
+                };
+                for tgt_col in tgt
+                    .iter_mut()
+                    .skip(self.start_pos.0)
+                    .take(horizont_offset + 1)
+                {
+                    tgt_col[self.start_pos.1] = StructureElement::Floor;
+                }
+                for r in calc_range(self.end_pos.1, self.start_pos.1) {
+                    tgt[self.start_pos.0 + horizont_offset][r] = StructureElement::Floor;
+                }
+                for tgt_col in tgt
+                    .iter_mut()
+                    .take(self.end_pos.0 + 1)
+                    .skip(self.start_pos.0 + horizont_offset)
+                {
+                    tgt_col[self.end_pos.1] = StructureElement::Floor;
+                }
+            }
         }
     }
 }
@@ -64,12 +121,12 @@ pub struct Room {
 
 impl Room {
     pub fn new(rng: &mut ThreadRng) -> Self {
-        let width = ROOM_WIDTH-1; //rng.gen_range(3..ROOM_WIDTH);
+        let width = rng.gen_range(ROOM_MIN_WIDTH..ROOM_WIDTH);
-        let height = ROOM_HEIGHT-1; //rng.gen_range(3..ROOM_HEIGHT);
+        let height = rng.gen_range(ROOM_MIN_HEIGHT..ROOM_HEIGHT);
-        let offset_x = 0; //rng.gen_range(0..(ROOM_WIDTH - width));
+        let offset_x = rng.gen_range(0..(ROOM_WIDTH - width));
-        let offset_y = 0; //rng.gen_range(0..(ROOM_HEIGHT - height));
+        let offset_y = rng.gen_range(0..(ROOM_HEIGHT - height));
-        let sx = offset_x + rng.gen_range(1..width-1);
+        let sx = offset_x + rng.gen_range(1..width - 1);
-        let sy = offset_y + rng.gen_range(1..height-1);
+        let sy = offset_y + rng.gen_range(1..height - 1);
 
         Self {
             kind: RoomType::EmptyRoom,
@@ -83,13 +140,13 @@ impl Room {
         }
     }
 
-    pub fn get_x_range(&self) -> Range<usize> {
+    // pub fn get_x_range(&self) -> Range<usize> {
-        self.offset_x..self.offset_x + self.width
+    //     self.offset_x..self.offset_x + self.width
-    }
+    // }
 
-    pub fn get_y_range(&self) -> Range<usize> {
+    // pub fn get_y_range(&self) -> Range<usize> {
-        self.offset_y..self.offset_y + self.height
+    //     self.offset_y..self.offset_y + self.height
-    }
+    // }
 
     pub fn render(
         &self,