Struct Grid 

pub struct Grid<C: Cell = Tile> { /* private fields */ }

2D grid of cells

Implementations

impl<C: Cell> Grid<C>

pub fn new(width: usize, height: usize) -> Self

Examples found in repository

examples/bsp_analysis.rs (line 6)

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/distance_transforms.rs (line 15)

fn main() {
    println!("=== Distance Transform Demo ===\n");

    // Generate a simple room layout
    let mut grid = Grid::new(20, 15);
    let algo = algorithms::get("rooms").unwrap();
    algo.generate(&mut grid, 12345);

    println!("1. Original Grid (20x15):");
    print_grid(&grid);

    // Generate distance fields with different metrics
    println!("\n2. Euclidean Distance Field:");
    let euclidean = distance_field(&grid, DistanceMetric::Euclidean);
    print_distance_field(&euclidean);

    println!("\n3. Manhattan Distance Field:");
    let manhattan = distance_field(&grid, DistanceMetric::Manhattan);
    print_distance_field(&manhattan);

    println!("\n4. Chebyshev Distance Field:");
    let chebyshev = distance_field(&grid, DistanceMetric::Chebyshev);
    print_distance_field(&chebyshev);

    // Performance comparison
    println!("\n5. Performance Comparison:");
    let start = std::time::Instant::now();
    let _ = distance_field(&grid, DistanceMetric::Euclidean);
    println!("   Euclidean: {:?}", start.elapsed());

    let start = std::time::Instant::now();
    let _ = distance_field(&grid, DistanceMetric::Manhattan);
    println!("   Manhattan: {:?}", start.elapsed());

    let start = std::time::Instant::now();
    let _ = distance_field(&grid, DistanceMetric::Chebyshev);
    println!("   Chebyshev: {:?}", start.elapsed());
}

examples/phase1_demo.rs (line 19)

fn demo_hierarchical_markers() {
    println!("🎯 Demo 1: Hierarchical Marker Types");

    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 mut semantic = extractor.extract(&grid, &mut rng);

    // Add hierarchical markers manually for demo
    if let Some(region) = semantic.regions.first() {
        let (x, y) = region.cells[0];

        // Quest markers
        semantic.markers.push(Marker::new(
            x,
            y,
            MarkerType::QuestObjective { priority: 1 },
        ));
        semantic
            .markers
            .push(Marker::new(x + 2, y, MarkerType::QuestStart));

        // Loot markers
        semantic
            .markers
            .push(Marker::new(x, y + 2, MarkerType::LootTier { tier: 3 }));
        semantic
            .markers
            .push(Marker::new(x + 1, y + 2, MarkerType::Treasure));

        // Encounter zones
        semantic.markers.push(Marker::new(
            x + 3,
            y + 1,
            MarkerType::EncounterZone { difficulty: 5 },
        ));
        semantic
            .markers
            .push(Marker::new(x + 4, y + 1, MarkerType::BossRoom));
    }

    // Show marker categories
    let mut categories = std::collections::HashMap::new();
    for marker in &semantic.markers {
        *categories.entry(marker.marker_type.category()).or_insert(0) += 1;
    }

    for (category, count) in categories {
        println!("  {} markers: {}", category, count);
    }

    println!("  Sample markers:");
    for marker in semantic.markers.iter().take(3) {
        println!("    {} at ({}, {})", marker.tag(), marker.x, marker.y);
    }
    println!();
}

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!();
}

fn demo_vertical_connectivity() {
    println!("🏗️ Demo 3: Vertical Connectivity");

    // Create two simple floor grids
    let mut floor1 = Grid::new(20, 20);
    let mut floor2 = Grid::new(20, 20);

    // Add some floor areas
    for y in 5..15 {
        for x in 5..15 {
            floor1.set(x, y, terrain_forge::Tile::Floor);
            floor2.set(x, y, terrain_forge::Tile::Floor);
        }
    }

    let floors = vec![floor1, floor2];
    let mut connectivity = VerticalConnectivity::new();

    connectivity.analyze_stair_candidates(&floors, 2);
    connectivity.place_stairs(3);

    println!(
        "  Stair candidates found: {}",
        connectivity.stair_candidates.len()
    );
    println!("  Stairs placed: {}", connectivity.stairs.len());

    if let Some((x, y, from, to)) = connectivity.stairs.first() {
        println!(
            "  Sample stair: ({}, {}) connecting floor {} to {}",
            x, y, from, to
        );
    }
    println!();
}

examples/advanced_pathfinding.rs (line 15)

fn main() {
    println!("=== Advanced Pathfinding Demo ===\n");

    // Generate a dungeon layout
    let mut grid = Grid::new(25, 20);
    let algo = algorithms::get("bsp").unwrap();
    algo.generate(&mut grid, 54321);

    println!("1. Dungeon Layout (25x20):");
    print_grid(&grid);

    // Single goal pathfinding
    println!("\n2. Single Goal Dijkstra Map:");
    let goals = vec![(12, 10)]; // Center goal
    let constraints = PathfindingConstraints::default();
    let dijkstra = dijkstra_map(&grid, &goals, &constraints);
    print_dijkstra_map(&dijkstra);

    // Multiple goals pathfinding
    println!("\n3. Multiple Goals Dijkstra Map:");
    let goals = vec![(5, 5), (20, 15), (15, 5)]; // Three goals
    let dijkstra_multi = dijkstra_map(&grid, &goals, &constraints);
    print_dijkstra_map(&dijkstra_multi);

    // Flow field generation
    println!("\n4. Flow Field from Single Goal:");
    let flow = flow_field_from_dijkstra(&dijkstra);
    print_flow_field(&flow);

    // Custom movement costs
    println!("\n5. Custom Movement Costs (diagonal penalty):");
    let mut custom_constraints = PathfindingConstraints::default();
    custom_constraints.movement_cost.insert((-1, -1), 2.0);
    custom_constraints.movement_cost.insert((-1, 1), 2.0);
    custom_constraints.movement_cost.insert((1, -1), 2.0);
    custom_constraints.movement_cost.insert((1, 1), 2.0);

    let dijkstra_custom = dijkstra_map(&grid, &goals, &custom_constraints);
    print_dijkstra_map(&dijkstra_custom);

    // Performance analysis
    println!("\n6. Performance Analysis:");
    let start = std::time::Instant::now();
    let _ = dijkstra_map(&grid, &goals, &constraints);
    println!("   Dijkstra map generation: {:?}", start.elapsed());

    let start = std::time::Instant::now();
    let _ = flow_field_from_dijkstra(&dijkstra);
    println!("   Flow field generation: {:?}", start.elapsed());
}

