Struct PrefabLibrary 

pub struct PrefabLibrary { /* private fields */ }

Implementations

impl PrefabLibrary

pub fn new() -> Self

Examples found in repository

examples/phase4_workflow.rs (line 282)

fn create_specialized_library() -> PrefabLibrary {
    let mut library = PrefabLibrary::new();

    // Boss room (very rare, large)
    let boss_room = PrefabData {
        name: "boss_chamber".to_string(),
        width: 9,
        height: 7,
        pattern: vec![
            "#########".to_string(),
            "#.......#".to_string(),
            "#..###..#".to_string(),
            "#..#B#..#".to_string(),
            "#..###..#".to_string(),
            "#.......#".to_string(),
            "#########".to_string(),
        ],
        weight: 0.2,
        tags: vec![
            "boss".to_string(),
            "special".to_string(),
            "large".to_string(),
        ],
        legend: None,
    };
    library.add_prefab(terrain_forge::algorithms::Prefab::from_data(boss_room));

    // Treasure room (rare)
    let treasure_room = PrefabData {
        name: "treasure_vault".to_string(),
        width: 5,
        height: 5,
        pattern: vec![
            "#####".to_string(),
            "#...#".to_string(),
            "#.T.#".to_string(),
            "#...#".to_string(),
            "#####".to_string(),
        ],
        weight: 0.8,
        tags: vec![
            "treasure".to_string(),
            "special".to_string(),
            "small".to_string(),
        ],
        legend: None,
    };
    library.add_prefab(terrain_forge::algorithms::Prefab::from_data(treasure_room));

    // Secret passage (uncommon)
    let secret_passage = PrefabData {
        name: "secret_passage".to_string(),
        width: 3,
        height: 7,
        pattern: vec![
            "###".to_string(),
            "#.#".to_string(),
            "#.#".to_string(),
            "#.#".to_string(),
            "#.#".to_string(),
            "#.#".to_string(),
            "###".to_string(),
        ],
        weight: 1.2,
        tags: vec!["secret".to_string(), "corridor".to_string()],
        legend: None,
    };
    library.add_prefab(terrain_forge::algorithms::Prefab::from_data(secret_passage));

    library
}

examples/advanced_prefabs.rs (line 194)

fn create_sample_library() -> PrefabLibrary {
    let mut library = PrefabLibrary::new();

    // Small room (high weight)
    let small_room = PrefabData {
        name: "small_room".to_string(),
        width: 5,
        height: 5,
        pattern: vec![
            "#####".to_string(),
            "#...#".to_string(),
            "#...#".to_string(),
            "#...#".to_string(),
            "#####".to_string(),
        ],
        weight: 3.0,
        tags: vec!["room".to_string(), "small".to_string()],
        legend: None,
    };
    library.add_prefab(terrain_forge::algorithms::Prefab::from_data(small_room));

    // Large room (medium weight)
    let large_room = PrefabData {
        name: "large_room".to_string(),
        width: 7,
        height: 6,
        pattern: vec![
            "#######".to_string(),
            "#.....#".to_string(),
            "#.....#".to_string(),
            "#.....#".to_string(),
            "#.....#".to_string(),
            "#######".to_string(),
        ],
        weight: 1.5,
        tags: vec!["room".to_string(), "large".to_string()],
        legend: None,
    };
    library.add_prefab(terrain_forge::algorithms::Prefab::from_data(large_room));

    // Corridor (low weight)
    let corridor = PrefabData {
        name: "corridor".to_string(),
        width: 7,
        height: 3,
        pattern: vec![
            "#######".to_string(),
            ".......".to_string(),
            "#######".to_string(),
        ],
        weight: 0.8,
        tags: vec!["corridor".to_string(), "connection".to_string()],
        legend: None,
    };
    library.add_prefab(terrain_forge::algorithms::Prefab::from_data(corridor));

    // L-shaped room (rare)
    let mut legend = std::collections::HashMap::new();
    legend.insert(
        "M".to_string(),
        terrain_forge::algorithms::PrefabLegendEntry {
            tile: Some("floor".to_string()),
            marker: Some("loot_slot".to_string()),
            mask: None,
        },
    );
    let l_room = PrefabData {
        name: "l_shaped_room".to_string(),
        width: 6,
        height: 6,
        pattern: vec![
            "######".to_string(),
            "#....#".to_string(),
            "#....#".to_string(),
            "#..M##".to_string(),
            "#..###".to_string(),
            "######".to_string(),
        ],
        weight: 0.5,
        tags: vec![
            "room".to_string(),
            "special".to_string(),
            "l_shaped".to_string(),
        ],
        legend: Some(legend),
    };
    library.add_prefab(terrain_forge::algorithms::Prefab::from_data(l_room));

    library
}

pub fn add_prefab(&mut self, prefab: Prefab)

Examples found in repository

examples/phase4_workflow.rs (line 306)

fn create_specialized_library() -> PrefabLibrary {
    let mut library = PrefabLibrary::new();

    // Boss room (very rare, large)
    let boss_room = PrefabData {
        name: "boss_chamber".to_string(),
        width: 9,
        height: 7,
        pattern: vec![
            "#########".to_string(),
            "#.......#".to_string(),
            "#..###..#".to_string(),
            "#..#B#..#".to_string(),
            "#..###..#".to_string(),
            "#.......#".to_string(),
            "#########".to_string(),
        ],
        weight: 0.2,
        tags: vec![
            "boss".to_string(),
            "special".to_string(),
            "large".to_string(),
        ],
        legend: None,
    };
    library.add_prefab(terrain_forge::algorithms::Prefab::from_data(boss_room));

    // Treasure room (rare)
    let treasure_room = PrefabData {
        name: "treasure_vault".to_string(),
        width: 5,
        height: 5,
        pattern: vec![
            "#####".to_string(),
            "#...#".to_string(),
            "#.T.#".to_string(),
            "#...#".to_string(),
            "#####".to_string(),
        ],
        weight: 0.8,
        tags: vec![
            "treasure".to_string(),
            "special".to_string(),
            "small".to_string(),
        ],
        legend: None,
    };
    library.add_prefab(terrain_forge::algorithms::Prefab::from_data(treasure_room));

    // Secret passage (uncommon)
    let secret_passage = PrefabData {
        name: "secret_passage".to_string(),
        width: 3,
        height: 7,
        pattern: vec![
            "###".to_string(),
            "#.#".to_string(),
            "#.#".to_string(),
            "#.#".to_string(),
            "#.#".to_string(),
            "#.#".to_string(),
            "###".to_string(),
        ],
        weight: 1.2,
        tags: vec!["secret".to_string(), "corridor".to_string()],
        legend: None,
    };
    library.add_prefab(terrain_forge::algorithms::Prefab::from_data(secret_passage));

    library
}

