cleanup

src/constants.rs

@@ -12,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;
@@ -40,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!(
@@ -73,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::MonsterRoom, 5),
+            (RoomType::ArtifactRoom, 10),
+            (RoomType::MonsterRoom, 20),
             (RoomType::BasicRoom, 20),
         ],
         // level 2
@@ -85,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;
 
@@ -24,6 +25,7 @@ use crate::{
     room::{Room, RoomType},
 };
 
+type GeneratorGraph = Graph<(usize, usize), usize, petgraph::Undirected>;
 pub struct LevelGenerator {
     level: usize,
     rooms: [[Room; ROOMS_VERTICAL]; ROOMS_HORIZONTAL],
@@ -134,10 +136,13 @@ impl LevelGenerator {
         rooms
     }
 
-    fn create_mst(
-        rooms: &[[Room; ROOMS_VERTICAL]; ROOMS_HORIZONTAL],
-    ) -> Graph<(usize, usize), u16, petgraph::Undirected> {
-        let mut graph = UnGraph::<(usize, usize), u16>::default();
+    fn create_mst(rooms: &[[Room; ROOMS_VERTICAL]; ROOMS_HORIZONTAL]) -> GeneratorGraph {
+        // calculate the weight of an edge
+        fn calc_edge_weight(delta: usize) -> usize {
+            delta * delta
+        }
+
+        let mut graph: GeneratorGraph = UnGraph::<(usize, usize), usize>::default();
         for (col, tgt_col) in rooms.iter().enumerate().take(ROOMS_HORIZONTAL) {
             for (row, room) in tgt_col.iter().enumerate().take(ROOMS_VERTICAL) {
                 if room.kind != RoomType::EmptyRoom {
@@ -161,7 +166,11 @@ impl LevelGenerator {
                             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;
                             }
                         }
@@ -171,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;
                             }
                         }
@@ -179,13 +192,40 @@ impl LevelGenerator {
                 }
             }
         }
-        Graph::from_elements(min_spanning_tree(&graph))
-        // graph
+        let mut mst: GeneratorGraph = 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: &Graph<(usize, usize), u16, petgraph::Undirected>,
+        mst: &GeneratorGraph,
     ) {
         for edge in mst.raw_edges() {
             // the tuples are (col, row)
@@ -231,8 +271,7 @@ impl LevelGenerator {
             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: Graph<(usize, usize), u16, petgraph::Undirected> =
-            LevelGenerator::create_mst(&rooms);
+        let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
         LevelGenerator::create_connections(&mut rooms, &mst);
         LevelGenerator { level, rooms, rng }
     }
@@ -314,7 +353,7 @@ impl LevelGenerator {
                 }
                 if let Some(connection) = self.rooms[col][row].connection_right {
                     // println!("right");
-                    connection.render(&mut self.rng,&mut structure);
+                    connection.render(&mut self.rng, &mut structure);
                 }
             }
         }