examples/phase2_demo.rs (line 19)

fn demo_conditional_pipeline() {
    println!("🔀 Demo 1: Conditional Pipeline Operations");

    let mut grid = Grid::new(30, 20);
    let mut context = PipelineContext::new();
    let mut rng = Rng::new(12345);

    // Create conditional pipeline
    let mut pipeline = ConditionalPipeline::new();

    // Add algorithm operation
    pipeline.add_operation(ConditionalOperation::simple(PipelineOperation::Algorithm {
        name: "bsp".to_string(),
        seed: Some(12345),
    }));

    // Add conditional operation based on floor density
    pipeline.add_operation(ConditionalOperation::conditional(
        PipelineOperation::Log {
            message: "Evaluating floor density".to_string(),
        },
        PipelineCondition::Density {
            min: Some(0.2),
            max: Some(0.6),
        },
        vec![ConditionalOperation::simple(
            PipelineOperation::SetParameter {
                key: "density_status".to_string(),
                value: "acceptable".to_string(),
            },
        )],
        vec![ConditionalOperation::simple(
            PipelineOperation::SetParameter {
                key: "density_status".to_string(),
                value: "out_of_range".to_string(),
            },
        )],
    ));

    // Execute pipeline
    let result = pipeline.execute(&mut grid, &mut context, &mut rng);

    println!(
        "  Pipeline execution: {}",
        if result.success {
            "✅ Success"
        } else {
            "❌ Failed"
        }
    );
    if let Some(msg) = result.message {
        println!("  Message: {}", msg);
    }

    println!("  Floor tiles: {}", grid.count(|t| t.is_floor()));
    println!(
        "  Density status: {}",
        context
            .get_parameter("density_status")
            .unwrap_or(&"unknown".to_string())
    );
    println!("  Execution log: {:?}", context.execution_history());
    println!();
}

fn demo_pipeline_templates() {
    println!("📋 Demo 2: Pipeline Templates");

    // Create custom template
    let template = PipelineTemplate::new("custom_dungeon", "Customizable dungeon template")
        .with_parameter("algorithm", "cellular")
        .with_parameter("seed", "54321")
        .with_parameter("type", "dungeon")
        .with_operation(ConditionalOperation::simple(PipelineOperation::Algorithm {
            name: "{algorithm}".to_string(),
            seed: Some(54321),
        }))
        .with_operation(ConditionalOperation::simple(
            PipelineOperation::SetParameter {
                key: "generation_type".to_string(),
                value: "{type}".to_string(),
            },
        ));

    // Instantiate with custom parameters
    let mut custom_params = std::collections::HashMap::new();
    custom_params.insert("algorithm".to_string(), "bsp".to_string());
    custom_params.insert("type".to_string(), "fortress".to_string());

    let pipeline = template.instantiate(Some(custom_params));

    let mut grid = Grid::new(25, 25);
    let mut context = PipelineContext::new();
    let mut rng = Rng::new(98765);

    let result = pipeline.execute(&mut grid, &mut context, &mut rng);

    println!("  Template: {}", template.name);
    println!("  Description: {}", template.description);
    println!(
        "  Execution: {}",
        if result.success {
            "✅ Success"
        } else {
            "❌ Failed"
        }
    );
    println!(
        "  Generation type: {}",
        context
            .get_parameter("generation_type")
            .unwrap_or(&"unknown".to_string())
    );
    println!("  Floor tiles: {}", grid.count(|t| t.is_floor()));
    println!();
}

fn demo_template_library() {
    println!("📚 Demo 3: Template Library");

    let library = TemplateLibrary::new();

    println!("  Available templates:");
    for name in library.template_names() {
        if let Some(template) = library.get_template(name) {
            println!("    - {}: {}", name, template.description);
        }
    }

    // Use built-in template
    if let Some(template) = library.get_template("simple_dungeon") {
        let pipeline = template.instantiate(None);

        let mut grid = Grid::new(40, 30);
        let mut context = PipelineContext::new();
        let mut rng = Rng::new(11111);

        let result = pipeline.execute(&mut grid, &mut context, &mut rng);

        println!("\n  Executed 'simple_dungeon' template:");
        println!(
            "    Result: {}",
            if result.success {
                "✅ Success"
            } else {
                "❌ Failed"
            }
        );
        println!("    Floor tiles: {}", grid.count(|t| t.is_floor()));
        println!("    Steps executed: {}", context.execution_history().len());
    }
    println!();
}

examples/hierarchical_markers.rs (line 7)

fn main() {
    println!("=== Hierarchical Marker Types Demo ===\n");

    // Generate a basic dungeon
    let mut grid = Grid::new(30, 20);
    algorithms::get("bsp").unwrap().generate(&mut grid, 12345);

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

    // Add hierarchical markers
    if let Some(region) = semantic.regions.first() {
        let (x, y) = region.cells[0];

        // Quest markers with priorities
        semantic.markers.push(Marker::new(
            x,
            y,
            MarkerType::QuestObjective { priority: 1 },
        ));
        semantic.markers.push(Marker::new(
            x + 2,
            y,
            MarkerType::QuestObjective { priority: 3 },
        ));
        semantic
            .markers
            .push(Marker::new(x + 4, y, MarkerType::QuestStart));

        // Loot with different tiers
        semantic
            .markers
            .push(Marker::new(x, y + 2, MarkerType::LootTier { tier: 1 }));
        semantic
            .markers
            .push(Marker::new(x + 2, y + 2, MarkerType::LootTier { tier: 3 }));
        semantic
            .markers
            .push(Marker::new(x + 4, y + 2, MarkerType::Treasure));

        // Encounter zones
        semantic.markers.push(Marker::new(
            x,
            y + 4,
            MarkerType::EncounterZone { difficulty: 2 },
        ));
        semantic
            .markers
            .push(Marker::new(x + 2, y + 4, MarkerType::BossRoom));
        semantic
            .markers
            .push(Marker::new(x + 4, y + 4, MarkerType::SafeZone));
    }

    // Show marker categories and types
    println!("Generated {} markers:", semantic.markers.len());
    for marker in &semantic.markers {
        println!(
            "  {} at ({}, {}) - Category: {}",
            marker.tag(),
            marker.x,
            marker.y,
            marker.marker_type.category()
        );
    }

    // Group by category
    let mut categories = std::collections::HashMap::new();
    for marker in &semantic.markers {
        *categories.entry(marker.marker_type.category()).or_insert(0) += 1;
    }

    println!("\nMarker distribution:");
    for (category, count) in categories {
        println!("  {}: {} markers", category, count);
    }
}