examples/advanced_prefabs.rs (line 212)

fn create_sample_library() -> PrefabLibrary {
    let mut library = PrefabLibrary::new();

    // Small room (high weight)
    let small_room = PrefabData {
        name: "small_room".to_string(),
        width: 5,
        height: 5,
        pattern: vec![
            "#####".to_string(),
            "#...#".to_string(),
            "#...#".to_string(),
            "#...#".to_string(),
            "#####".to_string(),
        ],
        weight: 3.0,
        tags: vec!["room".to_string(), "small".to_string()],
        legend: None,
    };
    library.add_prefab(terrain_forge::algorithms::Prefab::from_data(small_room));

    // Large room (medium weight)
    let large_room = PrefabData {
        name: "large_room".to_string(),
        width: 7,
        height: 6,
        pattern: vec![
            "#######".to_string(),
            "#.....#".to_string(),
            "#.....#".to_string(),
            "#.....#".to_string(),
            "#.....#".to_string(),
            "#######".to_string(),
        ],
        weight: 1.5,
        tags: vec!["room".to_string(), "large".to_string()],
        legend: None,
    };
    library.add_prefab(terrain_forge::algorithms::Prefab::from_data(large_room));

    // Corridor (low weight)
    let corridor = PrefabData {
        name: "corridor".to_string(),
        width: 7,
        height: 3,
        pattern: vec![
            "#######".to_string(),
            ".......".to_string(),
            "#######".to_string(),
        ],
        weight: 0.8,
        tags: vec!["corridor".to_string(), "connection".to_string()],
        legend: None,
    };
    library.add_prefab(terrain_forge::algorithms::Prefab::from_data(corridor));

    // L-shaped room (rare)
    let mut legend = std::collections::HashMap::new();
    legend.insert(
        "M".to_string(),
        terrain_forge::algorithms::PrefabLegendEntry {
            tile: Some("floor".to_string()),
            marker: Some("loot_slot".to_string()),
            mask: None,
        },
    );
    let l_room = PrefabData {
        name: "l_shaped_room".to_string(),
        width: 6,
        height: 6,
        pattern: vec![
            "######".to_string(),
            "#....#".to_string(),
            "#....#".to_string(),
            "#..M##".to_string(),
            "#..###".to_string(),
            "######".to_string(),
        ],
        weight: 0.5,
        tags: vec![
            "room".to_string(),
            "special".to_string(),
            "l_shaped".to_string(),
        ],
        legend: Some(legend),
    };
    library.add_prefab(terrain_forge::algorithms::Prefab::from_data(l_room));

    library
}

pub fn load_from_json<P: AsRef<Path>>(path: P) -> Result<Self, Box<dyn Error>>

Examples found in repository

