more tests

src/game.rs

@@ -1,25 +1,31 @@
 use crate::level::Level;
+use crate::level_generator::LevelGenerator;
 use crate::player::Player;
 use crate::position::Position;
 
 pub const LEVELS: usize = 2;
 
-pub struct Game<'game> {
-    pub(crate) player: &'game mut Player,
-    pub(crate) levels: Vec<Level>,
+pub struct Game {
+    pub player: Player,
+    pub levels: Vec<Level>,
 }
 
-impl Game<'_> {
-    pub fn new(p: &mut Player) -> Game {
+impl Game {
+    pub fn new(p: Player) -> Game {
         let mut v: Vec<Level> = Vec::with_capacity(LEVELS);
         for d in 0..LEVELS {
-            let l = Level::new(d);
-            v.push(l);
+            v.push(LevelGenerator::generate(d).render());
         }
-        Game {
+        let mut g = Game {
             player: p,
             levels: v,
+        };
+        let mut start = (0,0);
+        {
+            start = g.get_level(0).start;
         }
+        g.get_mutable_player().get_position().set(0,start.0, start.1);
+        g
     }
 
     pub fn get_player(&self) -> &Player {
@@ -28,4 +34,39 @@ 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] }
+}
+
+#[test]
+fn game_has_correct_number_of_levels() {
+    let p = Player::new("foo", 42);
+    let g = Game::new(p);
+    assert_eq!(g.levels.len(), LEVELS);
+}
+
+#[test]
+fn game_has_player() {
+    let p = Player::new("foo", 42);
+    let g = Game::new(p);
+    assert_eq!(g.get_player().get_name(), "foo");
+    assert_eq!(g.get_player().get_immutable_position().get_level(), 0);
+}
+
+#[test]
+fn game_has_mutable_player() {
+    let p = Player::new("foo", 42);
+    let mut g = Game::new(p);
+    assert_eq!(g.get_player().get_name(), "foo");
+    g.get_mutable_player().change_life(-1);
+    assert_eq!(g.get_player().get_life(), 41);
+}
+
+#[test]
+fn game_get_level() {
+    let p = Player::new("foo", 42);
+    let mut g = Game::new(p);
+    g.get_level(0);
+    assert_ne!(g.get_level(0).start, (0, 0));
+    g.get_mutable_level(0).discover(&Position::new(0, 1, 1));
 }