use rand::prelude::*;
use std::collections::HashSet;
fn main() {
// Dimensions du labyrinthe (doit être impair pour avoir des murs aux bords)
let width = 29;
let height = 19;
// Générer le labyrinthe
let maze = generate_maze(width, height);
// Afficher le labyrinthe
print_maze(&maze, width, height);
}
fn generate_maze(width: usize, height: usize) -> Vec<Vec<char>> {
// Initialiser le labyrinthe avec des murs partout
let mut maze = vec![vec!['#'; width]; height];
let mut rng = rand::thread_rng();
// Ensemble pour suivre les cellules visitées
let mut visited = HashSet::new();
// Pile pour l'algorithme DFS
let mut stack = Vec::new();
// Point de départ (coordonnées impaires)
let start_x = 1;
let start_y = 1;
// Marquer le point de départ comme un chemin
maze[start_y][start_x] = ' ';
visited.insert((start_x, start_y));
stack.push((start_x, start_y));
// Directions possibles: droite, bas, gauche, haut
let directions = [(2, 0), (0, 2), (-2, 0), (0, -2)];
// Tant que la pile n'est pas vide
while !stack.is_empty() {
let current = stack.last().unwrap().clone();
let (x, y) = current;
// Trouver les voisins non visités
let mut neighbors = Vec::new();
for (dx, dy) in directions.iter() {
let nx = (x as isize + dx) as usize;
let ny = (y as isize + dy) as usize;
// Vérifier si le voisin est dans les limites du labyrinthe
if nx > 0 && nx < width - 1 && ny > 0 && ny < height - 1
&& !visited.contains(&(nx, ny)) {
neighbors.push((nx, ny, *dx, *dy));
}
}
// S'il y a des voisins non visités
if !neighbors.is_empty() {
// Choisir un voisin au hasard
let (nx, ny, dx, dy) = neighbors[rng.gen_range(0..neighbors.len())];
// Creuser un passage
let wall_x = (x as isize + dx / 2) as usize;
let wall_y = (y as isize + dy / 2) as usize;
maze[wall_y][wall_x] = ' ';
// Marquer le voisin comme visité
maze[ny][nx] = ' ';
visited.insert((nx, ny));
// Pousser le nouveau voisin sur la pile
stack.push((nx, ny));
} else {
// Retour en arrière si aucun voisin non visité
stack.pop();
}
}
// Définir l'entrée et la sortie
maze[0][1] = ' '; // Entrée en haut
maze[height - 1][width - 2] = ' '; // Sortie en bas
maze
}
fn print_maze(maze: &Vec<Vec<char>>, width: usize, height: usize) {
for y in 0..height {
for x in 0..width {
print!("{}", maze[y][x]);
}
println!();
}
}
cargo.toml:
[dependencies]
rand = "0.8.5"
résultat:
$ cargo run
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.02s
Running `target/debug/maze_claudeia`
# ###########################
# # # # # #
# ####### # # # ### ##### # #
# # # # # # # #
### # ############### ### # #
# # # # # #
# ##### # ### ##### ### ### #
# # # # # # #
########### ### # ####### ###
# # # # # #
# ### ### ### ############# #
# # # # # # #
# # ### ######### ##### ### #
# # # # # # #
# ### ### # ### # ### ##### #
# # # # # # # # # #
# ### # ##### # ### # # # # #
# # # # # #
########################### #
