127 lines
3.3 KiB
Rust
127 lines
3.3 KiB
Rust
use lazy_static::lazy_static;
|
|
use bracket_lib::prelude::*;
|
|
|
|
pub const HEIGHT: usize = 64;
|
|
pub const WIDTH: usize = 64;
|
|
pub const HALLWAY_CHANCE: f32 = 0.5;
|
|
pub const VERTICAL_CORRIDOR_MIN_LENGTH: i32 = 2;
|
|
pub const VERTICAL_CORRIDOR_MAX_LENGTH: i32 = 9;
|
|
pub const HORIZONTAL_CORRIDOR_MIN_LENGTH: i32 = 5;
|
|
pub const HORIZONTAL_CORRIDOR_MAX_LENGTH: i32 = 15;
|
|
|
|
pub enum Operator {
|
|
LessThan,
|
|
GreaterThan,
|
|
LessThanEqualTo,
|
|
GreaterThanEqualTo,
|
|
EqualTo,
|
|
}
|
|
|
|
impl Operator {
|
|
pub fn eval(&self, a: i32, b: i32) -> bool {
|
|
match self {
|
|
Operator::LessThan => a < b,
|
|
Operator::GreaterThan => a > b,
|
|
Operator::LessThanEqualTo => a <= b,
|
|
Operator::GreaterThanEqualTo => a >= b,
|
|
Operator::EqualTo => a == b,
|
|
}
|
|
}
|
|
pub fn string(&self) -> &str {
|
|
match self {
|
|
Operator::LessThan => "<",
|
|
Operator::GreaterThan => ">",
|
|
Operator::LessThanEqualTo => "<=",
|
|
Operator::GreaterThanEqualTo => ">=",
|
|
Operator::EqualTo => "==",
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct CellRules {
|
|
pub adjacent_type: i32,
|
|
pub into: i32,
|
|
pub operator: Operator,
|
|
pub n: i32,
|
|
}
|
|
|
|
impl CellRules {
|
|
const fn new(adjacent_type: i32, into: i32, operator: Operator, n: i32) -> CellRules {
|
|
CellRules {
|
|
adjacent_type,
|
|
into,
|
|
operator,
|
|
n,
|
|
}
|
|
}
|
|
}
|
|
|
|
lazy_static! {
|
|
pub static ref CA: Vec<Vec<CellRules>> = vec![
|
|
vec![CellRules::new(1, 1, Operator::GreaterThanEqualTo, 4)],
|
|
vec![
|
|
CellRules::new(0, 0, Operator::GreaterThanEqualTo, 5),
|
|
CellRules::new(1, 0, Operator::LessThan, 2)
|
|
]
|
|
];
|
|
}
|
|
|
|
#[derive(Debug, Copy, Clone, PartialEq)]
|
|
pub enum Direction {
|
|
NoDir = -1,
|
|
North = 0,
|
|
East = 1,
|
|
South = 2,
|
|
West = 3,
|
|
}
|
|
|
|
impl Direction {
|
|
pub fn transform(&self) -> Point {
|
|
match self {
|
|
Direction::NoDir => unreachable!("Direction::NoDir should never be transformed"),
|
|
Direction::North => Point::new(0, -1),
|
|
Direction::East => Point::new(1, 0),
|
|
Direction::South => Point::new(0, 1),
|
|
Direction::West => Point::new(-1, 0),
|
|
}
|
|
}
|
|
pub fn opposite_dir(&self) -> Direction {
|
|
match self {
|
|
Direction::NoDir => unreachable!("Direction::NoDir has no opposite."),
|
|
Direction::North => Direction::South,
|
|
Direction::East => Direction::West,
|
|
Direction::South => Direction::North,
|
|
Direction::West => Direction::East,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct DirectionIterator {
|
|
current: Direction,
|
|
}
|
|
|
|
impl DirectionIterator {
|
|
pub fn new() -> DirectionIterator {
|
|
DirectionIterator {
|
|
current: Direction::North,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Iterator for DirectionIterator {
|
|
type Item = Direction;
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
use Direction::*;
|
|
let next_direction = match self.current {
|
|
North => East,
|
|
East => South,
|
|
South => West,
|
|
West => {
|
|
return None;
|
|
}
|
|
NoDir => unreachable!("Direction::NoDir should never be iterated over."),
|
|
};
|
|
self.current = next_direction;
|
|
Some(next_direction)
|
|
}
|
|
}
|