From 7f775b80dd6122a6e90a13e8f33093377e49ad86 Mon Sep 17 00:00:00 2001 From: Llywelwyn Date: Thu, 20 Jul 2023 15:26:51 +0100 Subject: [PATCH] voronoi, and starting on wfc --- resources/wfc-demo1.xp | Bin 0 -> 688 bytes resources/wfc-demo2.xp | Bin 0 -> 117 bytes resources/wfc-populated.xp | Bin 0 -> 877 bytes src/map.rs | 5 +- src/map_builders/mod.rs | 9 +- src/map_builders/voronoi.rs | 177 +++++++++++++++++++++++++++ src/map_builders/wfc/image_loader.rs | 24 ++++ src/map_builders/wfc/mod.rs | 84 +++++++++++++ src/rex_assets.rs | 4 + src/spawner.rs | 2 +- 10 files changed, 301 insertions(+), 4 deletions(-) create mode 100644 resources/wfc-demo1.xp create mode 100644 resources/wfc-demo2.xp create mode 100644 resources/wfc-populated.xp create mode 100644 src/map_builders/voronoi.rs create mode 100644 src/map_builders/wfc/image_loader.rs create mode 100644 src/map_builders/wfc/mod.rs diff --git a/resources/wfc-demo1.xp b/resources/wfc-demo1.xp new file mode 100644 index 0000000000000000000000000000000000000000..3809f021689601003f0bf9302961b38340720197 GIT binary patch literal 688 zcmb2|=3oE=?zgub^Oy{ISOcnrm+0+&qGYQWKKERn%Tb4({rlfO(Vwu!$;dBm4v)|F z+}r!~rk{TQ@7K-v`@dh;?Z2OA?mBnT>x3!uUq*iW?PSw=;csQtv6S~0oznH!az!n^ z{vl<;`lDGFowG~S3`G+pXa6r=Gt(xGL)Umy+=b^RRb}qC7j6BN-Cd~vb;rM?SJy8W z%j@Q~-28u`I!S)*jjpb;!!>?UD_+ZO{-|>(bl#Q^*SB7sc-&k``<+yO=aQ|P#LN$+ zq|Wc{i+U00rTwgq`R3+Y`?ms5vlG`H`<=HTD%UmU?dABE`6t&bJKDQsYgKOH^{7oU3xQUpZ}>srG44qu0WHv)t}gXUz^%y}IVs^lPW0+9z%an3)z9(i3*X zVo~)pvFO(l?_ZyIcTDPOOw?jIIoed}w12*4NGU~Y272RnXos!wR%hqk%RZDN~%+jntPwvV0 z&*)lZ*{(kJr~3FBkEmkz_pigFN*7tIJ$zX1=I_({&tQ zW0Sb6%#yxHZayeFC2Wb{t=w4Mb%Muo#dN=%Fnm63OHJ-YOa{V5S z?EjD7Z@cs>Ms3|TyW8;>&Tn6$y4KD*aa!2Ei@)D2K0j|qwNvKR>!14m{J;Mx^-a_t zYxDZA53Xg3D(@CM%)9ye*)>lK55H;Qk<5JRdgtS_(_h4xwy1+cefc+zISmDzJDJpHRu|4%*nVV2QT5tu>!+_x zSoLp~-0e+vC)dAwTWcfN&%bm^{_*FhKmIJKdH4PI+cIxa&%Hic)!ygV*fV`}S@`<# zl{>-m^S|!hYnpY3tzGO^RbP3%O=xB7#aCC`-@SkCJoWxlm&l8=a+{MIYx6F8*VM=T z4fPAjiP}8xND9N!{6F_E+Ww51=Xxsj|H6}Jj&N7abE_`jrepQ)ZLxQ{qG!G-G1}Fs&2^ctJ1cur}r#r&7Z!_@5zU$8@$Yq zrG{L(HFMg!LlLgu-CUwx#Hs1d{K~c|?N^1AIFzw+#K zS2NRnpEd2;o0B*4wmf=1EpJWbvZdDfs=8BHOQO$ZIlj9!Ni2WQ`&5Rx(_-rDr`4ys za6jACvm-l8YHi0(Rl|CfwXvC@Zl2t!D^uN0UYPWvz2vN?_w2B@?;|em%=}uU8@1WS zVvEIRp1pUcW@bJSYY+Q9XBz8Tan@9M)zwd~7K;ufWq-#?pY{tPVIqQ$>!(e?EACqpw5 zy;RmN5%tczuxNE*?dJE{&nl9`GAAs&(e$m2rU%w^neSdAS>T!;(y&!RC3Qv-FQ$ZD*XGafznr=C>r2hvkNGwC`to!$ z7hdC$iQ1Gb{Oe!Xr7ow{vfhg>9_ncc+j2q9{qmyq*Pnz*&IpaVD}4L%qm+AE+7)@{ z|Nr;Xv$ycd6E_ZfeAh62&Ecaf#obDxq_p$SoY`We%V&PZL&JSp`FX|6Ozpe>ZcXm= zHOTzA+;m%4aj9*d-PIeDH;0EWJla|2*SYa{b#?5ys}^@IOk3oAqyNC_3$y;Ne>6u( v=IXoMw&zcV6)p`-n&$KOUG`6DHBWDqB*UFc6En4}zp~%>?O{>S#=rmoKYPe9 literal 0 HcmV?d00001 diff --git a/src/map.rs b/src/map.rs index 4dde995..7a61654 100644 --- a/src/map.rs +++ b/src/map.rs @@ -206,7 +206,7 @@ pub fn draw_map(map: &Map, ctx: &mut Rltk) { fn is_revealed_and_wall(map: &Map, x: i32, y: i32) -> bool { let idx = map.xy_idx(x, y); - map.tiles[idx] == TileType::Wall //&& map.revealed_tiles[idx] + map.tiles[idx] == TileType::Wall && map.revealed_tiles[idx] } fn wall_glyph(map: &Map, x: i32, y: i32) -> rltk::FontCharType { @@ -277,8 +277,11 @@ fn wall_glyph(map: &Map, x: i32, y: i32) -> rltk::FontCharType { 55 => 185, 59 => 204, 63 => 203, + 87 => 185, 126 => 203, 143 => 206, + 77 => 202, + 171 => 204, 187 => 204, 215 => 185, 190 => 203, diff --git a/src/map_builders/mod.rs b/src/map_builders/mod.rs index 137bb42..e9845bd 100644 --- a/src/map_builders/mod.rs +++ b/src/map_builders/mod.rs @@ -7,6 +7,8 @@ mod dla; mod drunkard; mod maze; mod simple_map; +mod voronoi; +mod wfc; use common::*; use rltk::RandomNumberGenerator; use specs::prelude::*; @@ -22,7 +24,7 @@ pub trait MapBuilder { pub fn random_builder(new_depth: i32) -> Box { /*let mut rng = rltk::RandomNumberGenerator::new(); - let builder = rng.roll_dice(1, 14); + let builder = rng.roll_dice(1, 17); match builder { 1 => Box::new(bsp_dungeon::BspDungeonBuilder::new(new_depth)), 2 => Box::new(bsp_interior::BspInteriorBuilder::new(new_depth)), @@ -37,7 +39,10 @@ pub fn random_builder(new_depth: i32) -> Box { 9 => Box::new(dla::DLABuilder::walk_outwards(new_depth)), 10 => Box::new(dla::DLABuilder::central_attractor(new_depth)), 11 => Box::new(dla::DLABuilder::insectoid(new_depth)), + 12 => Box::new(voronoi::VoronoiBuilder::pythagoras(new_depth)), + 12 => Box::new(voronoi::VoronoiBuilder::manhattan(new_depth)), + 12 => Box::new(voronoi::VoronoiBuilder::chebyshev(new_depth)), _ => Box::new(simple_map::SimpleMapBuilder::new(new_depth)), }*/ - Box::new(drunkard::DrunkardsWalkBuilder::fearful_symmetry(new_depth)) + Box::new(wfc::WaveFunctionCollapseBuilder::new(new_depth)) } diff --git a/src/map_builders/voronoi.rs b/src/map_builders/voronoi.rs new file mode 100644 index 0000000..3e04ff4 --- /dev/null +++ b/src/map_builders/voronoi.rs @@ -0,0 +1,177 @@ +use super::{ + generate_voronoi_spawn_regions, remove_unreachable_areas_returning_most_distant, spawner, Map, MapBuilder, + Position, TileType, SHOW_MAPGEN, +}; +use rltk::RandomNumberGenerator; +use specs::prelude::*; +use std::collections::HashMap; + +#[derive(PartialEq, Copy, Clone)] +pub enum DistanceAlgorithm { + Pythagoras, + Manhattan, + Chebyshev, +} + +pub struct VoronoiBuilder { + map: Map, + starting_position: Position, + depth: i32, + history: Vec, + noise_areas: HashMap>, + n_seeds: usize, + distance_algorithm: DistanceAlgorithm, +} + +impl MapBuilder for VoronoiBuilder { + fn build_map(&mut self, rng: &mut RandomNumberGenerator) { + return self.build(rng); + } + fn spawn_entities(&mut self, ecs: &mut World) { + for area in self.noise_areas.iter() { + spawner::spawn_region(ecs, area.1, self.depth); + } + } + // Getters + fn get_map(&mut self) -> Map { + return self.map.clone(); + } + fn get_starting_pos(&mut self) -> Position { + return self.starting_position.clone(); + } + // Mapgen visualisation stuff + fn get_snapshot_history(&self) -> Vec { + return self.history.clone(); + } + fn take_snapshot(&mut self) { + if SHOW_MAPGEN { + let mut snapshot = self.map.clone(); + for v in snapshot.revealed_tiles.iter_mut() { + *v = true; + } + self.history.push(snapshot); + } + } +} + +impl VoronoiBuilder { + pub fn pythagoras(new_depth: i32) -> VoronoiBuilder { + VoronoiBuilder { + map: Map::new(new_depth), + starting_position: Position { x: 0, y: 0 }, + depth: new_depth, + history: Vec::new(), + noise_areas: HashMap::new(), + n_seeds: 64, + distance_algorithm: DistanceAlgorithm::Pythagoras, + } + } + pub fn manhattan(new_depth: i32) -> VoronoiBuilder { + VoronoiBuilder { + map: Map::new(new_depth), + starting_position: Position { x: 0, y: 0 }, + depth: new_depth, + history: Vec::new(), + noise_areas: HashMap::new(), + n_seeds: 64, + distance_algorithm: DistanceAlgorithm::Manhattan, + } + } + pub fn chebyshev(new_depth: i32) -> VoronoiBuilder { + VoronoiBuilder { + map: Map::new(new_depth), + starting_position: Position { x: 0, y: 0 }, + depth: new_depth, + history: Vec::new(), + noise_areas: HashMap::new(), + n_seeds: 64, + distance_algorithm: DistanceAlgorithm::Chebyshev, + } + } + + #[allow(clippy::map_entry)] + fn build(&mut self, rng: &mut RandomNumberGenerator) { + // Make a Voronoi diagram. We'll do this the hard way to learn about the technique! + let mut voronoi_seeds: Vec<(usize, rltk::Point)> = Vec::new(); + + while voronoi_seeds.len() < self.n_seeds { + let vx = rng.roll_dice(1, self.map.width - 1); + let vy = rng.roll_dice(1, self.map.height - 1); + let vidx = self.map.xy_idx(vx, vy); + let candidate = (vidx, rltk::Point::new(vx, vy)); + if !voronoi_seeds.contains(&candidate) { + voronoi_seeds.push(candidate); + } + } + + let mut voronoi_distance = vec![(0, 0.0f32); self.n_seeds]; + let mut voronoi_membership: Vec = vec![0; self.map.width as usize * self.map.height as usize]; + for (i, vid) in voronoi_membership.iter_mut().enumerate() { + let x = i as i32 % self.map.width; + let y = i as i32 / self.map.width; + + for (seed, pos) in voronoi_seeds.iter().enumerate() { + let distance; + match self.distance_algorithm { + DistanceAlgorithm::Pythagoras => { + distance = rltk::DistanceAlg::PythagorasSquared.distance2d(rltk::Point::new(x, y), pos.1); + } + DistanceAlgorithm::Manhattan => { + distance = rltk::DistanceAlg::Manhattan.distance2d(rltk::Point::new(x, y), pos.1); + } + DistanceAlgorithm::Chebyshev => { + distance = rltk::DistanceAlg::Chebyshev.distance2d(rltk::Point::new(x, y), pos.1); + } + } + voronoi_distance[seed] = (seed, distance); + } + + voronoi_distance.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap()); + + *vid = voronoi_distance[0].0 as i32; + } + + for y in 1..self.map.height - 1 { + for x in 1..self.map.width - 1 { + let mut neighbors = 0; + let my_idx = self.map.xy_idx(x, y); + let my_seed = voronoi_membership[my_idx]; + if voronoi_membership[self.map.xy_idx(x - 1, y)] != my_seed { + neighbors += 1; + } + if voronoi_membership[self.map.xy_idx(x + 1, y)] != my_seed { + neighbors += 1; + } + if voronoi_membership[self.map.xy_idx(x, y - 1)] != my_seed { + neighbors += 1; + } + if voronoi_membership[self.map.xy_idx(x, y + 1)] != my_seed { + neighbors += 1; + } + + if neighbors < 2 { + self.map.tiles[my_idx] = TileType::Floor; + } + } + self.take_snapshot(); + } + + // Find a starting point; start at the middle and walk left until we find an open tile + self.starting_position = Position { x: self.map.width / 2, y: self.map.height / 2 }; + let mut start_idx = self.map.xy_idx(self.starting_position.x, self.starting_position.y); + while self.map.tiles[start_idx] != TileType::Floor { + self.starting_position.x -= 1; + start_idx = self.map.xy_idx(self.starting_position.x, self.starting_position.y); + } + self.take_snapshot(); + // Find all tiles we can reach from the starting point + let exit_tile = remove_unreachable_areas_returning_most_distant(&mut self.map, start_idx); + self.take_snapshot(); + // Place the stairs + self.map.tiles[exit_tile] = TileType::DownStair; + self.take_snapshot(); + + // Now we build a noise map for use in spawning entities later + self.noise_areas = generate_voronoi_spawn_regions(&self.map, rng); + } +} diff --git a/src/map_builders/wfc/image_loader.rs b/src/map_builders/wfc/image_loader.rs new file mode 100644 index 0000000..5087742 --- /dev/null +++ b/src/map_builders/wfc/image_loader.rs @@ -0,0 +1,24 @@ +use super::{Map, TileType}; +use rltk::rex::XpFile; + +// Load RexPaint file, convert to map format +pub fn load_rex_map(new_depth: i32, xp_file: &XpFile) -> Map { + let mut map: Map = Map::new(new_depth); + + for layer in &xp_file.layers { + for y in 0..layer.height { + for x in 0..layer.width { + let cell = layer.get(x, y).unwrap(); + if x < map.width as usize && y < map.height as usize { + let idx = map.xy_idx(x as i32, y as i32); + match cell.ch { + 32 => map.tiles[idx] = TileType::Floor, // . + 35 => map.tiles[idx] = TileType::Wall, // # + _ => {} + } + } + } + } + } + map +} diff --git a/src/map_builders/wfc/mod.rs b/src/map_builders/wfc/mod.rs new file mode 100644 index 0000000..20c8515 --- /dev/null +++ b/src/map_builders/wfc/mod.rs @@ -0,0 +1,84 @@ +use super::{ + generate_voronoi_spawn_regions, remove_unreachable_areas_returning_most_distant, spawner, Map, MapBuilder, + Position, TileType, SHOW_MAPGEN, +}; +mod image_loader; +use image_loader::load_rex_map; +use rltk::RandomNumberGenerator; +use specs::prelude::*; +use std::collections::HashMap; + +pub struct WaveFunctionCollapseBuilder { + map: Map, + starting_position: Position, + depth: i32, + history: Vec, + noise_areas: HashMap>, +} + +impl MapBuilder for WaveFunctionCollapseBuilder { + fn build_map(&mut self, rng: &mut RandomNumberGenerator) { + return self.build(rng); + } + fn spawn_entities(&mut self, ecs: &mut World) { + for area in self.noise_areas.iter() { + spawner::spawn_region(ecs, area.1, self.depth); + } + } + // Getters + fn get_map(&mut self) -> Map { + return self.map.clone(); + } + fn get_starting_pos(&mut self) -> Position { + return self.starting_position.clone(); + } + // Mapgen visualisation stuff + fn get_snapshot_history(&self) -> Vec { + return self.history.clone(); + } + fn take_snapshot(&mut self) { + if SHOW_MAPGEN { + let mut snapshot = self.map.clone(); + for v in snapshot.revealed_tiles.iter_mut() { + *v = true; + } + self.history.push(snapshot); + } + } +} + +impl WaveFunctionCollapseBuilder { + pub fn new(new_depth: i32) -> WaveFunctionCollapseBuilder { + WaveFunctionCollapseBuilder { + map: Map::new(new_depth), + starting_position: Position { x: 0, y: 0 }, + depth: new_depth, + history: Vec::new(), + noise_areas: HashMap::new(), + } + } + + fn build(&mut self, rng: &mut RandomNumberGenerator) { + self.map = load_rex_map(self.depth, &rltk::rex::XpFile::from_resource("../resources/wfc-demo1.xp").unwrap()); + + // Find a starting point; start at the middle and walk left until we find an open tile + self.starting_position = Position { x: self.map.width / 2, y: self.map.height / 2 }; + let mut start_idx = self.map.xy_idx(self.starting_position.x, self.starting_position.y); + //while self.map.tiles[start_idx] != TileType::Floor { + // self.starting_position.x -= 1; + // start_idx = self.map.xy_idx(self.starting_position.x, self.starting_position.y); + //} + self.take_snapshot(); + + // Find all tiles we can reach from the starting point + let exit_tile = remove_unreachable_areas_returning_most_distant(&mut self.map, start_idx); + self.take_snapshot(); + + // Place the stairs + self.map.tiles[exit_tile] = TileType::DownStair; + self.take_snapshot(); + + // Now we build a noise map for use in spawning entities later + self.noise_areas = generate_voronoi_spawn_regions(&self.map, rng); + } +} diff --git a/src/rex_assets.rs b/src/rex_assets.rs index caca3fa..d0f749c 100644 --- a/src/rex_assets.rs +++ b/src/rex_assets.rs @@ -1,6 +1,8 @@ use rltk::rex::XpFile; rltk::embedded_resource!(CAVE_TUNNEL, "../resources/cave_tunnel80x60.xp"); +rltk::embedded_resource!(WFC_DEMO_IMAGE1, "../resources/wfc-demo1.xp"); +rltk::embedded_resource!(WFC_DEMO_IMAGE2, "../resources/wfc-demo2.xp"); pub struct RexAssets { pub menu: XpFile, @@ -10,6 +12,8 @@ impl RexAssets { #[allow(clippy::new_without_default)] pub fn new() -> RexAssets { rltk::link_resource!(CAVE_TUNNEL, "../resources/cave_tunnel80x60.xp"); + rltk::link_resource!(WFC_DEMO_IMAGE1, "../resources/wfc-demo1.xp"); + rltk::link_resource!(WFC_DEMO_IMAGE2, "../resources/wfc-demo2.xp"); RexAssets { menu: XpFile::from_resource("../resources/cave_tunnel80x60.xp").unwrap() } } diff --git a/src/spawner.rs b/src/spawner.rs index aa64b7c..97909ec 100644 --- a/src/spawner.rs +++ b/src/spawner.rs @@ -69,7 +69,7 @@ pub fn roll_hit_dice(ecs: &mut World, n: i32, d: i32) -> i32 { } // Consts -const MAX_ENTITIES: i32 = 4; +const MAX_ENTITIES: i32 = 2; #[allow(clippy::map_entry)] pub fn spawn_room(ecs: &mut World, room: &Rect, map_depth: i32) {