Enum Tile 

pub enum Tile {
    Wall,
    Floor,
}

Basic tile type for dungeon/terrain generation

Variants

Wall

Floor

Implementations

impl Tile

pub fn is_wall(&self) -> bool

pub fn is_floor(&self) -> bool

Examples found in repository

examples/advanced_pathfinding.rs (line 66)

fn print_grid(grid: &Grid<Tile>) {
    for y in 0..grid.height() {
        for x in 0..grid.width() {
            let tile = grid.get(x as i32, y as i32).unwrap();
            print!("{}", if tile.is_floor() { "." } else { "#" });
        }
        println!();
    }
}

examples/distance_transforms.rs (line 54)

fn print_grid(grid: &Grid<Tile>) {
    for y in 0..grid.height() {
        for x in 0..grid.width() {
            let tile = grid.get(x as i32, y as i32).unwrap();
            print!("{}", if tile.is_floor() { "." } else { "#" });
        }
        println!();
    }
}

examples/delaunay_connections.rs (line 144)

fn count_rooms(grid: &Grid<Tile>) -> usize {
    // Simple room counting by finding floor clusters
    let mut room_count = 0;
    let mut visited = vec![vec![false; grid.width()]; grid.height()];

    for y in 0..grid.height() {
        for x in 0..grid.width() {
            if !visited[y][x] {
                if let Some(tile) = grid.get(x as i32, y as i32) {
                    if tile.is_floor() {
                        flood_fill(grid, &mut visited, x, y);
                        room_count += 1;
                    }
                }
            }
        }
    }

    room_count
}

fn flood_fill(grid: &Grid<Tile>, visited: &mut [Vec<bool>], start_x: usize, start_y: usize) {
    let mut stack = vec![(start_x, start_y)];

    while let Some((x, y)) = stack.pop() {
        if visited[y][x] {
            continue;
        }
        visited[y][x] = true;

        for (dx, dy) in [(-1, 0), (1, 0), (0, -1), (0, 1)] {
            let nx = x as i32 + dx;
            let ny = y as i32 + dy;

            if nx >= 0 && ny >= 0 && (nx as usize) < grid.width() && (ny as usize) < grid.height() {
                let nx = nx as usize;
                let ny = ny as usize;

                if !visited[ny][nx] {
                    if let Some(tile) = grid.get(nx as i32, ny as i32) {
                        if tile.is_floor() {
                            stack.push((nx, ny));
                        }
                    }
                }
            }
        }
    }
}

fn find_room_centers(grid: &Grid<Tile>) -> Vec<Point> {
    let mut centers = Vec::new();
    let mut visited = vec![vec![false; grid.width()]; grid.height()];

    for y in 0..grid.height() {
        for x in 0..grid.width() {
            if !visited[y][x] {
                if let Some(tile) = grid.get(x as i32, y as i32) {
                    if tile.is_floor() {
                        let center = find_room_center(grid, &mut visited, x, y);
                        centers.push(center);
                    }
                }
            }
        }
    }

    centers
}

fn find_room_center(
    grid: &Grid<Tile>,
    visited: &mut [Vec<bool>],
    start_x: usize,
    start_y: usize,
) -> Point {
    let mut room_cells = Vec::new();
    let mut stack = vec![(start_x, start_y)];

    while let Some((x, y)) = stack.pop() {
        if visited[y][x] {
            continue;
        }
        visited[y][x] = true;
        room_cells.push((x, y));

        for (dx, dy) in [(-1, 0), (1, 0), (0, -1), (0, 1)] {
            let nx = x as i32 + dx;
            let ny = y as i32 + dy;

            if nx >= 0 && ny >= 0 && (nx as usize) < grid.width() && (ny as usize) < grid.height() {
                let nx = nx as usize;
                let ny = ny as usize;

                if !visited[ny][nx] {
                    if let Some(tile) = grid.get(nx as i32, ny as i32) {
                        if tile.is_floor() {
                            stack.push((nx, ny));
                        }
                    }
                }
            }
        }
    }

    // Calculate centroid
    let sum_x: usize = room_cells.iter().map(|(x, _)| x).sum();
    let sum_y: usize = room_cells.iter().map(|(_, y)| y).sum();
    let count = room_cells.len();

    Point::new(sum_x as f32 / count as f32, sum_y as f32 / count as f32)
}

examples/phase1_demo.rs (line 90)

