From e47036bd8d068a23225538860c0847901bf09a53 Mon Sep 17 00:00:00 2001 From: Joachim Lusiardi Date: Thu, 7 Dec 2023 10:12:44 +0100 Subject: [PATCH] more tests --- src/game.rs | 57 ++++++++++++++++++++++++++++++++++++------ src/level_generator.rs | 30 ++++++++++++++-------- src/level_widget.rs | 2 +- src/main.rs | 2 +- src/monster.rs | 6 +++++ src/player.rs | 21 +++++++++++++--- src/position.rs | 39 ++++++++++++++++++++++++++--- 7 files changed, 129 insertions(+), 28 deletions(-) diff --git a/src/game.rs b/src/game.rs index fb87d4f..8693f75 100644 --- a/src/game.rs +++ b/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, +pub struct Game { + pub player: Player, + pub levels: Vec, } -impl Game<'_> { - pub fn new(p: &mut Player) -> Game { +impl Game { + pub fn new(p: Player) -> Game { let mut v: Vec = 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)); } \ No newline at end of file diff --git a/src/level_generator.rs b/src/level_generator.rs index 8ed67cb..024b3d2 100644 --- a/src/level_generator.rs +++ b/src/level_generator.rs @@ -11,7 +11,8 @@ use rand::rngs::ThreadRng; use crate::level::{Level, StructureElement}; use crate::monster::Monster; -use crate::artifacts::Artifact; +use crate::artifacts::{Artifact, Chest}; +use crate::position::Position; const ROOMS_VERTICAL: usize = 7; const ROOMS_HORIZONTAL: usize = 4; @@ -79,6 +80,7 @@ impl Room { pub struct LevelGenerator { rooms: [[Room; ROOMS_HORIZONTAL]; ROOMS_VERTICAL], + level: usize, } impl LevelGenerator { @@ -105,6 +107,7 @@ impl LevelGenerator { room_types.push(RoomType::StairDown); } room_types.push(RoomType::MonsterRoom); + room_types.push(RoomType::TreasureRoom); // generate a random set of rooms and shuffle them for _ in room_types.len()..ROOMS_HORIZONTAL * ROOMS_VERTICAL { match rng.gen_range(1..=100) { @@ -205,7 +208,8 @@ impl LevelGenerator { } LevelGenerator { - rooms + rooms, + level, } } @@ -260,13 +264,13 @@ impl LevelGenerator { if room.kind == RoomType::TreasureRoom { let t_x = left + room.offset_x + rng.gen_range(0..room.width); let t_y = top + room.offset_y + rng.gen_range(0..room.height); - // artifacts[t_x][t_y] = Some(Artifact::Chest { gold: rng.gen_range(2..30) }); + artifacts.push(Box::new(Chest::new(Position::new(self.level, t_x, t_y)))); } if room.kind == RoomType::MonsterRoom { let t_x = left + room.offset_x + rng.gen_range(0..room.width); let t_y = top + room.offset_y + rng.gen_range(0..room.height); // TODO randomize enemies here - // enemies[t_x][t_y] = Some(Monster::new(2)); + enemies.push(Monster::new_with_position(10, Position::new(self.level, t_x, t_y))); } if room.kind == RoomType::StairDown { end_x = left + room.offset_x + rng.gen_range(0..room.width); @@ -320,7 +324,7 @@ impl LevelGenerator { } } Level { - level: 0, + level: self.level, structure, discovered: [[false; 1 + ROOMS_HORIZONTAL * ROOM_HEIGHT]; 1 + ROOMS_VERTICAL * ROOM_WIDTH], monsters: enemies, @@ -331,9 +335,13 @@ impl LevelGenerator { } } -// #[test] -// fn test_level_gen() { -// let level = LevelGenerator::generate(0); -// println!("{:#?}", level); -// assert_eq!(1, 2); -// } \ No newline at end of file +#[test] +fn test_level_gen() { + let level = LevelGenerator::generate(23).render(); + assert_eq!(level.level, 23); + assert_ne!(level.start, (0, 0)); + assert_ne!(level.end, (0, 0)); + assert_ne!(level.start, level.end); + assert_ne!(level.monsters.len(), 0); + assert_ne!(level.artifacts.len(), 0); +} \ No newline at end of file diff --git a/src/level_widget.rs b/src/level_widget.rs index 77921f4..847b1f9 100644 --- a/src/level_widget.rs +++ b/src/level_widget.rs @@ -9,7 +9,7 @@ const FG_BROWN: Color = Color::Rgb(186, 74, 0); //⌂ α Ω pub struct LevelWidget<'a> { - pub game: &'a Game<'a>, + pub game: &'a Game, } impl LevelWidget<'_> { diff --git a/src/main.rs b/src/main.rs index c4c7d9a..2f58dd6 100644 --- a/src/main.rs +++ b/src/main.rs @@ -36,7 +36,7 @@ fn main() -> Result<()> { levels.push(LevelGenerator::generate(l).render()); } let mut g = Game { - player: &mut Player::new(realname().as_str(), 10), + player: Player::new(realname().as_str(), 10), levels, }; diff --git a/src/monster.rs b/src/monster.rs index 2fdf08a..055a839 100644 --- a/src/monster.rs +++ b/src/monster.rs @@ -12,6 +12,12 @@ impl Monster { position: Position::new(0, 0, 0), } } + pub fn new_with_position(life: usize, position: Position) -> Self { + Monster { + life, + position, + } + } pub fn get_life(&self) -> usize { self.life } pub fn is_dead(&self) -> bool { self.life <= 0 } pub fn decrease_life(&mut self, by: usize) { diff --git a/src/player.rs b/src/player.rs index be21e01..877f156 100644 --- a/src/player.rs +++ b/src/player.rs @@ -76,13 +76,13 @@ fn test_change_life() { max_life: 10, gold: 0, }; - assert_eq!(p.life, 5); + assert_eq!(p.get_life(), 5); p.change_life(-2); - assert_eq!(p.life, 3); + assert_eq!(p.get_life(), 3); p.change_life(10); - assert_eq!(p.life, 10); + assert_eq!(p.get_life(), 10); p.change_life(-12); - assert_eq!(p.life, 0); + assert_eq!(p.get_life(), 0); } #[test] @@ -96,4 +96,17 @@ fn player_can_move() { p.get_position().set(1, 2, 3); p.get_position().change(2, 1); assert_eq!(p.get_position(), &Position::new(1, 4, 4)); + assert_eq!(p.get_immutable_position(), &Position::new(1, 4, 4)); +} + +#[test] +fn test_max_life() { + let p = Player { + name: "Teddy Tester".to_string(), + position: Position::new(0, 1, 1), + life: 5, + max_life: 10, + gold: 0, + }; + assert_eq!(p.get_max_life(), 10); } diff --git a/src/position.rs b/src/position.rs index c6d8178..ea915e5 100644 --- a/src/position.rs +++ b/src/position.rs @@ -1,3 +1,5 @@ +use std::cmp::max; + #[derive(PartialEq, Debug)] pub struct Position { level: usize, @@ -13,9 +15,10 @@ impl Position { y, } } - pub fn change(&mut self, dx: i16, dy: i16) { - self.x = ((self.x as i16) + dx) as usize; - self.y = ((self.y as i16) + dy) as usize; + pub fn change(&mut self, dx: i16, dy: i16) -> (usize, usize) { + self.x = max((self.x as i16) + dx, 0) as usize; + self.y = max((self.y as i16) + dy, 0) as usize; + (self.x, self.y) } pub fn set(&mut self, level: usize, x: usize, y: usize) { self.level = level; @@ -32,4 +35,34 @@ impl Position { } pub fn get_y(&self) -> usize { self.y } +} + +#[test] +fn test_position_change() { + let mut p = Position::new(0, 10, 10); + + let res = p.change(-1, 1); + assert_eq!(res, (9, 11)); + assert_eq!(p.get_x(), 9); + assert_eq!(p.get_y(), 11); + + let res = p.change(-9, 1); + assert_eq!(res, (0, 12)); + assert_eq!(p.get_x(), 0); + assert_eq!(p.get_y(), 12); + + let res = p.change(-1, -13); + assert_eq!(res, (0, 0)); + assert_eq!(p.get_x(), 0); + assert_eq!(p.get_y(), 0); +} + +#[test] +fn test_position_set() { + let mut p = Position::new(0, 10, 10); + + p.set(1, 2, 3); + assert_eq!(p.get_level(), 1); + assert_eq!(p.get_x(), 2); + assert_eq!(p.get_y(), 3); } \ No newline at end of file