Additional examples can be found in:

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

pub fn width(&self) -> usize

Examples found in repository

examples/advanced_pathfinding.rs (line 64)

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 52)

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/morphological_operations.rs (line 98)

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!();
    }
}

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

examples/requirements_demo.rs (line 21)

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);
        }
    }
}

examples/enhanced_wfc.rs (line 56)

fn main() {
    println!("=== Enhanced Wave Function Collapse Demo ===\n");

    // Step 1: Generate example map for pattern learning
    println!("1. Generating Example Map for Pattern Learning:");
    let mut example_grid = Grid::new(20, 15);
    let bsp = Bsp::default();
    bsp.generate(&mut example_grid, 54321);

    print_grid(&example_grid, "Example Map");

    // Step 2: Extract patterns from example
    println!("\n2. Extracting Patterns from Example:");
    let patterns = WfcPatternExtractor::extract_patterns(&example_grid, 3);
    println!("   Extracted {} unique patterns", patterns.len());

    // Step 3: Generate with learned patterns (no backtracking)
    println!("\n3. WFC Generation without Backtracking:");
    let mut grid1 = Grid::new(25, 20);
    let wfc_no_backtrack = Wfc::new(WfcConfig {
        floor_weight: 0.4,
        pattern_size: 3,
        enable_backtracking: false,
    });
    wfc_no_backtrack.generate_with_patterns(&mut grid1, patterns.clone(), 12345);
    print_grid(&grid1, "Without Backtracking");

    // Step 4: Generate with backtracking enabled
    println!("\n4. WFC Generation with Backtracking:");
    let mut grid2 = Grid::new(25, 20);
    let wfc_backtrack = Wfc::new(WfcConfig {
        floor_weight: 0.4,
        pattern_size: 3,
        enable_backtracking: true,
    });
    wfc_backtrack.generate_with_patterns(&mut grid2, patterns.clone(), 12345);
    print_grid(&grid2, "With Backtracking");

    // Step 5: Compare results
    println!("\n5. Comparison:");
    let floors1 = grid1.count(|t| t.is_floor());
    let floors2 = grid2.count(|t| t.is_floor());

    println!(
        "   Without backtracking: {} floors ({:.1}%)",
        floors1,
        100.0 * floors1 as f32 / (grid1.width() * grid1.height()) as f32
    );
    println!(
        "   With backtracking: {} floors ({:.1}%)",
        floors2,
        100.0 * floors2 as f32 / (grid2.width() * grid2.height()) as f32
    );

    // Step 6: Different pattern sizes
    println!("\n6. Pattern Size Comparison:");
    for size in [2, 3, 4] {
        let patterns = WfcPatternExtractor::extract_patterns(&example_grid, size);
        let mut grid = Grid::new(15, 12);
        let wfc = Wfc::new(WfcConfig {
            floor_weight: 0.4,
            pattern_size: size,
            enable_backtracking: true,
        });
        wfc.generate_with_patterns(&mut grid, patterns.clone(), 98765);

        let floors = grid.count(|t| t.is_floor());
        println!(
            "   Pattern size {}: {} patterns, {} floors",
            size,
            patterns.len(),
            floors
        );
    }

    println!("\n✅ Enhanced WFC demo complete!");
    println!("   - Pattern learning extracts reusable structures");
    println!("   - Backtracking improves generation success rate");
    println!("   - Constraint propagation ensures valid outputs");
}

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

examples/delaunay_connections.rs (line 23)

fn main() {
    println!("=== Delaunay Triangulation Demo ===\n");

    // Step 1: Generate base dungeon with rooms
    println!("1. Generating Base Dungeon:");
    let mut grid = Grid::new(40, 30);
    let bsp = Bsp::default();
    bsp.generate(&mut grid, 42424);

    let room_count = count_rooms(&grid);
    println!(
        "   Generated {}x{} dungeon with ~{} rooms",
        grid.width(),
        grid.height(),
        room_count
    );

    // Step 2: Find room centers
    println!("\n2. Identifying Room Centers:");
    let room_centers = find_room_centers(&grid);
    println!("   Found {} room centers:", room_centers.len());
    for (i, center) in room_centers.iter().enumerate() {
        println!("     Room {}: ({:.1}, {:.1})", i + 1, center.x, center.y);
    }

    // Step 3: Create Delaunay triangulation
    println!("\n3. Creating Delaunay Triangulation:");
    let triangulation = DelaunayTriangulation::new(room_centers.clone());

    println!("   Triangulation results:");
    println!("     Vertices: {}", triangulation.points.len());
    println!("     Triangles: {}", triangulation.triangles.len());
    println!("     Edges: {}", triangulation.edges.len());

    // Step 4: Generate minimum spanning tree
    println!("\n4. Generating Minimum Spanning Tree:");
    let mst_edges = triangulation.minimum_spanning_tree();

    println!("   MST results:");
    println!("     Edges: {}", mst_edges.len());
    println!(
        "     Expected for {} rooms: {}",
        room_centers.len(),
        room_centers.len().saturating_sub(1)
    );

    let total_length: f32 = mst_edges
        .iter()
        .map(|edge| edge.length(&triangulation.points))
        .sum();
    println!("     Total length: {:.1}", total_length);

    // Step 5: Graph analysis
    println!("\n5. Graph Analysis:");
    let graph = Graph::new(triangulation.points.clone(), mst_edges.clone());
    let analysis = GraphAnalysis::analyze(&graph);

    println!("   Connectivity analysis:");
    println!("     Connected: {}", analysis.is_connected);
    println!("     Components: {}", analysis.component_count);
    println!("     Diameter: {:.1}", analysis.diameter);
    println!("     Avg clustering: {:.3}", analysis.average_clustering);

    // Step 6: Compare with full triangulation
    println!("\n6. Comparison: MST vs Full Triangulation:");
    let full_graph = Graph::new(triangulation.points.clone(), triangulation.edges.clone());
    let full_analysis = GraphAnalysis::analyze(&full_graph);

    println!("   Full triangulation:");
    println!("     Edges: {}", full_analysis.edge_count);
    println!("     Diameter: {:.1}", full_analysis.diameter);
    println!(
        "     Avg clustering: {:.3}",
        full_analysis.average_clustering
    );

    println!("   MST (optimized):");
    println!("     Edges: {}", analysis.edge_count);
    println!("     Diameter: {:.1}", analysis.diameter);
    println!("     Avg clustering: {:.3}", analysis.average_clustering);

    // Step 7: Pathfinding example
    println!("\n7. Pathfinding Example:");
    if room_centers.len() >= 2 {
        let start = 0;
        let end = room_centers.len() - 1;

        if let Some(path) = graph.shortest_path(start, end) {
            println!("   Path from room {} to room {}:", start + 1, end + 1);
            print!("     Route: ");
            for (i, &room) in path.iter().enumerate() {
                if i > 0 {
                    print!(" -> ");
                }
                print!("Room {}", room + 1);
            }
            println!();

            let mut path_length = 0.0;
            for i in 0..(path.len() - 1) {
                path_length += room_centers[path[i]].distance_to(&room_centers[path[i + 1]]);
            }
            println!("     Total distance: {:.1}", path_length);
        } else {
            println!("   No path found between rooms");
        }
    }

    // Step 8: Performance analysis
    println!("\n8. Performance Analysis:");
    let start = std::time::Instant::now();
    let _ = DelaunayTriangulation::new(room_centers.clone());
    println!("   Triangulation time: {:?}", start.elapsed());

    let start = std::time::Instant::now();
    let _ = triangulation.minimum_spanning_tree();
    println!("   MST generation time: {:?}", start.elapsed());

    println!("\n✅ Delaunay triangulation demo complete!");
    println!("   - Natural room connections via triangulation");
    println!("   - Optimal corridor networks with MST");
    println!("   - Graph analysis for connectivity insights");
}

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)
}

