implement local highscore list

fix formatting
rename monster.rs to monsters.rs
2024-12-07 08:43:02 +01:00 · 2024-11-25 21:20:36 +01:00 · 2024-11-25 07:20:03 +01:00 · 2024-11-24 13:30:31 +01:00 · 2024-11-24 13:30:10 +01:00 · 2024-11-24 13:24:39 +01:00
15 changed files with 799 additions and 194 deletions
--- a/.gitea/workflows/publish.yaml
+++ b/.gitea/workflows/publish.yaml
@@ -22,3 +22,7 @@ jobs:
          ls -al target/debian
          UPLOAD_FILE=$(ls target/debian/*.deb)
          curl --user jlusiardi:${{ secrets.UPLOAD_TOKEN }} --upload-file ${UPLOAD_FILE} https://gitea.intern.haus-in-hirschaid.de/api/packages/jlusiardi/debian/pool/bionic/main/upload          
+          echo -e "${{ secrets.DEPLOY_PRIVATE_KEY }}" > /tmp/ssh_key
+          chmod 0600 /tmp/ssh_key
+          scp -o StrictHostKeyChecking=no -i /tmp/ssh_key ${UPLOAD_FILE} jlusiardi@april2023.lusiardi.de:/var/www/p17.lusiardi.de/el_diabolo
+          ssh -o StrictHostKeyChecking=no -i /tmp/ssh_key jlusiardi@april2023.lusiardi.de /var/www/p17.lusiardi.de/el_diabolo/generate_index.sh
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -20,6 +20,21 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5"

+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.1.0"
@@ -59,12 +74,41 @@ dependencies = [
 "rustversion",
 ]

+[[package]]
+name = "cc"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f34d93e62b03caf570cccc334cbc6c2fceca82f39211051345108adcba3eebdc"
+dependencies = [
+ "shlex",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
+name = "chrono"
+version = "0.4.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "compact_str"
 version = "0.8.0"
@@ -79,6 +123,12 @@ dependencies = [
 "static_assertions",
 ]

+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
 [[package]]
 name = "crossterm"
 version = "0.28.1"
@@ -147,13 +197,18 @@ checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"

 [[package]]
 name = "el_diabolo"
-version = "0.1.0"
+version = "0.2.3"
 dependencies = [
+ "chrono",
 "crossterm",
+ "homedir",
 "macros",
 "petgraph",
 "rand",
 "ratatui",
+ "serde",
+ "serde_json",
+ "tempfile",
 "whoami",
 ]

@@ -173,6 +228,12 @@ dependencies = [
 "windows-sys",
 ]

+[[package]]
+name = "fastrand"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "486f806e73c5707928240ddc295403b1b93c96a02038563881c4a2fd84b81ac4"
+
 [[package]]
 name = "fixedbitset"
 version = "0.4.2"
@@ -218,6 +279,41 @@ version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"

+[[package]]
+name = "homedir"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bdbbd5bc8c5749697ccaa352fa45aff8730cf21c68029c0eef1ffed7c3d6ba2"
+dependencies = [
+ "cfg-if",
+ "nix",
+ "widestring",
+ "windows",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.61"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows-core 0.52.0",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -234,6 +330,12 @@ dependencies = [
 "hashbrown",
 ]

+[[package]]
+name = "indoc"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
+
 [[package]]
 name = "instability"
 version = "0.3.2"
@@ -315,6 +417,12 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
 [[package]]
 name = "mio"
 version = "1.0.2"
@@ -329,10 +437,31 @@ dependencies = [
 ]

 [[package]]
-name = "once_cell"
-version = "1.18.0"
+name = "nix"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
+dependencies = [
+ "bitflags 2.4.1",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"

 [[package]]
 name = "parking_lot"
@@ -429,23 +558,23 @@ dependencies = [

 [[package]]
 name = "ratatui"
-version = "0.28.1"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdef7f9be5c0122f890d58bdf4d964349ba6a6161f705907526d891efabba57d"
+checksum = "eabd94c2f37801c20583fc49dd5cd6b0ba68c716787c2dd6ed18571e1e63117b"
 dependencies = [
 "bitflags 2.4.1",
 "cassowary",
 "compact_str",
 "crossterm",
+ "indoc",
 "instability",
 "itertools",
 "lru",
 "paste",
 "strum",
- "strum_macros",
 "unicode-segmentation",
 "unicode-truncate",
- "unicode-width",
+ "unicode-width 0.2.0",
 ]

 [[package]]
@@ -468,9 +597,9 @@ dependencies = [

 [[package]]
 name = "rustix"
-version = "0.38.37"
+version = "0.38.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811"
+checksum = "d7f649912bc1495e167a6edee79151c84b1bad49748cb4f1f1167f459f6224f6"
 dependencies = [
 "bitflags 2.4.1",
 "errno",
@@ -497,6 +626,44 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"

+[[package]]
+name = "serde"
+version = "1.0.215"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.215"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.133"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
 [[package]]
 name = "signal-hook"
 version = "0.3.17"
@@ -578,6 +745,19 @@ dependencies = [
 "unicode-ident",
 ]

+[[package]]
+name = "tempfile"
+version = "3.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28cce251fcbc87fac86a866eeb0d6c2d536fc16d06f184bb61aeae11aa4cee0c"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "once_cell",
+ "rustix",
+ "windows-sys",
+]
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.12"
@@ -598,7 +778,7 @@ checksum = "b3644627a5af5fa321c95b9b235a72fd24cd29c648c2c379431e6628655627bf"
 dependencies = [
 "itertools",
 "unicode-segmentation",
- "unicode-width",
+ "unicode-width 0.1.14",
 ]

 [[package]]
@@ -607,6 +787,12 @@ version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"

+[[package]]
+name = "unicode-width"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
+
 [[package]]
 name = "version_check"
 version = "0.9.4"
@@ -700,6 +886,12 @@ dependencies = [
 "web-sys",
 ]

+[[package]]
+name = "widestring"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7219d36b6eac893fa81e84ebe06485e7dcbb616177469b142df14f1f4deb1311"
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -722,6 +914,68 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

+[[package]]
+name = "windows"
+version = "0.57.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12342cb4d8e3b046f3d80effd474a7a02447231330ef77d71daa6fbc40681143"
+dependencies = [
+ "windows-core 0.57.0",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.57.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2ed2439a290666cd67ecce2b0ffaad89c2a56b976b736e6ece670297897832d"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-result",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.57.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9107ddc059d5b6fbfbffdfa7a7fe3e22a226def0b2608f72e9d552763d3e1ad7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.57.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29bee4b38ea3cde66011baa44dba677c432a78593e202392d1e9070cf2a7fca7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,18 +3,23 @@ members = ["macros"]

 [package]
 name = "el_diabolo"
-version = "0.1.0"
+version = "0.2.3"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-ratatui = "0.28.1"
+ratatui = "0.29.0"
 crossterm = "0.28.1"
 rand = "0.8.5"
 petgraph = "0.6.5"
 whoami = "1.5.2"
 macros = { path = "./macros" }
+serde = {version="1.0.210", features = ["derive"]}
+serde_json = "1.0.128"
+homedir = "0.3.4"
+tempfile = "3.14.0"
+chrono = "0.4.38"

 [package.metadata.deb]
 maintainer = "Joachim Lusiardi <joachim@lusiardi.de>"
--- a/macros/src/lib.rs
+++ b/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);
@@ -25,6 +24,7 @@ pub fn create_monsters(input: TokenStream) -> TokenStream {
            experience_gain: usize,
            ticks_between_steps: u128,
            damage_range: RangeInclusive<usize>,
+            defense: usize,
        }
        impl Monster for #variant_name {
            fn get_name(&self) -> &str { &self.name }
@@ -36,7 +36,7 @@ pub fn create_monsters(input: TokenStream) -> TokenStream {
            }
            fn get_ticks_between_steps(&self) -> u128 { self.ticks_between_steps }
            fn damage(&self) -> usize { rand::thread_rng().gen_range(self.damage_range.clone()) }
-
+            fn defense(&self) -> usize { self.defense }
            #[cfg(test)]
            fn get_life(&self) -> usize { self.life }
        }
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -1,7 +1,6 @@
 use std::{collections::HashMap, ops::RangeInclusive};

-use crate::{monster::MonsterTypes, room::RoomType};
-
+use crate::{monsters::MonsterTypes, room::RoomType};

 /// the number of rooms in vertical direction
 pub const ROOMS_HORIZONTAL: usize = 8;
@@ -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;
@@ -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::MonsterRoom, 5),
+            (RoomType::ArtifactRoom, 10),
+            (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!(
--- a/src/game.rs
+++ b/src/game.rs
@@ -164,10 +164,10 @@ impl Game {
        match m {
            None => {}
            Some(m) => {
-                let player_dmg = self.player.damage();
+                let player_dmg = self.player.damage().saturating_sub(m.defense());
                m.decrease_life(player_dmg);
                if m.is_dead() {
-                    self.player.gain_experience(m.get_experience_gain());
+                    let level_up: bool = self.player.gain_experience(m.get_experience_gain());
                    self.messages.insert(
                        0,
                        format!(
@@ -177,13 +177,23 @@ impl Game {
                        )
                        .to_string(),
                    );
+                    if level_up {
+                        self.messages.insert(
+                            0,
+                            format!(
+                                "you reach a new experience level, it's now {}",
+                                self.player.get_experience_level(),
+                            )
+                            .to_string(),
+                        );
+                    }
                } else {
                    self.messages.insert(
                        0,
                        format!("you hit {} for {} damage.", m.get_name(), player_dmg).to_string(),
                    );
-                    let monster_dmg = m.damage() as i16;
-                    self.player.change_life(-monster_dmg);
+                    let monster_dmg = m.damage().saturating_sub(self.player.defense());
+                    self.player.change_life(-(monster_dmg as i16));

                    self.messages.insert(
                        0,
--- a/src/highscore.rs
+++ b/src/highscore.rs
@@ -0,0 +1,92 @@
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use std::{fs::File, io::Write, path::Path};
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct HighscoreEntry {
+    pub player_name: String,
+    pub experience: usize,
+    pub gold: usize,
+    pub timestamp: i64,
+}
+
+impl HighscoreEntry {
+    pub fn new(player_name: String, experience: usize, gold: usize) -> Self {
+        HighscoreEntry {
+            player_name,
+            experience,
+            gold,
+            timestamp: Utc::now().timestamp(),
+        }
+    }
+    pub fn get_date(&self) -> String {
+        let dt = DateTime::from_timestamp(self.timestamp, 0).unwrap();
+        format!("{}", dt.format("%Y-%m-%d"))
+    }
+}
+
+pub type HighscoreList = Vec<HighscoreEntry>;
+
+pub trait Sortable {
+    fn insert_and_load<P: AsRef<Path>>(path: P, score: HighscoreEntry) -> Self;
+}
+
+impl Sortable for HighscoreList {
+    fn insert_and_load<P: AsRef<Path>>(path: P, score: HighscoreEntry) -> Self {
+        let file = File::open(&path);
+
+        let mut result: HighscoreList = match file {
+            Ok(file) => {
+                if let Ok(result) = serde_json::from_reader(&file) {
+                    result
+                } else {
+                    HighscoreList::new()
+                }
+            }
+            Err(_) => HighscoreList::new(),
+        };
+        result.push(score);
+        result.sort_by_key(|k| k.experience);
+        result.reverse();
+        let mut file = File::create(path).unwrap();
+        file.write_all(serde_json::to_string(&result).unwrap().as_bytes())
+            .unwrap();
+        file.sync_all().unwrap();
+        result
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use tempfile::NamedTempFile;
+
+    #[test]
+    fn test_highscore_list() {
+        let file = NamedTempFile::new().unwrap();
+        let tmpfile = file.path();
+
+        let list = HighscoreList::insert_and_load(
+            Path::new(tmpfile),
+            HighscoreEntry::new("noob".to_string(), 23, 0),
+        );
+        assert_eq!(list.len(), 1);
+        assert_eq!(list.first().unwrap().experience, 23);
+
+        let list = HighscoreList::insert_and_load(
+            Path::new(tmpfile),
+            HighscoreEntry::new("noob".to_string(), 42, 1),
+        );
+        assert_eq!(list.len(), 2);
+        assert_eq!(list.first().unwrap().experience, 42);
+
+        let list = HighscoreList::insert_and_load(
+            Path::new(tmpfile),
+            HighscoreEntry::new("noob".to_string(), 41, 2),
+        );
+        assert_eq!(list.len(), 3);
+        assert_eq!(list.first().unwrap().experience, 42);
+        assert_eq!(list[1].experience, 41);
+    }
+}
--- a/src/level.rs
+++ b/src/level.rs
@@ -8,9 +8,9 @@ use crate::artifacts::Artifact;
 use crate::artifacts::{Chest, Potion};
 use crate::constants::LEVEL_HEIGHT;
 use crate::constants::LEVEL_WIDTH;
-use crate::monster::Monster;
+use crate::monsters::Monster;
 #[cfg(test)]
-use crate::monster::{Orc, Rat};
+use crate::monsters::{Orc, Rat};
 use crate::player::Player;
 use crate::position::HasPosition;
 use crate::position::Position;
@@ -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);
@@ -147,43 +147,70 @@ impl Level {
                    if player.get_immutable_position().get_x() == new_x
                        && player.get_immutable_position().get_y() == new_y
                    {
-                        let monster_dmg = self.monsters[index].damage() as i16;
-                        player.change_life(-monster_dmg);
-                        messages.insert(
-                            0,
-                            format!(
-                                "{} hits you for {} damage.",
-                                self.monsters[index].get_name(),
-                                monster_dmg
-                            )
-                            .to_string(),
-                        );
-
-                        let player_dmg = player.damage();
-                        self.monsters[index].decrease_life(player_dmg);
-
-                        // if the attack did not kill the opponent, back down
-                        if !player.is_dead() {
+                        let monster_dmg = self.monsters[index]
+                            .damage()
+                            .saturating_sub(player.defense());
+                        player.change_life(-(monster_dmg as i16));
+                        if player.is_dead() {
                            messages.insert(
                                0,
                                format!(
-                                    "you hit {} for {} damage and kill it.",
+                                    "{} hits you for {} damage and kills you.",
                                    self.monsters[index].get_name(),
-                                    player_dmg
+                                    monster_dmg
                                )
                                .to_string(),
                            );
-                            self.monsters[index].get_position().change(-dx, -dy);
                        } else {
                            messages.insert(
                                0,
                                format!(
-                                    "you hit {} for {} damage.",
+                                    "{} hits you for {} damage.",
                                    self.monsters[index].get_name(),
-                                    player_dmg
+                                    monster_dmg
                                )
                                .to_string(),
                            );
+                            // player not dead => monster can occupy new position
+                            self.monsters[index].get_position().change(-dx, -dy);
+                            // player fights back
+                            let player_dmg = player
+                                .damage()
+                                .saturating_sub(self.monsters[index].defense());
+                            self.monsters[index].decrease_life(player_dmg);
+                            if self.monsters[index].is_dead() {
+                                let level_up: bool = player
+                                    .gain_experience(self.monsters[index].get_experience_gain());
+                                messages.insert(
+                                    0,
+                                    format!(
+                                        "you hit {} for {} damage and kill it.",
+                                        self.monsters[index].get_name(),
+                                        player_dmg
+                                    )
+                                    .to_string(),
+                                );
+                                if level_up {
+                                    messages.insert(
+                                        0,
+                                        format!(
+                                            "you reach a new experience level, it's now {}",
+                                            player.get_experience_level(),
+                                        )
+                                        .to_string(),
+                                    );
+                                }
+                            } else {
+                                messages.insert(
+                                    0,
+                                    format!(
+                                        "you hit {} for {} damage.",
+                                        self.monsters[index].get_name(),
+                                        player_dmg
+                                    )
+                                    .to_string(),
+                                );
+                            }
                        }
                    }
                    break;
--- a/src/level_generator.rs
+++ b/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;

@@ -12,8 +13,8 @@ use crate::artifacts::Potion;
 use crate::constants::get_monsters_per_level;
 use crate::constants::ROOM_HEIGHT;
 use crate::constants::ROOM_WIDTH;
-use crate::monster::create_monster_by_type;
-use crate::monster::Monster;
+use crate::monsters::create_monster_by_type;
+use crate::monsters::Monster;
 use crate::position::Position;
 use crate::room::Connection;
 use crate::{
@@ -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],
@@ -84,8 +86,8 @@ impl LevelGenerator {
                match directions_to_try.pop().unwrap() {
                    Direction::Horizontal => {
                        let mut free_cols: Vec<usize> = vec![];
-                        for col in 0..ROOMS_HORIZONTAL {
-                            if rooms[col][room_row].kind == RoomType::EmptyRoom {
+                        for (col, room_col) in rooms.iter().enumerate().take(ROOMS_HORIZONTAL) {
+                            if room_col[room_row].kind == RoomType::EmptyRoom {
                                free_cols.push(col);
                            }
                        }
@@ -120,9 +122,9 @@ impl LevelGenerator {
            // 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 in 0..ROOMS_HORIZONTAL {
-                    for row in 0..ROOMS_VERTICAL {
-                        if rooms[col][row].kind == RoomType::EmptyRoom {
+                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));
                        }
                    }
@@ -134,13 +136,16 @@ 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();
-        for col in 0..ROOMS_HORIZONTAL {
-            for row in 0..ROOMS_VERTICAL {
-                if rooms[col][row].kind != RoomType::EmptyRoom {
+    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 {
                    graph.add_node((col, row));
                }
            }
@@ -151,12 +156,21 @@ impl LevelGenerator {
                    continue;
                }
                if let Some(src_index) = graph.node_indices().find(|i| graph[*i] == (col, row)) {
-                    for col_1 in col + 1..ROOMS_HORIZONTAL {
-                        if rooms[col_1][row].kind != RoomType::EmptyRoom {
+                    for (col_1, tgt_col) in rooms
+                        .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;
                            }
                        }
@@ -166,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;
                            }
                        }
@@ -174,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)
@@ -190,6 +235,7 @@ impl LevelGenerator {
            let tgt_room = rooms[tgt_node_col][tgt_node_row];

            if src_node_col == tgt_node_col {
+                // Right
                let start_col =
                    src_node_col * ROOM_WIDTH + src_room.offset_x + (src_room.width + 1) / 2;
                let start_row =
@@ -202,13 +248,14 @@ impl LevelGenerator {
                    end_pos: (end_col, end_row),
                });
            } else {
-                // println!("Right");
-                let start_col = 1 + (src_node_col * ROOM_WIDTH) + src_room.offset_x + src_room.width;
+                // Down
+                let start_col =
+                    1 + (src_node_col * ROOM_WIDTH) + src_room.offset_x + src_room.width;
                let start_row =
-                    1 + src_node_row * ROOM_HEIGHT + src_room.offset_y + (src_room.height-1) / 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;
+                    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),
@@ -220,40 +267,11 @@ impl LevelGenerator {
    pub fn generate(level: usize, first: bool, last: bool) -> Self {
        let mut rng = rand::thread_rng();

-        /*
-           Fill grid with unconnected rooms
-        */
-
        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);

