updated deps

fixed clippy remarks

src/game.rs

@@ -9,14 +9,13 @@ pub const LEVELS: usize = 10;
 /// represents a state of a game
 pub enum GameState {
     /// the game is ongoing (neither won or lost)
-    RUNNING,
+    Running,
     /// the player died
-    LOST,
+    Lost,
     /// the player reached the Ω
-    WON,
+    Won,
 }
 
-
 /// the main structure to hold all information about the ongoing game
 pub struct Game {
     /// the player
@@ -37,11 +36,12 @@ impl Game {
             levels: v,
             messages: Vec::with_capacity(10),
         };
-        let start = {
-            g.get_level(0).start
-        };
-        g.get_mutable_player().get_position().set(0, start.0, start.1);
-        g.get_mutable_level(0).discover(&Position::new(0, start.0, start.1));
+        let start = { g.get_level(0).start };
+        g.get_mutable_player()
+            .get_position()
+            .set(0, start.0, start.1);
+        g.get_mutable_level(0)
+            .discover(&Position::new(0, start.0, start.1));
         g
     }
 
@@ -49,11 +49,8 @@ impl Game {
     fn player_reached_goal(&mut self) -> bool {
         match self.next_element(0, 0) {
             None => {}
-            Some(a) => {
-                match a {
-                    StructureElement::End => { return true; }
-                    _ => {}
-                }
+            Some(a) => if a == StructureElement::End {
+                return true
             }
         };
         false
@@ -61,12 +58,12 @@ impl Game {
     /// returns the state of the game (depending on player's life and position)
     pub fn get_game_state(&mut self) -> GameState {
         if self.player.is_dead() {
-            return GameState::LOST;
+            return GameState::Lost;
         }
         if self.player_reached_goal() {
-            return GameState::WON;
+            return GameState::Won;
         }
-        GameState::RUNNING
+        GameState::Running
     }
     pub fn get_player(&self) -> &Player {
         &self.player
@@ -74,8 +71,12 @@ impl Game {
     pub fn get_mutable_player(&mut self) -> &mut Player {
         &mut self.player
     }
-    pub fn get_level(&self, level: usize) -> &Level { &self.levels[level] }
-    pub fn get_mutable_level(&mut self, level: usize) -> &mut Level { &mut self.levels[level] }
+    pub fn get_level(&self, level: usize) -> &Level {
+        &self.levels[level]
+    }
+    pub fn get_mutable_level(&mut self, level: usize) -> &mut Level {
+        &mut self.levels[level]
+    }
     /// check if the player can move in the given direction. This only checks for structure element
     /// limitation as walls.
     fn can_move(&mut self, dx: i16, dy: i16) -> bool {
@@ -120,32 +121,36 @@ impl Game {
         let structure = self.next_element(dx, dy);
 
         // use stairs if walked onto one
-        match structure {
-            Some(e) => {
-                match e {
-                    StructureElement::StairDown => {
-                        (dx, dy) = (0, 0);
-                        let (next_level, x, y) = self.next_start();
-                        player_level = next_level;
-                        self.messages.insert(0, format!("you climb down to level {}.", next_level));
-                        self.get_mutable_player().get_position().set(next_level, x, y);
-                    }
-                    StructureElement::StairUp => {
-                        (dx, dy) = (0, 0);
-                        let (next_level, x, y) = self.prev_end();
-                        player_level = next_level;
-                        self.messages.insert(0, format!("you climb up to level {}.", next_level));
-                        self.get_mutable_player().get_position().set(next_level, x, y);
-                    }
-                    _ => {}
+        if let Some(e) = structure {
+            match e {
+                StructureElement::StairDown => {
+                    (dx, dy) = (0, 0);
+                    let (next_level, x, y) = self.next_start();
+                    player_level = next_level;
+                    self.messages
+                        .insert(0, format!("you climb down to level {}.", next_level));
+                    self.get_mutable_player()
+                        .get_position()
+                        .set(next_level, x, y);
                 }
+                StructureElement::StairUp => {
+                    (dx, dy) = (0, 0);
+                    let (next_level, x, y) = self.prev_end();
+                    player_level = next_level;
+                    self.messages
+                        .insert(0, format!("you climb up to level {}.", next_level));
+                    self.get_mutable_player()
+                        .get_position()
+                        .set(next_level, x, y);
+                }
+                _ => {}
             }
-            _ => {}
-        }
+        };
 
         // update position and discover area on new position
         let (new_x, new_y) = self.get_mutable_player().get_position().change(dx, dy);
-        self.get_mutable_level(player_level).discover(&Position::new(player_level, new_x, new_y));
+        self.get_mutable_level(player_level)
+            .discover(&Position::new(player_level, new_x, new_y));
         (-dx, -dy)
     }
     pub fn player_fights_monster(&mut self) -> bool {
@@ -159,8 +164,10 @@ impl Game {
                 // TODO fight the monster
                 self.player.change_life(-1);
                 m.decrease_life(1);
-                self.messages.insert(0, format!("{} hits you.", m.get_name()).to_string());
-                self.messages.insert(0, format!("you hit {}.", m.get_name()).to_string());
+                self.messages
+                    .insert(0, format!("{} hits you.", m.get_name()).to_string());
+                self.messages
+                    .insert(0, format!("you hit {}.", m.get_name()).to_string());
                 // monster died, player gains experience
                 if m.is_dead() {
                     self.player.gain_experience(m.get_experience_gain());