Additional examples can be found in:

• examples/spatial_workflow.rs
• examples/pipeline_templates.rs
• examples/advanced_prefabs.rs
• examples/complete_workflow.rs
• examples/phase4_workflow.rs

pub fn height(&self) -> usize

Examples found in repository

examples/advanced_pathfinding.rs (line 63)

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 51)

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/morphological_operations.rs (line 97)

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!();
    }
}

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

examples/requirements_demo.rs (line 21)

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);
        }
    }
}

examples/enhanced_wfc.rs (line 56)

fn main() {
    println!("=== Enhanced Wave Function Collapse Demo ===\n");

    // Step 1: Generate example map for pattern learning
    println!("1. Generating Example Map for Pattern Learning:");
    let mut example_grid = Grid::new(20, 15);
    let bsp = Bsp::default();
    bsp.generate(&mut example_grid, 54321);

    print_grid(&example_grid, "Example Map");

    // Step 2: Extract patterns from example
    println!("\n2. Extracting Patterns from Example:");
    let patterns = WfcPatternExtractor::extract_patterns(&example_grid, 3);
    println!("   Extracted {} unique patterns", patterns.len());

    // Step 3: Generate with learned patterns (no backtracking)
    println!("\n3. WFC Generation without Backtracking:");
    let mut grid1 = Grid::new(25, 20);
    let wfc_no_backtrack = Wfc::new(WfcConfig {
        floor_weight: 0.4,
        pattern_size: 3,
        enable_backtracking: false,
    });
    wfc_no_backtrack.generate_with_patterns(&mut grid1, patterns.clone(), 12345);
    print_grid(&grid1, "Without Backtracking");

    // Step 4: Generate with backtracking enabled
    println!("\n4. WFC Generation with Backtracking:");
    let mut grid2 = Grid::new(25, 20);
    let wfc_backtrack = Wfc::new(WfcConfig {
        floor_weight: 0.4,
        pattern_size: 3,
        enable_backtracking: true,
    });
    wfc_backtrack.generate_with_patterns(&mut grid2, patterns.clone(), 12345);
    print_grid(&grid2, "With Backtracking");

    // Step 5: Compare results
    println!("\n5. Comparison:");
    let floors1 = grid1.count(|t| t.is_floor());
    let floors2 = grid2.count(|t| t.is_floor());

    println!(
        "   Without backtracking: {} floors ({:.1}%)",
        floors1,
        100.0 * floors1 as f32 / (grid1.width() * grid1.height()) as f32
    );
    println!(
        "   With backtracking: {} floors ({:.1}%)",
        floors2,
        100.0 * floors2 as f32 / (grid2.width() * grid2.height()) as f32
    );

    // Step 6: Different pattern sizes
    println!("\n6. Pattern Size Comparison:");
    for size in [2, 3, 4] {
        let patterns = WfcPatternExtractor::extract_patterns(&example_grid, size);
        let mut grid = Grid::new(15, 12);
        let wfc = Wfc::new(WfcConfig {
            floor_weight: 0.4,
            pattern_size: size,
            enable_backtracking: true,
        });
        wfc.generate_with_patterns(&mut grid, patterns.clone(), 98765);

        let floors = grid.count(|t| t.is_floor());
        println!(
            "   Pattern size {}: {} patterns, {} floors",
            size,
            patterns.len(),
            floors
        );
    }

    println!("\n✅ Enhanced WFC demo complete!");
    println!("   - Pattern learning extracts reusable structures");
    println!("   - Backtracking improves generation success rate");
    println!("   - Constraint propagation ensures valid outputs");
}

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

examples/delaunay_connections.rs (line 24)