-        // debug print a text view of the dungeon
-        println!("  0 1 2 3 4 5 6 7");
-        for r in 0..ROOMS_VERTICAL {
-            print!("{} ", r);
-            for c in 0..ROOMS_HORIZONTAL {
-                match rooms[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!();
-        }
-
-        /*
-           Construct a graph from the unconnected rooms and make a minum spanning tree of it
-        */
-
-        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 }
    }
@@ -331,11 +349,11 @@ impl LevelGenerator {
            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);
                }
            }
        }
@@ -352,20 +370,20 @@ impl LevelGenerator {
    }
 }

-// #[test]
-// fn test_level_gen() {
-//     for _ in 0..1000 {
-//         LevelGenerator::generate(0, true, false).render();
-//     }
-// }
+#[test]
+fn test_level_gen() {
+    for _ in 0..1000 {
+        LevelGenerator::generate(0, true, false).render();
+    }
+}

-// #[test]
-// fn test_level_gen_respects_level() {
-//     let level = LevelGenerator::generate(0, true, false).render();
-//     assert_eq!(0, level.level);
-//     let level = LevelGenerator::generate(1, true, false).render();
-//     assert_eq!(1, level.level);
-// }
+#[test]
+fn test_level_gen_respects_level() {
+    let level = LevelGenerator::generate(0, true, false).render();
+    assert_eq!(0, level.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) {
@@ -500,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);

@@ -522,12 +540,12 @@ fn test_create_mst() {
    rooms[3][3].kind = RoomType::BasicRoom;
    let res = LevelGenerator::create_mst(&rooms);
    assert_eq!(res.node_count(), 4);
-    assert_eq!(res.edge_count(), 3);
+    assert_eq!(res.edge_count(), 4);

    rooms[3][5].kind = RoomType::BasicRoom;
    let res = LevelGenerator::create_mst(&rooms);
    assert_eq!(res.node_count(), 5);
-    assert_eq!(res.edge_count(), 4);
+    assert_eq!(res.edge_count(), 5);
 }

 #[test]
@@ -545,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);

