el_diablo/src/level.rs

use std::cmp::{max, min};
use crate::artifacts::{Artifact, Chest, Potion};
use crate::monster::Monster;
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<Monster>,
    pub(crate) artifacts: Vec<Box<dyn Artifact>>,
    /// the position of the start in the level (eiter stair up or start point)
    pub(crate) start: (usize, usize),
    /// the position of the end in the level (eiter stair down or end point)
    pub(crate) end: (usize, usize),
}

impl Level {
    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),
        }
    }
    pub fn get_element(&mut self, x: i16, y: i16) -> (Option<StructureElement>, Option<&mut Monster>, 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 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)
    }
    pub fn add_monster(&mut self, mut monster: Monster) -> 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(monster);
        Ok(())
    }

    pub fn remove_dead_monster(&mut self, position: &Position) -> Result<(), String> {
        if self.level != position.get_level() {
            return Err("Wrong Level".to_string());
        }
        for (index, m) in &mut self.monsters.iter().enumerate() {
            if m.get_immutable_position() == position {
                if !m.is_dead() {
                    return Err("Monster not dead".to_string());
                }
                self.monsters.remove(index);
                break;
            }
        }
        Ok(())
    }
    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(())
    }
    pub fn remove_artifact(&mut self, position: &Position) -> Result<(), String> {
        if self.level != position.get_level() {
            return Err("Wrong Level".to_string());
        }
        for (index, a) in &mut self.artifacts.iter().enumerate() {
            if a.get_immutable_position() == position {
                self.monsters.remove(index);
                break;
            }
        }
        Ok(())
    }
    /// 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;
            }
        }
    }
}

#[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 mut m = Monster::new(2);
    m.get_position().set(1, 2, 3);
    assert_eq!(l.add_monster(m), Err("Wrong Level".to_string()));

    let mut m = Monster::new(2);
    m.get_position().set(0, 2, 3);
    assert_eq!(l.add_monster(m), Ok(()));

    let mut m = Monster::new(2);
    m.get_position().set(0, 2, 3);
    assert_eq!(l.add_monster(m), Err("Position already used".to_string()));

    let mut m = Monster::new(2);
    m.get_position().set(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 mut m = Monster::new(23);
    m.get_position().set(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(), 23);

    m.decrease_life(2);
    assert_eq!(l.get_element(10, 10).1.unwrap().get_life(), 21);
}

#[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 mut m = Monster::new(23);
    m.get_position().set(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(), 23);
}

#[test]
fn test_monster_can_be_removed() {
    let mut level = Level::new(0);
    level.discover(&Position::new(0, 10, 10));

    let mut m = Monster::new(2);
    m.get_position().set(0, 10, 10);
    level.add_monster(m).expect("Panic because of");

    let m = level.get_element(10, 10).1.unwrap();
    m.decrease_life(3);

    assert_eq!(level.remove_dead_monster(&Position::new(0, 10, 10)), Ok(()));

    assert!(level.get_element(10, 10).1.is_none());
}