fn main() {
    println!("=== Delaunay Triangulation Demo ===\n");

    // Step 1: Generate base dungeon with rooms
    println!("1. Generating Base Dungeon:");
    let mut grid = Grid::new(40, 30);
    let bsp = Bsp::default();
    bsp.generate(&mut grid, 42424);

    let room_count = count_rooms(&grid);
    println!(
        "   Generated {}x{} dungeon with ~{} rooms",
        grid.width(),
        grid.height(),
        room_count
    );

    // Step 2: Find room centers
    println!("\n2. Identifying Room Centers:");
    let room_centers = find_room_centers(&grid);
    println!("   Found {} room centers:", room_centers.len());
    for (i, center) in room_centers.iter().enumerate() {
        println!("     Room {}: ({:.1}, {:.1})", i + 1, center.x, center.y);
    }

    // Step 3: Create Delaunay triangulation
    println!("\n3. Creating Delaunay Triangulation:");
    let triangulation = DelaunayTriangulation::new(room_centers.clone());

    println!("   Triangulation results:");
    println!("     Vertices: {}", triangulation.points.len());
    println!("     Triangles: {}", triangulation.triangles.len());
    println!("     Edges: {}", triangulation.edges.len());

    // Step 4: Generate minimum spanning tree
    println!("\n4. Generating Minimum Spanning Tree:");
    let mst_edges = triangulation.minimum_spanning_tree();

    println!("   MST results:");
    println!("     Edges: {}", mst_edges.len());
    println!(
        "     Expected for {} rooms: {}",
        room_centers.len(),
        room_centers.len().saturating_sub(1)
    );

    let total_length: f32 = mst_edges
        .iter()
        .map(|edge| edge.length(&triangulation.points))
        .sum();
    println!("     Total length: {:.1}", total_length);

    // Step 5: Graph analysis
    println!("\n5. Graph Analysis:");
    let graph = Graph::new(triangulation.points.clone(), mst_edges.clone());
    let analysis = GraphAnalysis::analyze(&graph);

    println!("   Connectivity analysis:");
    println!("     Connected: {}", analysis.is_connected);
    println!("     Components: {}", analysis.component_count);
    println!("     Diameter: {:.1}", analysis.diameter);
    println!("     Avg clustering: {:.3}", analysis.average_clustering);

    // Step 6: Compare with full triangulation
    println!("\n6. Comparison: MST vs Full Triangulation:");
    let full_graph = Graph::new(triangulation.points.clone(), triangulation.edges.clone());
    let full_analysis = GraphAnalysis::analyze(&full_graph);

    println!("   Full triangulation:");
    println!("     Edges: {}", full_analysis.edge_count);
    println!("     Diameter: {:.1}", full_analysis.diameter);
    println!(
        "     Avg clustering: {:.3}",
        full_analysis.average_clustering
    );

    println!("   MST (optimized):");
    println!("     Edges: {}", analysis.edge_count);
    println!("     Diameter: {:.1}", analysis.diameter);
    println!("     Avg clustering: {:.3}", analysis.average_clustering);

    // Step 7: Pathfinding example
    println!("\n7. Pathfinding Example:");
    if room_centers.len() >= 2 {
        let start = 0;
        let end = room_centers.len() - 1;

        if let Some(path) = graph.shortest_path(start, end) {
            println!("   Path from room {} to room {}:", start + 1, end + 1);
            print!("     Route: ");
            for (i, &room) in path.iter().enumerate() {
                if i > 0 {
                    print!(" -> ");
                }
                print!("Room {}", room + 1);
            }
            println!();

            let mut path_length = 0.0;
            for i in 0..(path.len() - 1) {
                path_length += room_centers[path[i]].distance_to(&room_centers[path[i + 1]]);
            }
            println!("     Total distance: {:.1}", path_length);
        } else {
            println!("   No path found between rooms");
        }
    }

    // Step 8: Performance analysis
    println!("\n8. Performance Analysis:");
    let start = std::time::Instant::now();
    let _ = DelaunayTriangulation::new(room_centers.clone());
    println!("   Triangulation time: {:?}", start.elapsed());

    let start = std::time::Instant::now();
    let _ = triangulation.minimum_spanning_tree();
    println!("   MST generation time: {:?}", start.elapsed());

    println!("\n✅ Delaunay triangulation demo complete!");
    println!("   - Natural room connections via triangulation");
    println!("   - Optimal corridor networks with MST");
    println!("   - Graph analysis for connectivity insights");
}

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)
}

Additional examples can be found in:

• examples/spatial_workflow.rs
• examples/pipeline_templates.rs
• examples/advanced_prefabs.rs
• examples/complete_workflow.rs
• examples/phase4_workflow.rs

pub fn in_bounds(&self, x: i32, y: i32) -> bool

pub fn get(&self, x: i32, y: i32) -> Option<&C>

Examples found in repository

examples/advanced_pathfinding.rs (line 65)

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 53)

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/morphological_operations.rs (line 99)

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!();
    }
}

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

examples/advanced_prefabs.rs (line 299)

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

examples/enhanced_wfc.rs (line 96)

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

examples/phase4_workflow.rs (line 225)

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)
}

Additional examples can be found in:

• examples/delaunay_connections.rs
• examples/spatial_workflow.rs
• examples/complete_workflow.rs

pub fn get_mut(&mut self, x: i32, y: i32) -> Option<&mut C>

pub fn set(&mut self, x: i32, y: i32, cell: C) -> bool

Examples found in repository

examples/phase1_demo.rs (line 107)

fn demo_vertical_connectivity() {
    println!("🏗️ Demo 3: Vertical Connectivity");

    // Create two simple floor grids
    let mut floor1 = Grid::new(20, 20);
    let mut floor2 = Grid::new(20, 20);

    // Add some floor areas
    for y in 5..15 {
        for x in 5..15 {
            floor1.set(x, y, terrain_forge::Tile::Floor);
            floor2.set(x, y, terrain_forge::Tile::Floor);
        }
    }

    let floors = vec![floor1, floor2];
    let mut connectivity = VerticalConnectivity::new();

    connectivity.analyze_stair_candidates(&floors, 2);
    connectivity.place_stairs(3);

    println!(
        "  Stair candidates found: {}",
        connectivity.stair_candidates.len()
    );
    println!("  Stairs placed: {}", connectivity.stairs.len());

    if let Some((x, y, from, to)) = connectivity.stairs.first() {
        println!(
            "  Sample stair: ({}, {}) connecting floor {} to {}",
            x, y, from, to
        );
    }
    println!();
}

examples/vertical_connectivity.rs (line 13)

fn main() {
    println!("=== Vertical Connectivity Demo ===\n");

    // Create two floors for a multi-level dungeon
    let mut floor1 = Grid::new(25, 20);
    let mut floor2 = Grid::new(25, 20);

    // Floor 1: Large central room with corridors
    for y in 5..15 {
        for x in 5..20 {
            floor1.set(x, y, Tile::Floor);
        }
    }
    // Add some corridors
    for x in 2..5 {
        for y in 8..12 {
            floor1.set(x, y, Tile::Floor);
        }
    }

    // Floor 2: Multiple smaller rooms
    // Room 1
    for y in 3..8 {
        for x in 3..10 {
            floor2.set(x, y, Tile::Floor);
        }
    }
    // Room 2
    for y in 12..17 {
        for x in 8..18 {
            floor2.set(x, y, Tile::Floor);
        }
    }
    // Room 3
    for y in 6..12 {
        for x in 15..22 {
            floor2.set(x, y, Tile::Floor);
        }
    }

    let floors = vec![floor1, floor2];

    println!("Created 2-floor dungeon:");
    println!(
        "  Floor 1: {} floor tiles",
        floors[0].count(|t| t.is_floor())
    );
    println!(
        "  Floor 2: {} floor tiles",
        floors[1].count(|t| t.is_floor())
    );

    // Analyze vertical connectivity
    let mut connectivity = VerticalConnectivity::new();

    // Find stair candidates with different clearance requirements
    println!("\n1. Stair Candidate Analysis:");

    connectivity.analyze_stair_candidates(&floors, 1); // Minimal clearance
    println!(
        "  With 1-tile clearance: {} candidates",
        connectivity.stair_candidates.len()
    );

    connectivity.analyze_stair_candidates(&floors, 2); // More clearance
    println!(
        "  With 2-tile clearance: {} candidates",
        connectivity.stair_candidates.len()
    );

    connectivity.analyze_stair_candidates(&floors, 3); // Maximum clearance
    println!(
        "  With 3-tile clearance: {} candidates",
        connectivity.stair_candidates.len()
    );

    // Place stairs with different limits
    println!("\n2. Stair Placement:");

    connectivity.place_stairs(1);
    println!("  Placed {} stairs (max 1)", connectivity.stairs.len());

    connectivity.place_stairs(3);
    println!("  Placed {} stairs (max 3)", connectivity.stairs.len());

    connectivity.place_stairs(5);
    println!("  Placed {} stairs (max 5)", connectivity.stairs.len());

    // Show stair locations
    println!("\n3. Stair Locations:");
    for (i, &(x, y, from_floor, to_floor)) in connectivity.stairs.iter().enumerate() {
        println!(
            "  Stair {}: ({}, {}) connecting floor {} to floor {}",
            i + 1,
            x,
            y,
            from_floor,
            to_floor
        );
    }

    // Demonstrate with 3 floors
    println!("\n4. Three-Floor Example:");

    let mut floor3 = Grid::new(25, 20);
    // Floor 3: Single large room
    for y in 6..14 {
        for x in 6..19 {
            floor3.set(x, y, Tile::Floor);
        }
    }

    let three_floors = vec![floors[0].clone(), floors[1].clone(), floor3];
    let mut connectivity3 = VerticalConnectivity::new();

    connectivity3.analyze_stair_candidates(&three_floors, 2);
    connectivity3.place_stairs(2);

    println!(
        "  Floor 3: {} floor tiles",
        three_floors[2].count(|t| t.is_floor())
    );
    println!(
        "  Total stair candidates: {}",
        connectivity3.stair_candidates.len()
    );
    println!("  Stairs placed: {}", connectivity3.stairs.len());

    // Group stairs by floor connection
    let mut connections = std::collections::HashMap::new();
    for &(_, _, from, to) in &connectivity3.stairs {
        *connections.entry((from, to)).or_insert(0) += 1;
    }

    println!("  Floor connections:");
    for ((from, to), count) in connections {
        println!("    Floor {} ↔ Floor {}: {} stairs", from, to, count);
    }
}

examples/complete_workflow.rs (line 153)

fn main() {
    println!("=== Complete Phase 1 & 2 Feature Demo ===\n");

    // Demo: Complete workflow using all new features
    println!("🏰 Generating Advanced Multi-Feature Dungeon\n");

    // Step 1: Use pipeline template with custom parameters
    println!("1. Pipeline Template Generation:");
    let library = TemplateLibrary::new();
    let template = library.get_template("simple_dungeon").unwrap();

    let mut custom_params = std::collections::HashMap::new();
    custom_params.insert("seed".to_string(), "12345".to_string());

    let pipeline = template.instantiate(Some(custom_params));

    let mut grid = Grid::new(40, 30);
    let mut context = PipelineContext::new();
    let mut rng = Rng::new(12345);

    let result = pipeline.execute(&mut grid, &mut context, &mut rng);
    println!(
        "   Template execution: {}",
        if result.success {
            "✅ Success"
        } else {
            "❌ Failed"
        }
    );
    println!("   Floor tiles: {}", grid.count(|t| t.is_floor()));

    // Step 2: Extract semantic information
    println!("\n2. Semantic Analysis:");
    let extractor = SemanticExtractor::for_rooms();
    let mut semantic = extractor.extract(&grid, &mut rng);

    println!("   Regions found: {}", semantic.regions.len());
    println!("   Original markers: {}", semantic.markers.len());

    // Step 3: Add hierarchical markers based on regions
    println!("\n3. Hierarchical Marker Placement:");
    let mut quest_count = 0;
    let mut loot_count = 0;
    let mut encounter_count = 0;

    for (i, region) in semantic.regions.iter().enumerate() {
        if !region.cells.is_empty() {
            let (x, y) = region.cells[region.cells.len() / 2]; // Middle of region

            match i % 3 {
                0 => {
                    // Quest area
                    semantic.markers.push(Marker::new(
                        x,
                        y,
                        MarkerType::QuestObjective {
                            priority: (i % 3 + 1) as u8,
                        },
                    ));
                    quest_count += 1;
                }
                1 => {
                    // Loot area
                    semantic.markers.push(Marker::new(
                        x,
                        y,
                        MarkerType::LootTier {
                            tier: (i % 3 + 1) as u8,
                        },
                    ));
                    loot_count += 1;
                }
                2 => {
                    // Encounter area
                    if i == 2 {
                        semantic
                            .markers
                            .push(Marker::new(x, y, MarkerType::BossRoom));
                    } else {
                        semantic.markers.push(Marker::new(
                            x,
                            y,
                            MarkerType::EncounterZone {
                                difficulty: (i % 5 + 1) as u8,
                            },
                        ));
                    }
                    encounter_count += 1;
                }
                _ => {}
            }
        }
    }

    println!("   Added {} quest markers", quest_count);
    println!("   Added {} loot markers", loot_count);
    println!("   Added {} encounter markers", encounter_count);

    // Step 4: Validate with requirements
    println!("\n4. Requirement Validation:");
    let mut requirements = SemanticRequirements::none();
    requirements.min_regions.insert("Hall".to_string(), 1);
    requirements
        .required_markers
        .insert(MarkerType::Custom("PlayerStart".to_string()), 1);

    let validation_result = requirements.validate(&semantic);
    println!(
        "   Requirements met: {}",
        if validation_result {
            "✅ Yes"
        } else {
            "❌ No"
        }
    );

    // Step 5: Marker constraints analysis
    println!("\n5. Marker Constraint Analysis:");
    let quest_constraints = MarkerConstraints::quest_objective();
    let loot_constraints = MarkerConstraints::loot();

    println!("   Quest marker constraints:");
    println!(
        "     Min distance (same type): {:?}",
        quest_constraints.min_distance_same
    );
    println!(
        "     Excluded types: {} types",
        quest_constraints.exclude_types.len()
    );

    println!("   Loot marker constraints:");
    println!(
        "     Min distance (same type): {:?}",
        loot_constraints.min_distance_same
    );
    println!(
        "     Min distance (any): {:?}",
        loot_constraints.min_distance_any
    );

    // Step 6: Multi-floor connectivity simulation
    println!("\n6. Multi-Floor Connectivity:");

    // Create a second floor based on the first
    let mut floor2 = Grid::new(40, 30);
    // Copy some areas from floor 1 to create overlapping regions
    for y in 5..25 {
        for x in 5..35 {
            if grid.get(x, y).is_some_and(|t| t.is_floor()) && rng.random() < 0.6 {
                floor2.set(x, y, terrain_forge::Tile::Floor);
            }
        }
    }

    let floors = vec![grid.clone(), floor2];
    let mut connectivity = VerticalConnectivity::new();

    connectivity.analyze_stair_candidates(&floors, 2);
    connectivity.place_stairs(3);

    println!("   Floor 1 tiles: {}", floors[0].count(|t| t.is_floor()));
    println!("   Floor 2 tiles: {}", floors[1].count(|t| t.is_floor()));
    println!(
        "   Stair candidates: {}",
        connectivity.stair_candidates.len()
    );
    println!("   Stairs placed: {}", connectivity.stairs.len());

    // Step 7: Final summary
    println!("\n🎯 Generation Summary:");
    println!("   Grid size: {}x{}", grid.width(), grid.height());
    println!("   Total floor area: {}", grid.count(|t| t.is_floor()));
    println!(
        "   Density: {:.1}%",
        (grid.count(|t| t.is_floor()) as f32 / (grid.width() * grid.height()) as f32) * 100.0
    );
    println!("   Regions: {}", semantic.regions.len());
    println!("   Total markers: {}", semantic.markers.len());

    // Group markers by category
    let mut categories = std::collections::HashMap::new();
    for marker in &semantic.markers {
        *categories.entry(marker.marker_type.category()).or_insert(0) += 1;
    }

    println!("   Marker distribution:");
    for (category, count) in categories {
        println!("     {}: {}", category, count);
    }

    println!(
        "   Pipeline steps executed: {}",
        context.execution_history().len()
    );
    println!("   Multi-floor stairs: {}", connectivity.stairs.len());

    println!("\n✨ Advanced dungeon generation complete!");
}

pub fn fill(&mut self, cell: C)

pub fn fill_rect(&mut self, x: i32, y: i32, w: usize, h: usize, cell: C)

pub fn count<F: Fn(&C) -> bool>(&self, predicate: F) -> usize

Examples found in repository

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);
        }
    }
}

examples/phase2_demo.rs (line 70)

fn demo_conditional_pipeline() {
    println!("🔀 Demo 1: Conditional Pipeline Operations");

    let mut grid = Grid::new(30, 20);
    let mut context = PipelineContext::new();
    let mut rng = Rng::new(12345);

    // Create conditional pipeline
    let mut pipeline = ConditionalPipeline::new();

    // Add algorithm operation
    pipeline.add_operation(ConditionalOperation::simple(PipelineOperation::Algorithm {
        name: "bsp".to_string(),
        seed: Some(12345),
    }));

    // Add conditional operation based on floor density
    pipeline.add_operation(ConditionalOperation::conditional(
        PipelineOperation::Log {
            message: "Evaluating floor density".to_string(),
        },
        PipelineCondition::Density {
            min: Some(0.2),
            max: Some(0.6),
        },
        vec![ConditionalOperation::simple(
            PipelineOperation::SetParameter {
                key: "density_status".to_string(),
                value: "acceptable".to_string(),
            },
        )],
        vec![ConditionalOperation::simple(
            PipelineOperation::SetParameter {
                key: "density_status".to_string(),
                value: "out_of_range".to_string(),
            },
        )],
    ));

    // Execute pipeline
    let result = pipeline.execute(&mut grid, &mut context, &mut rng);

    println!(
        "  Pipeline execution: {}",
        if result.success {
            "✅ Success"
        } else {
            "❌ Failed"
        }
    );
    if let Some(msg) = result.message {
        println!("  Message: {}", msg);
    }

    println!("  Floor tiles: {}", grid.count(|t| t.is_floor()));
    println!(
        "  Density status: {}",
        context
            .get_parameter("density_status")
            .unwrap_or(&"unknown".to_string())
    );
    println!("  Execution log: {:?}", context.execution_history());
    println!();
}

fn demo_pipeline_templates() {
    println!("📋 Demo 2: Pipeline Templates");

    // Create custom template
    let template = PipelineTemplate::new("custom_dungeon", "Customizable dungeon template")
        .with_parameter("algorithm", "cellular")
        .with_parameter("seed", "54321")
        .with_parameter("type", "dungeon")
        .with_operation(ConditionalOperation::simple(PipelineOperation::Algorithm {
            name: "{algorithm}".to_string(),
            seed: Some(54321),
        }))
        .with_operation(ConditionalOperation::simple(
            PipelineOperation::SetParameter {
                key: "generation_type".to_string(),
                value: "{type}".to_string(),
            },
        ));

    // Instantiate with custom parameters
    let mut custom_params = std::collections::HashMap::new();
    custom_params.insert("algorithm".to_string(), "bsp".to_string());
    custom_params.insert("type".to_string(), "fortress".to_string());

    let pipeline = template.instantiate(Some(custom_params));

    let mut grid = Grid::new(25, 25);
    let mut context = PipelineContext::new();
    let mut rng = Rng::new(98765);

    let result = pipeline.execute(&mut grid, &mut context, &mut rng);

    println!("  Template: {}", template.name);
    println!("  Description: {}", template.description);
    println!(
        "  Execution: {}",
        if result.success {
            "✅ Success"
        } else {
            "❌ Failed"
        }
    );
    println!(
        "  Generation type: {}",
        context
            .get_parameter("generation_type")
            .unwrap_or(&"unknown".to_string())
    );
    println!("  Floor tiles: {}", grid.count(|t| t.is_floor()));
    println!();
}

fn demo_template_library() {
    println!("📚 Demo 3: Template Library");

    let library = TemplateLibrary::new();

    println!("  Available templates:");
    for name in library.template_names() {
        if let Some(template) = library.get_template(name) {
            println!("    - {}: {}", name, template.description);
        }
    }

    // Use built-in template
    if let Some(template) = library.get_template("simple_dungeon") {
        let pipeline = template.instantiate(None);

        let mut grid = Grid::new(40, 30);
        let mut context = PipelineContext::new();
        let mut rng = Rng::new(11111);

        let result = pipeline.execute(&mut grid, &mut context, &mut rng);

        println!("\n  Executed 'simple_dungeon' template:");
        println!(
            "    Result: {}",
            if result.success {
                "✅ Success"
            } else {
                "❌ Failed"
            }
        );
        println!("    Floor tiles: {}", grid.count(|t| t.is_floor()));
        println!("    Steps executed: {}", context.execution_history().len());
    }
    println!();
}

examples/requirement_generation.rs (line 13)

fn main() {
    println!("=== Requirement-Driven Generation Demo ===\n");

    // Demo 1: Basic dungeon requirements
    println!("1. Basic Dungeon Requirements:");
    let basic_req = SemanticRequirements::basic_dungeon();

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

    // Demo 2: Custom requirements
    println!("\n2. Custom Cave Requirements:");
    let mut cave_req = SemanticRequirements::none();
    cave_req.min_regions.insert("cavern".to_string(), 2);
    cave_req.min_walkable_area = Some(200);
    cave_req
        .required_markers
        .insert(MarkerType::Custom("entrance".to_string()), 1);
    cave_req
        .required_markers
        .insert(MarkerType::Custom("treasure".to_string()), 1);

    match generate_with_requirements("cellular", 50, 40, cave_req, Some(10), 54321) {
        Ok((grid, semantic)) => {
            println!("  ✅ Generated valid cave system!");
            println!("  Floor tiles: {}", grid.count(|t| t.is_floor()));
            println!("  Regions: {}", semantic.regions.len());

            // Show region types
            let mut region_types = std::collections::HashMap::new();
            for region in &semantic.regions {
                *region_types.entry(&region.kind).or_insert(0) += 1;
            }
            for (kind, count) in region_types {
                println!("    {}: {}", kind, count);
            }
        }
        Err(msg) => println!("  ❌ Failed: {}", msg),
    }

    // Demo 3: Strict requirements (likely to fail)
    println!("\n3. Strict Requirements (demonstration of failure):");
    let mut strict_req = SemanticRequirements::none();
    strict_req.min_regions.insert("room".to_string(), 10); // Very strict
    strict_req
        .required_markers
        .insert(MarkerType::QuestObjective { priority: 1 }, 5);
    strict_req.min_walkable_area = Some(800);

    match generate_with_requirements("bsp", 30, 20, strict_req, Some(3), 98765) {
        Ok((grid, _semantic)) => {
            println!("  ✅ Unexpectedly succeeded!");
            println!("  Floor tiles: {}", grid.count(|t| t.is_floor()));
        }
        Err(msg) => println!("  ❌ Expected failure: {}", msg),
    }
}

examples/enhanced_wfc.rs (line 50)

fn main() {
    println!("=== Enhanced Wave Function Collapse Demo ===\n");

    // Step 1: Generate example map for pattern learning
    println!("1. Generating Example Map for Pattern Learning:");
    let mut example_grid = Grid::new(20, 15);
    let bsp = Bsp::default();
    bsp.generate(&mut example_grid, 54321);

    print_grid(&example_grid, "Example Map");

    // Step 2: Extract patterns from example
    println!("\n2. Extracting Patterns from Example:");
    let patterns = WfcPatternExtractor::extract_patterns(&example_grid, 3);
    println!("   Extracted {} unique patterns", patterns.len());

    // Step 3: Generate with learned patterns (no backtracking)
    println!("\n3. WFC Generation without Backtracking:");
    let mut grid1 = Grid::new(25, 20);
    let wfc_no_backtrack = Wfc::new(WfcConfig {
        floor_weight: 0.4,
        pattern_size: 3,
        enable_backtracking: false,
    });
    wfc_no_backtrack.generate_with_patterns(&mut grid1, patterns.clone(), 12345);
    print_grid(&grid1, "Without Backtracking");

    // Step 4: Generate with backtracking enabled
    println!("\n4. WFC Generation with Backtracking:");
    let mut grid2 = Grid::new(25, 20);
    let wfc_backtrack = Wfc::new(WfcConfig {
        floor_weight: 0.4,
        pattern_size: 3,
        enable_backtracking: true,
    });
    wfc_backtrack.generate_with_patterns(&mut grid2, patterns.clone(), 12345);
    print_grid(&grid2, "With Backtracking");

    // Step 5: Compare results
    println!("\n5. Comparison:");
    let floors1 = grid1.count(|t| t.is_floor());
    let floors2 = grid2.count(|t| t.is_floor());

    println!(
        "   Without backtracking: {} floors ({:.1}%)",
        floors1,
        100.0 * floors1 as f32 / (grid1.width() * grid1.height()) as f32
    );
    println!(
        "   With backtracking: {} floors ({:.1}%)",
        floors2,
        100.0 * floors2 as f32 / (grid2.width() * grid2.height()) as f32
    );

    // Step 6: Different pattern sizes
    println!("\n6. Pattern Size Comparison:");
    for size in [2, 3, 4] {
        let patterns = WfcPatternExtractor::extract_patterns(&example_grid, size);
        let mut grid = Grid::new(15, 12);
        let wfc = Wfc::new(WfcConfig {
            floor_weight: 0.4,
            pattern_size: size,
            enable_backtracking: true,
        });
        wfc.generate_with_patterns(&mut grid, patterns.clone(), 98765);

        let floors = grid.count(|t| t.is_floor());
        println!(
            "   Pattern size {}: {} patterns, {} floors",
            size,
            patterns.len(),
            floors
        );
    }

    println!("\n✅ Enhanced WFC demo complete!");
    println!("   - Pattern learning extracts reusable structures");
    println!("   - Backtracking improves generation success rate");
    println!("   - Constraint propagation ensures valid outputs");
}

Additional examples can be found in:

• 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

pub fn iter(&self) -> impl Iterator<Item = (usize, usize, &C)>

Trait Implementations

impl<C: Clone + Cell> Clone for Grid<C>

fn clone(&self) -> Grid<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug + Cell> Debug for Grid<C>

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

Formats the value using the given formatter.

impl<C: Cell> Index<(usize, usize)> for Grid<C>

type Output = C

The returned type after indexing.

fn index(&self, (x, y): (usize, usize)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<C: Cell> IndexMut<(usize, usize)> for Grid<C>

fn index_mut(&mut self, (x, y): (usize, usize)) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<C: Cell + PartialEq> PartialEq for Grid<C>

fn eq(&self, other: &Self) -> 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<C: Cell + Eq> Eq for Grid<C>