fn demo_generate_with_requirements() {
    println!("📋 Demo 2: Generate with Requirements");

    let mut requirements = SemanticRequirements::basic_dungeon();
    requirements.min_regions.insert("room".to_string(), 4);
    requirements
        .required_markers
        .insert(MarkerType::LootTier { tier: 1 }, 2);

    match terrain_forge::generate_with_requirements("bsp", 60, 40, requirements, Some(5), 54321) {
        Ok((grid, semantic)) => {
            println!("  ✅ Generated valid dungeon!");
            println!("  Regions: {}", semantic.regions.len());
            println!("  Markers: {}", semantic.markers.len());
            println!("  Floor tiles: {}", grid.count(|t| t.is_floor()));
        }
        Err(msg) => println!("  ❌ Failed: {}", msg),
    }
    println!();
}

examples/bsp_analysis.rs (line 14)

fn main() {
    println!("=== BSP Algorithm Analysis ===\n");

    let mut grid = Grid::new(40, 30);
    algorithms::get("bsp").unwrap().generate(&mut grid, 12345);

    let extractor = SemanticExtractor::for_rooms();
    let mut rng = Rng::new(12345);
    let semantic = extractor.extract(&grid, &mut rng);

    println!("Generated map analysis:");
    println!("  Floor tiles: {}", grid.count(|t| t.is_floor()));
    println!("  Total regions: {}", semantic.regions.len());

    println!("\nRegion breakdown:");
    let mut region_counts = std::collections::HashMap::new();
    for region in &semantic.regions {
        *region_counts.entry(&region.kind).or_insert(0) += 1;
    }

    for (kind, count) in &region_counts {
        println!("  {}: {}", kind, count);
    }

    println!("\nMarker breakdown:");
    let mut marker_counts = std::collections::HashMap::new();
    for marker in &semantic.markers {
        *marker_counts.entry(marker.tag()).or_insert(0) += 1;
    }

    for (tag, count) in &marker_counts {
        println!("  {}: {}", tag, count);
    }
}

examples/requirements_demo.rs (line 22)

fn main() {
    println!("=== Generate with Requirements Demo ===\n");

    // Create simple requirements that match BSP output
    let mut requirements = SemanticRequirements::none();
    requirements.min_regions.insert("Hall".to_string(), 1); // BSP produces "Hall" regions
    requirements
        .required_markers
        .insert(MarkerType::Custom("PlayerStart".to_string()), 1); // BSP produces "PlayerStart"

    println!("Requirements:");
    println!("  - Minimum 1 Hall region");
    println!("  - At least 1 PlayerStart marker");
    println!();

    match generate_with_requirements("bsp", 40, 30, requirements, Some(10), 12345) {
        Ok((grid, semantic)) => {
            println!("✅ Successfully generated map meeting requirements!");
            println!("  Grid size: {}x{}", grid.width(), grid.height());
            println!("  Floor tiles: {}", grid.count(|t| t.is_floor()));
            println!("  Total regions: {}", semantic.regions.len());

            // Count Hall regions
            let hall_count = semantic.regions.iter().filter(|r| r.kind == "Hall").count();
            println!("  Hall regions: {}", hall_count);

            // Count PlayerStart markers
            let start_count = semantic
                .markers
                .iter()
                .filter(|m| m.tag() == "PlayerStart")
                .count();
            println!("  PlayerStart markers: {}", start_count);

            println!("\nFirst few regions:");
            for (i, region) in semantic.regions.iter().take(3).enumerate() {
                println!("  {}: {} ({} cells)", i + 1, region.kind, region.area());
            }
        }
        Err(msg) => {
            println!("❌ Failed to generate: {}", msg);
        }
    }
}

Additional examples can be found in:

• examples/phase2_demo.rs
• examples/requirement_generation.rs
• examples/enhanced_wfc.rs
• examples/morphological_operations.rs
• examples/conditional_pipelines.rs
• examples/vertical_connectivity.rs
• examples/spatial_workflow.rs
• examples/pipeline_templates.rs
• examples/advanced_prefabs.rs
• examples/complete_workflow.rs
• examples/phase4_workflow.rs

Trait Implementations

impl Cell for Tile

fn is_passable(&self) -> bool

impl Clone for Tile

fn clone(&self) -> Tile

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Tile

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

Formats the value using the given formatter.

impl Default for Tile

fn default() -> Tile

Returns the “default value” for a type.

impl Hash for Tile

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Tile

fn eq(&self, other: &Tile) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Tile

impl Eq for Tile

impl StructuralPartialEq for Tile