@@ -333,7 +372,6 @@ impl LevelGenerator {
 
 #[test]
 fn test_level_gen() {
-    let mut rng = rand::thread_rng();
     for _ in 0..1000 {
         LevelGenerator::generate(0, true, false).render();
     }
@@ -341,7 +379,6 @@ fn test_level_gen() {
 
 #[test]
 fn test_level_gen_respects_level() {
-    let mut rng = rand::thread_rng();
     let level = LevelGenerator::generate(0, true, false).render();
     assert_eq!(0, level.level);
     let level = LevelGenerator::generate(1, true, false).render();
@@ -481,7 +518,7 @@ fn test_place_rooms() {
 fn test_create_mst() {
     let mut rng = rand::thread_rng();
     let mut rooms = [[Room::new(&mut rng); ROOMS_VERTICAL]; ROOMS_HORIZONTAL];
-    let res: Graph<(usize, usize), u16, petgraph::Undirected> = LevelGenerator::create_mst(&rooms);
+    let res: GeneratorGraph = LevelGenerator::create_mst(&rooms);
     assert_eq!(res.node_count(), 0);
     assert_eq!(res.edge_count(), 0);
 
@@ -526,7 +563,7 @@ fn test_create_connections() {
     rooms[3][0].height = ROOM_HEIGHT - 1;
     rooms[3][0].offset_y = 0;
     rooms[3][0].kind = RoomType::BasicRoom;
-    let mst: Graph<(usize, usize), u16, petgraph::Undirected> = LevelGenerator::create_mst(&rooms);
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
     println!("{:?}", mst);
     LevelGenerator::create_connections(&mut rooms, &mst);
 
@@ -561,7 +598,7 @@ fn test_create_connections_2() {
     rooms[3][0].height = ROOM_HEIGHT - 1;
     rooms[3][0].offset_y = 0;
     rooms[3][0].kind = RoomType::BasicRoom;
-    let mst: Graph<(usize, usize), u16, petgraph::Undirected> = LevelGenerator::create_mst(&rooms);
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
     LevelGenerator::create_connections(&mut rooms, &mst);
 
     assert!(rooms[1][0].connection_right.is_some());
@@ -595,7 +632,7 @@ fn test_create_connections_d_1() {
     rooms[0][3].height = ROOM_HEIGHT - 1;
     rooms[0][3].offset_y = 0;
     rooms[0][3].kind = RoomType::BasicRoom;
-    let mst: Graph<(usize, usize), u16, petgraph::Undirected> = LevelGenerator::create_mst(&rooms);
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
     println!("{:?}", mst);
     LevelGenerator::create_connections(&mut rooms, &mst);
 
@@ -632,7 +669,7 @@ fn test_create_connections_d_2() {
     rooms[1][3].height = ROOM_HEIGHT - 1;
     rooms[1][3].offset_y = 0;
     rooms[1][3].kind = RoomType::BasicRoom;
-    let mst: Graph<(usize, usize), u16, petgraph::Undirected> = LevelGenerator::create_mst(&rooms);
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
     LevelGenerator::create_connections(&mut rooms, &mst);
 
     assert!(rooms[1][1].connection_down.is_some());
@@ -667,7 +704,7 @@ fn test_create_connections_d_3() {
     rooms[1][3].height = ROOM_HEIGHT - 1;
     rooms[1][3].offset_y = 0;
     rooms[1][3].kind = RoomType::BasicRoom;
-    let mst: Graph<(usize, usize), u16, petgraph::Undirected> = LevelGenerator::create_mst(&rooms);
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
     LevelGenerator::create_connections(&mut rooms, &mst);
 
     assert!(rooms[1][1].connection_down.is_some());
@@ -702,7 +739,7 @@ fn test_create_connections_d_4() {
     rooms[1][3].height = ROOM_HEIGHT - 1;
     rooms[1][3].offset_y = 0;
     rooms[1][3].kind = RoomType::BasicRoom;
-    let mst: Graph<(usize, usize), u16, petgraph::Undirected> = LevelGenerator::create_mst(&rooms);
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
     LevelGenerator::create_connections(&mut rooms, &mst);
 
     assert!(rooms[1][1].connection_down.is_some());
@@ -737,7 +774,7 @@ fn test_create_connections_d_5() {
     rooms[1][3].height = 4;
     rooms[1][3].offset_y = 1;
     rooms[1][3].kind = RoomType::BasicRoom;
-    let mst: Graph<(usize, usize), u16, petgraph::Undirected> = LevelGenerator::create_mst(&rooms);
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
     LevelGenerator::create_connections(&mut rooms, &mst);
 
     assert!(rooms[1][1].connection_down.is_some());
@@ -771,7 +808,7 @@ fn test_create_connections_right_1() {
     rooms[3][1].height = ROOM_HEIGHT - 1;
     rooms[3][1].offset_y = 0;
     rooms[3][1].kind = RoomType::BasicRoom;
-    let mst: Graph<(usize, usize), u16, petgraph::Undirected> = LevelGenerator::create_mst(&rooms);
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
     LevelGenerator::create_connections(&mut rooms, &mst);
 
     assert!(rooms[1][1].connection_down.is_none());
@@ -806,7 +843,7 @@ fn test_create_connections_right_2() {
     rooms[3][1].height = 4;
     rooms[3][1].offset_y = 2;
     rooms[3][1].kind = RoomType::BasicRoom;
-    let mst: Graph<(usize, usize), u16, petgraph::Undirected> = LevelGenerator::create_mst(&rooms);
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
     LevelGenerator::create_connections(&mut rooms, &mst);
 
     assert!(rooms[1][1].connection_down.is_none());
@@ -841,7 +878,7 @@ fn test_create_connections_right_3() {
     rooms[3][1].height = 2;
     rooms[3][1].offset_y = 4;
     rooms[3][1].kind = RoomType::BasicRoom;
-    let mst: Graph<(usize, usize), u16, petgraph::Undirected> = LevelGenerator::create_mst(&rooms);
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
     LevelGenerator::create_connections(&mut rooms, &mst);
 
     assert!(rooms[1][1].connection_down.is_none());
@@ -876,7 +913,7 @@ fn test_create_connections_right_4() {
     rooms[3][1].height = 2;
     rooms[3][1].offset_y = 4;
     rooms[3][1].kind = RoomType::BasicRoom;
-    let mst: Graph<(usize, usize), u16, petgraph::Undirected> = LevelGenerator::create_mst(&rooms);
+    let mst: GeneratorGraph = LevelGenerator::create_mst(&rooms);
     LevelGenerator::create_connections(&mut rooms, &mst);
 
     assert!(rooms[1][1].connection_down.is_none());

src/room.rs

@@ -1,7 +1,12 @@
-use std::{cmp::{max, min}, ops::RangeInclusive};
+use std::{
+    cmp::{max, min},
+    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;
@@ -26,12 +31,16 @@ pub struct Connection {
 }
 
 impl Connection {
-    pub fn render(&self, rng: &mut ThreadRng, tgt: &mut [[StructureElement; LEVEL_HEIGHT]; LEVEL_WIDTH])  {
-        fn calc_range(a: usize, b:usize) -> RangeInclusive<usize>{
+    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
+                b..=a
             } else {
-               a..=b
+                a..=b
             }
         }
         // the tuples are (col, row)
@@ -42,7 +51,7 @@ impl Connection {
             max(self.start_pos.1, self.end_pos.1) - min(self.start_pos.1, self.end_pos.1);
 
         if abs_d_col == 0 {
-            for row in calc_range(self.end_pos.1, self.start_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 {
@@ -55,8 +64,10 @@ impl Connection {
                 // 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};
+                    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;
                 }
@@ -69,16 +80,25 @@ impl Connection {
             } else {
                 // more left/right
                 let d_col = self.end_pos.0 - self.start_pos.0;
-                for tgt_col in tgt.iter_mut().skip(self.start_pos.0).take(d_col / 2 + 1) {
+                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 + d_col / 2][r] = StructureElement::Floor;
+                    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 + d_col / 2)
+                    .skip(self.start_pos.0 + horizont_offset)
                 {
                     tgt_col[self.end_pos.1] = StructureElement::Floor;
                 }
@@ -101,8 +121,8 @@ pub struct Room {
 
 impl Room {
     pub fn new(rng: &mut ThreadRng) -> Self {
-        let width = rng.gen_range(3..ROOM_WIDTH);
-        let height = rng.gen_range(3..ROOM_HEIGHT);
+        let width = rng.gen_range(ROOM_MIN_WIDTH..ROOM_WIDTH);
+        let height = rng.gen_range(ROOM_MIN_HEIGHT..ROOM_HEIGHT);
         let offset_x = rng.gen_range(0..(ROOM_WIDTH - width));
         let offset_y = rng.gen_range(0..(ROOM_HEIGHT - height));
         let sx = offset_x + rng.gen_range(1..width - 1);