1 use super::tile_image::{Edge, TileImage}; |
1 use super::tile_image::{Edge, TileImage}; |
2 use super::wavefront_collapse::WavefrontCollapse; |
2 use super::wavefront_collapse::{CollapseRule, Tile, WavefrontCollapse}; |
3 use crate::{LandGenerationParameters, LandGenerator}; |
3 use crate::{LandGenerationParameters, LandGenerator}; |
4 use integral_geometry::Size; |
4 use integral_geometry::Size; |
5 use png::Decoder; |
5 use png::Decoder; |
|
6 use std::collections::HashSet; |
6 use std::fs::File; |
7 use std::fs::File; |
7 use std::io::BufReader; |
8 use std::io::BufReader; |
8 |
9 |
9 pub struct WavefrontCollapseLandGenerator { |
10 pub struct WavefrontCollapseLandGenerator {} |
10 wfc: WavefrontCollapse, |
|
11 } |
|
12 |
11 |
13 impl WavefrontCollapseLandGenerator { |
12 impl WavefrontCollapseLandGenerator { |
14 pub fn new() -> Self { |
13 pub fn new() -> Self { |
15 Self { |
14 Self {} |
16 wfc: WavefrontCollapse::default(), |
|
17 } |
|
18 } |
15 } |
19 |
16 |
20 pub fn load_template<T: Copy + PartialEq + Default>( |
17 pub fn load_template<T: Copy + PartialEq + Default>( |
21 &self, |
18 &self, |
22 parameters: &LandGenerationParameters<T>, |
19 parameters: &LandGenerationParameters<T>, |
73 parameters: &LandGenerationParameters<T>, |
70 parameters: &LandGenerationParameters<T>, |
74 random_numbers: &mut I, |
71 random_numbers: &mut I, |
75 ) -> land2d::Land2D<T> { |
72 ) -> land2d::Land2D<T> { |
76 let tiles = self.load_template(parameters); |
73 let tiles = self.load_template(parameters); |
77 |
74 |
78 todo!() |
75 let mut rules = Vec::<CollapseRule>::new(); |
|
76 |
|
77 let default_connection = HashSet::from_iter(vec![Tile::Outside, Tile::Empty].into_iter()); |
|
78 for (i, tile) in tiles.iter().enumerate() { |
|
79 let mut right = default_connection.clone(); |
|
80 let mut bottom = default_connection.clone(); |
|
81 let mut left = default_connection.clone(); |
|
82 let mut top = default_connection.clone(); |
|
83 |
|
84 for p in 0..i { |
|
85 if tiles[p].left_edge() == tile.right_edge() { |
|
86 rules[p].left.insert(Tile::Numbered(i)); |
|
87 right.insert(Tile::Numbered(p)); |
|
88 } |
|
89 |
|
90 if tiles[p].right_edge() == tile.left_edge() { |
|
91 rules[p].right.insert(Tile::Numbered(i)); |
|
92 left.insert(Tile::Numbered(p)); |
|
93 } |
|
94 |
|
95 if tiles[p].top_edge() == tile.bottom_edge() { |
|
96 rules[p].top.insert(Tile::Numbered(i)); |
|
97 bottom.insert(Tile::Numbered(p)); |
|
98 } |
|
99 |
|
100 if tiles[p].bottom_edge() == tile.top_edge() { |
|
101 rules[p].bottom.insert(Tile::Numbered(i)); |
|
102 top.insert(Tile::Numbered(p)); |
|
103 } |
|
104 } |
|
105 |
|
106 rules.push(CollapseRule { |
|
107 tile: Tile::Numbered(i), |
|
108 top, |
|
109 right, |
|
110 bottom, |
|
111 left, |
|
112 }); |
|
113 } |
|
114 |
|
115 let mut wfc = WavefrontCollapse::default(); |
|
116 wfc.set_rules(rules); |
|
117 |
|
118 wfc.generate_map(&Size::new(40, 20), |_| {}, random_numbers); |
|
119 |
|
120 let grid = wfc.grid(); |
|
121 |
|
122 for r in 0..grid.height() { |
|
123 for c in 0..grid.width() { |
|
124 print!("{:?}", grid.get(r, c)); |
|
125 } |
|
126 |
|
127 println!(); |
|
128 } |
|
129 |
|
130 todo!("build result") |
79 } |
131 } |
80 } |
132 } |
81 |
133 |
82 #[cfg(test)] |
134 #[cfg(test)] |
83 mod tests { |
135 mod tests { |