pub fn get(name: &str) -> Option<Box<dyn Algorithm<Tile>>>Expand description
Get algorithm by name
Examples found in repository?
examples/bsp_analysis.rs (line 7)
3fn main() {
4 println!("=== BSP Algorithm Analysis ===\n");
5
6 let mut grid = Grid::new(40, 30);
7 algorithms::get("bsp").unwrap().generate(&mut grid, 12345);
8
9 let extractor = SemanticExtractor::for_rooms();
10 let mut rng = Rng::new(12345);
11 let semantic = extractor.extract(&grid, &mut rng);
12
13 println!("Generated map analysis:");
14 println!(" Floor tiles: {}", grid.count(|t| t.is_floor()));
15 println!(" Total regions: {}", semantic.regions.len());
16
17 println!("\nRegion breakdown:");
18 let mut region_counts = std::collections::HashMap::new();
19 for region in &semantic.regions {
20 *region_counts.entry(®ion.kind).or_insert(0) += 1;
21 }
22
23 for (kind, count) in ®ion_counts {
24 println!(" {}: {}", kind, count);
25 }
26
27 println!("\nMarker breakdown:");
28 let mut marker_counts = std::collections::HashMap::new();
29 for marker in &semantic.markers {
30 *marker_counts.entry(marker.tag()).or_insert(0) += 1;
31 }
32
33 for (tag, count) in &marker_counts {
34 println!(" {}: {}", tag, count);
35 }
36}More examples
examples/distance_transforms.rs (line 16)
11fn main() {
12 println!("=== Distance Transform Demo ===\n");
13
14 // Generate a simple room layout
15 let mut grid = Grid::new(20, 15);
16 let algo = algorithms::get("rooms").unwrap();
17 algo.generate(&mut grid, 12345);
18
19 println!("1. Original Grid (20x15):");
20 print_grid(&grid);
21
22 // Generate distance fields with different metrics
23 println!("\n2. Euclidean Distance Field:");
24 let euclidean = distance_field(&grid, DistanceMetric::Euclidean);
25 print_distance_field(&euclidean);
26
27 println!("\n3. Manhattan Distance Field:");
28 let manhattan = distance_field(&grid, DistanceMetric::Manhattan);
29 print_distance_field(&manhattan);
30
31 println!("\n4. Chebyshev Distance Field:");
32 let chebyshev = distance_field(&grid, DistanceMetric::Chebyshev);
33 print_distance_field(&chebyshev);
34
35 // Performance comparison
36 println!("\n5. Performance Comparison:");
37 let start = std::time::Instant::now();
38 let _ = distance_field(&grid, DistanceMetric::Euclidean);
39 println!(" Euclidean: {:?}", start.elapsed());
40
41 let start = std::time::Instant::now();
42 let _ = distance_field(&grid, DistanceMetric::Manhattan);
43 println!(" Manhattan: {:?}", start.elapsed());
44
45 let start = std::time::Instant::now();
46 let _ = distance_field(&grid, DistanceMetric::Chebyshev);
47 println!(" Chebyshev: {:?}", start.elapsed());
48}examples/phase1_demo.rs (line 20)
16fn demo_hierarchical_markers() {
17 println!("🎯 Demo 1: Hierarchical Marker Types");
18
19 let mut grid = Grid::new(40, 30);
20 algorithms::get("bsp").unwrap().generate(&mut grid, 12345);
21
22 let extractor = SemanticExtractor::for_rooms();
23 let mut rng = Rng::new(12345);
24 let mut semantic = extractor.extract(&grid, &mut rng);
25
26 // Add hierarchical markers manually for demo
27 if let Some(region) = semantic.regions.first() {
28 let (x, y) = region.cells[0];
29
30 // Quest markers
31 semantic.markers.push(Marker::new(
32 x,
33 y,
34 MarkerType::QuestObjective { priority: 1 },
35 ));
36 semantic
37 .markers
38 .push(Marker::new(x + 2, y, MarkerType::QuestStart));
39
40 // Loot markers
41 semantic
42 .markers
43 .push(Marker::new(x, y + 2, MarkerType::LootTier { tier: 3 }));
44 semantic
45 .markers
46 .push(Marker::new(x + 1, y + 2, MarkerType::Treasure));
47
48 // Encounter zones
49 semantic.markers.push(Marker::new(
50 x + 3,
51 y + 1,
52 MarkerType::EncounterZone { difficulty: 5 },
53 ));
54 semantic
55 .markers
56 .push(Marker::new(x + 4, y + 1, MarkerType::BossRoom));
57 }
58
59 // Show marker categories
60 let mut categories = std::collections::HashMap::new();
61 for marker in &semantic.markers {
62 *categories.entry(marker.marker_type.category()).or_insert(0) += 1;
63 }
64
65 for (category, count) in categories {
66 println!(" {} markers: {}", category, count);
67 }
68
69 println!(" Sample markers:");
70 for marker in semantic.markers.iter().take(3) {
71 println!(" {} at ({}, {})", marker.tag(), marker.x, marker.y);
72 }
73 println!();
74}examples/advanced_pathfinding.rs (line 16)
11fn main() {
12 println!("=== Advanced Pathfinding Demo ===\n");
13
14 // Generate a dungeon layout
15 let mut grid = Grid::new(25, 20);
16 let algo = algorithms::get("bsp").unwrap();
17 algo.generate(&mut grid, 54321);
18
19 println!("1. Dungeon Layout (25x20):");
20 print_grid(&grid);
21
22 // Single goal pathfinding
23 println!("\n2. Single Goal Dijkstra Map:");
24 let goals = vec![(12, 10)]; // Center goal
25 let constraints = PathfindingConstraints::default();
26 let dijkstra = dijkstra_map(&grid, &goals, &constraints);
27 print_dijkstra_map(&dijkstra);
28
29 // Multiple goals pathfinding
30 println!("\n3. Multiple Goals Dijkstra Map:");
31 let goals = vec![(5, 5), (20, 15), (15, 5)]; // Three goals
32 let dijkstra_multi = dijkstra_map(&grid, &goals, &constraints);
33 print_dijkstra_map(&dijkstra_multi);
34
35 // Flow field generation
36 println!("\n4. Flow Field from Single Goal:");
37 let flow = flow_field_from_dijkstra(&dijkstra);
38 print_flow_field(&flow);
39
40 // Custom movement costs
41 println!("\n5. Custom Movement Costs (diagonal penalty):");
42 let mut custom_constraints = PathfindingConstraints::default();
43 custom_constraints.movement_cost.insert((-1, -1), 2.0);
44 custom_constraints.movement_cost.insert((-1, 1), 2.0);
45 custom_constraints.movement_cost.insert((1, -1), 2.0);
46 custom_constraints.movement_cost.insert((1, 1), 2.0);
47
48 let dijkstra_custom = dijkstra_map(&grid, &goals, &custom_constraints);
49 print_dijkstra_map(&dijkstra_custom);
50
51 // Performance analysis
52 println!("\n6. Performance Analysis:");
53 let start = std::time::Instant::now();
54 let _ = dijkstra_map(&grid, &goals, &constraints);
55 println!(" Dijkstra map generation: {:?}", start.elapsed());
56
57 let start = std::time::Instant::now();
58 let _ = flow_field_from_dijkstra(&dijkstra);
59 println!(" Flow field generation: {:?}", start.elapsed());
60}examples/hierarchical_markers.rs (line 8)
3fn main() {
4 println!("=== Hierarchical Marker Types Demo ===\n");
5
6 // Generate a basic dungeon
7 let mut grid = Grid::new(30, 20);
8 algorithms::get("bsp").unwrap().generate(&mut grid, 12345);
9
10 let extractor = SemanticExtractor::for_rooms();
11 let mut rng = Rng::new(12345);
12 let mut semantic = extractor.extract(&grid, &mut rng);
13
14 // Add hierarchical markers
15 if let Some(region) = semantic.regions.first() {
16 let (x, y) = region.cells[0];
17
18 // Quest markers with priorities
19 semantic.markers.push(Marker::new(
20 x,
21 y,
22 MarkerType::QuestObjective { priority: 1 },
23 ));
24 semantic.markers.push(Marker::new(
25 x + 2,
26 y,
27 MarkerType::QuestObjective { priority: 3 },
28 ));
29 semantic
30 .markers
31 .push(Marker::new(x + 4, y, MarkerType::QuestStart));
32
33 // Loot with different tiers
34 semantic
35 .markers
36 .push(Marker::new(x, y + 2, MarkerType::LootTier { tier: 1 }));
37 semantic
38 .markers
39 .push(Marker::new(x + 2, y + 2, MarkerType::LootTier { tier: 3 }));
40 semantic
41 .markers
42 .push(Marker::new(x + 4, y + 2, MarkerType::Treasure));
43
44 // Encounter zones
45 semantic.markers.push(Marker::new(
46 x,
47 y + 4,
48 MarkerType::EncounterZone { difficulty: 2 },
49 ));
50 semantic
51 .markers
52 .push(Marker::new(x + 2, y + 4, MarkerType::BossRoom));
53 semantic
54 .markers
55 .push(Marker::new(x + 4, y + 4, MarkerType::SafeZone));
56 }
57
58 // Show marker categories and types
59 println!("Generated {} markers:", semantic.markers.len());
60 for marker in &semantic.markers {
61 println!(
62 " {} at ({}, {}) - Category: {}",
63 marker.tag(),
64 marker.x,
65 marker.y,
66 marker.marker_type.category()
67 );
68 }
69
70 // Group by category
71 let mut categories = std::collections::HashMap::new();
72 for marker in &semantic.markers {
73 *categories.entry(marker.marker_type.category()).or_insert(0) += 1;
74 }
75
76 println!("\nMarker distribution:");
77 for (category, count) in categories {
78 println!(" {}: {} markers", category, count);
79 }
80}examples/morphological_operations.rs (line 16)
11fn main() {
12 println!("=== Morphological Operations Demo ===\n");
13
14 // Generate a cellular automata cave
15 let mut grid = Grid::new(30, 20);
16 let algo = algorithms::get("cellular").unwrap();
17 algo.generate(&mut grid, 98765);
18
19 println!("1. Original Cave System (30x20):");
20 print_grid(&grid);
21
22 // Erosion - shrink shapes
23 println!("\n2. Erosion (3x3 rectangle):");
24 let rect_element = StructuringElement::rectangle(3, 3);
25 let eroded = morphological_transform(&grid, MorphologyOp::Erosion, &rect_element);
26 print_grid(&eroded);
27
28 // Dilation - expand shapes
29 println!("\n3. Dilation (3x3 rectangle):");
30 let dilated = morphological_transform(&grid, MorphologyOp::Dilation, &rect_element);
31 print_grid(&dilated);
32
33 // Opening - erosion followed by dilation (removes small features)
34 println!("\n4. Opening (removes small features):");
35 let opened = morphological_transform(&grid, MorphologyOp::Opening, &rect_element);
36 print_grid(&opened);
37
38 // Closing - dilation followed by erosion (fills small gaps)
39 println!("\n5. Closing (fills small gaps):");
40 let closed = morphological_transform(&grid, MorphologyOp::Closing, &rect_element);
41 print_grid(&closed);
42
43 // Different structuring elements
44 println!("\n6. Circular Structuring Element (radius 2):");
45 let circle_element = StructuringElement::circle(2);
46 let circle_eroded = morphological_transform(&grid, MorphologyOp::Erosion, &circle_element);
47 print_grid(&circle_eroded);
48
49 println!("\n7. Cross Structuring Element (size 5):");
50 let cross_element = StructuringElement::cross(5);
51 let cross_dilated = morphological_transform(&grid, MorphologyOp::Dilation, &cross_element);
52 print_grid(&cross_dilated);
53
54 // Iterative processing
55 println!("\n8. Multiple Iterations (3x erosion):");
56 let mut iterative = grid.clone();
57 for i in 1..=3 {
58 iterative = morphological_transform(&iterative, MorphologyOp::Erosion, &rect_element);
59 println!(" Iteration {}:", i);
60 print_grid_compact(&iterative);
61 }
62
63 // Performance comparison
64 println!("\n9. Performance Analysis:");
65 let elements = [
66 ("Rectangle 3x3", StructuringElement::rectangle(3, 3)),
67 ("Circle r=2", StructuringElement::circle(2)),
68 ("Cross 5x5", StructuringElement::cross(5)),
69 ];
70
71 for (name, element) in &elements {
72 let start = std::time::Instant::now();
73 let _ = morphological_transform(&grid, MorphologyOp::Erosion, element);
74 println!(" {} erosion: {:?}", name, start.elapsed());
75 }
76
77 // Shape analysis
78 println!("\n10. Shape Analysis:");
79 let original_floors = grid.count(|t| t.is_floor());
80 let eroded_floors = eroded.count(|t| t.is_floor());
81 let dilated_floors = dilated.count(|t| t.is_floor());
82
83 println!(" Original floors: {}", original_floors);
84 println!(
85 " After erosion: {} ({:.1}% reduction)",
86 eroded_floors,
87 100.0 * (original_floors - eroded_floors) as f32 / original_floors as f32
88 );
89 println!(
90 " After dilation: {} ({:.1}% increase)",
91 dilated_floors,
92 100.0 * (dilated_floors - original_floors) as f32 / original_floors as f32
93 );
94}Additional examples can be found in: