1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use super::consts::*;
use super::row::*;
use super::skill::*;
use super::slab_def::*;

pub struct Level {
    rows: Vec<Row>,
    seed: u64,
    w: usize,
    skill: Skill,
}

impl Level {
    /// Create a new level, with a given size
    ///
    /// # Examples
    ///
    /// ```
    /// use babalcore::*;
    ///
    /// let _level = Level::new(0, 10, Skill::Easy);
    /// ```
    pub fn new(seed: u64, width: usize, skill: Skill) -> Level {
        let w = if width > WIDTH_MAX as usize {
            WIDTH_MAX
        } else {
            width
        };
        Level {
            rows: Vec::new(),
            seed,
            w,
            skill,
        }
    }

    /// Get the level width. It is fixed for a given game session.
    ///
    /// # Examples
    ///
    /// ```
    /// use babalcore::*;
    ///
    /// let level = Level::new(0, 10, Skill::Easy);
    /// assert_eq!(10, level.width());
    /// ```
    pub fn width(&self) -> usize {
        self.w
    }

    /// Get the level length. Length typically increases as
    /// the ball rolls on.
    ///
    /// # Examples
    ///
    /// ```
    /// use babalcore::*;
    ///
    /// let level = Level::new(0, 10, Skill::Easy);
    /// assert_eq!(0, level.len());
    /// ```
    pub fn len(&self) -> usize {
        self.rows.len()
    }

    pub fn push(&mut self, row: Row) {
        if self.rows.len() >= LENGTH_MAX {
            return;
        }
        self.rows.push(row)
    }

    pub fn extend(&mut self, n: usize) {
        if self.rows.len() >= LENGTH_MAX {
            return;
        }
        for _ in 0..n {
            let row = Row::new(SlabDef::Floor);
            self.push(row)
        }
    }
}

impl std::fmt::Display for Level {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let str_list: Vec<String> = self
            .rows
            .iter()
            .map(|x| format!("{}", x)[0..self.w].to_string())
            .collect();
        write!(f, "{}", str_list.join("\n"))
    }
}

#[cfg(test)]
mod tests {
    use crate::*;

    #[test]
    fn test_fmt() {
        assert_eq!("", format!("{}", Level::new(0, 10, Skill::Easy)));
        let mut lvl = Level::new(0, 5, Skill::Noob);
        lvl.extend(3);
        assert_eq!("#####\n#####\n#####", format!("{}", lvl));
    }

    #[test]
    fn test_length_max() {
        let mut lvl = Level::new(0, 2, Skill::Noob);
        assert_eq!(0, lvl.len());
        let row = Row::new(SlabDef::Floor);
        lvl.extend(LENGTH_MAX - 1);
        assert_eq!(LENGTH_MAX - 1, lvl.len());
        lvl.extend(2);
        assert_eq!(LENGTH_MAX, lvl.len());
        lvl.push(row);
        assert_eq!(LENGTH_MAX, lvl.len());
    }
}