Struct leemaze::AllowedMoves2D

pub struct AllowedMoves2D {
    pub moves: Vec<(i32, i32)>,
}

Lee Algorithm in rust provides one of the shortest paths through a maze.

Maze may be 2d (Vec<Vec>) or 3d, 4d or 5d (Yea! 5D - plan your nth morning commute through shifting traffic and 2% driver crazies to arrive at a place and time... probably.) Maze need not be composed of same length vectors. Movement rules (allowed directions) through maze need to be defined in a vector.
The maze may be exceptionally large, but please remember that the Lee algorithm can be memory hungry. Only one fastest path is returned, even if there are many. Walls are true, paths are zeros. decode the returned maze direction path with your list of allowed directional maze moves by index value. Mazes & minataurs remind me of that song Woolly Bully, so thanks Sam the Sham for that ear-worm.

Example

use leemaze::*; fn main() { let thisisanexamplenonrectangularthreedmaze = vec![ vec![ vec![0, 1, 0, 0, 0], vec![0, 1, 0, 1, 0], vec![0, 1, 0, 1, 0], vec![0, 1, 0, 1, 1], vec![0, 0, 1, 1, 0], ], vec![ vec![0, 1, 0, 0, 0], vec![0, 0, 0], vec![0, 1, 1, 0, 0], vec![0, 1, 0, 0, 0], vec![1, 0, 0, 1, 0], ], ];

let boolean_maze: Vec<Vec<Vec<bool>>> =
    boolify_3d_maze(&0, &thisisanexamplenonrectangularthreedmaze);

let axis_moves = AllowedMoves3D {
    moves: vec![
        (0, 0, -1),
        (0, 0, 1),
        (0, -1, 0),
        (0, 1, 0),
        (-1, 0, 0),
        (1, 0, 0),
    ],
};
let moves_text: Vec<&str> = vec![
    "drop level",
    "climb level",
    "north",
    "south",
    "west",
    "east",
];

let (from_here, to_there) = ((0, 0, 0), (4, 4, 0));

let directions = maze_directions3d(&boolean_maze, &axis_moves, &from_here, &to_there);
let mut lev: i32 = 0;
println!("Maze");
for each in thisisanexamplenonrectangularthreedmaze {
    println!("maze level {}", lev);
    for rows in each {
        println!("{:?}", rows);
    }
    lev = lev + 1;
}

println!("diretions from {:?} to {:?} ", from_here, to_there);

if directions.is_some() {
    let mut level = 0;

    for index in directions.unwrap() {
        print!(" {}, ", moves_text[(index as usize)]);
    }
} else {
    println!("Is there a way through the maze?");
}
println!();

} 2d connection rules- provide a vector of (i32,i32) tuples that describe how a player can move in two (x, y) dimensions through a 2d maze.
North south east west might be vec!( (0,1),(0,-1),(1,0),(-1,0) ) Chess knight moves might be vec( (1,2),(-1,2),(1,-2),(-1,-2),((2,1),(-2,1),(2,-1),(-2,-1) )

Fields

moves: Vec<(i32, i32)>

Trait Implementations

impl Clone for AllowedMoves2D

fn clone(&self) -> AllowedMoves2D

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AllowedMoves2D

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.