examples/advanced_prefabs.rs (line 131)

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

    // Step 1: Create prefab library programmatically
    println!("1. Creating Prefab Library:");
    let library = create_sample_library();

    println!(
        "   Created library with {} prefabs:",
        library.get_prefabs().len()
    );
    for prefab in library.get_prefabs() {
        println!(
            "     - {} ({}x{}, weight: {:.1}, tags: {:?})",
            prefab.name, prefab.width, prefab.height, prefab.weight, prefab.tags
        );
    }

    // Step 2: Demonstrate weighted selection
    println!("\n2. Weighted Selection Test:");
    let mut rng = Rng::new(12345);
    let mut selection_counts = std::collections::HashMap::new();

    for _ in 0..100 {
        if let Some(prefab) = library.select_weighted(&mut rng, None) {
            *selection_counts.entry(prefab.name.clone()).or_insert(0) += 1;
        }
    }

    println!("   Selection frequency (100 trials):");
    for (name, count) in &selection_counts {
        println!("     {}: {} times", name, count);
    }

    // Step 3: Tag-based selection
    println!("\n3. Tag-based Selection:");
    let room_prefabs = library.get_by_tag("room");
    let corridor_prefabs = library.get_by_tag("corridor");

    println!("   Room prefabs: {}", room_prefabs.len());
    for prefab in &room_prefabs {
        println!("     - {}", prefab.name);
    }

    println!("   Corridor prefabs: {}", corridor_prefabs.len());
    for prefab in &corridor_prefabs {
        println!("     - {}", prefab.name);
    }

    // Step 4: Transformation examples
    println!("\n4. Prefab Transformations:");
    if let Some(base_prefab) = library.get_prefabs().first() {
        println!(
            "   Base prefab '{}' ({}x{}):",
            base_prefab.name, base_prefab.width, base_prefab.height
        );
        print_prefab_pattern(base_prefab);

        // Rotation
        let rotated = base_prefab.rotated();
        println!(
            "   After 90° rotation ({}x{}):",
            rotated.width, rotated.height
        );
        print_prefab_pattern(&rotated);

        // Horizontal mirror
        let mirrored = base_prefab.mirrored_horizontal();
        println!(
            "   After horizontal mirror ({}x{}):",
            mirrored.width, mirrored.height
        );
        print_prefab_pattern(&mirrored);

        // Combined transformation
        let transform = PrefabTransform {
            rotation: 1,
            mirror_h: true,
            mirror_v: false,
        };
        let transformed = transform.apply(base_prefab);
        println!(
            "   After rotation + mirror ({}x{}):",
            transformed.width, transformed.height
        );
        print_prefab_pattern(&transformed);
    }

    // Step 5: Generation with advanced prefabs
    println!("\n5. Generation with Advanced Prefabs:");
    let config = PrefabConfig {
        max_prefabs: 5,
        min_spacing: 3,
        allow_rotation: true,
        allow_mirroring: true,
        weighted_selection: true,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let placer = PrefabPlacer::new(config, library.clone());
    let mut grid = Grid::new(30, 25);
    placer.generate(&mut grid, 54321);

    let floor_count = grid.count(|t| t.is_floor());
    println!(
        "   Generated {}x{} grid with {} floor tiles",
        grid.width(),
        grid.height(),
        floor_count
    );

    print_grid(&grid);

    // Step 6: JSON serialization example
    println!("\n6. JSON Serialization:");
    match library.save_to_json("prefab_library.json") {
        Ok(()) => {
            println!("   ✅ Saved library to prefab_library.json");

            // Try to load it back
            match PrefabLibrary::load_from_json("prefab_library.json") {
                Ok(loaded_library) => {
                    println!("   ✅ Successfully loaded library back");
                    println!("   Loaded {} prefabs", loaded_library.get_prefabs().len());
                }
                Err(e) => println!("   ❌ Failed to load: {}", e),
            }
        }
        Err(e) => println!("   ❌ Failed to save: {}", e),
    }

    // Step 7: Performance comparison
    println!("\n7. Performance Comparison:");

    // Simple generation
    let simple_config = PrefabConfig {
        max_prefabs: 10,
        min_spacing: 2,
        allow_rotation: false,
        allow_mirroring: false,
        weighted_selection: false,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let start = std::time::Instant::now();
    let simple_placer = PrefabPlacer::new(simple_config, library.clone());
    let mut simple_grid = Grid::new(40, 30);
    simple_placer.generate(&mut simple_grid, 98765);
    let simple_time = start.elapsed();

    // Advanced generation
    let advanced_config = PrefabConfig {
        max_prefabs: 10,
        min_spacing: 2,
        allow_rotation: true,
        allow_mirroring: true,
        weighted_selection: true,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let start = std::time::Instant::now();
    let advanced_placer = PrefabPlacer::new(advanced_config, library);
    let mut advanced_grid = Grid::new(40, 30);
    advanced_placer.generate(&mut advanced_grid, 98765);
    let advanced_time = start.elapsed();

    println!("   Simple generation: {:?}", simple_time);
    println!("   Advanced generation: {:?}", advanced_time);
    println!(
        "   Overhead: {:.1}x",
        advanced_time.as_nanos() as f32 / simple_time.as_nanos() as f32
    );

    println!("\n✅ Advanced prefab system demo complete!");
    println!("   - JSON serialization for persistent libraries");
    println!("   - Weighted selection for balanced generation");
    println!("   - Transformations for variety and reuse");
    println!("   - Tag-based organization for targeted selection");
}

pub fn load_from_paths<I, P>(paths: I) -> Result<Self, Box<dyn Error>>

where I: IntoIterator<Item = P>, P: AsRef<Path>,

pub fn load_from_dir<P: AsRef<Path>>(path: P) -> Result<Self, Box<dyn Error>>

pub fn save_to_json<P: AsRef<Path>>( &self, path: P, ) -> Result<(), Box<dyn Error>>

Examples found in repository

examples/advanced_prefabs.rs (line 126)

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

    // Step 1: Create prefab library programmatically
    println!("1. Creating Prefab Library:");
    let library = create_sample_library();

    println!(
        "   Created library with {} prefabs:",
        library.get_prefabs().len()
    );
    for prefab in library.get_prefabs() {
        println!(
            "     - {} ({}x{}, weight: {:.1}, tags: {:?})",
            prefab.name, prefab.width, prefab.height, prefab.weight, prefab.tags
        );
    }

    // Step 2: Demonstrate weighted selection
    println!("\n2. Weighted Selection Test:");
    let mut rng = Rng::new(12345);
    let mut selection_counts = std::collections::HashMap::new();

    for _ in 0..100 {
        if let Some(prefab) = library.select_weighted(&mut rng, None) {
            *selection_counts.entry(prefab.name.clone()).or_insert(0) += 1;
        }
    }

    println!("   Selection frequency (100 trials):");
    for (name, count) in &selection_counts {
        println!("     {}: {} times", name, count);
    }

    // Step 3: Tag-based selection
    println!("\n3. Tag-based Selection:");
    let room_prefabs = library.get_by_tag("room");
    let corridor_prefabs = library.get_by_tag("corridor");

    println!("   Room prefabs: {}", room_prefabs.len());
    for prefab in &room_prefabs {
        println!("     - {}", prefab.name);
    }

    println!("   Corridor prefabs: {}", corridor_prefabs.len());
    for prefab in &corridor_prefabs {
        println!("     - {}", prefab.name);
    }

    // Step 4: Transformation examples
    println!("\n4. Prefab Transformations:");
    if let Some(base_prefab) = library.get_prefabs().first() {
        println!(
            "   Base prefab '{}' ({}x{}):",
            base_prefab.name, base_prefab.width, base_prefab.height
        );
        print_prefab_pattern(base_prefab);

        // Rotation
        let rotated = base_prefab.rotated();
        println!(
            "   After 90° rotation ({}x{}):",
            rotated.width, rotated.height
        );
        print_prefab_pattern(&rotated);

        // Horizontal mirror
        let mirrored = base_prefab.mirrored_horizontal();
        println!(
            "   After horizontal mirror ({}x{}):",
            mirrored.width, mirrored.height
        );
        print_prefab_pattern(&mirrored);

        // Combined transformation
        let transform = PrefabTransform {
            rotation: 1,
            mirror_h: true,
            mirror_v: false,
        };
        let transformed = transform.apply(base_prefab);
        println!(
            "   After rotation + mirror ({}x{}):",
            transformed.width, transformed.height
        );
        print_prefab_pattern(&transformed);
    }

    // Step 5: Generation with advanced prefabs
    println!("\n5. Generation with Advanced Prefabs:");
    let config = PrefabConfig {
        max_prefabs: 5,
        min_spacing: 3,
        allow_rotation: true,
        allow_mirroring: true,
        weighted_selection: true,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let placer = PrefabPlacer::new(config, library.clone());
    let mut grid = Grid::new(30, 25);
    placer.generate(&mut grid, 54321);

    let floor_count = grid.count(|t| t.is_floor());
    println!(
        "   Generated {}x{} grid with {} floor tiles",
        grid.width(),
        grid.height(),
        floor_count
    );

    print_grid(&grid);

    // Step 6: JSON serialization example
    println!("\n6. JSON Serialization:");
    match library.save_to_json("prefab_library.json") {
        Ok(()) => {
            println!("   ✅ Saved library to prefab_library.json");

            // Try to load it back
            match PrefabLibrary::load_from_json("prefab_library.json") {
                Ok(loaded_library) => {
                    println!("   ✅ Successfully loaded library back");
                    println!("   Loaded {} prefabs", loaded_library.get_prefabs().len());
                }
                Err(e) => println!("   ❌ Failed to load: {}", e),
            }
        }
        Err(e) => println!("   ❌ Failed to save: {}", e),
    }

    // Step 7: Performance comparison
    println!("\n7. Performance Comparison:");

    // Simple generation
    let simple_config = PrefabConfig {
        max_prefabs: 10,
        min_spacing: 2,
        allow_rotation: false,
        allow_mirroring: false,
        weighted_selection: false,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let start = std::time::Instant::now();
    let simple_placer = PrefabPlacer::new(simple_config, library.clone());
    let mut simple_grid = Grid::new(40, 30);
    simple_placer.generate(&mut simple_grid, 98765);
    let simple_time = start.elapsed();

    // Advanced generation
    let advanced_config = PrefabConfig {
        max_prefabs: 10,
        min_spacing: 2,
        allow_rotation: true,
        allow_mirroring: true,
        weighted_selection: true,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let start = std::time::Instant::now();
    let advanced_placer = PrefabPlacer::new(advanced_config, library);
    let mut advanced_grid = Grid::new(40, 30);
    advanced_placer.generate(&mut advanced_grid, 98765);
    let advanced_time = start.elapsed();

    println!("   Simple generation: {:?}", simple_time);
    println!("   Advanced generation: {:?}", advanced_time);
    println!(
        "   Overhead: {:.1}x",
        advanced_time.as_nanos() as f32 / simple_time.as_nanos() as f32
    );

    println!("\n✅ Advanced prefab system demo complete!");
    println!("   - JSON serialization for persistent libraries");
    println!("   - Weighted selection for balanced generation");
    println!("   - Transformations for variety and reuse");
    println!("   - Tag-based organization for targeted selection");
}

examples/phase4_workflow.rs (line 192)

fn main() {
    println!("=== Phase 4 Complete Workflow Demo ===\n");

    // Step 1: Generate base layout with BSP
    println!("1. Generating Base Layout:");
    let mut base_grid = Grid::new(35, 25);
    let bsp = Bsp::default();
    bsp.generate(&mut base_grid, 12345);

    let base_floors = base_grid.count(|t| t.is_floor());
    println!(
        "   Generated {}x{} base layout with {} floors",
        base_grid.width(),
        base_grid.height(),
        base_floors
    );

    // Step 2: Learn patterns from base layout
    println!("\n2. Learning Patterns from Base Layout:");
    let learned_patterns = WfcPatternExtractor::extract_patterns(&base_grid, 3);
    println!(
        "   Extracted {} unique 3x3 patterns",
        learned_patterns.len()
    );

    // Step 3: Generate enhanced areas with WFC
    println!("\n3. Generating Enhanced Areas with Learned Patterns:");
    let mut wfc_grid = Grid::new(20, 15);
    let wfc = Wfc::new(WfcConfig {
        floor_weight: 0.45,
        pattern_size: 3,
        enable_backtracking: true,
    });
    wfc.generate_with_patterns(&mut wfc_grid, learned_patterns.clone(), 54321);

    let wfc_floors = wfc_grid.count(|t| t.is_floor());
    println!(
        "   WFC generated {} floors with learned patterns",
        wfc_floors
    );

    // Step 4: Find room centers for connectivity analysis
    println!("\n4. Analyzing Room Connectivity:");
    let room_centers = find_room_centers(&base_grid);
    println!("   Identified {} room centers", room_centers.len());

    // Step 5: Create optimal connections with Delaunay + MST
    println!("\n5. Creating Optimal Room Connections:");
    if room_centers.len() >= 3 {
        let triangulation = DelaunayTriangulation::new(room_centers.clone());
        let mst_edges = triangulation.minimum_spanning_tree();

        println!("   Delaunay triangulation:");
        println!("     Triangles: {}", triangulation.triangles.len());
        println!("     All edges: {}", triangulation.edges.len());

        println!("   Minimum spanning tree:");
        println!("     Optimal edges: {}", mst_edges.len());

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

        // Graph analysis
        let graph = Graph::new(triangulation.points.clone(), mst_edges);
        let analysis = GraphAnalysis::analyze(&graph);

        println!("   Connectivity analysis:");
        println!("     Connected: {}", analysis.is_connected);
        println!("     Diameter: {:.1}", analysis.diameter);
        println!("     Clustering: {:.3}", analysis.average_clustering);
    } else {
        println!("   Not enough rooms for connectivity analysis");
    }

    // Step 6: Create specialized prefab library
    println!("\n6. Creating Specialized Prefab Library:");
    let library = create_specialized_library();

    println!(
        "   Created library with {} prefabs:",
        library.get_prefabs().len()
    );
    for prefab in library.get_prefabs() {
        println!(
            "     - {} (weight: {:.1}, tags: {:?})",
            prefab.name, prefab.weight, prefab.tags
        );
    }

    // Step 7: Place special features with advanced prefabs
    println!("\n7. Placing Special Features:");
    let mut feature_grid = Grid::new(30, 20);

    // Place boss rooms (rare, large)
    let boss_config = PrefabConfig {
        max_prefabs: 1,
        min_spacing: 8,
        allow_rotation: false,
        allow_mirroring: false,
        weighted_selection: true,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let boss_placer = PrefabPlacer::new(boss_config, library.clone());
    boss_placer.generate(&mut feature_grid, 98765);

    // Place treasure rooms (medium rarity)
    let treasure_config = PrefabConfig {
        max_prefabs: 2,
        min_spacing: 5,
        allow_rotation: true,
        allow_mirroring: true,
        weighted_selection: true,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let treasure_placer = PrefabPlacer::new(treasure_config, library.clone());
    treasure_placer.generate(&mut feature_grid, 13579);

    let feature_floors = feature_grid.count(|t| t.is_floor());
    println!("   Placed special features: {} floor tiles", feature_floors);

    // Step 8: Performance and quality metrics
    println!("\n8. Performance and Quality Metrics:");

    // WFC performance
    let start = std::time::Instant::now();
    let mut perf_grid = Grid::new(25, 20);
    wfc.generate_with_patterns(&mut perf_grid, learned_patterns.clone(), 24680);
    let wfc_time = start.elapsed();

    // Prefab performance
    let start = std::time::Instant::now();
    let placer = PrefabPlacer::new(PrefabConfig::default(), library.clone());
    let mut prefab_grid = Grid::new(25, 20);
    placer.generate(&mut prefab_grid, 24680);
    let prefab_time = start.elapsed();

    // Delaunay performance
    let start = std::time::Instant::now();
    let _ = DelaunayTriangulation::new(room_centers.clone());
    let delaunay_time = start.elapsed();

    println!("   Performance metrics:");
    println!("     WFC generation: {:?}", wfc_time);
    println!("     Prefab placement: {:?}", prefab_time);
    println!("     Delaunay triangulation: {:?}", delaunay_time);

    // Step 9: Quality comparison
    println!("\n9. Quality Comparison:");

    // Basic generation
    let mut basic_grid = Grid::new(25, 20);
    bsp.generate(&mut basic_grid, 11111);
    let basic_floors = basic_grid.count(|t| t.is_floor());

    // Enhanced generation (WFC + prefabs)
    let enhanced_floors = perf_grid.count(|t| t.is_floor()) + prefab_grid.count(|t| t.is_floor());

    println!("   Floor tile comparison:");
    println!(
        "     Basic BSP: {} floors ({:.1}%)",
        basic_floors,
        100.0 * basic_floors as f32 / (25 * 20) as f32
    );
    println!(
        "     Enhanced (WFC + Prefabs): {} floors ({:.1}%)",
        enhanced_floors,
        100.0 * enhanced_floors as f32 / (50 * 20) as f32
    );

    // Step 10: Save configuration for reuse
    println!("\n10. Saving Configuration:");
    match library.save_to_json("phase4_library.json") {
        Ok(()) => println!("   ✅ Saved prefab library to phase4_library.json"),
        Err(e) => println!("   ❌ Failed to save library: {}", e),
    }

    println!("\n✅ Phase 4 complete workflow finished!");
    println!("   Workflow summary:");
    println!("   1. Generated base layout with BSP algorithm");
    println!(
        "   2. Learned {} patterns for WFC enhancement",
        learned_patterns.len()
    );
    println!(
        "   3. Analyzed {} room connections with Delaunay triangulation",
        room_centers.len()
    );
    println!("   4. Placed specialized features with weighted prefab selection");
    println!("   5. Achieved optimal room connectivity with MST");
    println!("   6. Demonstrated pattern learning and constraint propagation");
    println!("   \n   Phase 4 features enable:");
    println!("   - Intelligent pattern-based generation");
    println!("   - Mathematically optimal room connections");
    println!("   - Flexible, reusable prefab systems");
    println!("   - Advanced graph analysis for level design");
}

pub fn get_prefabs(&self) -> &[Prefab]

Examples found in repository

examples/advanced_prefabs.rs (line 19)

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

    // Step 1: Create prefab library programmatically
    println!("1. Creating Prefab Library:");
    let library = create_sample_library();

    println!(
        "   Created library with {} prefabs:",
        library.get_prefabs().len()
    );
    for prefab in library.get_prefabs() {
        println!(
            "     - {} ({}x{}, weight: {:.1}, tags: {:?})",
            prefab.name, prefab.width, prefab.height, prefab.weight, prefab.tags
        );
    }

    // Step 2: Demonstrate weighted selection
    println!("\n2. Weighted Selection Test:");
    let mut rng = Rng::new(12345);
    let mut selection_counts = std::collections::HashMap::new();

    for _ in 0..100 {
        if let Some(prefab) = library.select_weighted(&mut rng, None) {
            *selection_counts.entry(prefab.name.clone()).or_insert(0) += 1;
        }
    }

    println!("   Selection frequency (100 trials):");
    for (name, count) in &selection_counts {
        println!("     {}: {} times", name, count);
    }

    // Step 3: Tag-based selection
    println!("\n3. Tag-based Selection:");
    let room_prefabs = library.get_by_tag("room");
    let corridor_prefabs = library.get_by_tag("corridor");

    println!("   Room prefabs: {}", room_prefabs.len());
    for prefab in &room_prefabs {
        println!("     - {}", prefab.name);
    }

    println!("   Corridor prefabs: {}", corridor_prefabs.len());
    for prefab in &corridor_prefabs {
        println!("     - {}", prefab.name);
    }

    // Step 4: Transformation examples
    println!("\n4. Prefab Transformations:");
    if let Some(base_prefab) = library.get_prefabs().first() {
        println!(
            "   Base prefab '{}' ({}x{}):",
            base_prefab.name, base_prefab.width, base_prefab.height
        );
        print_prefab_pattern(base_prefab);

        // Rotation
        let rotated = base_prefab.rotated();
        println!(
            "   After 90° rotation ({}x{}):",
            rotated.width, rotated.height
        );
        print_prefab_pattern(&rotated);

        // Horizontal mirror
        let mirrored = base_prefab.mirrored_horizontal();
        println!(
            "   After horizontal mirror ({}x{}):",
            mirrored.width, mirrored.height
        );
        print_prefab_pattern(&mirrored);

        // Combined transformation
        let transform = PrefabTransform {
            rotation: 1,
            mirror_h: true,
            mirror_v: false,
        };
        let transformed = transform.apply(base_prefab);
        println!(
            "   After rotation + mirror ({}x{}):",
            transformed.width, transformed.height
        );
        print_prefab_pattern(&transformed);
    }

    // Step 5: Generation with advanced prefabs
    println!("\n5. Generation with Advanced Prefabs:");
    let config = PrefabConfig {
        max_prefabs: 5,
        min_spacing: 3,
        allow_rotation: true,
        allow_mirroring: true,
        weighted_selection: true,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let placer = PrefabPlacer::new(config, library.clone());
    let mut grid = Grid::new(30, 25);
    placer.generate(&mut grid, 54321);

    let floor_count = grid.count(|t| t.is_floor());
    println!(
        "   Generated {}x{} grid with {} floor tiles",
        grid.width(),
        grid.height(),
        floor_count
    );

    print_grid(&grid);

    // Step 6: JSON serialization example
    println!("\n6. JSON Serialization:");
    match library.save_to_json("prefab_library.json") {
        Ok(()) => {
            println!("   ✅ Saved library to prefab_library.json");

            // Try to load it back
            match PrefabLibrary::load_from_json("prefab_library.json") {
                Ok(loaded_library) => {
                    println!("   ✅ Successfully loaded library back");
                    println!("   Loaded {} prefabs", loaded_library.get_prefabs().len());
                }
                Err(e) => println!("   ❌ Failed to load: {}", e),
            }
        }
        Err(e) => println!("   ❌ Failed to save: {}", e),
    }

    // Step 7: Performance comparison
    println!("\n7. Performance Comparison:");

    // Simple generation
    let simple_config = PrefabConfig {
        max_prefabs: 10,
        min_spacing: 2,
        allow_rotation: false,
        allow_mirroring: false,
        weighted_selection: false,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let start = std::time::Instant::now();
    let simple_placer = PrefabPlacer::new(simple_config, library.clone());
    let mut simple_grid = Grid::new(40, 30);
    simple_placer.generate(&mut simple_grid, 98765);
    let simple_time = start.elapsed();

    // Advanced generation
    let advanced_config = PrefabConfig {
        max_prefabs: 10,
        min_spacing: 2,
        allow_rotation: true,
        allow_mirroring: true,
        weighted_selection: true,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let start = std::time::Instant::now();
    let advanced_placer = PrefabPlacer::new(advanced_config, library);
    let mut advanced_grid = Grid::new(40, 30);
    advanced_placer.generate(&mut advanced_grid, 98765);
    let advanced_time = start.elapsed();

    println!("   Simple generation: {:?}", simple_time);
    println!("   Advanced generation: {:?}", advanced_time);
    println!(
        "   Overhead: {:.1}x",
        advanced_time.as_nanos() as f32 / simple_time.as_nanos() as f32
    );

    println!("\n✅ Advanced prefab system demo complete!");
    println!("   - JSON serialization for persistent libraries");
    println!("   - Weighted selection for balanced generation");
    println!("   - Transformations for variety and reuse");
    println!("   - Tag-based organization for targeted selection");
}

examples/phase4_workflow.rs (line 97)

fn main() {
    println!("=== Phase 4 Complete Workflow Demo ===\n");

    // Step 1: Generate base layout with BSP
    println!("1. Generating Base Layout:");
    let mut base_grid = Grid::new(35, 25);
    let bsp = Bsp::default();
    bsp.generate(&mut base_grid, 12345);

    let base_floors = base_grid.count(|t| t.is_floor());
    println!(
        "   Generated {}x{} base layout with {} floors",
        base_grid.width(),
        base_grid.height(),
        base_floors
    );

    // Step 2: Learn patterns from base layout
    println!("\n2. Learning Patterns from Base Layout:");
    let learned_patterns = WfcPatternExtractor::extract_patterns(&base_grid, 3);
    println!(
        "   Extracted {} unique 3x3 patterns",
        learned_patterns.len()
    );

    // Step 3: Generate enhanced areas with WFC
    println!("\n3. Generating Enhanced Areas with Learned Patterns:");
    let mut wfc_grid = Grid::new(20, 15);
    let wfc = Wfc::new(WfcConfig {
        floor_weight: 0.45,
        pattern_size: 3,
        enable_backtracking: true,
    });
    wfc.generate_with_patterns(&mut wfc_grid, learned_patterns.clone(), 54321);

    let wfc_floors = wfc_grid.count(|t| t.is_floor());
    println!(
        "   WFC generated {} floors with learned patterns",
        wfc_floors
    );

    // Step 4: Find room centers for connectivity analysis
    println!("\n4. Analyzing Room Connectivity:");
    let room_centers = find_room_centers(&base_grid);
    println!("   Identified {} room centers", room_centers.len());

    // Step 5: Create optimal connections with Delaunay + MST
    println!("\n5. Creating Optimal Room Connections:");
    if room_centers.len() >= 3 {
        let triangulation = DelaunayTriangulation::new(room_centers.clone());
        let mst_edges = triangulation.minimum_spanning_tree();

        println!("   Delaunay triangulation:");
        println!("     Triangles: {}", triangulation.triangles.len());
        println!("     All edges: {}", triangulation.edges.len());

        println!("   Minimum spanning tree:");
        println!("     Optimal edges: {}", mst_edges.len());

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

        // Graph analysis
        let graph = Graph::new(triangulation.points.clone(), mst_edges);
        let analysis = GraphAnalysis::analyze(&graph);

        println!("   Connectivity analysis:");
        println!("     Connected: {}", analysis.is_connected);
        println!("     Diameter: {:.1}", analysis.diameter);
        println!("     Clustering: {:.3}", analysis.average_clustering);
    } else {
        println!("   Not enough rooms for connectivity analysis");
    }

    // Step 6: Create specialized prefab library
    println!("\n6. Creating Specialized Prefab Library:");
    let library = create_specialized_library();

    println!(
        "   Created library with {} prefabs:",
        library.get_prefabs().len()
    );
    for prefab in library.get_prefabs() {
        println!(
            "     - {} (weight: {:.1}, tags: {:?})",
            prefab.name, prefab.weight, prefab.tags
        );
    }

    // Step 7: Place special features with advanced prefabs
    println!("\n7. Placing Special Features:");
    let mut feature_grid = Grid::new(30, 20);

    // Place boss rooms (rare, large)
    let boss_config = PrefabConfig {
        max_prefabs: 1,
        min_spacing: 8,
        allow_rotation: false,
        allow_mirroring: false,
        weighted_selection: true,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let boss_placer = PrefabPlacer::new(boss_config, library.clone());
    boss_placer.generate(&mut feature_grid, 98765);

    // Place treasure rooms (medium rarity)
    let treasure_config = PrefabConfig {
        max_prefabs: 2,
        min_spacing: 5,
        allow_rotation: true,
        allow_mirroring: true,
        weighted_selection: true,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let treasure_placer = PrefabPlacer::new(treasure_config, library.clone());
    treasure_placer.generate(&mut feature_grid, 13579);

    let feature_floors = feature_grid.count(|t| t.is_floor());
    println!("   Placed special features: {} floor tiles", feature_floors);

    // Step 8: Performance and quality metrics
    println!("\n8. Performance and Quality Metrics:");

    // WFC performance
    let start = std::time::Instant::now();
    let mut perf_grid = Grid::new(25, 20);
    wfc.generate_with_patterns(&mut perf_grid, learned_patterns.clone(), 24680);
    let wfc_time = start.elapsed();

    // Prefab performance
    let start = std::time::Instant::now();
    let placer = PrefabPlacer::new(PrefabConfig::default(), library.clone());
    let mut prefab_grid = Grid::new(25, 20);
    placer.generate(&mut prefab_grid, 24680);
    let prefab_time = start.elapsed();

    // Delaunay performance
    let start = std::time::Instant::now();
    let _ = DelaunayTriangulation::new(room_centers.clone());
    let delaunay_time = start.elapsed();

    println!("   Performance metrics:");
    println!("     WFC generation: {:?}", wfc_time);
    println!("     Prefab placement: {:?}", prefab_time);
    println!("     Delaunay triangulation: {:?}", delaunay_time);

    // Step 9: Quality comparison
    println!("\n9. Quality Comparison:");

    // Basic generation
    let mut basic_grid = Grid::new(25, 20);
    bsp.generate(&mut basic_grid, 11111);
    let basic_floors = basic_grid.count(|t| t.is_floor());

    // Enhanced generation (WFC + prefabs)
    let enhanced_floors = perf_grid.count(|t| t.is_floor()) + prefab_grid.count(|t| t.is_floor());

    println!("   Floor tile comparison:");
    println!(
        "     Basic BSP: {} floors ({:.1}%)",
        basic_floors,
        100.0 * basic_floors as f32 / (25 * 20) as f32
    );
    println!(
        "     Enhanced (WFC + Prefabs): {} floors ({:.1}%)",
        enhanced_floors,
        100.0 * enhanced_floors as f32 / (50 * 20) as f32
    );

    // Step 10: Save configuration for reuse
    println!("\n10. Saving Configuration:");
    match library.save_to_json("phase4_library.json") {
        Ok(()) => println!("   ✅ Saved prefab library to phase4_library.json"),
        Err(e) => println!("   ❌ Failed to save library: {}", e),
    }

    println!("\n✅ Phase 4 complete workflow finished!");
    println!("   Workflow summary:");
    println!("   1. Generated base layout with BSP algorithm");
    println!(
        "   2. Learned {} patterns for WFC enhancement",
        learned_patterns.len()
    );
    println!(
        "   3. Analyzed {} room connections with Delaunay triangulation",
        room_centers.len()
    );
    println!("   4. Placed specialized features with weighted prefab selection");
    println!("   5. Achieved optimal room connectivity with MST");
    println!("   6. Demonstrated pattern learning and constraint propagation");
    println!("   \n   Phase 4 features enable:");
    println!("   - Intelligent pattern-based generation");
    println!("   - Mathematically optimal room connections");
    println!("   - Flexible, reusable prefab systems");
    println!("   - Advanced graph analysis for level design");
}

pub fn extend_from(&mut self, other: PrefabLibrary)

pub fn get_by_tag(&self, tag: &str) -> Vec<&Prefab>

Examples found in repository

examples/advanced_prefabs.rs (line 46)

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

    // Step 1: Create prefab library programmatically
    println!("1. Creating Prefab Library:");
    let library = create_sample_library();

    println!(
        "   Created library with {} prefabs:",
        library.get_prefabs().len()
    );
    for prefab in library.get_prefabs() {
        println!(
            "     - {} ({}x{}, weight: {:.1}, tags: {:?})",
            prefab.name, prefab.width, prefab.height, prefab.weight, prefab.tags
        );
    }

    // Step 2: Demonstrate weighted selection
    println!("\n2. Weighted Selection Test:");
    let mut rng = Rng::new(12345);
    let mut selection_counts = std::collections::HashMap::new();

    for _ in 0..100 {
        if let Some(prefab) = library.select_weighted(&mut rng, None) {
            *selection_counts.entry(prefab.name.clone()).or_insert(0) += 1;
        }
    }

    println!("   Selection frequency (100 trials):");
    for (name, count) in &selection_counts {
        println!("     {}: {} times", name, count);
    }

    // Step 3: Tag-based selection
    println!("\n3. Tag-based Selection:");
    let room_prefabs = library.get_by_tag("room");
    let corridor_prefabs = library.get_by_tag("corridor");

    println!("   Room prefabs: {}", room_prefabs.len());
    for prefab in &room_prefabs {
        println!("     - {}", prefab.name);
    }

    println!("   Corridor prefabs: {}", corridor_prefabs.len());
    for prefab in &corridor_prefabs {
        println!("     - {}", prefab.name);
    }

    // Step 4: Transformation examples
    println!("\n4. Prefab Transformations:");
    if let Some(base_prefab) = library.get_prefabs().first() {
        println!(
            "   Base prefab '{}' ({}x{}):",
            base_prefab.name, base_prefab.width, base_prefab.height
        );
        print_prefab_pattern(base_prefab);

        // Rotation
        let rotated = base_prefab.rotated();
        println!(
            "   After 90° rotation ({}x{}):",
            rotated.width, rotated.height
        );
        print_prefab_pattern(&rotated);

        // Horizontal mirror
        let mirrored = base_prefab.mirrored_horizontal();
        println!(
            "   After horizontal mirror ({}x{}):",
            mirrored.width, mirrored.height
        );
        print_prefab_pattern(&mirrored);

        // Combined transformation
        let transform = PrefabTransform {
            rotation: 1,
            mirror_h: true,
            mirror_v: false,
        };
        let transformed = transform.apply(base_prefab);
        println!(
            "   After rotation + mirror ({}x{}):",
            transformed.width, transformed.height
        );
        print_prefab_pattern(&transformed);
    }

    // Step 5: Generation with advanced prefabs
    println!("\n5. Generation with Advanced Prefabs:");
    let config = PrefabConfig {
        max_prefabs: 5,
        min_spacing: 3,
        allow_rotation: true,
        allow_mirroring: true,
        weighted_selection: true,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let placer = PrefabPlacer::new(config, library.clone());
    let mut grid = Grid::new(30, 25);
    placer.generate(&mut grid, 54321);

    let floor_count = grid.count(|t| t.is_floor());
    println!(
        "   Generated {}x{} grid with {} floor tiles",
        grid.width(),
        grid.height(),
        floor_count
    );

    print_grid(&grid);

    // Step 6: JSON serialization example
    println!("\n6. JSON Serialization:");
    match library.save_to_json("prefab_library.json") {
        Ok(()) => {
            println!("   ✅ Saved library to prefab_library.json");

            // Try to load it back
            match PrefabLibrary::load_from_json("prefab_library.json") {
                Ok(loaded_library) => {
                    println!("   ✅ Successfully loaded library back");
                    println!("   Loaded {} prefabs", loaded_library.get_prefabs().len());
                }
                Err(e) => println!("   ❌ Failed to load: {}", e),
            }
        }
        Err(e) => println!("   ❌ Failed to save: {}", e),
    }

    // Step 7: Performance comparison
    println!("\n7. Performance Comparison:");

    // Simple generation
    let simple_config = PrefabConfig {
        max_prefabs: 10,
        min_spacing: 2,
        allow_rotation: false,
        allow_mirroring: false,
        weighted_selection: false,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let start = std::time::Instant::now();
    let simple_placer = PrefabPlacer::new(simple_config, library.clone());
    let mut simple_grid = Grid::new(40, 30);
    simple_placer.generate(&mut simple_grid, 98765);
    let simple_time = start.elapsed();

    // Advanced generation
    let advanced_config = PrefabConfig {
        max_prefabs: 10,
        min_spacing: 2,
        allow_rotation: true,
        allow_mirroring: true,
        weighted_selection: true,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let start = std::time::Instant::now();
    let advanced_placer = PrefabPlacer::new(advanced_config, library);
    let mut advanced_grid = Grid::new(40, 30);
    advanced_placer.generate(&mut advanced_grid, 98765);
    let advanced_time = start.elapsed();

    println!("   Simple generation: {:?}", simple_time);
    println!("   Advanced generation: {:?}", advanced_time);
    println!(
        "   Overhead: {:.1}x",
        advanced_time.as_nanos() as f32 / simple_time.as_nanos() as f32
    );

    println!("\n✅ Advanced prefab system demo complete!");
    println!("   - JSON serialization for persistent libraries");
    println!("   - Weighted selection for balanced generation");
    println!("   - Transformations for variety and reuse");
    println!("   - Tag-based organization for targeted selection");
}

pub fn select_weighted( &self, rng: &mut Rng, tag: Option<&str>, ) -> Option<&Prefab>

Examples found in repository

examples/advanced_prefabs.rs (line 34)

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

    // Step 1: Create prefab library programmatically
    println!("1. Creating Prefab Library:");
    let library = create_sample_library();

    println!(
        "   Created library with {} prefabs:",
        library.get_prefabs().len()
    );
    for prefab in library.get_prefabs() {
        println!(
            "     - {} ({}x{}, weight: {:.1}, tags: {:?})",
            prefab.name, prefab.width, prefab.height, prefab.weight, prefab.tags
        );
    }

    // Step 2: Demonstrate weighted selection
    println!("\n2. Weighted Selection Test:");
    let mut rng = Rng::new(12345);
    let mut selection_counts = std::collections::HashMap::new();

    for _ in 0..100 {
        if let Some(prefab) = library.select_weighted(&mut rng, None) {
            *selection_counts.entry(prefab.name.clone()).or_insert(0) += 1;
        }
    }

    println!("   Selection frequency (100 trials):");
    for (name, count) in &selection_counts {
        println!("     {}: {} times", name, count);
    }

    // Step 3: Tag-based selection
    println!("\n3. Tag-based Selection:");
    let room_prefabs = library.get_by_tag("room");
    let corridor_prefabs = library.get_by_tag("corridor");

    println!("   Room prefabs: {}", room_prefabs.len());
    for prefab in &room_prefabs {
        println!("     - {}", prefab.name);
    }

    println!("   Corridor prefabs: {}", corridor_prefabs.len());
    for prefab in &corridor_prefabs {
        println!("     - {}", prefab.name);
    }

    // Step 4: Transformation examples
    println!("\n4. Prefab Transformations:");
    if let Some(base_prefab) = library.get_prefabs().first() {
        println!(
            "   Base prefab '{}' ({}x{}):",
            base_prefab.name, base_prefab.width, base_prefab.height
        );
        print_prefab_pattern(base_prefab);

        // Rotation
        let rotated = base_prefab.rotated();
        println!(
            "   After 90° rotation ({}x{}):",
            rotated.width, rotated.height
        );
        print_prefab_pattern(&rotated);

        // Horizontal mirror
        let mirrored = base_prefab.mirrored_horizontal();
        println!(
            "   After horizontal mirror ({}x{}):",
            mirrored.width, mirrored.height
        );
        print_prefab_pattern(&mirrored);

        // Combined transformation
        let transform = PrefabTransform {
            rotation: 1,
            mirror_h: true,
            mirror_v: false,
        };
        let transformed = transform.apply(base_prefab);
        println!(
            "   After rotation + mirror ({}x{}):",
            transformed.width, transformed.height
        );
        print_prefab_pattern(&transformed);
    }

    // Step 5: Generation with advanced prefabs
    println!("\n5. Generation with Advanced Prefabs:");
    let config = PrefabConfig {
        max_prefabs: 5,
        min_spacing: 3,
        allow_rotation: true,
        allow_mirroring: true,
        weighted_selection: true,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let placer = PrefabPlacer::new(config, library.clone());
    let mut grid = Grid::new(30, 25);
    placer.generate(&mut grid, 54321);

    let floor_count = grid.count(|t| t.is_floor());
    println!(
        "   Generated {}x{} grid with {} floor tiles",
        grid.width(),
        grid.height(),
        floor_count
    );

    print_grid(&grid);

    // Step 6: JSON serialization example
    println!("\n6. JSON Serialization:");
    match library.save_to_json("prefab_library.json") {
        Ok(()) => {
            println!("   ✅ Saved library to prefab_library.json");

            // Try to load it back
            match PrefabLibrary::load_from_json("prefab_library.json") {
                Ok(loaded_library) => {
                    println!("   ✅ Successfully loaded library back");
                    println!("   Loaded {} prefabs", loaded_library.get_prefabs().len());
                }
                Err(e) => println!("   ❌ Failed to load: {}", e),
            }
        }
        Err(e) => println!("   ❌ Failed to save: {}", e),
    }

    // Step 7: Performance comparison
    println!("\n7. Performance Comparison:");

    // Simple generation
    let simple_config = PrefabConfig {
        max_prefabs: 10,
        min_spacing: 2,
        allow_rotation: false,
        allow_mirroring: false,
        weighted_selection: false,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let start = std::time::Instant::now();
    let simple_placer = PrefabPlacer::new(simple_config, library.clone());
    let mut simple_grid = Grid::new(40, 30);
    simple_placer.generate(&mut simple_grid, 98765);
    let simple_time = start.elapsed();

    // Advanced generation
    let advanced_config = PrefabConfig {
        max_prefabs: 10,
        min_spacing: 2,
        allow_rotation: true,
        allow_mirroring: true,
        weighted_selection: true,
        placement_mode: terrain_forge::algorithms::PrefabPlacementMode::Overwrite,
        tags: None,
    };

    let start = std::time::Instant::now();
    let advanced_placer = PrefabPlacer::new(advanced_config, library);
    let mut advanced_grid = Grid::new(40, 30);
    advanced_placer.generate(&mut advanced_grid, 98765);
    let advanced_time = start.elapsed();

    println!("   Simple generation: {:?}", simple_time);
    println!("   Advanced generation: {:?}", advanced_time);
    println!(
        "   Overhead: {:.1}x",
        advanced_time.as_nanos() as f32 / simple_time.as_nanos() as f32
    );

    println!("\n✅ Advanced prefab system demo complete!");
    println!("   - JSON serialization for persistent libraries");
    println!("   - Weighted selection for balanced generation");
    println!("   - Transformations for variety and reuse");
    println!("   - Tag-based organization for targeted selection");
}

pub fn select_with_tags( &self, rng: &mut Rng, tags: Option<&[String]>, weighted: bool, ) -> Option<&Prefab>

pub fn get_by_any_tag(&self, tags: &[String]) -> Vec<&Prefab>

pub fn create_default() -> Self

Trait Implementations

impl Clone for PrefabLibrary

fn clone(&self) -> PrefabLibrary

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for PrefabLibrary

fn default() -> Self

Returns the “default value” for a type.