@@ -580,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());
@@ -614,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);

@@ -651,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());
@@ -686,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());
@@ -721,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());
@@ -756,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());
@@ -790,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());
@@ -825,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());
@@ -860,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());
@@ -895,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());
--- a/src/level_ladder.rs
+++ b/src/level_ladder.rs
@@ -0,0 +1,30 @@
+pub struct LevelLadder {
+    curr: usize,
+    next: usize,
+}
+
+impl Iterator for LevelLadder {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let current = self.curr;
+
+        self.curr = self.next;
+        self.next += current;
+
+        // Since there's no endpoint to a Fibonacci sequence, the `Iterator`
+        // will never return `None`, and `Some` is always returned.
+        Some(current * 30)
+    }
+}
+
+// Returns a Fibonacci sequence generator
+pub fn get_level_ladder() -> LevelLadder {
+    LevelLadder { curr: 1, next: 2 }
+}
+
+#[test]
+fn test_level_ladder() {
+    let mut iter = get_level_ladder();
+    assert_eq!(iter.next(), Some(30));
+}
--- a/src/level_widget.rs
+++ b/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));
    }
 }

--- a/src/main.rs
+++ b/src/main.rs
@@ -13,8 +13,11 @@ use crossterm::{
    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
    ExecutableCommand,
 };
