300 lines
10 KiB
Rust
300 lines
10 KiB
Rust
use std::cmp::{max, min};
|
|
|
|
#[cfg(test)]
|
|
use crate::artifacts::{Chest, Potion};
|
|
use crate::artifacts::Artifact;
|
|
#[cfg(test)]
|
|
use crate::monster::{Orc, Rat};
|
|
use crate::monster::Monster;
|
|
use crate::player::Player;
|
|
use crate::position::HasPosition;
|
|
use crate::position::Position;
|
|
|
|
pub const LEVEL_WIDTH: usize = 50;
|
|
pub const LEVEL_HEIGHT: usize = 25;
|
|
|
|
#[derive(Copy, Clone, Debug, PartialEq)]
|
|
pub enum StructureElement {
|
|
Start,
|
|
End,
|
|
Wall,
|
|
Floor,
|
|
StairDown,
|
|
StairUp,
|
|
Unknown,
|
|
}
|
|
|
|
pub struct Level {
|
|
pub(crate) level: usize,
|
|
pub(crate) structure: [[StructureElement; LEVEL_HEIGHT]; LEVEL_WIDTH],
|
|
pub(crate) discovered: [[bool; LEVEL_HEIGHT]; LEVEL_WIDTH],
|
|
pub(crate) monsters: Vec<Box<dyn Monster>>,
|
|
pub(crate) artifacts: Vec<Box<dyn Artifact>>,
|
|
/// the position of the start in the level (either stair up or start point)
|
|
pub(crate) start: (usize, usize),
|
|
/// the position of the end in the level (either stair down or end point)
|
|
pub(crate) end: (usize, usize),
|
|
}
|
|
|
|
impl Level {
|
|
pub fn get_element(&mut self, x: i16, y: i16) -> (Option<StructureElement>, Option<&mut Box<(dyn Monster + 'static)>>, Option<&mut Box<(dyn Artifact + 'static)>>) {
|
|
if x < 0 || y < 0 {
|
|
return (None, None, None);
|
|
}
|
|
let x = x as usize;
|
|
let y = y as usize;
|
|
if x >= LEVEL_WIDTH || y >= LEVEL_HEIGHT {
|
|
return (None, None, None);
|
|
}
|
|
if !self.discovered[x][y] {
|
|
return (Some(StructureElement::Unknown), None, None);
|
|
}
|
|
let search_pos = &Position::new(self.level, x, y);
|
|
let mut res_m: Option<&mut Box<dyn Monster>> = None;
|
|
for m in &mut self.monsters {
|
|
if m.get_immutable_position() == search_pos {
|
|
res_m = Some(m);
|
|
}
|
|
}
|
|
let mut res_a: Option<&mut Box<dyn Artifact>> = None;
|
|
for a in &mut self.artifacts {
|
|
if a.get_immutable_position() == search_pos {
|
|
res_a = Some(a);
|
|
}
|
|
}
|
|
(Some(self.structure[x][y]), res_m, res_a)
|
|
}
|
|
/// discover the area with in the level around the given position
|
|
pub fn discover(&mut self, pos: &Position) {
|
|
let x = pos.get_x();
|
|
let y = pos.get_y();
|
|
|
|
// uncover fields directly next to the player
|
|
for x_r in max(x - 1, 0)..=min(x + 1, LEVEL_WIDTH - 1) {
|
|
for y_r in max(y - 1, 0)..=min(y + 1, LEVEL_HEIGHT - 1) {
|
|
self.discovered[x_r][y_r] = true;
|
|
}
|
|
}
|
|
|
|
// uncover fields up to 2 fields right of the player
|
|
for x_r in x..=min(x + 2, LEVEL_WIDTH - 1) {
|
|
self.discovered[x_r][y] = true;
|
|
if self.structure[x_r][y] == StructureElement::Wall {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// uncover fields up to 2 fields below of the player
|
|
for y_r in y..=min(y + 2, LEVEL_HEIGHT - 1) {
|
|
self.discovered[x][y_r] = true;
|
|
if self.structure[x][y_r] == StructureElement::Wall {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// uncover fields up to 2 fields left of the player
|
|
for x_r in (max(x, 2)..x + 2).rev() {
|
|
self.discovered[x_r - 2][y] = true;
|
|
if self.structure[x_r - 2][y] == StructureElement::Wall {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// uncover fields up to 2 fields above of the player
|
|
for y_r in (max(y, 2)..y + 2).rev() {
|
|
self.discovered[x][y_r - 2] = true;
|
|
if self.structure[x][y_r - 2] == StructureElement::Wall {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
pub fn update(&mut self) {
|
|
for (index, a) in &mut self.artifacts.iter().enumerate() {
|
|
if a.was_collected() {
|
|
self.artifacts.remove(index);
|
|
break;
|
|
}
|
|
}
|
|
for (index, m) in &mut self.monsters.iter().enumerate() {
|
|
if m.is_dead() {
|
|
self.monsters.remove(index);
|
|
break;
|
|
}
|
|
}
|
|
for index in 0..self.monsters.len() {
|
|
if self.can_monster_move(self.monsters[index].as_ref(), 0, 1) {
|
|
self.monsters[index].get_position().change(0, 1);
|
|
} else if self.can_monster_move(self.monsters[index].as_ref(), 0, -1) {
|
|
self.monsters[index].get_position().change(0, -1);
|
|
}
|
|
}
|
|
}
|
|
pub fn can_monster_move(&self, agent: &dyn Monster, dx: i16, dy: i16) -> bool {
|
|
let agent_pos = agent.get_immutable_position();
|
|
let new_x: usize = (agent_pos.get_x() as i16 + dx) as usize;
|
|
let new_y: usize = (agent_pos.get_y() as i16 + dy) as usize;
|
|
self.structure[new_x][new_y] != StructureElement::Wall
|
|
}
|
|
pub fn can_player_move(&self, agent: &Player, dx: i16, dy: i16) -> bool {
|
|
let agent_pos = agent.get_immutable_position();
|
|
let new_x: usize = (agent_pos.get_x() as i16 + dx) as usize;
|
|
let new_y: usize = (agent_pos.get_y() as i16 + dy) as usize;
|
|
self.structure[new_x][new_y] != StructureElement::Wall
|
|
}
|
|
#[cfg(test)]
|
|
pub fn new(level: usize) -> Level {
|
|
let mut s = [[StructureElement::Wall; LEVEL_HEIGHT]; LEVEL_WIDTH];
|
|
for x in 2..LEVEL_WIDTH - 2 {
|
|
for y in 2..LEVEL_HEIGHT - 2 {
|
|
s[x][y] = StructureElement::Floor;
|
|
}
|
|
}
|
|
Level {
|
|
level,
|
|
structure: s,
|
|
discovered: [[false; LEVEL_HEIGHT]; LEVEL_WIDTH],
|
|
monsters: Vec::with_capacity(10),
|
|
artifacts: Vec::with_capacity(10),
|
|
start: (0, 0),
|
|
end: (0, 0),
|
|
}
|
|
}
|
|
#[cfg(test)]
|
|
pub fn add_monster(&mut self, mut monster: impl Monster + 'static) -> Result<(), String> {
|
|
if self.level != monster.get_position().get_level() {
|
|
return Err("Wrong Level".to_string());
|
|
}
|
|
for m in &mut self.monsters {
|
|
if m.get_position() == monster.get_position() {
|
|
return Err("Position already used".to_string());
|
|
}
|
|
}
|
|
self.monsters.push(Box::new(monster));
|
|
Ok(())
|
|
}
|
|
#[cfg(test)]
|
|
pub fn add_artifact(&mut self, artifact: impl Artifact + 'static) -> Result<(), String> {
|
|
if self.level != artifact.get_immutable_position().get_level() {
|
|
return Err("Wrong Level".to_string());
|
|
}
|
|
for a in &mut self.artifacts {
|
|
if a.get_immutable_position() == artifact.get_immutable_position() {
|
|
return Err("Position already used".to_string());
|
|
}
|
|
}
|
|
self.artifacts.push(Box::new(artifact));
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_element() {
|
|
let mut l = Level::new(0);
|
|
assert_eq!(l.get_element(-1, -1).0, None);
|
|
assert_eq!(l.get_element(0, 0).0.unwrap(), StructureElement::Unknown);
|
|
assert_eq!(l.get_element(LEVEL_WIDTH as i16 - 1, LEVEL_HEIGHT as i16 - 1).0.unwrap(), StructureElement::Unknown);
|
|
assert_eq!(l.get_element(LEVEL_WIDTH as i16, LEVEL_HEIGHT as i16).0, None);
|
|
}
|
|
|
|
#[test]
|
|
fn test_discover_get_element() {
|
|
let mut l = Level::new(0);
|
|
assert_eq!(l.get_element(10, 10).0.unwrap(), StructureElement::Unknown);
|
|
let p = Position::new(0, 10, 10);
|
|
l.discover(&p);
|
|
assert_eq!(l.get_element(10, 10).0.unwrap(), StructureElement::Floor);
|
|
assert_eq!(l.get_element(9, 10).0.unwrap(), StructureElement::Floor);
|
|
assert_eq!(l.get_element(10, 9).0.unwrap(), StructureElement::Floor);
|
|
assert_eq!(l.get_element(11, 10).0.unwrap(), StructureElement::Floor);
|
|
assert_eq!(l.get_element(10, 11).0.unwrap(), StructureElement::Floor);
|
|
}
|
|
|
|
#[test]
|
|
fn test_discover_can_add_monster() {
|
|
let mut l = Level::new(0);
|
|
let m = Rat::new_with_position(Position::new(1, 2, 3));
|
|
assert_eq!(l.add_monster(m), Err("Wrong Level".to_string()));
|
|
|
|
let mut m = Orc::new_with_position(Position::new(0, 2, 3));
|
|
m.get_position().set(0, 2, 3);
|
|
assert_eq!(l.add_monster(m), Ok(()));
|
|
|
|
let m = Rat::new_with_position(Position::new(0, 2, 3));
|
|
assert_eq!(l.add_monster(m), Err("Position already used".to_string()));
|
|
|
|
let m = Rat::new_with_position(Position::new(0, 2, 4));
|
|
assert_eq!(l.add_monster(m), Ok(()));
|
|
}
|
|
|
|
#[test]
|
|
fn test_discover_can_add_artifact() {
|
|
let mut l = Level::new(0);
|
|
let a = Chest::new(Position::new(1, 2, 3));
|
|
assert_eq!(l.add_artifact(a), Err("Wrong Level".to_string()));
|
|
|
|
let a = Chest::new(Position::new(0, 2, 3));
|
|
assert_eq!(l.add_artifact(a), Ok(()));
|
|
|
|
let a = Potion::new(Position::new(0, 2, 3));
|
|
assert_eq!(l.add_artifact(a), Err("Position already used".to_string()));
|
|
|
|
let a = Chest::new(Position::new(0, 1, 3));
|
|
assert_eq!(l.add_artifact(a), Ok(()));
|
|
}
|
|
|
|
#[test]
|
|
fn test_discover_get_monster() {
|
|
let mut l = Level::new(0);
|
|
let p = Position::new(0, 10, 10);
|
|
l.discover(&p);
|
|
assert_eq!(l.get_element(10, 10).0.unwrap(), StructureElement::Floor);
|
|
assert!(l.get_element(10, 10).1.is_none());
|
|
|
|
let m = Rat::new_with_position(Position::new(0, 10, 10));
|
|
assert_eq!(l.add_monster(m), Ok(()));
|
|
|
|
let elem = l.get_element(10, 10);
|
|
assert_eq!(elem.0.unwrap(), StructureElement::Floor);
|
|
assert!(elem.1.is_some());
|
|
let m = elem.1.unwrap();
|
|
assert_eq!(m.get_life(), 2);
|
|
|
|
m.decrease_life(2);
|
|
assert_eq!(l.get_element(10, 10).1.unwrap().get_life(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_discover_get_artifact() {
|
|
let mut l = Level::new(0);
|
|
let p = Position::new(0, 10, 10);
|
|
l.discover(&p);
|
|
assert_eq!(l.get_element(10, 10).0.unwrap(), StructureElement::Floor);
|
|
assert!(l.get_element(10, 10).2.is_none());
|
|
|
|
let a = Chest::new(Position::new(0, 10, 10));
|
|
assert_eq!(l.add_artifact(a), Ok(()));
|
|
|
|
let elem = l.get_element(10, 10);
|
|
assert_eq!(elem.0.unwrap(), StructureElement::Floor);
|
|
assert!(elem.2.is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn test_discover_get_monster_can_move() {
|
|
let mut l = Level::new(0);
|
|
let p = Position::new(0, 10, 10);
|
|
l.discover(&p);
|
|
|
|
let m = Rat::new_with_position(Position::new(0, 10, 10));
|
|
l.add_monster(m).expect("Panic because of");
|
|
|
|
let m = l.get_element(10, 10).1.unwrap();
|
|
m.get_position().change(1, 1);
|
|
|
|
let m = l.get_element(10, 10).1;
|
|
assert!(m.is_none());
|
|
let m = l.get_element(11, 11).1;
|
|
assert!(m.is_some());
|
|
assert_eq!(m.unwrap().get_life(), 2);
|
|
}
|