+use highscore::HighscoreEntry;
+use highscore::HighscoreList;
+use highscore::Sortable;
+use homedir::my_home;
 use ratatui::prelude::*;
-use ratatui::widgets::block::{Position, Title};
 use ratatui::widgets::{Block, BorderType, Borders, Wrap};
 use ratatui::{
    prelude::{CrosstermBackend, Terminal},
@@ -30,14 +33,19 @@ use crate::position::HasPosition;
 mod artifacts;
 mod constants;
 mod game;
+mod highscore;
 mod level;
 mod level_generator;
+mod level_ladder;
 mod level_widget;
-mod monster;
+mod monsters;
 mod player;
 mod position;
 mod room;

+const BACKGROUND_COLOR: Color = Color::DarkGray;
+const PANEL_BACKGROUND_COLOR: Color = Color::Black;
+
 //
 fn main() -> Result<()> {
    let mut game = Game::new(Player::new(realname().as_str(), 30));
@@ -53,7 +61,7 @@ fn main() -> Result<()> {
        terminal.draw(|frame| {
            let mut area = frame.area();
            frame.render_widget(
-                Block::default().style(Style::default().bg(Color::Green)),
+                Block::default().style(Style::default().bg(BACKGROUND_COLOR)),
                area,
            );

@@ -100,20 +108,19 @@ fn main() -> Result<()> {
                height: map_area.height / 2 + 1,
            };
            let block = Block::default()
-                .title(
-                    Title::from(format!(" {} ", game.get_player().get_name()))
-                        .alignment(Alignment::Center)
-                        .position(Position::Top),
+                .title_top(
+                    Line::from(format!(" {} ", game.get_player().get_name())).centered()
                )
                .borders(Borders::TOP)
                .border_style(Style::default().fg(Color::White))
                .border_type(BorderType::Rounded)
-                .style(Style::default().bg(Color::Blue));
+                .style(Style::default().bg(PANEL_BACKGROUND_COLOR));
            frame.render_widget(
                Paragraph::new(format!(
-                    "Health: {} of {}\nExp: {}\nGold: {}\nLevel: {} of {}\nInventory used: {} of {}",
+                    "Health: {} of {}\nDefense: {}\nExp: {}\nGold: {}\nLevel: {} of {}\nInventory used: {} of {}",
                    game.get_player().get_life(),
                    game.get_player().get_max_life(),
+                    game.get_player().defense(),
                    game.get_player().get_experience(),
                    game.get_player().get_gold(),
                    game.get_player().get_immutable_position().get_level() + 1,
@@ -133,15 +140,13 @@ fn main() -> Result<()> {
            };
            // Display the latest messages from the game to the user
            let block = Block::default()
-                .title(
-                    Title::from(" messages ")
-                        .alignment(Alignment::Center)
-                        .position(Position::Top),
+                .title_top(
+                    Line::from(" messages ").centered()
                )
                .borders(Borders::TOP)
                .border_style(Style::default().fg(Color::White))
                .border_type(BorderType::Rounded)
-                .style(Style::default().bg(Color::Blue));
+                .style(Style::default().bg(PANEL_BACKGROUND_COLOR));

            let paragraph1 = if game.messages.is_empty() {
                "".to_string()
@@ -207,23 +212,43 @@ fn main() -> Result<()> {
        }
        ticks += 1;
    }
+    handle_game_end_screen(start_time, game, terminal);
+    stdout().execute(LeaveAlternateScreen)?;
+    disable_raw_mode()?;
+    Ok(())
+}
+
+fn handle_game_end_screen(
+    start_time: Instant,
+    mut game: Game,
+    mut terminal: Terminal<CrosstermBackend<std::io::Stdout>>,
+) {
    let playtime = start_time.elapsed();
+    let statsfile = my_home()
+        .unwrap()
+        .unwrap()
+        .as_path()
+        .join(".eldiablo_highscore.json");
+    let highscores = HighscoreList::insert_and_load(
+        statsfile,
+        HighscoreEntry::new(
+            game.get_player().get_name(),
+            game.get_player().get_experience(),
+            game.get_player().get_gold(),
+        ),
+    );
    loop {
        let _ = terminal.draw(|frame| {
            let mut area = frame.area();
            let w = area.width / 2;
            let h = area.height / 2;
-            area.x += w - 20;
+            area.x += w - 30;
            area.y += h - 10;
-            area.width = 40;
-            area.height = 20;
+            area.width = 60;
+            area.height = 10;
            let block = Block::default()
-                .title(
-                    Title::from(" Game ended ")
-                        .alignment(Alignment::Center)
-                        .position(Position::Top),
-                )
-                .title(Title::from("Press `q` to quit!").position(Position::Bottom))
+                .title_top(Line::from(" Game ended ").centered())
+                // .title_bottom(Line::from("Press `q` to quit!"))
                .borders(Borders::ALL)
                .border_style(Style::default().fg(Color::White))
                .border_type(BorderType::Rounded)
@@ -249,16 +274,33 @@ fn main() -> Result<()> {
            text += format!("\nYou played {} seconds.", playtime.as_secs()).as_str();
            let paragraph = Paragraph::new(text).block(block).wrap(Wrap { trim: true });
            frame.render_widget(paragraph, area);
+            let block = Block::default()
+                .title_top(Line::from(" Highscore ").centered())
+                .title_bottom(Line::from("Press `q` to quit!"))
+                .borders(Borders::ALL)
+                .border_style(Style::default().fg(Color::White))
+                .border_type(BorderType::Rounded)
+                .style(Style::default().bg(Color::Black));
+            let mut text = "".to_string();
+            for e in &highscores {
+                text += &format!(
+                    "{}: {} XP / {} Gold on {}\n",
+                    e.player_name,
+                    e.experience,
+                    e.gold,
+                    e.get_date()
+                );
+            }
+            let paragraph = Paragraph::new(text).block(block).wrap(Wrap { trim: true });
+            area.y += 10;
+            frame.render_widget(paragraph, area);
        });
-        if event::poll(std::time::Duration::from_millis(16))? {
-            if let event::Event::Key(key) = event::read()? {
+        if event::poll(std::time::Duration::from_millis(16)).unwrap() {
+            if let event::Event::Key(key) = event::read().unwrap() {
                if key.kind == KeyEventKind::Press && key.code == KeyCode::Char('q') {
                    break;
                }
            }
        }
    }
-    stdout().execute(LeaveAlternateScreen)?;
-    disable_raw_mode()?;
-    Ok(())
 }
--- a/src/monsters.rs
+++ b/src/monsters.rs
@@ -16,6 +16,7 @@ pub trait Monster: HasPosition {
    #[cfg(test)]
    fn get_life(&self) -> usize;
    fn damage(&self) -> usize;
+    fn defense(&self) -> usize;
 }

 #[derive(CreateMonsters, PartialEq, Eq, Hash, Clone, Copy)]
@@ -45,10 +46,11 @@ 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,
+    defense: 0,
 );

 create_monster!(
@@ -56,10 +58,11 @@ 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,
+    defense: 0,
 );

 create_monster!(
@@ -67,10 +70,11 @@ 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,
+    defense: 0,
 );

 create_monster!(
@@ -78,10 +82,11 @@ 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,
+    defense: 0,
 );

 create_monster!(
@@ -89,10 +94,11 @@ 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,
+    defense: 0,
 );

 pub fn create_monster_by_type(monster_type: &MonsterTypes, position: Position) -> Box<dyn Monster> {
--- a/src/player.rs
+++ b/src/player.rs
@@ -2,6 +2,7 @@ use rand::Rng;
 use std::cmp::{max, min};

 use crate::artifacts::Potion;
+use crate::level_ladder::get_level_ladder;
 use crate::position::{HasPosition, Position};

 pub struct Player {
@@ -13,6 +14,8 @@ pub struct Player {
    experience: usize,
    inventory: Vec<Potion>,
    inventory_slots: usize,
+    level: usize,
+    defense: usize,
 }

 impl Player {
@@ -26,6 +29,8 @@ impl Player {
            experience: 0,
            inventory: vec![],
            inventory_slots: 2,
+            level: 1,
+            defense: 0,
        }
    }
    pub fn get_name(&self) -> String {
@@ -59,8 +64,28 @@ impl Player {
        self.gold
    }

-    pub fn gain_experience(&mut self, amount: usize) {
-        self.experience += amount
+    pub fn gain_experience(&mut self, amount: usize) -> bool {
+        let mut result = false;
+        for (i, level_step) in get_level_ladder().enumerate() {
+            if self.experience <= level_step && self.experience + amount > level_step {
+                self.level += 1;
+                // make life gain depend on level?
+                self.max_life += 5;
+                self.defense += 1;
+                self.life = self.max_life;
+                result = true;
+                break;
+            }
+            if i > self.level {
+                break;
+            }
+        }
+        self.experience += amount;
+        result
+    }
+
+    pub fn get_experience_level(&self) -> usize {
+        self.level
    }

    pub fn get_experience(&self) -> usize {
@@ -71,6 +96,10 @@ impl Player {
        rand::thread_rng().gen_range(1..4)
    }

+    pub fn defense(&self) -> usize {
+        self.defense
+    }
+
    pub fn add_to_inventory(&mut self, potion: &Potion) -> bool {
        if self.inventory.len() < self.inventory_slots {
            self.inventory.push(*potion);
@@ -116,6 +145,8 @@ fn test_get_name() {
        experience: 0,
        inventory: vec![],
        inventory_slots: 1,
+        level: 0,
+        defense: 0,
    };
    assert_eq!(p.get_name(), "Teddy Tester");
 }
@@ -141,6 +172,8 @@ fn test_change_life() {
        experience: 0,
        inventory: vec![],
        inventory_slots: 1,
+        level: 0,
+        defense: 0,
    };
    assert_eq!(p.get_life(), 5);
    p.change_life(-2);
@@ -176,6 +209,8 @@ fn test_max_life() {
        experience: 0,
        inventory: vec![],
        inventory_slots: 1,
+        level: 0,
+        defense: 0,
    };
    assert_eq!(p.get_max_life(), 10);
 }
--- a/src/room.rs
+++ b/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]) {
-        // the tuples are (col, row)
-        println!("{:?} -> {:?}",self.start_pos, self.end_pos);
-        let d_col = 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);
-
-        if d_col == 0 {
-            for row in self.start_pos.1..=self.end_pos.1 {
-                tgt[self.end_pos.0][row] = StructureElement::Floor;
+    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
            }
        }
-        if d_row == 0 {
-            for col in self.start_pos.0..=self.end_pos.0 {
+        // the tuples are (col, row)
+        let abs_d_col =
+            max(self.start_pos.0, self.end_pos.0) - min(self.start_pos.0, self.end_pos.0);
+
+        let abs_d_row =
+            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) {
+                tgt[self.end_pos.0][row] = StructureElement::Floor;
+            }
+        } else if abs_d_row == 0 {
+            for col in calc_range(self.end_pos.0, self.start_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 height = ROOM_HEIGHT-1; //rng.gen_range(3..ROOM_HEIGHT);
-        let offset_x = 0; //rng.gen_range(0..(ROOM_WIDTH - width));
-        let offset_y = 0; //rng.gen_range(0..(ROOM_HEIGHT - height));
-        let sx = offset_x + rng.gen_range(1..width-1);
-        let sy = offset_y + rng.gen_range(1..height-1);
+        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);
+        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> {
-        self.offset_x..self.offset_x + self.width
-    }
+    // pub fn get_x_range(&self) -> Range<usize> {
+    //     self.offset_x..self.offset_x + self.width
+    // }

-    pub fn get_y_range(&self) -> Range<usize> {
-        self.offset_y..self.offset_y + self.height
-    }
+    // pub fn get_y_range(&self) -> Range<usize> {
+    //     self.offset_y..self.offset_y + self.height
+    // }

    pub fn render(
        &self,
Author	SHA1	Message	Date
Joachim Lusiardi	09673c9b6c	implement local highscore list	2024-12-07 08:43:02 +01:00
Joachim Lusiardi	530067f743	fix formatting	2024-11-25 21:20:36 +01:00
Joachim Lusiardi	94c787d8c7	rename monster.rs to monsters.rs	2024-11-25 07:20:03 +01:00
Joachim Lusiardi	9776482922	version bump	2024-11-24 13:30:31 +01:00
Joachim Lusiardi	fb69c932a8	adjust background colors	2024-11-24 13:30:10 +01:00
Joachim Lusiardi	62e13ace4c	add defense attribute to player and monster	2024-11-24 13:24:39 +01:00
Joachim Lusiardi	51123ecd8e	version bump and index generation	2024-11-07 09:57:32 +01:00
Joachim Lusiardi	4d77265b2f	remove debug output	2024-11-07 09:47:49 +01:00
Joachim Lusiardi	c91d57f049	next try	2024-11-07 09:46:15 +01:00
Joachim Lusiardi	8f151836bd	next try	2024-11-07 09:41:40 +01:00
Joachim Lusiardi	9d862011a7	testing	2024-11-07 09:37:22 +01:00
Joachim Lusiardi	d068620c3f	more tuning	2024-11-07 09:35:30 +01:00
Joachim Lusiardi	6660c11306	more debug	2024-11-07 09:29:24 +01:00
Joachim Lusiardi	1d8896d1ad	debugging	2024-11-07 09:27:31 +01:00
Joachim Lusiardi	252c1c244d	make key secure in container	2024-11-07 09:24:19 +01:00
Joachim Lusiardi	ef3a6026f5	minor fixes	2024-11-07 09:22:19 +01:00
Joachim Lusiardi	542616cb0b	version bump	2024-11-07 09:15:44 +01:00
Joachim Lusiardi	9a6c8f5116	try to auto publish to website	2024-11-07 09:15:24 +01:00
Joachim Lusiardi	d82e0d2d48	version updates	2024-11-06 14:33:11 +01:00
Joachim Lusiardi	a542e4b1c0	add mechanism for level gain	2024-11-06 14:29:30 +01:00
Joachim Lusiardi	3249529f94	cleanup	2024-11-06 09:22:22 +01:00
Joachim Lusiardi	72f7be2ed8	more work on level generators	2024-11-05 12:02:45 +01:00
Joachim Lusiardi	5311f56ca0	extract minimal room size as constant	2024-11-03 10:32:04 +01:00
Joachim Lusiardi	df80dfdd8a	introduce custom type for the graph	2024-11-01 13:08:02 +01:00
Joachim Lusiardi	8b23c565b8	make connections more variable	2024-11-01 12:06:50 +01:00
Joachim Lusiardi	789a41cb3f	make connections more variable	2024-11-01 12:02:11 +01:00
Joachim Lusiardi	d42d8a12b4	make spiders more visible	2024-11-01 08:49:12 +01:00
Joachim Lusiardi	8ee142586b	make monsters visible	2024-10-31 22:39:11 +01:00
Joachim Lusiardi	1878959e69	Clippy	2024-10-31 22:36:23 +01:00
Joachim Lusiardi	8bae1c7668	formatted	2024-10-31 22:34:35 +01:00
Joachim Lusiardi	3096386ad1	improve paths	2024-10-31 21:52:04 +01:00