update with main branch

is slow

.vscode/launch.json

@@ -14,17 +14,12 @@
 			"args": [],
 			"cwd": "${workspaceRoot}/game/main",
 			"preLaunchTask": "Build",
-			"environment": [
+			// "environment": [
 			// 	{
 			// 		"name": "RUST_BACKTRACE",
 			// 		"value": "1"
-				// },
+			// 	}
-				{
+			// ]
-					//Set Asset Folder
-					"name": "CARGO_MANIFEST_DIR",
-					"value": "${workspaceRoot}\\game\\main"
-				}
-			]
 		}
 	]
 }

Cargo.toml

@@ -2,15 +2,10 @@
 resolver = "2"
 members = [
     "game/main",
-	"game/shared",
 	"game/buildings",
-	"game/units",
+	"game/shared",
-	"game/resources",
     "engine/world_generation",
-	"engine/asset_loader",
+	"engine/asset_loader", "game/buildings", "game/shared", "game/units", "engine/data"]
-	"engine/data",
-	"engine/hex",
-]
 
 # Enable a small amount of optimization in debug mode
 [profile.dev]

engine/asset_loader/Cargo.toml

@@ -3,11 +3,10 @@ name = "asset_loader"
 version = "0.1.0"
 edition = "2021"
 
-
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-serde = "1.0.228"
+serde = "1.0.204"
-serde_json = "1.0.149"
+serde_json = "1.0.120"
-bevy = "0.18.0"
+bevy = "0.14.0"
-ron = "0.12.0"
+ron = "0.8.1"

engine/asset_loader/src/lib.rs

@@ -1 +1,69 @@
-pub mod macros;
+pub mod macros {
+
+	#[macro_export]
+	macro_rules! create_asset_loader {
+		(
+			$plugin_name: ident,
+			$loader_name: ident,
+			$asset_type: ident,
+			$extensions: expr,
+			$($string_name: ident -> $handle_name: ident)* ;
+			$($string_array_name: ident -> $handle_array_name: ident)* ?
+		) => {
+			use bevy::prelude::*;
+			use bevy::asset::{AssetLoader, AssetEvent, AssetEvents, LoadContext, LoadState, AsyncReadExt, io::Reader};
+			use bevy::utils::BoxedFuture;
+			pub struct $plugin_name;
+			impl Plugin for $plugin_name {
+				fn build(&self, app: &mut App) {
+					app.init_asset::<$asset_type>()
+						.init_asset_loader::<$loader_name>();
+				}
+			}
+
+			#[derive(Default)]
+			pub struct $loader_name;
+
+			impl AssetLoader for $loader_name {
+				type Asset = $asset_type;
+
+				type Settings = ();
+
+				type Error = String;
+
+				async fn load<'a>(
+					&'a self,
+					reader: &'a mut Reader<'_>,
+					_settings: &'a Self::Settings,
+					load_context: &'a mut LoadContext<'_>,
+				) -> Result<Self::Asset, Self::Error> {
+					let mut bytes = Vec::new();
+					let read_result = reader.read_to_end(&mut bytes).await;
+					if read_result.is_err() {
+						return Err(read_result.err().unwrap().to_string());
+					}
+					let serialized: Result<Self::Asset, _> =
+						ron::de::from_bytes::<Self::Asset>(&bytes);
+					if serialized.is_err() {
+						return Err(serialized.err().unwrap().to_string());
+					}
+					let mut asset = serialized.unwrap();
+					$(
+
+						asset.$handle_name = load_context.load(&asset.$string_name);
+					)*
+					$(
+						for i in 0..asset.$string_array_name.len(){
+							asset.$handle_array_name.push(load_context.load(&asset.$string_array_name[i]));
+						}
+					)?
+					return Ok(asset);
+				}
+
+				fn extensions(&self) -> &[&str] {
+					$extensions
+				}
+			}
+		};
+	}
+}

engine/asset_loader/src/macros.rs

@@ -1,65 +0,0 @@
-#[macro_export]
-macro_rules! create_asset_loader {
-	(
-		$plugin_name: ident,
-		$loader_name: ident,
-		$asset_type: ident,
-		$extensions: expr,
-		$($string_name: ident -> $handle_name: ident)* ;
-		$($string_array_name: ident -> $handle_array_name: ident)* ?
-	) => {
-		use bevy::prelude::*;
-		use bevy::asset::{AssetLoader, AssetEvent,  LoadContext, LoadState, AsyncReadExt, io::Reader};
-		pub struct $plugin_name;
-		impl Plugin for $plugin_name {
-			fn build(&self, app: &mut App) {
-				app.init_asset::<$asset_type>()
-					.init_asset_loader::<$loader_name>();
-			}
-		}
-
-		#[derive(Default, TypePath)]
-		pub struct $loader_name;
-
-		impl AssetLoader for $loader_name {
-			type Asset = $asset_type;
-
-			type Settings = ();
-
-			type Error = String;
-
-			async fn load(
-		        &self,
-		        reader: &mut dyn bevy::asset::io::Reader,
-		        settings: &Self::Settings,
-		        load_context: &mut bevy::asset::LoadContext<'_>,
-		    ) -> Result<Self::Asset, Self::Error>{
-				let mut bytes = Vec::new();
-				let read_result = reader.read_to_end(&mut bytes).await;
-				if read_result.is_err() {
-					return Err(read_result.err().unwrap().to_string());
-				}
-				let serialized: Result<Self::Asset, _> =
-					ron::de::from_bytes::<Self::Asset>(&bytes);
-				if serialized.is_err() {
-					return Err(serialized.err().unwrap().to_string());
-				}
-				let mut asset = serialized.unwrap();
-				$(
-
-					asset.$handle_name = load_context.load(&asset.$string_name);
-				)*
-				$(
-					for i in 0..asset.$string_array_name.len(){
-						asset.$handle_array_name.push(load_context.load(&asset.$string_array_name[i]));
-					}
-				)?
-				return Ok(asset);
-			}
-
-			fn extensions(&self) -> &[&str] {
-				$extensions
-			}
-		}
-	};
-}

engine/hex/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "hex"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-bevy = "0.18.1"
-serde = { version = "1.0.228", features = ["derive"] }

engine/hex/src/lib.rs

@@ -1,17 +0,0 @@
-mod chunk;
-mod hex_coord;
-pub mod prelude
-{
-	pub use crate::chunk::*;
-	pub use crate::hex_coord::*;
-	pub use crate::*;
-}
-
-pub const OUTER_RADIUS: f32 = 1.;
-pub const INNER_RADIUS: f32 = OUTER_RADIUS * (SQRT_3 / 2.);
-pub const SHORT_DIAGONAL: f32 = 1. * SQRT_3;
-pub const LONG_DIAGONAL: f32 = 2. * OUTER_RADIUS;
-pub const SQRT_3: f32 = 1.7320508076;
-
-#[cfg(test)]
-mod tests;

engine/hex/src/tests.rs

@@ -1,7 +0,0 @@
-use super::prelude::*;
-
-#[test]
-fn create_coord()
-{
-	let coord = HexCoord::from_grid_pos(3, 3);
-}

engine/world_generation/Cargo.toml

@@ -6,21 +6,20 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.18.0"
+bevy = "0.14.0"
 noise = "0.9.0"
-serde = { version = "1.0.228", features = ["derive"] }
+serde = { version = "1.0.203", features = ["derive"] }
-serde_json = "1.0.149"
+serde_json = "1.0.115"
 asset_loader = { path = "../asset_loader" }
-rayon = "1.11.0"
+rayon = "1.10.0"
-bevy-inspector-egui = "0.36.0"
+bevy-inspector-egui = "0.25.0"
-bevy_asset_loader = { version = "0.25.0", features = [
+bevy_asset_loader = { version = "0.21.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }
-ron = "0.12.0"
+ron = "0.8.1"
-image = "0.25.9"
+image = "0.25.2"
 num = "0.4.3"
-hex = { path = "../hex" }
 
 [features]
 tracing = ["bevy/trace_tracy"]

engine/world_generation/src/consts.rs

@@ -1,7 +1,9 @@
-use bevy::{mesh::MeshVertexAttribute, prelude::*, render::render_resource::VertexFormat};
+use bevy::{
-use hex::{INNER_RADIUS, OUTER_RADIUS};
+	prelude::*,
+	render::{mesh::MeshVertexAttribute, render_resource::VertexFormat},
+};
 
-// use crate::hex_utils::{INNER_RADIUS, OUTER_RADIUS};
+use crate::hex_utils::{INNER_RADIUS, OUTER_RADIUS};
 
 pub const TEX_MULTI: Vec2 = Vec2::new(1000., 1.);
 
@@ -14,21 +16,6 @@ pub const HEX_CORNERS: [Vec3; 6] = [
 	Vec3::new(-INNER_RADIUS, 0., 0.5 * OUTER_RADIUS),
 ];
 
-pub const WATER_HEX_CORNERS: [Vec3; 12] = [
-	Vec3::new(0., 0., OUTER_RADIUS),
-	Vec3::new(INNER_RADIUS / 2.0, 0., 0.75 * OUTER_RADIUS),
-	Vec3::new(INNER_RADIUS, 0., 0.5 * OUTER_RADIUS),
-	Vec3::new(INNER_RADIUS, 0., 0.),
-	Vec3::new(INNER_RADIUS, 0., -0.5 * OUTER_RADIUS),
-	Vec3::new(INNER_RADIUS / 2.0, 0., -0.75 * OUTER_RADIUS),
-	Vec3::new(0., 0., -OUTER_RADIUS),
-	Vec3::new(-INNER_RADIUS / 2.0, 0., -0.75 * OUTER_RADIUS),
-	Vec3::new(-INNER_RADIUS, 0., -0.5 * OUTER_RADIUS),
-	Vec3::new(-INNER_RADIUS, 0., 0.),
-	Vec3::new(-INNER_RADIUS, 0., 0.5 * OUTER_RADIUS),
-	Vec3::new(-INNER_RADIUS / 2.0, 0., 0.75 * OUTER_RADIUS),
-];
-
 pub const HEX_NORMALS: [Vec3; 6] = [
 	Vec3::new(INNER_RADIUS / 2., 0., (OUTER_RADIUS + 0.5 * OUTER_RADIUS) / 2.),
 	Vec3::Z,
@@ -39,9 +26,9 @@ pub const HEX_NORMALS: [Vec3; 6] = [
 ];
 
 pub const ATTRIBUTE_PACKED_VERTEX_DATA: MeshVertexAttribute =
-	MeshVertexAttribute::new("PackedVertexData", 7, VertexFormat::Uint32);
+	MeshVertexAttribute::new("PackedVertexData", 988540817, VertexFormat::Uint32);
 pub const ATTRIBUTE_VERTEX_HEIGHT: MeshVertexAttribute =
-	MeshVertexAttribute::new("VertexHeight", 8, VertexFormat::Float32);
+	MeshVertexAttribute::new("VertexHeight", 988540717, VertexFormat::Float32);
 
 pub const ATTRIBUTE_TEXTURE_INDEX: MeshVertexAttribute =
 	MeshVertexAttribute::new("TextureIndex", 988540917, VertexFormat::Uint32);

engine/world_generation/src/generators/chunk_colliders.rs

@@ -1,22 +1,18 @@
-use crate::prelude::*;
+use crate::{hex_utils::*, prelude::*};
 #[cfg(feature = "tracing")]
 use bevy::log::*;
 use bevy::prelude::*;
-use hex::prelude::*;
 
 const CHUNK_TOTAL: usize = Chunk::SIZE * Chunk::SIZE;
 
-pub fn generate_chunk_collider(chunk: &MeshChunkData) -> (Vec<Vec3>, Vec<[u32; 3]>)
+pub fn generate_chunk_collider(chunk: &MeshChunkData) -> (Vec<Vec3>, Vec<[u32; 3]>) {
-{
 	#[cfg(feature = "tracing")]
 	let span = info_span!("generate_chunk_collider").entered();
 	let vertex_count: usize = CHUNK_TOTAL * 6;
 	let mut verts = Vec::with_capacity(vertex_count);
 	let mut indices = Vec::with_capacity(vertex_count);
-	for z in 0..Chunk::SIZE
+	for z in 0..Chunk::SIZE {
-	{
+		for x in 0..Chunk::SIZE {
-		for x in 0..Chunk::SIZE
-		{
 			let height = chunk.heights[x + z * Chunk::SIZE];
 			let coord = HexCoord::from_grid_pos(x, z);
 			let neighbors = chunk.get_neighbors(&coord);
@@ -28,11 +24,9 @@ pub fn generate_chunk_collider(chunk: &MeshChunkData) -> (Vec<Vec3>, Vec<[u32; 3
 	return (verts, indices);
 }
 
-fn create_tile_collider(pos: Vec3, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32; 3]>, neighbors: &[f32; 6])
+fn create_tile_collider(pos: Vec3, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32; 3]>, neighbors: &[f32; 6]) {
-{
 	let idx = verts.len() as u32;
-	for i in 0..6
+	for i in 0..6 {
-	{
 		let p = pos + HEX_CORNERS[i];
 		verts.push(p);
 	}
@@ -43,11 +37,9 @@ fn create_tile_collider(pos: Vec3, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32
 	indices.push([idx + 2, idx + 4, idx + 5]);
 	indices.push([idx + 2, idx + 3, idx + 4]);
 
-	for i in 0..neighbors.len()
+	for i in 0..neighbors.len() {
-	{
 		let n_height = neighbors[i];
-		if n_height < pos.y
+		if n_height < pos.y {
-		{
 			create_tile_wall_collider(
 				idx,
 				Vec3::new(pos.x, n_height.min(pos.y - OUTER_RADIUS / 2.), pos.z),
@@ -59,8 +51,7 @@ fn create_tile_collider(pos: Vec3, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32
 	}
 }
 
-fn create_tile_wall_collider(idx: u32, pos: Vec3, dir: usize, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32; 3]>)
+fn create_tile_wall_collider(idx: u32, pos: Vec3, dir: usize, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32; 3]>) {
-{
 	let idx2 = verts.len() as u32;
 
 	verts.push(pos + HEX_CORNERS[(dir) % 6]);

engine/world_generation/src/generators/mesh_generator.rs

@@ -1,13 +1,16 @@
-use crate::prelude::*;
+use crate::hex_utils::HexCoord;
-use bevy::asset::RenderAssetUsages;
+use crate::{hex_utils::offset3d_to_world, prelude::*};
 #[cfg(feature = "tracing")]
 use bevy::log::*;
-use bevy::mesh::{Indices, PrimitiveTopology};
+use bevy::{
-use bevy::prelude::*;
+	prelude::*,
-use hex::prelude::*;
+	render::{
+		mesh::{Indices, PrimitiveTopology},
+		render_asset::RenderAssetUsages,
+	},
+};
 
-pub fn generate_chunk_mesh(chunk: &MeshChunkData) -> Mesh
+pub fn generate_chunk_mesh(chunk: &MeshChunkData) -> Mesh {
-{
 	#[cfg(feature = "tracing")]
 	let span = info_span!("generate_chunk_mesh").entered();
 
@@ -17,10 +20,8 @@ pub fn generate_chunk_mesh(chunk: &MeshChunkData) -> Mesh
 	let mut indices = Vec::with_capacity(vertex_count);
 	let mut normals = Vec::with_capacity(vertex_count);
 
-	for z in 0..Chunk::SIZE
+	for z in 0..Chunk::SIZE {
-	{
+		for x in 0..Chunk::SIZE {
-		for x in 0..Chunk::SIZE
-		{
 			let idx = x + z * Chunk::SIZE;
 			let height = chunk.heights[idx];
 			let off_pos = Vec3::new(x as f32, height, z as f32);
@@ -62,23 +63,20 @@ fn create_tile(
 	normals: &mut Vec<Vec3>,
 	texture_index: u32,
 	side_texture_index: u32,
-)
+) {
-{
 	let uv_offset = Vec2::splat(0.5);
 	let tex_off = Vec2::new(texture_index as f32, 0.);
 	let side_tex_off = Vec2::new(side_texture_index as f32, 0.);
 
 	let idx = verts.len() as u32;
-	for i in 0..6
+	for i in 0..6 {
-	{
 		let p = pos + HEX_CORNERS[i];
 		verts.push(p);
 		let uv = (HEX_CORNERS[i].xz() / 2.) + uv_offset;
 		uvs.push((uv / TEX_MULTI) + tex_off);
 		normals.push(Vec3::Y);
 	}
-	for i in 0..3
+	for i in 0..3 {
-	{
 		let off = i * 2;
 		indices.push(off + idx);
 		indices.push(((off + 1) % 6) + idx);
@@ -88,178 +86,14 @@ fn create_tile(
 	indices.push(idx + 2);
 	indices.push(idx + 4);
 
-	for i in 0..neighbors.len()
+	for i in 0..neighbors.len() {
-	{
 		let n_height = neighbors[i];
-		if n_height < pos.y
+		if n_height < pos.y {
-		{
 			create_tile_wall(pos, i, n_height, verts, uvs, indices, normals, side_tex_off);
 		}
 	}
 }
 
-#[allow(unused)]
-pub fn generate_chunk_water_mesh(chunk: &MeshChunkData, sealevel: f32, map_width: usize, map_height: usize) -> Mesh
-{
-	#[cfg(feature = "tracing")]
-	let _gen_mesh = info_span!("Generate Water Surface Mesh").entered();
-	let vertex_count: usize = Chunk::SIZE * Chunk::SIZE * 7;
-	let mut verts = Vec::with_capacity(vertex_count);
-	let mut uvs = Vec::with_capacity(vertex_count);
-	let mut indices = Vec::with_capacity(vertex_count);
-	let mut normals = Vec::with_capacity(vertex_count);
-
-	for z in 0..Chunk::SIZE
-	{
-		for x in 0..Chunk::SIZE
-		{
-			let idx = x + z * Chunk::SIZE;
-			let height = chunk.heights[idx];
-			if height > sealevel
-			{
-				continue;
-			}
-			let off_pos = Vec3::new(x as f32, sealevel, z as f32);
-			let tile_pos = offset3d_to_world(off_pos);
-			let coord = HexCoord::from_grid_pos(x, z);
-			let (n, neighbor_has_land) = chunk.get_neighbors_with_water_info(&coord);
-
-			create_tile_water_surface(
-				tile_pos,
-				chunk.distance_to_land[idx],
-				&n,
-				neighbor_has_land,
-				&mut verts,
-				&mut uvs,
-				&mut indices,
-				&mut normals,
-			);
-		}
-	}
-	let mesh = Mesh::new(
-		PrimitiveTopology::TriangleList,
-		RenderAssetUsages::MAIN_WORLD | RenderAssetUsages::RENDER_WORLD,
-	)
-	.with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, verts)
-	.with_inserted_attribute(Mesh::ATTRIBUTE_UV_0, uvs)
-	.with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, normals)
-	.with_inserted_indices(Indices::U32(indices));
-	return mesh;
-}
-
-fn create_tile_water_surface(
-	pos: Vec3,
-	dist_to_land: f32,
-	neighbors: &[(f32, Option<f32>); 6],
-	neighbor_has_land: bool,
-	verts: &mut Vec<Vec3>,
-	uvs: &mut Vec<Vec2>,
-	indices: &mut Vec<u32>,
-	normals: &mut Vec<Vec3>,
-)
-{
-	if !neighbor_has_land
-	{
-		crate_tile_water_inner_surface(pos, dist_to_land, neighbors, verts, uvs, indices, normals);
-		return;
-	}
-	crate_tile_water_shore_surface(pos, dist_to_land, neighbors, verts, uvs, indices, normals);
-}
-
-fn crate_tile_water_inner_surface(
-	pos: Vec3,
-	dist_to_land: f32,
-	neighbors: &[(f32, Option<f32>); 6],
-	verts: &mut Vec<Vec3>,
-	uvs: &mut Vec<Vec2>,
-	indices: &mut Vec<u32>,
-	normals: &mut Vec<Vec3>,
-)
-{
-	//todo: share verts
-	let idx = verts.len() as u32;
-	for i in 0..6
-	{
-		let p = pos + HEX_CORNERS[i];
-		verts.push(p);
-		let n1 = if let Some(v) = neighbors[i].1 { v } else { dist_to_land };
-		let n2 = if let Some(v) = neighbors[(i + 5) % 6].1
-		{
-			v
-		}
-		else
-		{
-			dist_to_land
-		};
-		let d = (n1 + n2 + dist_to_land) / 3.0;
-		uvs.push(Vec2::new(0.0, d.remap(0., 4., 1.0, 0.0)));
-		normals.push(Vec3::Y);
-	}
-	for i in 0..3
-	{
-		let off = i * 2;
-		indices.push(off + idx);
-		indices.push(((off + 1) % 6) + idx);
-		indices.push(((off + 2) % 6) + idx);
-	}
-	indices.push(idx);
-	indices.push(idx + 2);
-	indices.push(idx + 4);
-}
-
-fn crate_tile_water_shore_surface(
-	pos: Vec3,
-	dist_to_land: f32,
-	neighbors: &[(f32, Option<f32>); 6],
-	verts: &mut Vec<Vec3>,
-	uvs: &mut Vec<Vec2>,
-	indices: &mut Vec<u32>,
-	normals: &mut Vec<Vec3>,
-)
-{
-	let idx = verts.len() as u32;
-	//todo: only use triangle fan when on shoreline
-	verts.push(pos);
-	uvs.push(Vec2::new(0.0, dist_to_land.remap(0., 4., 1.0, 0.0)));
-	normals.push(Vec3::Y);
-	for i in 0..12
-	{
-		let p = pos + WATER_HEX_CORNERS[i];
-		verts.push(p);
-		let ni = i / 2;
-		let n = neighbors[ni];
-		let nn = neighbors[(ni + 5) % 6];
-		let mut uv = Vec2::new(0.0, dist_to_land.remap(0., 4., 1.0, 0.0));
-
-		if nn.0 > pos.y || n.0 > pos.y
-		{
-			uv.x = 1.0;
-		}
-		if ni * 2 != i
-		{
-			if n.0 <= pos.y
-			{
-				uv.x = 0.0;
-			}
-			let d = if let Some(v) = n.1 { v } else { dist_to_land };
-			uv.y = ((d + dist_to_land) / 2.0).remap(0., 4., 1.0, 0.0);
-		}
-		else
-		{
-			let d = if let Some(v) = n.1 { v } else { dist_to_land };
-			let d2 = if let Some(v) = nn.1 { v } else { dist_to_land };
-			uv.y = ((d + d2 + dist_to_land) / 3.0).remap(0., 4., 1.0, 0.0);
-		}
-
-		indices.push(idx);
-		indices.push(idx + 1 + i as u32);
-		indices.push(idx + 1 + ((i as u32 + 1) % 12));
-
-		uvs.push(uv);
-		normals.push(Vec3::Y);
-	}
-}
-
 fn create_tile_wall(
 	pos: Vec3,
 	dir: usize,
@@ -269,8 +103,7 @@ fn create_tile_wall(
 	indices: &mut Vec<u32>,
 	normals: &mut Vec<Vec3>,
 	tex_off: Vec2,
-)
+) {
-{
 	let p1 = HEX_CORNERS[(dir) % 6] + pos;
 	let p2 = HEX_CORNERS[(dir + 1) % 6] + pos;
 	let p3 = Vec3::new(p1.x, height, p1.z);
@@ -304,14 +137,12 @@ fn create_tile_wall(
 }
 
 #[cfg(test)]
-mod tests
+mod tests {
-{
 
 	use super::*;
 
 	#[test]
-	fn generate_tile_wall()
+	fn generate_tile_wall() {
-	{
 		let mut verts = Vec::new();
 		let mut uvs = Vec::new();
 		let mut normals = Vec::new();
@@ -338,8 +169,7 @@ mod tests
 	}
 
 	#[test]
-	fn generate_tile()
+	fn generate_tile() {
-	{
 		let mut verts = Vec::new();
 		let mut uvs = Vec::new();
 		let mut normals = Vec::new();

engine/world_generation/src/generators/packed_mesh_generator.rs

@@ -1,26 +1,43 @@
+use crate::hex_utils::HexCoord;
+use crate::map::biome_map::{self, BiomeChunk, BiomeMap};
 use crate::prelude::*;
-use bevy::asset::RenderAssetUsages;
+use crate::tile_manager::TileAsset;
+use crate::tile_mapper::TileMapperAsset;
+use crate::{biome_asset::BiomeAsset, biome_painter::BiomePainterAsset};
 use bevy::{
-	mesh::{Indices, PrimitiveTopology},
 	prelude::*,
+	render::{
+		mesh::{Indices, PrimitiveTopology},
+		render_asset::RenderAssetUsages,
+	},
 };
-use hex::prelude::*;
 
-pub fn generate_packed_chunk_mesh(chunk: &MeshChunkData) -> Mesh
+pub fn generate_packed_chunk_mesh(
-{
+	chunk: &Chunk,
+	map: &Map,
+	biome_chunk: &BiomeChunk,
+	painter: &BiomePainterAsset,
+	tiles: &Res<Assets<TileAsset>>,
+	biomes: &Res<Assets<BiomeAsset>>,
+	mappers: &Res<Assets<TileMapperAsset>>,
+) -> Mesh {
 	let vertex_count: usize = Chunk::SIZE * Chunk::SIZE * 6;
 	let mut packed_data = Vec::with_capacity(vertex_count);
 	let mut indices = Vec::with_capacity(vertex_count);
 	let mut heights = Vec::with_capacity(vertex_count);
 
-	for z in 0..Chunk::SIZE
+	for z in 0..Chunk::SIZE {
-	{
+		for x in 0..Chunk::SIZE {
-		for x in 0..Chunk::SIZE
+			let height = chunk.heights[x + z * Chunk::SIZE];
-		{
+			let data = biome_chunk.data[x + z * Chunk::SIZE];
-			let idx = x + z * Chunk::SIZE;
+			let coord =
-			let height = chunk.heights[idx];
+				HexCoord::from_offset(IVec2::new(x as i32, z as i32) + (chunk.chunk_offset * Chunk::SIZE as i32));
-			let coord = HexCoord::from_grid_pos(x, z);
+			let n = map.get_neighbors(&coord);
-			let n = chunk.get_neighbors(&coord);
+			let biome = biomes.get(painter.sample_biome(biomes, &data)).unwrap();
+
+			let mapper = mappers.get(biome.tile_mapper.id());
+			let tile_handle = mapper.unwrap().sample_tile(height);
+			let tile = tiles.get(tile_handle).unwrap();
 
 			create_packed_tile(
 				UVec2::new(x as u32, z as u32),
@@ -29,8 +46,8 @@ pub fn generate_packed_chunk_mesh(chunk: &MeshChunkData) -> Mesh
 				&mut packed_data,
 				&mut indices,
 				&mut heights,
-				chunk.textures[idx][0],
+				tile.texture_id,
-				chunk.textures[idx][1],
+				tile.side_texture_id,
 			);
 		}
 	}
@@ -48,20 +65,18 @@ pub fn generate_packed_chunk_mesh(chunk: &MeshChunkData) -> Mesh
 fn create_packed_tile(
 	offset: UVec2,
 	height: f32,
-	neighbors: &[f32; 6],
+	neighbors: &[Option<f32>; 6],
 	packed_data: &mut Vec<u32>,
 	indices: &mut Vec<u32>,
 	heights: &mut Vec<f32>,
 	texture_index: u32,
 	side_texture_index: u32,
-)
+) {
-{
 	let idx = packed_data.len() as u32;
 
 	packed_data.push(pack_vertex_data(offset, 0, texture_index));
 	heights.push(height);
-	for i in 0..6
+	for i in 0..6 {
-	{
 		packed_data.push(pack_vertex_data(offset, i + 1, texture_index));
 		indices.push(idx);
 		indices.push(idx + 1 + i as u32);
@@ -69,11 +84,11 @@ fn create_packed_tile(
 		heights.push(height);
 	}
 
-	for i in 0..neighbors.len()
+	for i in 0..neighbors.len() {
-	{
+		let cur_n = neighbors[i];
-		let n_height = neighbors[i];
+		match cur_n {
-		if n_height < height
+			Some(n_height) => {
-		{
+				if n_height < height {
 					create_packed_tile_wall(
 						offset,
 						height,
@@ -86,6 +101,9 @@ fn create_packed_tile(
 					);
 				}
 			}
+			_ => {}
+		}
+	}
 }
 
 fn create_packed_tile_wall(
@@ -97,8 +115,7 @@ fn create_packed_tile_wall(
 	indices: &mut Vec<u32>,
 	heights: &mut Vec<f32>,
 	side_texture_index: u32,
-)
+) {
-{
 	let idx = packed_data.len() as u32;
 
 	let side_2 = ((side + 1) % 6) + 1;
@@ -121,8 +138,7 @@ fn create_packed_tile_wall(
 	indices.push(idx + 3);
 }
 
-fn pack_vertex_data(offset: UVec2, vert: usize, tex: u32) -> u32
+fn pack_vertex_data(offset: UVec2, vert: usize, tex: u32) -> u32 {
-{
 	//6 + 6 bits offset
 	//4 bits vert
 	//12 bits texture

engine/world_generation/src/heightmap.rs

@@ -3,16 +3,14 @@ use core::f32;
 use bevy::math::{IVec2, UVec2};
 use bevy::prelude::{FloatExt, Vec2};
 use bevy::utils::default;
-use hex::prelude::*;
 use noise::{NoiseFn, Simplex, SuperSimplex};
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 
 use crate::biome_painter::BiomePainter;
 use crate::map::biome_map::{BiomeChunk, BiomeData, BiomeMap};
-use crate::prelude::*;
+use crate::{map, prelude::*};
 
-pub fn generate_heightmap(cfg: &GenerationConfig, seed: u32, painter: &BiomePainter) -> (Map, BiomeMap)
+pub fn generate_heightmap(cfg: &GenerationConfig, seed: u32, painter: &BiomePainter) -> (Map, BiomeMap) {
-{
 	let biomes = generate_biomes(cfg, seed, painter);
 	let biomes_borrow = &biomes;
 	// let mut chunks: Vec<Chunk> = Vec::with_capacity(cfg.size.length_squared() as usize);
@@ -27,14 +25,11 @@ pub fn generate_heightmap(cfg: &GenerationConfig, seed: u32, painter: &BiomePain
 		.collect();
 	let mut min = f32::MAX;
 	let mut max = f32::MIN;
-	for chunk in &chunks
+	for chunk in &chunks {
-	{
+		if chunk.min_level < min {
-		if chunk.min_level < min
-		{
 			min = chunk.min_level;
 		}
-		if chunk.max_level > max
+		if chunk.max_level > max {
-		{
 			max = chunk.max_level;
 		}
 	}
@@ -44,7 +39,7 @@ pub fn generate_heightmap(cfg: &GenerationConfig, seed: u32, painter: &BiomePain
 			chunks,
 			height: cfg.size.y as usize,
 			width: cfg.size.x as usize,
-			sealevel: cfg.sea_level as f32,
+			sea_level: cfg.sea_level as f32,
 			min_level: min,
 			max_level: max,
 			biome_count: painter.biomes.len(),
@@ -53,8 +48,7 @@ pub fn generate_heightmap(cfg: &GenerationConfig, seed: u32, painter: &BiomePain
 	);
 }
 
-pub fn generate_biomes(cfg: &GenerationConfig, seed: u32, biome_painter: &BiomePainter) -> BiomeMap
+pub fn generate_biomes(cfg: &GenerationConfig, seed: u32, biome_painter: &BiomePainter) -> BiomeMap {
-{
 	let mut map = BiomeMap::new(cfg.size, biome_painter.biomes.len());
 	map.chunks = (0..cfg.size.y)
 		.into_par_iter()
@@ -74,8 +68,7 @@ pub fn generate_biome_chunk(
 	cfg: &GenerationConfig,
 	seed: u32,
 	biome_painter: &BiomePainter,
-) -> BiomeChunk
+) -> BiomeChunk {
-{
 	let mut chunk = BiomeChunk {
 		offset: UVec2::new(chunk_x as u32, chunk_y as u32),
 		data: [BiomeData::default(); Chunk::AREA],
@@ -85,10 +78,8 @@ pub fn generate_biome_chunk(
 	let noise_t = Simplex::new(seed + 2);
 	let noise_c = Simplex::new(seed + 3);
 
-	for z in 0..Chunk::SIZE
+	for z in 0..Chunk::SIZE {
-	{
+		for x in 0..Chunk::SIZE {
-		for x in 0..Chunk::SIZE
-		{
 			let moisture = sample_point(
 				x as f64 + chunk_x as f64 * Chunk::SIZE as f64,
 				z as f64 + chunk_y as f64 * Chunk::SIZE as f64,
@@ -132,16 +123,14 @@ pub fn generate_biome_chunk(
 	return chunk;
 }
 
-pub fn generate_noise_map(size: UVec2, seed: u32, cfg: &NoiseConfig, border_size: f32) -> Vec<f32>
+pub fn generate_noise_map(size: UVec2, seed: u32, cfg: &NoiseConfig, border_size: f32) -> Vec<f32> {
-{
 	let noise = SuperSimplex::new(seed);
 
 	let data: Vec<_> = (0..(size.y as usize * Chunk::SIZE))
 		.into_par_iter()
 		.flat_map(|y| {
 			let mut row = Vec::with_capacity(size.x as usize * Chunk::SIZE);
-			for x in 0..row.capacity()
+			for x in 0..row.capacity() {
-			{
 				row.push(sample_point(
 					x as f64,
 					y as f64,
@@ -165,26 +154,21 @@ pub fn generate_chunk(
 	seed: u32,
 	biome_chunk: &BiomeChunk,
 	biome_painter: &BiomePainter,
-) -> Chunk
+) -> Chunk {
-{
 	let mut result: [f32; Chunk::SIZE * Chunk::SIZE] = [0.; Chunk::AREA];
 	let mut data = [BiomeData::default(); Chunk::AREA];
 	let mut biome_ids = [0; Chunk::AREA];
 	let noise = Simplex::new(seed);
 	let mut min = f32::MAX;
 	let mut max = f32::MIN;
-	for z in 0..Chunk::SIZE
+	for z in 0..Chunk::SIZE {
-	{
+		for x in 0..Chunk::SIZE {
-		for x in 0..Chunk::SIZE
-		{
 			let biome_data = biome_chunk.get_biome_data(x, z);
 			let biome_blend = biome_chunk.get_biome(x, z);
 			let mut sample = 0.;
-			for i in 0..biome_blend.len()
+			for i in 0..biome_blend.len() {
-			{
 				let blend = biome_blend[i];
-				if blend == 0.
+				if blend == 0. {
-				{
 					continue;
 				}
 				let biome = &biome_painter.biomes[i];
@@ -201,12 +185,10 @@ pub fn generate_chunk(
 			let idx = x + z * Chunk::SIZE;
 			biome_ids[idx] = biome_chunk.get_biome_id_dithered(x, z, &noise, cfg.biome_dither);
 			result[idx] = sample;
-			if sample > max
+			if sample > max {
-			{
 				max = sample;
 			}
-			if sample < min
+			if sample < min {
-			{
 				min = sample;
 			}
 			data[idx] = biome_data.clone();
@@ -230,29 +212,23 @@ fn sample_point(
 	size: Vec2,
 	border_size: f32,
 	border_value: f32,
-) -> f32
+) -> f32 {
-{
 	let x_s = x / cfg.scale;
 	let z_s = z / cfg.scale;
 
 	let mut elevation: f64 = 0.;
-	for i in 0..cfg.layers.len()
+	for i in 0..cfg.layers.len() {
-	{
 		let value: f64;
 		let layer = &cfg.layers[i];
-		if layer.is_rigid
+		if layer.is_rigid {
-		{
 			value = sample_rigid(x_s, z_s, layer, noise);
-		}
+		} else {
-		else
-		{
 			value = sample_simple(x_s, z_s, layer, noise);
 		}
 		elevation += value;
 	}
 
-	if border_size == 0.0
+	if border_size == 0.0 {
-	{
 		return elevation as f32;
 	}
 
@@ -267,14 +243,12 @@ fn sample_point(
 	return border_value.lerp(elevation as f32, d);
 }
 
-fn sample_simple(x: f64, z: f64, cfg: &GeneratorLayer, noise: &impl NoiseFn<f64, 2>) -> f64
+fn sample_simple(x: f64, z: f64, cfg: &GeneratorLayer, noise: &impl NoiseFn<f64, 2>) -> f64 {
-{
 	let mut freq: f64 = cfg.base_roughness;
 	let mut amp: f64 = 1.;
 	let mut value = 0.;
 
-	for _ in 0..cfg.layers
+	for _ in 0..cfg.layers {
-	{
 		let v = noise.get([x * freq, z * freq]);
 		value += (v + 1.) * 0.5 * amp;
 		freq *= cfg.roughness;
@@ -283,14 +257,12 @@ fn sample_simple(x: f64, z: f64, cfg: &GeneratorLayer, noise: &impl NoiseFn<f64,
 	value -= cfg.min_value;
 	return value * cfg.strength;
 }
-fn sample_rigid(x: f64, z: f64, cfg: &GeneratorLayer, noise: &impl NoiseFn<f64, 2>) -> f64
+fn sample_rigid(x: f64, z: f64, cfg: &GeneratorLayer, noise: &impl NoiseFn<f64, 2>) -> f64 {
-{
 	let mut freq: f64 = cfg.base_roughness;
 	let mut amp: f64 = 1.;
 	let mut value = 0.;
 	let mut weight = 1.;
-	for _ in 0..cfg.layers
+	for _ in 0..cfg.layers {
-	{
 		let mut v = 1. - noise.get([x * freq, z * freq]).abs();
 		v *= v;
 		v *= weight;

engine/world_generation/src/hex_utils.rs

@@ -1,25 +1,28 @@
+use num::{PrimInt, Saturating};
 use std::fmt::Display;
 
+use crate::prelude::Chunk;
 use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use crate::{INNER_RADIUS, OUTER_RADIUS, chunk::Chunk};
+pub const OUTER_RADIUS: f32 = 1.;
+pub const INNER_RADIUS: f32 = OUTER_RADIUS * (SQRT_3 / 2.);
+pub const SHORT_DIAGONAL: f32 = 1. * SQRT_3;
+pub const LONG_DIAGONAL: f32 = 2. * OUTER_RADIUS;
+const SQRT_3: f32 = 1.7320508076;
 
-pub fn offset3d_to_world(offset: Vec3) -> Vec3
+pub fn offset3d_to_world(offset: Vec3) -> Vec3 {
-{
 	let x = (offset.x + (offset.z * 0.5) - (offset.z / 2.).floor()) * (INNER_RADIUS * 2.);
 	return Vec3::new(x, offset.y, offset.z * OUTER_RADIUS * 1.5);
 }
 
-pub fn offset_to_world(offset: IVec2, height: f32) -> Vec3
+pub fn offset_to_world(offset: IVec2, height: f32) -> Vec3 {
-{
 	let off = offset.as_vec2();
 	let x = (off.x + (off.y * 0.5) - (off.y / 2.).floor()) * (INNER_RADIUS * 2.);
 	return Vec3::new(x, height, off.y * OUTER_RADIUS * 1.5);
 }
 
-pub fn offset_to_hex(offset: IVec2) -> IVec3
+pub fn offset_to_hex(offset: IVec2) -> IVec3 {
-{
 	let mut v = IVec3 {
 		x: offset.x - (offset.y / 2),
 		y: offset.y,
@@ -29,18 +32,15 @@ pub fn offset_to_hex(offset: IVec2) -> IVec3
 	return v;
 }
 
-pub fn offset_to_index(offset: IVec2, width: usize) -> usize
+pub fn offset_to_index(offset: IVec2, width: usize) -> usize {
-{
 	return offset.x as usize + offset.y as usize * width;
 }
 
-pub fn snap_to_hex_grid(world_pos: Vec3) -> Vec3
+pub fn snap_to_hex_grid(world_pos: Vec3) -> Vec3 {
-{
 	return offset_to_world(world_to_offset_pos(world_pos), world_pos.y);
 }
 
-pub fn world_to_offset_pos(world_pos: Vec3) -> IVec2
+pub fn world_to_offset_pos(world_pos: Vec3) -> IVec2 {
-{
 	let offset = world_pos.z / (OUTER_RADIUS * 3.);
 	let x = (world_pos.x / (INNER_RADIUS * 2.)) - offset;
 	let z = -world_pos.x - offset;
@@ -52,32 +52,26 @@ pub fn world_to_offset_pos(world_pos: Vec3) -> IVec2
 	return IVec2::new(ox, oz);
 }
 
-pub fn tile_to_world_distance(dist: u32) -> f32
+pub fn tile_to_world_distance(dist: u32) -> f32 {
-{
 	return dist as f32 * (2. * INNER_RADIUS);
 }
 
-pub fn get_tile_count_in_range(radius: usize) -> usize
+pub fn get_tile_count(radius: usize) -> usize {
-{
 	return 1 + 3 * (radius + 1) * radius;
 }
 
-#[derive(Default, Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize, Hash)]
+#[derive(Default, Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize)]
-pub struct HexCoord
+pub struct HexCoord {
-{
 	pub hex: IVec3,
 }
 
-impl Display for HexCoord
+impl Display for HexCoord {
-{
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
-	{
 		f.write_fmt(format_args!("HexCoord{}", self.hex))
 	}
 }
 
-impl HexCoord
+impl HexCoord {
-{
 	pub const DIRECTIONS: [IVec3; 6] = [
 		IVec3::new(0, 1, -1),
 		IVec3::new(1, 0, -1),
@@ -89,33 +83,27 @@ impl HexCoord
 
 	pub const ZERO: HexCoord = HexCoord { hex: IVec3::ZERO };
 
-	pub fn new(x: i32, z: i32) -> Self
+	pub fn new(x: i32, z: i32) -> Self {
-	{
 		return HexCoord {
 			hex: IVec3::new(x, z, -x - z),
 		};
 	}
 
-	pub fn from_axial(hex: IVec2) -> Self
+	pub fn from_hex(hex: IVec2) -> Self {
-	{
 		return HexCoord {
 			hex: IVec3::new(hex.x, hex.y, -hex.x - hex.y),
 		};
 	}
-
+	pub fn from_grid_pos(x: usize, z: usize) -> Self {
-	pub fn from_grid_pos(x: usize, z: usize) -> Self
-	{
 		return HexCoord::new(x as i32 - (z as i32 / 2), z as i32);
 	}
-	pub fn from_offset(offset_pos: IVec2) -> Self
+	pub fn from_offset(offset_pos: IVec2) -> Self {
-	{
 		return HexCoord {
 			hex: offset_to_hex(offset_pos),
 		};
 	}
 
-	pub fn from_world_pos(world_pos: Vec3) -> Self
+	pub fn from_world_pos(world_pos: Vec3) -> Self {
-	{
 		let offset = world_pos.z / (OUTER_RADIUS * 3.);
 		let mut x = world_pos.x / (INNER_RADIUS * 2.);
 		let mut z = -x;
@@ -129,31 +117,26 @@ impl HexCoord
 		return Self::from_offset(offset_pos);
 	}
 
-	pub fn is_in_bounds(&self, map_height: usize, map_width: usize) -> bool
+	pub fn is_in_bounds(&self, map_height: usize, map_width: usize) -> bool {
-	{
 		let off = self.to_offset();
-		if off.x < 0 || off.y < 0
+		if off.x < 0 || off.y < 0 {
-		{
 			return false;
 		}
 
-		if off.x >= map_width as i32 || off.y >= map_height as i32
+		if off.x >= map_width as i32 || off.y >= map_height as i32 {
-		{
 			return false;
 		}
 
 		return true;
 	}
 
-	pub fn is_on_chunk_edge(&self) -> bool
+	pub fn is_on_chunk_edge(&self) -> bool {
-	{
 		let offset = self.to_offset().rem_euclid(IVec2::splat(Chunk::SIZE as i32));
 		let e = (Chunk::SIZE - 1) as i32;
 		return offset.x == 0 || offset.y == 0 || offset.x == e || offset.y == e;
 	}
 
-	pub fn to_chunk_pos(&self) -> IVec2
+	pub fn to_chunk_pos(&self) -> IVec2 {
-	{
 		let off = self.to_offset();
 
 		return IVec2 {
@@ -163,8 +146,7 @@ impl HexCoord
 	}
 
 	/// Converts this coordinate to it's chunk local equivalent
-	pub fn to_chunk(&self) -> HexCoord
+	pub fn to_chunk(&self) -> HexCoord {
-	{
 		let c_pos = self.to_chunk_pos();
 		let off = self.to_offset();
 		return HexCoord::from_offset(
@@ -176,94 +158,76 @@ impl HexCoord
 		);
 	}
 
-	pub fn to_world(&self, height: f32) -> Vec3
+	pub fn to_world(&self, height: f32) -> Vec3 {
-	{
 		return offset_to_world(self.to_offset(), height);
 	}
 
-	pub fn to_offset(&self) -> IVec2
+	pub fn to_offset(&self) -> IVec2 {
-	{
 		return IVec2::new(self.hex.x + (self.hex.y / 2), self.hex.y);
 	}
 
 	/// Convert the current coordiante to an index
-	pub fn to_index(&self, width: usize) -> usize
+	pub fn to_index(&self, width: usize) -> usize {
-	{
 		return ((self.hex.x + self.hex.y * width as i32) + (self.hex.y / 2)) as usize;
 	}
 
 	/// Gets the index of this coord in the chunk array.
 	///
 	/// [`width`] is in number of chunks
-	pub fn to_chunk_index(&self, width: usize) -> usize
+	pub fn to_chunk_index(&self, width: usize) -> usize {
-	{
 		let pos = self.to_chunk_pos();
 		return (pos.x + pos.y * width as i32) as usize;
 	}
 
 	/// Gets the index of this tile in the chunk
-	pub fn to_chunk_local_index(&self) -> usize
+	pub fn to_chunk_local_index(&self) -> usize {
-	{
 		return self.to_chunk().to_index(Chunk::SIZE);
 	}
 
-	pub fn distance(&self, other: &HexCoord) -> i32
+	pub fn distance(&self, other: &HexCoord) -> i32 {
-	{
 		return (self.hex.x - other.hex.x).abs() + (self.hex.y - other.hex.y).abs() + (self.hex.z - other.hex.z).abs();
 	}
 
-	pub fn rotate_around(&self, center: &HexCoord, angle: i32) -> HexCoord
+	pub fn rotate_around(&self, center: &HexCoord, angle: i32) -> HexCoord {
-	{
+		if self == center || angle == 0 {
-		if self == center || angle == 0
-		{
 			return self.clone();
 		}
 
 		let mut a = angle % 6;
 		let mut pc = self.hex - center.hex;
 
-		if a > 0
+		if a > 0 {
-		{
+			for _ in 0..a {
-			for _ in 0..a
-			{
 				pc = Self::slide_right(pc);
 			}
-		}
+		} else {
-		else
-		{
 			a = a.abs();
-			for _ in 0..a
+			for _ in 0..a {
-			{
 				pc = Self::slide_left(pc);
 			}
 		}
-		return HexCoord::from_axial(pc.xy() + center.hex.xy());
+		return HexCoord::from_hex(pc.xy() + center.hex.xy());
 	}
 
-	fn slide_left(hex: IVec3) -> IVec3
+	fn slide_left(hex: IVec3) -> IVec3 {
-	{
 		return (hex * -1).yzx();
 	}
 
-	fn slide_right(hex: IVec3) -> IVec3
+	fn slide_right(hex: IVec3) -> IVec3 {
-	{
 		return (hex * -1).zxy();
 	}
 
-	pub fn scale(&self, dir: i32, radius: usize) -> HexCoord
+	pub fn scale(&self, dir: i32, radius: usize) -> HexCoord {
-	{
 		let s = Self::DIRECTIONS[(dir % 6) as usize] * radius as i32;
-		return Self::from_axial(self.hex.xy() + s.xy());
+		return Self::from_hex(self.hex.xy() + s.xy());
 	}
 
-	pub fn get_neighbor(&self, dir: usize) -> HexCoord
+	pub fn get_neighbor(&self, dir: usize) -> HexCoord {
-	{
 		let d = Self::DIRECTIONS[dir % 6];
-		return Self::from_axial(self.hex.xy() + d.xy());
+		return Self::from_hex(self.hex.xy() + d.xy());
 	}
 
-	pub fn get_neighbors(&self) -> [HexCoord; 6]
+	pub fn get_neighbors(&self) -> [HexCoord; 6] {
-	{
 		return [
 			self.get_neighbor(0),
 			self.get_neighbor(1),
@@ -274,23 +238,18 @@ impl HexCoord
 		];
 	}
 
-	pub fn hex_select(&self, radius: usize, include_center: bool) -> Vec<HexCoord>
+	pub fn hex_select(&self, radius: usize, include_center: bool) -> Vec<HexCoord> {
-	{
 		assert!(radius != 0, "Radius cannot be zero");
-		let mut result = Vec::with_capacity(get_tile_count_in_range(radius));
+		let mut result = Vec::with_capacity(get_tile_count(radius));
 
-		if include_center
+		if include_center {
-		{
 			result.push(*self);
 		}
 
-		for k in 0..(radius + 1)
+		for k in 0..(radius + 1) {
-		{
 			let mut p = self.scale(4, k);
-			for i in 0..6
+			for i in 0..6 {
-			{
+				for _j in 0..k {
-				for _j in 0..k
-				{
 					p = p.get_neighbor(i);
 					result.push(p);
 				}
@@ -300,30 +259,28 @@ impl HexCoord
 		return result;
 	}
 
-	pub fn hex_select_bounded(&self, radius: usize, include_center: bool, height: usize, width: usize)
+	pub fn hex_select_bounded(
-	-> Vec<HexCoord>
+		&self,
-	{
+		radius: usize,
+		include_center: bool,
+		height: usize,
+		width: usize,
+	) -> Vec<HexCoord> {
 		assert!(radius != 0, "Radius cannot be zero");
-		let mut result = Vec::with_capacity(get_tile_count_in_range(radius));
+		let mut result = Vec::with_capacity(get_tile_count(radius));
 
-		if include_center
+		if include_center {
-		{
+			if self.is_in_bounds(height, width) {
-			if self.is_in_bounds(height, width)
-			{
 				result.push(*self);
 			}
 		}
 
-		for k in 0..(radius + 1)
+		for k in 0..(radius + 1) {
-		{
 			let mut p = self.scale(4, k);
-			for i in 0..6
+			for i in 0..6 {
-			{
+				for _j in 0..k {
-				for _j in 0..k
-				{
 					p = p.get_neighbor(i);
-					if p.is_in_bounds(height, width)
+					if p.is_in_bounds(height, width) {
-					{
 						result.push(p);
 					}
 				}
@@ -333,22 +290,19 @@ impl HexCoord
 		return result;
 	}
 
-	pub fn select_ring(&self, radius: usize) -> Vec<HexCoord>
+	pub fn select_ring(&self, radius: usize) -> Vec<HexCoord> {
-	{
 		assert!(radius != 0, "Radius cannot be zero");
 		let mut result = Vec::with_capacity(radius * 6);
 
 		let mut p = self.scale(4, radius);
 
-		// if radius == 1 {
+		if radius == 1 {
-		// 	result.push(*self);
+			result.push(*self);
-		// 	return result;
+			return result;
-		// }
+		}
 
-		for i in 0..6
+		for i in 0..6 {
-		{
+			for _j in 0..radius {
-			for _j in 0..radius
-			{
 				result.push(p);
 				p = p.get_neighbor(i);
 			}

engine/world_generation/src/lib.rs

@@ -1,10 +1,11 @@
-pub mod biome_asset;
 pub mod biome_painter;
 pub mod consts;
 pub mod generators;
 pub mod heightmap;
+pub mod hex_utils;
 pub mod map;
 pub mod prelude;
 pub mod states;
 pub mod tile_manager;
 pub mod tile_mapper;
+pub mod biome_asset;

engine/world_generation/src/map/biome_map.rs

@@ -5,11 +5,10 @@ use bevy::{
 use noise::NoiseFn;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 
-use hex::prelude::*;
+use super::chunk::Chunk;
 
 #[derive(Clone, Resource)]
-pub struct BiomeMap
+pub struct BiomeMap {
-{
 	pub height: usize,
 	pub width: usize,
 	pub size: UVec2,
@@ -18,33 +17,26 @@ pub struct BiomeMap
 }
 
 #[derive(Default, Clone, Copy)]
-pub struct BiomeData
+pub struct BiomeData {
-{
 	pub moisture: f32,
 	pub temperature: f32,
 	pub continentality: f32,
 }
 
-impl Into<Vec3> for &BiomeData
+impl Into<Vec3> for &BiomeData {
-{
+	fn into(self) -> Vec3 {
-	fn into(self) -> Vec3
-	{
 		return Vec3::new(self.moisture, self.temperature, self.continentality);
 	}
 }
 
-impl Into<Vec3> for BiomeData
+impl Into<Vec3> for BiomeData {
-{
+	fn into(self) -> Vec3 {
-	fn into(self) -> Vec3
-	{
 		return Vec3::new(self.moisture, self.temperature, self.continentality);
 	}
 }
 
-impl BiomeMap
+impl BiomeMap {
-{
+	pub fn new(size: UVec2, biome_count: usize) -> Self {
-	pub fn new(size: UVec2, biome_count: usize) -> Self
-	{
 		let len = size.x as usize * size.y as usize * Chunk::AREA;
 		return BiomeMap {
 			size,
@@ -55,17 +47,14 @@ impl BiomeMap
 		};
 	}
 
-	pub fn blend(&mut self, count: usize)
+	pub fn blend(&mut self, count: usize) {
-	{
 		assert!(count != 0, "Count cannot be 0");
-		for _ in 0..count
+		for _ in 0..count {
-		{
 			self.blend_once();
 		}
 	}
 
-	fn blend_once(&mut self)
+	fn blend_once(&mut self) {
-	{
 		let c: Vec<BiomeChunk> = (0..self.chunks.len())
 			.into_par_iter()
 			.map(|i| &self.chunks[i])
@@ -74,8 +63,7 @@ impl BiomeMap
 					.into_par_iter()
 					.map(|y| {
 						let mut new_tiles = Vec::with_capacity(self.width);
-						for x in 0..Chunk::SIZE
+						for x in 0..Chunk::SIZE {
-						{
 							let tx = x as u32 + chunk.offset.x * Chunk::SIZE as u32;
 							let ty = y as u32 + chunk.offset.y * Chunk::SIZE as u32;
 							let kernel = self.get_kernel(tx as i32, ty as i32);
@@ -88,8 +76,7 @@ impl BiomeMap
 								});
 
 							let sum: f32 = r.iter().sum();
-							if sum == 0.
+							if sum == 0. {
-							{
 								new_tiles.push(vec![0.; self.biome_count]);
 								continue;
 							}
@@ -109,8 +96,7 @@ impl BiomeMap
 		self.chunks = c;
 	}
 
-	fn get_kernel(&self, x: i32, y: i32) -> [Option<&Vec<f32>>; 9]
+	fn get_kernel(&self, x: i32, y: i32) -> [Option<&Vec<f32>>; 9] {
-	{
 		return [
 			self.get_biome(x - 1, y - 1),
 			self.get_biome(x, y - 1),
@@ -124,14 +110,11 @@ impl BiomeMap
 		];
 	}
 
-	pub fn get_biome(&self, x: i32, y: i32) -> Option<&Vec<f32>>
+	pub fn get_biome(&self, x: i32, y: i32) -> Option<&Vec<f32>> {
-	{
+		if x < 0 || y < 0 {
-		if x < 0 || y < 0
-		{
 			return None;
 		}
-		if x >= self.width as i32 || y >= self.height as i32
+		if x >= self.width as i32 || y >= self.height as i32 {
-		{
 			return None;
 		}
 
@@ -142,8 +125,7 @@ impl BiomeMap
 		return Some(chunk.get_biome(x as usize - cx * Chunk::SIZE, y as usize - cy * Chunk::SIZE));
 	}
 
-	pub fn get_biome_id(&self, x: usize, y: usize) -> usize
+	pub fn get_biome_id(&self, x: usize, y: usize) -> usize {
-	{
 		let cx = (x as f32 / Chunk::SIZE as f32).floor() as usize;
 		let cy = (y as f32 / Chunk::SIZE as f32).floor() as usize;
 
@@ -152,8 +134,7 @@ impl BiomeMap
 		return chunk.get_biome_id(x - (cx * Chunk::SIZE), y - (cy * Chunk::SIZE));
 	}
 
-	pub fn get_biome_id_dithered(&self, x: usize, y: usize, noise: &impl NoiseFn<f64, 2>, scale: f64) -> usize
+	pub fn get_biome_id_dithered(&self, x: usize, y: usize, noise: &impl NoiseFn<f64, 2>, scale: f64) -> usize {
-	{
 		let cx = (x as f32 / Chunk::SIZE as f32).floor() as usize;
 		let cy = (y as f32 / Chunk::SIZE as f32).floor() as usize;
 
@@ -162,8 +143,7 @@ impl BiomeMap
 		return chunk.get_biome_id_dithered(x - (cx * Chunk::SIZE), y - (cy * Chunk::SIZE), noise, scale);
 	}
 
-	pub fn get_biome_data(&self, x: usize, y: usize) -> &BiomeData
+	pub fn get_biome_data(&self, x: usize, y: usize) -> &BiomeData {
-	{
 		let cx = (x as f32 / Chunk::SIZE as f32).floor() as usize;
 		let cy = (y as f32 / Chunk::SIZE as f32).floor() as usize;
 
@@ -174,35 +154,28 @@ impl BiomeMap
 }
 
 #[derive(Clone)]
-pub struct BiomeChunk
+pub struct BiomeChunk {
-{
 	pub tiles: Vec<Vec<f32>>,
 	pub offset: UVec2,
 	pub data: [BiomeData; Chunk::AREA],
 }
 
-impl BiomeChunk
+impl BiomeChunk {
-{
+	pub fn get_biome(&self, x: usize, y: usize) -> &Vec<f32> {
-	pub fn get_biome(&self, x: usize, y: usize) -> &Vec<f32>
-	{
 		return &self.tiles[x + y * Chunk::SIZE];
 	}
 
-	pub fn get_biome_data(&self, x: usize, y: usize) -> &BiomeData
+	pub fn get_biome_data(&self, x: usize, y: usize) -> &BiomeData {
-	{
 		return &self.data[x + y * Chunk::SIZE];
 	}
 
-	pub fn get_biome_id(&self, x: usize, y: usize) -> usize
+	pub fn get_biome_id(&self, x: usize, y: usize) -> usize {
-	{
 		let b = self.get_biome(x, y);
 		let mut max = 0.;
 		let mut idx = 0;
-		for i in 0..b.len()
+		for i in 0..b.len() {
-		{
 			let blend = b[i];
-			if blend > max
+			if blend > max {
-			{
 				max = blend;
 				idx = i;
 			}
@@ -210,21 +183,17 @@ impl BiomeChunk
 		return idx;
 	}
 
-	pub fn get_biome_id_dithered(&self, x: usize, y: usize, noise: &impl NoiseFn<f64, 2>, scale: f64) -> usize
+	pub fn get_biome_id_dithered(&self, x: usize, y: usize, noise: &impl NoiseFn<f64, 2>, scale: f64) -> usize {
-	{
 		let mut cur_id = self.get_biome_id(x, y);
 		let b = self.get_biome(x, y);
 		let n = (noise.get([x as f64 / scale, y as f64 / scale]) as f32 - 0.5)/ 2.0;
 		let mut max = b[cur_id] + n;
-		for i in 0..b.len()
+		for i in 0..b.len() {
-		{
 			let blend = b[i];
-			if blend == 0.
+			if blend == 0. {
-			{
 				continue;
 			}
-			if blend > max
+			if blend > max {
-			{
 				max = blend + n;
 				cur_id = i;
 			}
@@ -235,22 +204,18 @@ impl BiomeChunk
 }
 
 #[cfg(test)]
-mod tests
+mod tests {
-{
 
 	use super::*;
 
 	#[test]
-	fn biome_blend()
+	fn biome_blend() {
-	{
 		let mut biome = BiomeMap::new(UVec2::splat(4), 8);
 		let w = biome.size.x as usize;
 		let h = biome.size.y as usize;
 
-		for y in 0..h
+		for y in 0..h {
-		{
+			for x in 0..w {
-			for x in 0..w
-			{
 				let mut b = vec![0.; biome.biome_count];
 				let idx = (x + y) % biome.biome_count;
 				b[idx] = 1.;
@@ -262,8 +227,7 @@ mod tests
 		assert!(biome.chunks.iter().all(|f| f.tiles.len() == Chunk::AREA), "Data Lost");
 	}
 
-	fn generate_chunk(x: usize, y: usize, biome: Vec<f32>) -> BiomeChunk
+	fn generate_chunk(x: usize, y: usize, biome: Vec<f32>) -> BiomeChunk {
-	{
 		let chunk = BiomeChunk {
 			offset: UVec2::new(x as u32, y as u32),
 			data: [BiomeData::default(); Chunk::AREA],

engine/world_generation/src/map/chunk.rs

@@ -1,9 +1,10 @@
-use crate::SHORT_DIAGONAL;
+use crate::hex_utils::SHORT_DIAGONAL;
 use bevy::prelude::*;
 
+use super::biome_map::BiomeData;
+
 #[derive(Clone)]
-pub struct Chunk
+pub struct Chunk {
-{
 	pub heights: [f32; Chunk::AREA],
 	pub textures: [[u32; 2]; Chunk::AREA],
 	// pub biome_data: [BiomeData; Chunk::AREA],
@@ -13,10 +14,8 @@ pub struct Chunk
 	pub max_level: f32,
 }
 
-impl Default for Chunk
+impl Default for Chunk {
-{
+	fn default() -> Self {
-	fn default() -> Self
-	{
 		Self {
 			heights: [0.; Chunk::AREA],
 			textures: [[0; 2]; Chunk::AREA],
@@ -29,20 +28,17 @@ impl Default for Chunk
 	}
 }
 
-impl Chunk
+impl Chunk {
-{
 	pub const SIZE: usize = 64;
 	pub const AREA: usize = Chunk::SIZE * Chunk::SIZE;
 	pub const WORLD_WIDTH: f32 = Chunk::SIZE as f32 * SHORT_DIAGONAL;
 	pub const WORLD_HEIGHT: f32 = Chunk::SIZE as f32 * 1.5;
 	pub const WORLD_SIZE: Vec2 = Vec2::new(Chunk::WORLD_WIDTH, Chunk::WORLD_HEIGHT);
 
-	pub fn get_pos_z_edge(&self) -> [f32; Chunk::SIZE]
+	pub fn get_pos_z_edge(&self) -> [f32; Chunk::SIZE] {
-	{
 		let mut data = [0.; Chunk::SIZE];
 
-		for x in 0..Chunk::SIZE
+		for x in 0..Chunk::SIZE {
-		{
 			let idx = x + (Chunk::SIZE - 1) * Chunk::SIZE;
 			data[x] = self.heights[idx];
 		}
@@ -50,24 +46,20 @@ impl Chunk
 		return data;
 	}
 
-	pub fn get_neg_z_edge(&self) -> [f32; Chunk::SIZE]
+	pub fn get_neg_z_edge(&self) -> [f32; Chunk::SIZE] {
-	{
 		let mut data = [0.; Chunk::SIZE];
 
-		for x in 0..Chunk::SIZE
+		for x in 0..Chunk::SIZE {
-		{
 			data[x] = self.heights[x];
 		}
 
 		return data;
 	}
 
-	pub fn get_pos_x_edge(&self) -> [f32; Chunk::SIZE]
+	pub fn get_pos_x_edge(&self) -> [f32; Chunk::SIZE] {
-	{
 		let mut data = [0.; Chunk::SIZE];
 
-		for z in 0..Chunk::SIZE
+		for z in 0..Chunk::SIZE {
-		{
 			let idx = (Chunk::SIZE - 1) + z * Chunk::SIZE;
 			data[z] = self.heights[idx];
 		}
@@ -75,12 +67,10 @@ impl Chunk
 		return data;
 	}
 
-	pub fn get_neg_x_edge(&self) -> [f32; Chunk::SIZE]
+	pub fn get_neg_x_edge(&self) -> [f32; Chunk::SIZE] {
-	{
 		let mut data = [0.; Chunk::SIZE];
 
-		for z in 0..Chunk::SIZE
+		for z in 0..Chunk::SIZE {
-		{
 			let idx = z * Chunk::SIZE;
 			data[z] = self.heights[idx];
 		}

engine/world_generation/src/map/config.rs

@@ -1,13 +1,13 @@
 use bevy::prelude::*;
+use bevy_asset_loader::asset_collection::AssetCollection;
 use bevy_inspector_egui::InspectorOptions;
 use serde::{Deserialize, Serialize};
 
-use hex::prelude::*;
+use super::chunk::Chunk;
 
 #[derive(Resource, Reflect, Default, Clone)]
 #[reflect(Resource)]
-pub struct GenerationConfig
+pub struct GenerationConfig {
-{
 	pub sea_level: f64,
 	pub border_size: f32,
 	pub biome_blend: usize,
@@ -18,28 +18,23 @@ pub struct GenerationConfig
 	pub size: UVec2,
 }
 
-impl GenerationConfig
+impl GenerationConfig {
-{
+	pub fn get_total_width(&self) -> usize {
-	pub fn get_total_width(&self) -> usize
-	{
 		return self.size.x as usize * Chunk::SIZE;
 	}
-	pub fn get_total_height(&self) -> usize
+	pub fn get_total_height(&self) -> usize {
-	{
 		return self.size.y as usize * Chunk::SIZE;
 	}
 }
 
 #[derive(Serialize, Deserialize, Default, Reflect, Clone, Debug)]
-pub struct NoiseConfig
+pub struct NoiseConfig {
-{
 	pub scale: f64,
 	pub layers: Vec<GeneratorLayer>,
 }
 
 #[derive(Reflect, InspectorOptions, Serialize, Deserialize, Debug, Clone, Default)]
-pub struct GeneratorLayer
+pub struct GeneratorLayer {
-{
 	pub strength: f64,
 	pub min_value: f64,
 	pub base_roughness: f64,

engine/world_generation/src/map/map.rs

@@ -1,109 +1,45 @@
 use bevy::prelude::*;
-use hex::prelude::*;
 
-use super::mesh_chunk::MeshChunkData;
+use crate::hex_utils::*;
+
+use super::{
+	biome_map::{BiomeData, BiomeMap},
+	chunk::Chunk,
+	mesh_chunk::MeshChunkData,
+};
 
 #[derive(Resource, Clone)]
-pub struct Map
+pub struct Map {
-{
 	pub chunks: Vec<Chunk>,
 	pub height: usize,
 	pub width: usize,
-	pub sealevel: f32,
+	pub sea_level: f32,
 	pub min_level: f32,
 	pub max_level: f32,
 	pub biome_count: usize,
 }
 
-impl Map
+impl Map {
-{
+	pub fn get_chunk_mesh_data(&self, chunk_index: usize) -> MeshChunkData {
-	pub fn get_tile_count(&self) -> usize
-	{
-		return self.get_tile_width() * self.get_tile_height();
-	}
-
-	pub fn get_tile_width(&self) -> usize
-	{
-		return self.width * Chunk::SIZE;
-	}
-
-	pub fn get_tile_height(&self) -> usize
-	{
-		return self.height * Chunk::SIZE;
-	}
-
-	pub fn get_chunk_mesh_data(&self, chunk_index: usize) -> MeshChunkData
-	{
 		#[cfg(feature = "tracing")]
 		let _spawn_span = info_span!("Chunk Mesh Data").entered();
 		let chunk = &self.chunks[chunk_index];
 
 		return MeshChunkData {
 			min_height: self.min_level,
-			sealevel: self.sealevel,
 			heights: chunk.heights.clone(),
 			textures: chunk.textures.clone(),
-			distance_to_land: self.get_distance_from_land(chunk.chunk_offset, 4),
 		};
 	}
 
-	fn get_distance_from_land(&self, chunk_offset: IVec2, range: usize) -> [f32; Chunk::AREA]
+	pub fn get_neighbors(&self, pos: &HexCoord) -> [Option<f32>; 6] {
-	{
-		#[cfg(feature = "tracing")]
-		let _spawn_span = info_span!("Chunk Land Dist Data").entered();
-		let mut dists = [0.0; Chunk::AREA];
-		let cx = chunk_offset.x as usize * Chunk::SIZE;
-		let cz = chunk_offset.y as usize * Chunk::SIZE;
-		for z in 0..Chunk::SIZE
-		{
-			for x in 0..Chunk::SIZE
-			{
-				let coord = HexCoord::from_grid_pos(x + cx, z + cz);
-				let index = coord.to_chunk_local_index();
-
-				if !self.is_in_bounds(&coord)
-				{
-					warn!("Coord is not in bounds!?");
-				}
-
-				//Current tile is land tile
-				if self.sample_height(&coord) > self.sealevel
-				{
-					dists[index] = 0.0;
-					continue;
-				}
-
-				//Find closest land tile
-				if let Some(d) = self.hex_select_first(&coord, range, false, |_t, h, r| {
-					if h > self.sealevel
-					{
-						return Some(r as f32);
-					}
-					return None;
-				})
-				{
-					dists[index] = d;
-				}
-				else
-				{
-					dists[index] = range as f32;
-				}
-			}
-		}
-		return dists;
-	}
-
-	pub fn get_neighbors(&self, pos: &HexCoord) -> [Option<f32>; 6]
-	{
 		let mut results: [Option<f32>; 6] = [None; 6];
 		let w = self.width * Chunk::SIZE;
 		let h = self.height * Chunk::SIZE;
 		let n_tiles = pos.get_neighbors();
-		for i in 0..6
+		for i in 0..6 {
-		{
 			let n_tile = n_tiles[i];
-			if !n_tile.is_in_bounds(h, w)
+			if !n_tile.is_in_bounds(h, w) {
-			{
 				continue;
 			}
 			let c_idx = n_tile.to_chunk_index(self.width);
@@ -114,8 +50,7 @@ impl Map
 		return results;
 	}
 
-	pub fn sample_height(&self, pos: &HexCoord) -> f32
+	pub fn sample_height(&self, pos: &HexCoord) -> f32 {
-	{
 		assert!(
 			self.is_in_bounds(pos),
 			"The provided coordinate is not within the map bounds"
@@ -125,8 +60,7 @@ impl Map
 		return chunk.heights[pos.to_chunk_local_index()];
 	}
 
-	pub fn sample_height_mut(&mut self, pos: &HexCoord) -> &mut f32
+	pub fn sample_height_mut(&mut self, pos: &HexCoord) -> &mut f32 {
-	{
 		assert!(
 			self.is_in_bounds(pos),
 			"The provided coordinate is not within the map bounds"
@@ -136,13 +70,11 @@ impl Map
 		return &mut chunk.heights[pos.to_chunk_local_index()];
 	}
 
-	pub fn is_in_bounds(&self, pos: &HexCoord) -> bool
+	pub fn is_in_bounds(&self, pos: &HexCoord) -> bool {
-	{
 		return pos.is_in_bounds(self.height * Chunk::SIZE, self.width * Chunk::SIZE);
 	}
 
-	pub fn get_biome_id(&self, pos: &HexCoord) -> usize
+	pub fn get_biome_id(&self, pos: &HexCoord) -> usize {
-	{
 		assert!(
 			self.is_in_bounds(pos),
 			"The provided coordinate is not within the map bounds"
@@ -151,44 +83,70 @@ impl Map
 		let chunk = &self.chunks[pos.to_chunk_index(self.width)];
 		return chunk.biome_id[pos.to_chunk_local_index()];
 	}
+	/*
+	pub fn get_biome_noise(&self, pos: &HexCoord) -> &BiomeData {
+		assert!(
+			self.is_in_bounds(pos),
+			"The provided coordinate is not within the map bounds"
+		);
 
-	pub fn get_center(&self) -> Vec3
+		let chunk = &self.chunks[pos.to_chunk_index(self.width)];
-	{
+		return &chunk.biome_data[pos.to_chunk_local_index()];
-		let w = self.get_world_width();
-		let h = self.get_world_height();
-		return Vec3::new(w / 2., self.sealevel, h / 2.);
 	}
 
-	pub fn get_center_with_height(&self) -> Vec3
+	pub fn get_moisture(&self, pos: &HexCoord) -> f32 {
-	{
+		assert!(
-		let w = self.get_world_width();
+			self.is_in_bounds(pos),
-		let h = self.get_world_height();
+			"The provided coordinate is not within the map bounds"
-		let mut pos = Vec3::new(w / 2., self.sealevel, h / 2.);
+		);
-		pos.y = self.sample_height(&HexCoord::from_world_pos(pos));
+
-		return pos;
+		let chunk = &self.chunks[pos.to_chunk_index(self.width)];
+		return chunk.biome_data[pos.to_chunk_local_index()].moisture;
 	}
 
-	pub fn get_world_width(&self) -> f32
+	pub fn get_tempurature(&self, pos: &HexCoord) -> f32 {
-	{
+		assert!(
+			self.is_in_bounds(pos),
+			"The provided coordinate is not within the map bounds"
+		);
+
+		let chunk = &self.chunks[pos.to_chunk_index(self.width)];
+		return chunk.biome_data[pos.to_chunk_local_index()].temperature;
+	}
+
+	pub fn get_continentality(&self, pos: &HexCoord) -> f32 {
+		assert!(
+			self.is_in_bounds(pos),
+			"The provided coordinate is not within the map bounds"
+		);
+
+		let chunk = &self.chunks[pos.to_chunk_index(self.width)];
+		return chunk.biome_data[pos.to_chunk_local_index()].continentality;
+	}
+	*/
+
+	pub fn get_center(&self) -> Vec3 {
+		let w = self.get_world_width();
+		let h = self.get_world_height();
+		return Vec3::new(w / 2., self.sea_level, h / 2.);
+	}
+
+	pub fn get_world_width(&self) -> f32 {
 		return (self.width * Chunk::SIZE) as f32 * SHORT_DIAGONAL;
 	}
-	pub fn get_world_height(&self) -> f32
+	pub fn get_world_height(&self) -> f32 {
-	{
 		return (self.height * Chunk::SIZE) as f32 * 1.5;
 	}
 
-	pub fn get_world_size(&self) -> Vec2
+	pub fn get_world_size(&self) -> Vec2 {
-	{
 		return Vec2::new(self.get_world_width(), self.get_world_height());
 	}
 
-	pub fn set_height(&mut self, pos: &HexCoord, height: f32)
+	pub fn set_height(&mut self, pos: &HexCoord, height: f32) {
-	{
 		self.chunks[pos.to_chunk_index(self.width)].heights[pos.to_chunk_local_index()] = height;
 	}
 
-	pub fn create_crater(&mut self, pos: &HexCoord, radius: usize, depth: f32) -> Vec<(HexCoord, f32)>
+	pub fn create_crater(&mut self, pos: &HexCoord, radius: usize, depth: f32) -> Vec<(HexCoord, f32)> {
-	{
 		assert!(radius != 0, "Radius cannot be zero");
 
 		let tiles = self.hex_select_mut(pos, radius, true, |p, h, r| {
@@ -209,30 +167,22 @@ impl Map
 	{
 		assert!(radius != 0, "Radius cannot be zero");
 
-		let mut result = if include_center
+		let mut result = if include_center {
-		{
+			Vec::with_capacity(get_tile_count(radius) + 1)
-			Vec::with_capacity(get_tile_count_in_range(radius) + 1)
+		} else {
-		}
+			Vec::with_capacity(get_tile_count(radius))
-		else
-		{
-			Vec::with_capacity(get_tile_count_in_range(radius))
 		};
-		if include_center
+		if include_center {
-		{
 			let h = self.sample_height(&center);
 			result.push((op)(center, h, 0));
 		}
 
-		for k in 0..(radius + 1)
+		for k in 0..(radius + 1) {
-		{
 			let mut p = center.scale(4, k);
-			for i in 0..6
+			for i in 0..6 {
-			{
+				for _j in 0..k {
-				for _j in 0..k
-				{
 					p = p.get_neighbor(i);
-					if self.is_in_bounds(&p)
+					if self.is_in_bounds(&p) {
-					{
 						let h = self.sample_height(&p);
 						result.push((op)(&p, h, k));
 					}
@@ -243,92 +193,6 @@ impl Map
 		return result;
 	}
 
-	pub fn hex_select_first<OP, Ret>(
-		&self,
-		center: &HexCoord,
-		radius: usize,
-		include_center: bool,
-		op: OP,
-	) -> Option<Ret>
-	where
-		OP: (Fn(&HexCoord, f32, usize) -> Option<Ret>) + Sync + Send,
-	{
-		assert!(radius != 0, "Radius cannot be zero");
-
-		if include_center
-		{
-			let h = self.sample_height(&center);
-			let r = (op)(center, h, 0);
-			if r.is_some()
-			{
-				return r;
-			}
-		}
-
-		for k in 0..(radius + 1)
-		{
-			let mut p = center.scale(4, k);
-			for i in 0..6
-			{
-				for _j in 0..k
-				{
-					p = p.get_neighbor(i);
-					if self.is_in_bounds(&p)
-					{
-						let h = self.sample_height(&p);
-						let r = (op)(&p, h, k);
-						if r.is_some()
-						{
-							return r;
-						}
-					}
-				}
-			}
-		}
-
-		return None;
-	}
-
-	pub fn ring_select_first<OP, Ret>(
-		&self,
-		center: &HexCoord,
-		start_radius: usize,
-		end_radius: usize,
-		op: OP,
-	) -> Option<Ret>
-	where
-		OP: (Fn(&HexCoord, f32, usize) -> Option<Ret>) + Sync + Send,
-	{
-		assert!(start_radius != 0, "Start radius cannot be zero");
-		assert!(
-			start_radius > end_radius,
-			"Start radius cannot be lower than end radius"
-		);
-
-		for k in start_radius..(end_radius + 1)
-		{
-			let mut p = center.scale(4, k);
-			for i in 0..6
-			{
-				for _j in 0..k
-				{
-					p = p.get_neighbor(i);
-					if self.is_in_bounds(&p)
-					{
-						let h = self.sample_height(&p);
-						let r = (op)(&p, h, k);
-						if r.is_some()
-						{
-							return r;
-						}
-					}
-				}
-			}
-		}
-
-		return None;
-	}
-
 	pub fn hex_select_mut<OP, Ret>(
 		&mut self,
 		center: &HexCoord,
@@ -341,30 +205,22 @@ impl Map
 	{
 		assert!(radius != 0, "Radius cannot be zero");
 
-		let mut result = if include_center
+		let mut result = if include_center {
-		{
+			Vec::with_capacity(get_tile_count(radius) + 1)
-			Vec::with_capacity(get_tile_count_in_range(radius) + 1)
+		} else {
-		}
+			Vec::with_capacity(get_tile_count(radius))
-		else
-		{
-			Vec::with_capacity(get_tile_count_in_range(radius))
 		};
-		if include_center
+		if include_center {
-		{
 			let h = self.sample_height_mut(&center);
 			result.push((op)(center, h, 0));
 		}
 
-		for k in 0..(radius + 1)
+		for k in 0..(radius + 1) {
-		{
 			let mut p = center.scale(4, k);
-			for i in 0..6
+			for i in 0..6 {
-			{
+				for _j in 0..k {
-				for _j in 0..k
-				{
 					p = p.get_neighbor(i);
-					if self.is_in_bounds(&p)
+					if self.is_in_bounds(&p) {
-					{
 						let h = self.sample_height_mut(&p);
 						result.push((op)(&p, h, k));
 					}

engine/world_generation/src/map/map_utils.rs

@@ -4,17 +4,20 @@ use bevy::{math::VectorSpace, prelude::*};
 use image::ImageBuffer;
 use rayon::prelude::*;
 
-use hex::prelude::*;
+use crate::{biome_painter::BiomePainter, hex_utils::HexCoord};
 
-use super::{biome_map::BiomeMap, map::Map};
+use super::{
+	biome_map::{self, BiomeMap},
+	chunk::Chunk,
+	map::Map,
+};
 
 pub fn render_image(
 	size: UVec2,
 	data: &Vec<f32>,
 	color1: LinearRgba,
 	color2: LinearRgba,
-) -> ImageBuffer<image::Rgba<u8>, Vec<u8>>
+) -> ImageBuffer<image::Rgba<u8>, Vec<u8>> {
-{
 	let mut image = ImageBuffer::new(size.x * Chunk::SIZE as u32, size.y * Chunk::SIZE as u32);
 	update_image(size, data, color1, color2, &mut image);
 
@@ -27,8 +30,7 @@ pub fn update_image(
 	color1: LinearRgba,
 	color2: LinearRgba,
 	image: &mut ImageBuffer<image::Rgba<u8>, Vec<u8>>,
-)
+) {
-{
 	let min = *data.iter().min_by(|a, b| a.partial_cmp(b).unwrap()).unwrap_or(&0.0);
 	let max = *data.iter().min_by(|a, b| a.partial_cmp(b).unwrap()).unwrap_or(&1.0);
 
@@ -38,13 +40,12 @@ pub fn update_image(
 		let idx = (y * w + x) as usize;
 		let v = data[idx];
 		let t = v.remap(min, max, 0.0, 1.0);
-		let col = LinearRgba::lerp(color1, color2, t);
+		let col = LinearRgba::lerp(&color1, color2, t);
 		*pixel = to_pixel(&col);
 	});
 }
 
-fn to_pixel(col: &LinearRgba) -> image::Rgba<u8>
+fn to_pixel(col: &LinearRgba) -> image::Rgba<u8> {
-{
 	return image::Rgba([
 		(col.red * 255.0) as u8,
 		(col.green * 255.0) as u8,
@@ -52,8 +53,7 @@ fn to_pixel(col: &LinearRgba) -> image::Rgba<u8>
 		255,
 	]);
 }
-pub fn render_map(map: &Map, smooth: f32) -> ImageBuffer<image::Rgba<u8>, Vec<u8>>
+pub fn render_map(map: &Map, smooth: f32) -> ImageBuffer<image::Rgba<u8>, Vec<u8>> {
-{
 	let mut image = ImageBuffer::new(
 		map.width as u32 * Chunk::SIZE as u32,
 		map.height as u32 * Chunk::SIZE as u32,
@@ -61,21 +61,18 @@ pub fn render_map(map: &Map, smooth: f32) -> ImageBuffer<image::Rgba<u8>, Vec<u8
 	update_map(map, smooth, &mut image);
 	return image;
 }
-pub fn update_map(map: &Map, smooth: f32, image: &mut ImageBuffer<image::Rgba<u8>, Vec<u8>>)
+pub fn update_map(map: &Map, smooth: f32, image: &mut ImageBuffer<image::Rgba<u8>, Vec<u8>>) {
-{
 	image.par_enumerate_pixels_mut().for_each(|(x, y, pixel)| {
 		let coord = HexCoord::from_grid_pos(x as usize, y as usize);
 		let right = coord.get_neighbor(1);
 		let height = map.sample_height(&coord);
 
 		let mut color = Hsla::hsl(138.0, 1.0, 0.4);
-		if height < map.sealevel
+		if height < map.sea_level {
-		{
 			color.hue = 217.0;
 		}
 
-		if map.is_in_bounds(&right)
+		if map.is_in_bounds(&right) {
-		{
 			let h2 = map.sample_height(&right);
 			color = get_height_color_blend(color, height, h2, smooth);
 		}
@@ -84,35 +81,24 @@ pub fn update_map(map: &Map, smooth: f32, image: &mut ImageBuffer<image::Rgba<u8
 	});
 }
 
-fn get_height_color_blend(base_color: Hsla, height: f32, height2: f32, smooth: f32) -> Hsla
+fn get_height_color_blend(base_color: Hsla, height: f32, height2: f32, smooth: f32) -> Hsla {
-{
 	let mut color = base_color;
 	let mut d = height2 - height;
-	if smooth == 0.0 || d.abs() > smooth
+	if smooth == 0.0 || d.abs() > smooth {
-	{
+		if d > 0.0 {
-		if d > 0.0
-		{
 			color.lightness += 0.1;
-		}
+		} else if d < 0.0 {
-		else if d < 0.0
-		{
 			color.lightness -= 0.1;
 		}
-	}
+	} else {
-	else
+		if d.abs() <= smooth {
-	{
-		if d.abs() <= smooth
-		{
 			d /= smooth;
-			if d > 0.0
+			if d > 0.0 {
-			{
 				let c2: LinearRgba = color.with_lightness(color.lightness + 0.1).into();
-				color = LinearRgba::lerp(color.into(), c2, d).into();
+				color = LinearRgba::lerp(&color.into(), c2, d).into();
-			}
+			} else {
-			else
-			{
 				let c2: LinearRgba = color.with_lightness(color.lightness - 0.1).into();
-				color = LinearRgba::lerp(color.into(), c2, d.abs()).into();
+				color = LinearRgba::lerp(&color.into(), c2, d.abs()).into();
 			}
 		}
 	}
@@ -120,15 +106,13 @@ fn get_height_color_blend(base_color: Hsla, height: f32, height2: f32, smooth: f
 	return color;
 }
 
-pub fn render_biome_noise_map(map: &BiomeMap, multi: Vec3) -> ImageBuffer<image::Rgba<u8>, Vec<u8>>
+pub fn render_biome_noise_map(map: &BiomeMap, multi: Vec3) -> ImageBuffer<image::Rgba<u8>, Vec<u8>> {
-{
 	let mut image = ImageBuffer::new(map.width as u32, map.height as u32);
 	update_biome_noise_map(map, multi, &mut image);
 	return image;
 }
 
-pub fn update_biome_noise_map(map: &BiomeMap, multi: Vec3, image: &mut ImageBuffer<image::Rgba<u8>, Vec<u8>>)
+pub fn update_biome_noise_map(map: &BiomeMap, multi: Vec3, image: &mut ImageBuffer<image::Rgba<u8>, Vec<u8>>) {
-{
 	image.par_enumerate_pixels_mut().for_each(|(x, y, pixel)| {
 		let tile = map.get_biome_data(x as usize, y as usize);
 
@@ -141,8 +125,7 @@ pub fn update_biome_noise_map(map: &BiomeMap, multi: Vec3, image: &mut ImageBuff
 	});
 }
 
-pub fn render_biome_map(map: &Map, biome_map: &BiomeMap) -> ImageBuffer<image::Rgba<u8>, Vec<u8>>
+pub fn render_biome_map(map: &Map, biome_map: &BiomeMap) -> ImageBuffer<image::Rgba<u8>, Vec<u8>> {
-{
 	let mut image = ImageBuffer::new(
 		map.width as u32 * Chunk::SIZE as u32,
 		map.height as u32 * Chunk::SIZE as u32,
@@ -151,22 +134,19 @@ pub fn render_biome_map(map: &Map, biome_map: &BiomeMap) -> ImageBuffer<image::R
 	return image;
 }
 
-pub fn update_biome_map(map: &Map, biome_map: &BiomeMap, image: &mut ImageBuffer<image::Rgba<u8>, Vec<u8>>)
+pub fn update_biome_map(map: &Map, biome_map: &BiomeMap, image: &mut ImageBuffer<image::Rgba<u8>, Vec<u8>>) {
-{
 	let map_biome_count = map.biome_count as f32;
 	image.par_enumerate_pixels_mut().for_each(|(x, y, pixel)| {
 		let coord = HexCoord::from_grid_pos(x as usize, y as usize);
 		let biome_blend = biome_map.get_biome(x as i32, y as i32).unwrap();
 		let right = coord.get_neighbor(1);
 		let mut color = Oklaba::BLACK;
-		for i in 0..biome_blend.len()
+		for i in 0..biome_blend.len() {
-		{
 			let mut c: Oklaba = Hsla::hsl((i as f32 / map_biome_count) * 360.0, 0.8, 0.7).into();
 			c *= biome_blend[i];
 			color = Oklaba::add(c, color.into()).into();
 		}
-		if map.is_in_bounds(&right)
+		if map.is_in_bounds(&right) {
-		{
 			let h1 = map.sample_height(&coord);
 			let h2 = map.sample_height(&right);
 			color = get_height_color_blend(color.into(), h1, h2, 0.5).into();

engine/world_generation/src/map/mesh_chunk.rs

@@ -1,29 +1,20 @@
-use std::collections::VecDeque;
+use crate::hex_utils::HexCoord;
 
-use bevy::math::IVec2;
+use super::chunk::Chunk;
 
-use hex::prelude::*;
+pub struct MeshChunkData {
-
-pub struct MeshChunkData
-{
 	pub heights: [f32; Chunk::AREA],
 	pub textures: [[u32; 2]; Chunk::AREA],
 	pub min_height: f32,
-	pub sealevel: f32,
-	pub distance_to_land: [f32; Chunk::AREA],
 }
 
-impl MeshChunkData
+impl MeshChunkData {
-{
+	pub fn get_neighbors(&self, coord: &HexCoord) -> [f32; 6] {
-	pub fn get_neighbors(&self, coord: &HexCoord) -> [f32; 6]
-	{
 		let mut data = [self.min_height; 6];
 		let n_tiles = coord.get_neighbors();
-		for i in 0..6
+		for i in 0..6 {
-		{
 			let n = n_tiles[i];
-			if !n.is_in_bounds(Chunk::SIZE, Chunk::SIZE)
+			if !n.is_in_bounds(Chunk::SIZE, Chunk::SIZE) {
-			{
 				continue;
 			}
 			data[i] = self.heights[n.to_index(Chunk::SIZE)];
@@ -31,72 +22,4 @@ impl MeshChunkData
 
 		return data;
 	}
-
-	pub fn get_neighbors_with_water_info(&self, coord: &HexCoord) -> ([(f32, Option<f32>); 6], bool)
-	{
-		let mut has_land = false;
-		let mut data = [(self.min_height, None); 6];
-		let n_tiles = coord.get_neighbors();
-		for i in 0..6
-		{
-			let n = n_tiles[i];
-			if !n.is_in_bounds(Chunk::SIZE, Chunk::SIZE)
-			{
-				continue;
-			}
-			let idx = n.to_index(Chunk::SIZE);
-			data[i] = (self.heights[idx], Some(self.distance_to_land[idx]));
-			if data[i].0 > self.sealevel
-			{
-				has_land = true;
-			}
-		}
-		return (data, has_land);
-	}
-
-	pub fn caluclate_water_distances(data: &mut Vec<MeshChunkData>, height: usize, width: usize, _range: usize)
-	{
-		let mut open: VecDeque<(HexCoord, f32, usize)> = VecDeque::new();
-		// let mut closed: Vec<(HexCoord, f32)> = Vec::new();
-		for z in 0..height
-		{
-			for x in 0..width
-			{
-				let chunk = &mut data[z * height + x];
-				chunk.prepare_chunk_open(x * Chunk::SIZE, z * Chunk::SIZE, &mut open);
-			}
-		}
-	}
-
-	fn prepare_chunk_open(&mut self, offset_x: usize, offset_z: usize, open: &mut VecDeque<(HexCoord, f32, usize)>)
-	{
-		for z in 0..Chunk::SIZE
-		{
-			for x in 0..Chunk::SIZE
-			{
-				let coord = HexCoord::from_grid_pos(x + offset_x, z + offset_z);
-				let idx = coord.to_chunk_local_index();
-				let h = self.heights[idx];
-				self.distance_to_land[idx] = if h > self.sealevel { 0.0 } else { 4.0 };
-				if h > self.sealevel
-				{
-					open.push_back((coord, h, 0));
-				}
-			}
-		}
-	}
-
-	#[allow(dead_code)]
-	#[allow(unused)]
-	fn fill_chunk_borders(
-		&mut self,
-		chunks: &Vec<MeshChunkData>,
-		offset: IVec2,
-		open: &mut VecDeque<(HexCoord, f32, usize)>,
-		closed: &mut Vec<(HexCoord, f32)>,
-	)
-	{
-		self.prepare_chunk_open(offset.x as usize * Chunk::SIZE, offset.y as usize * Chunk::SIZE, open);
-		todo!("Fill closed list with bordering tiles")
-	}
 }

engine/world_generation/src/map/mod.rs

@@ -1,5 +1,6 @@
-pub mod biome_map;
+pub mod chunk;
+pub mod mesh_chunk;
 pub mod config;
 pub mod map;
+pub mod biome_map;
 pub mod map_utils;
-pub mod mesh_chunk;

engine/world_generation/src/prelude.rs

@@ -1,4 +1,5 @@
 pub use crate::consts::*;
+pub use crate::map::chunk::*;
 pub use crate::map::config::*;
 pub use crate::map::map::*;
 pub use crate::map::mesh_chunk::*;

engine/world_generation/src/tile_manager.rs

@@ -1,5 +1,5 @@
 use asset_loader::create_asset_loader;
-use bevy::{asset::Asset, reflect::TypePath};
+use bevy::{asset::Asset, ecs::system::Resource, reflect::TypePath};
 use serde::{Deserialize, Serialize};
 #[derive(Resource, Debug)]
 pub struct TileManager {

game/buildings/Cargo.toml

@@ -6,19 +6,18 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.18.0"
+bevy = "0.14.0"
 world_generation = { path = "../../engine/world_generation" }
 shared = { path = "../shared" }
-bevy_rapier3d = "0.33.0"
+bevy_rapier3d = "0.27.0"
-serde = { version = "1.0.228", features = ["derive"] }
+serde = { version = "1.0.204", features = ["derive"] }
 asset_loader = { path = "../../engine/asset_loader" }
-serde_json = "1.0.149"
+serde_json = "1.0.120"
-ron = "0.12.0"
+ron = "0.8.1"
-bevy_asset_loader = { version = "0.25.0", features = [
+bevy_asset_loader = { version = "0.21.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }
-hex = { path = "../../engine/hex" }
 
 [features]
 tracing = []

game/buildings/src/assets/building_asset.rs

@@ -1,134 +1,22 @@
 use asset_loader::create_asset_loader;
-use bevy::{
+use bevy::prelude::*;
-	gltf::{GltfMesh, GltfNode},
-	prelude::*,
-};
 use serde::{Deserialize, Serialize};
 use shared::identifiers::ResourceIdentifier;
 
-use crate::{
+use crate::footprint::BuildingFootprint;
-	buildings::{
-		conduit_building::ResourceConduitInfo, factory_building::FactoryBuildingInfo,
-		resource_gathering::ResourceGatheringBuildingInfo,
-	},
-	footprint::BuildingFootprint,
-};
 
 #[derive(Asset, TypePath, Debug, Serialize, Deserialize)]
-pub struct BuildingAsset
+pub struct BuildingAsset {
-{
 	pub name: String,
 	pub description: String,
 	pub footprint: BuildingFootprint,
 	pub prefab_path: String,
 	#[serde(skip)]
-	pub prefab: Handle<Gltf>,
+	pub prefab: Handle<Scene>,
-	pub base_mesh_path: String,
 
 	pub cost: Vec<ResourceIdentifier>,
 	pub consumption: Vec<ResourceIdentifier>,
 	pub production: Vec<ResourceIdentifier>,
-
-	pub health: u32,
-
-	pub building_type: BuildingType,
-	// pub components: Option<Vec<ComponentDefination>>,
-}
-
-impl BuildingAsset
-{
-	#[allow(unused)]
-	pub fn spawn(
-		&self,
-		pos: Vec3,
-		rot: Quat,
-		gltf: &Gltf,
-		commands: &mut Commands,
-		meshes: &Assets<GltfMesh>,
-		nodes: &Assets<GltfNode>,
-	) -> Option<Entity>
-	{
-		todo!("Update building spawning");
-		// let base_node = &gltf.named_nodes[&self.base_mesh_path.clone().into_boxed_str()];
-		// if let Some(node) = nodes.get(base_node.id()) {
-		// 	if let Some(mesh_handle) = &node.mesh {
-		// 		if let Some(gltf_mesh) = meshes.get(mesh_handle.id()) {
-		// 			let (mesh, mat) = gltf_mesh.unpack();
-		// 			let mut entity = commands.spawn((
-		// 				Mesh3d(mesh),
-		// 				MeshMaterial3d(mat),
-		// 				Transform::from_translation(pos).with_rotation(rot),
-		// 				Building,
-		// 			));
-		// 			entity.with_children(|b| {
-		// 				for child in &node.children {
-		// 					let child_node = nodes.get(child.id());
-		// 					if child_node.is_none() {
-		// 						continue;
-		// 					}
-		// 					self.process_node(child_node.unwrap(), meshes, nodes, b, &node.name);
-		// 				}
-		// 			});
-		// 			if let Some(component) = self.get_component_def(&format!("/{0}", &node.name)) {
-		// 				component.apply(&mut entity);
-		// 			}
-		// 			return Some(entity.id());
-		// 		}
-		// 	}
-		// }
-		// return None;
-	}
-
-	// fn process_node(
-	// 	&self,
-	// 	node: &GltfNode,
-	// 	meshes: &Assets<GltfMesh>,
-	// 	nodes: &Assets<GltfNode>,
-	// 	commands: &mut ChildBuilder,
-	// 	parent: &String,
-	// ) -> Option<Entity> {
-	// 	let path = format!("{0}/{1}", parent, node.name);
-	// 	if let Some(mesh) = &node.mesh {
-	// 		if let Some(gltf_mesh) = meshes.get(mesh.id()) {
-	// 			let (mesh, mat) = gltf_mesh.unpack();
-	// 			let mut entity = commands.spawn((Mesh3d(mesh), MeshMaterial3d(mat), node.transform, Building));
-	// 			entity.with_children(|b| {
-	// 				for child in &node.children {
-	// 					let child_node = nodes.get(child.id());
-	// 					if child_node.is_none() {
-	// 						continue;
-	// 					}
-	// 					self.process_node(child_node.unwrap(), meshes, nodes, b, &path);
-	// 				}
-	// 			});
-	// 			if let Some(component) = self.get_component_def(&path) {
-	// 				component.apply(&mut entity);
-	// 			}
-	// 			return Some(entity.id());
-	// 		}
-	// 	}
-	// 	return None;
-	// }
-
-	// fn get_component_def(&self, path: &String) -> Option<&ComponentDefination> {
-	// 	if let Some(components) = &self.components {
-	// 		for c in components {
-	// 			if c.path.ends_with(path) {
-	// 				return Some(c);
-	// 			}
-	// 		}
-	// 	}
-	// 	return None;
-	// }
-}
-
-#[derive(Serialize, Deserialize, Debug, TypePath)]
-pub enum BuildingType
-{
-	Basic,
-	Gathering(ResourceGatheringBuildingInfo),
-	FactoryBuildingInfo(FactoryBuildingInfo),
-	ResourceConduit(ResourceConduitInfo),
 }
 
 create_asset_loader!(

game/buildings/src/build_queue.rs

@@ -1,17 +1,16 @@
+use std::path::Display;
+
 use bevy::prelude::Resource;
-use hex::prelude::*;
 use shared::building::BuildingIdentifier;
+use world_generation::hex_utils::HexCoord;
 
 #[derive(Resource)]
-pub struct BuildQueue
+pub struct BuildQueue {
-{
 	pub queue: Vec<QueueEntry>,
 }
 
-impl Default for BuildQueue
+impl Default for BuildQueue {
-{
+	fn default() -> Self {
-	fn default() -> Self
-	{
 		Self {
 			queue: Default::default(),
 		}
@@ -19,8 +18,7 @@ impl Default for BuildQueue
 }
 
 #[derive(PartialEq, Eq)]
-pub struct QueueEntry
+pub struct QueueEntry {
-{
 	pub building: BuildingIdentifier,
 	pub pos: HexCoord,
 }

game/buildings/src/building_plugin.rs

@@ -1,19 +1,21 @@
-use bevy::{
+use std::f32::consts::E;
-	ecs::world::CommandQueue,
+
-	gltf::{GltfMesh, GltfNode},
+use bevy::{ecs::world::CommandQueue, prelude::*, window::PrimaryWindow};
-	prelude::*,
-};
 use bevy_asset_loader::loading_state::{
 	config::{ConfigureLoadingState, LoadingStateConfig},
 	LoadingStateAppExt,
 };
+use bevy_rapier3d::{parry::transformation::utils::transform, pipeline::QueryFilter, plugin::RapierContext};
 use shared::{
 	despawn::Despawn,
 	events::TileModifiedEvent,
 	resources::TileUnderCursor,
 	states::{AssetLoadState, GameplayState},
+	tags::MainCamera,
+};
+use world_generation::{
+	heightmap, hex_utils::HexCoord, map::map::Map, prelude::GenerationConfig, states::GeneratorState,
 };
-use world_generation::{map::map::Map, prelude::GenerationConfig, states::GeneratorState};
 
 use crate::{
 	assets::{
@@ -27,10 +29,8 @@ use crate::{
 
 pub struct BuildingPugin;
 
-impl Plugin for BuildingPugin
+impl Plugin for BuildingPugin {
-{
+	fn build(&self, app: &mut App) {
-	fn build(&self, app: &mut App)
-	{
 		app.insert_resource(BuildQueue::default());
 		app.add_plugins(BuildingAssetPlugin);
 
@@ -41,7 +41,7 @@ impl Plugin for BuildingPugin
 		app.add_systems(Update, init.run_if(in_state(AssetLoadState::Loading)));
 		app.add_systems(
 			Update,
-			hq_placement.run_if(in_state(GameplayState::PlaceHQ).and(in_state(GeneratorState::Idle))),
+			hq_placement.run_if(in_state(GameplayState::PlaceHQ).and_then(in_state(GeneratorState::Idle))),
 		);
 		app.add_systems(
 			PreUpdate,
@@ -57,15 +57,12 @@ impl Plugin for BuildingPugin
 	}
 }
 
-fn prepare_building_map(mut commands: Commands, cfg: Res<GenerationConfig>)
+fn prepare_building_map(mut commands: Commands, cfg: Res<GenerationConfig>) {
-{
 	commands.insert_resource(BuildingMap::new(cfg.size));
 }
 
-fn regernerate(mut commands: Commands, buildings: Query<Entity, With<Building>>, cfg: Res<GenerationConfig>)
+fn regernerate(mut commands: Commands, buildings: Query<Entity, With<Building>>, cfg: Res<GenerationConfig>) {
-{
+	for e in buildings.iter() {
-	for e in buildings.iter()
-	{
 		commands.entity(e).despawn();
 	}
 	commands.insert_resource(BuildingMap::new(cfg.size));
@@ -74,8 +71,7 @@ fn regernerate(mut commands: Commands, buildings: Query<Entity, With<Building>>,
 #[derive(Resource)]
 struct IndicatorCube(Handle<Mesh>, Handle<StandardMaterial>);
 
-fn init(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>, mut materials: ResMut<Assets<StandardMaterial>>)
+fn init(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>, mut materials: ResMut<Assets<StandardMaterial>>) {
-{
 	let cube = Cuboid::from_size(Vec3::splat(1.));
 	let mesh_handle = meshes.add(cube);
 	let mat_handle = materials.add(Color::WHITE);
@@ -90,15 +86,13 @@ fn hq_placement(
 	indicator: Res<IndicatorCube>,
 	mut build_queue: ResMut<BuildQueue>,
 	mut next_state: ResMut<NextState<GameplayState>>,
-)
+) {
-{
+
-	if let Some(contact) = tile_under_cursor.0
+	if let Some(contact) = tile_under_cursor.0 {
-	{
 		let positions = map.hex_select(&contact.tile, 3, true, |pos, h, _| pos.to_world(h));
 		show_indicators(positions, &mut commands, &indicator);
 
-		if mouse.just_pressed(MouseButton::Left)
+		if mouse.just_pressed(MouseButton::Left) {
-		{
 			build_queue.queue.push(QueueEntry {
 				building: 0.into(),
 				pos: contact.tile,
@@ -109,14 +103,15 @@ fn hq_placement(
 	}
 }
 
-fn show_indicators(positions: Vec<Vec3>, commands: &mut Commands, indicator: &IndicatorCube)
+fn show_indicators(positions: Vec<Vec3>, commands: &mut Commands, indicator: &IndicatorCube) {
-{
+	for p in positions {
-	for p in positions
-	{
 		commands.spawn((
-			Mesh3d(indicator.0.clone()),
+			PbrBundle {
-			MeshMaterial3d(indicator.1.clone()),
+				mesh: indicator.0.clone(),
-			Transform::from_translation(p),
+				material: indicator.1.clone(),
+				transform: Transform::from_translation(p),
+				..default()
+			},
 			Despawn,
 		));
 	}
@@ -127,65 +122,44 @@ fn process_build_queue(
 	mut commands: Commands,
 	db: Res<BuildingDatabase>,
 	building_assets: Res<Assets<BuildingAsset>>,
-	gltf_assets: Res<Assets<Gltf>>,
-	gltf_meshes: Res<Assets<GltfMesh>>,
-	gltf_nodes: Res<Assets<GltfNode>>,
 	mut building_map: ResMut<BuildingMap>,
 	heightmap: Res<Map>,
-)
+) {
-{
+	for item in &queue.queue {
-	for item in &queue.queue
-	{
 		let handle = &db.buildings[item.building.0];
-		if let Some(building) = building_assets.get(handle.id())
+		if let Some(building) = building_assets.get(handle.id()) {
-		{
 			let h = heightmap.sample_height(&item.pos);
 			println!("Spawning {} at {}", building.name, item.pos);
-			if let Some(gltf) = gltf_assets.get(building.prefab.id())
+			let e = commands.spawn((
-			{
+				SceneBundle {
-				let e = building.spawn(
+					scene: building.prefab.clone(),
-					item.pos.to_world(h),
+					transform: Transform::from_translation(item.pos.to_world(h)),
-					Quat::IDENTITY,
+					..Default::default()
-					gltf,
+				},
-					&mut commands,
+				Building,
-					&gltf_meshes,
+			));
-					&gltf_nodes,
+
-				);
+			building_map.add_building(BuildingEntry::new(item.pos, e.id()));
-				if let Some(b) = e
-				{
-					building_map.add_building(BuildingEntry::new(item.pos, b));
-				}
-			}
-			else
-			{
-				warn!("Failed to spawn building");
-			}
 		}
 	}
 	queue.queue.clear();
 }
 
 fn update_building_heights(
-	mut tile_updates: MessageReader<TileModifiedEvent>,
+	mut tile_updates: EventReader<TileModifiedEvent>,
 	building_map: Res<BuildingMap>,
 	mut commands: Commands,
-)
+) {
-{
+	for event in tile_updates.read() {
-	for event in tile_updates.read()
+		match event {
-	{
+			TileModifiedEvent::HeightChanged(coord, new_height) => {
-		match event
+				if let Some(building) = building_map.get_building(coord) {
-		{
-			TileModifiedEvent::HeightChanged(coord, new_height) =>
-			{
-				if let Some(building) = building_map.get_building(coord)
-				{
 					let mut queue = CommandQueue::default();
 					let e = building.entity.clone();
 					let h = *new_height;
 					queue.push(move |world: &mut World| {
 						let mut emut = world.entity_mut(e);
-						if let Some(mut transform) = emut.get_mut::<Transform>()
+						if let Some(mut transform) = emut.get_mut::<Transform>() {
-						{
 							transform.translation.y = h;
 						}
 					});

game/buildings/src/buildings/basic_building.rs

@@ -1,3 +0,0 @@
-use serde::{Deserialize, Serialize};
-#[derive(Serialize, Deserialize, Debug)]
-pub struct BasicBuildingInfo {}

game/buildings/src/buildings/conduit_building.rs

@@ -1,6 +0,0 @@
-use serde::{Deserialize, Serialize};
-#[derive(Serialize, Deserialize, Debug)]
-pub struct ResourceConduitInfo {
-	pub range: usize,
-	pub connection_range: usize,
-}

game/buildings/src/buildings/factory_building.rs

@@ -1,6 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct FactoryBuildingInfo {
-	pub units_to_build: Vec<()>
-}

game/buildings/src/buildings/mod.rs

@@ -1,5 +0,0 @@
-pub mod basic_building;
-pub mod conduit_building;
-pub mod factory_building;
-pub mod resource_gathering;
-pub mod tech_building;

game/buildings/src/buildings/resource_gathering.rs

@@ -1,8 +0,0 @@
-use serde::{Deserialize, Serialize};
-use shared::identifiers::ResourceIdentifier;
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct ResourceGatheringBuildingInfo {
-	pub resources_to_gather: Vec<ResourceIdentifier>,
-	pub gather_range: usize,
-}

game/buildings/src/buildings/tech_building.rs

@@ -1,9 +0,0 @@
-use serde::{Deserialize, Serialize};
-use shared::{building::BuildingIdentifier, StatusEffect};
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct TechBuildingInfo {
-	pub effect_range: usize,
-	pub buildings_to_unlock: Vec<BuildingIdentifier>,
-	pub buffs: Vec<StatusEffect>,
-}

game/buildings/src/buildings_map.rs

@@ -1,26 +1,21 @@
 use bevy::prelude::*;
-use hex::prelude::*;
+use world_generation::{hex_utils::HexCoord, prelude::Chunk};
 
 #[derive(Resource)]
-pub struct BuildingMap
+pub struct BuildingMap {
-{
 	pub chunks: Vec<BuildingChunk>,
 	pub size: UVec2,
 }
 
-impl BuildingMap
+impl BuildingMap {
-{
+	pub fn new(size: UVec2) -> Self {
-	pub fn new(size: UVec2) -> Self
-	{
 		let mut db = BuildingMap {
 			size,
 			chunks: Vec::with_capacity(size.length_squared() as usize),
 		};
 
-		for y in 0..size.y as i32
+		for y in 0..size.y as i32 {
-		{
+			for x in 0..size.x as i32 {
-			for x in 0..size.x as i32
-			{
 				let offset = IVec2::new(x, y);
 				let index = (x + y * size.x as i32) as usize;
 				db.chunks.push(BuildingChunk::new(offset, index));
@@ -30,8 +25,7 @@ impl BuildingMap
 		return db;
 	}
 
-	pub fn get_buildings_in_range(&self, coord: &HexCoord, radius: usize) -> Vec<&BuildingEntry>
+	pub fn get_buildings_in_range(&self, coord: &HexCoord, radius: usize) -> Vec<&BuildingEntry> {
-	{
 		assert!(radius != 0, "Radius cannot be zero");
 
 		let w = self.size.x as usize * Chunk::SIZE;
@@ -40,13 +34,10 @@ impl BuildingMap
 		return self.get_buildings_in_coords(coords);
 	}
 
-	pub fn get_buildings_in_coords(&self, coords: Vec<HexCoord>) -> Vec<&BuildingEntry>
+	pub fn get_buildings_in_coords(&self, coords: Vec<HexCoord>) -> Vec<&BuildingEntry> {
-	{
 		let mut result = Vec::new();
-		for coord in &coords
+		for coord in &coords {
-		{
+			if let Some(buidling) = self.get_building(coord) {
-			if let Some(buidling) = self.get_building(coord)
-			{
 				result.push(buidling);
 			}
 		}
@@ -54,30 +45,25 @@ impl BuildingMap
 		return result;
 	}
 
-	pub fn get_building(&self, coord: &HexCoord) -> Option<&BuildingEntry>
+	pub fn get_building(&self, coord: &HexCoord) -> Option<&BuildingEntry> {
-	{
 		let chunk = &self.chunks[coord.to_chunk_index(self.size.x as usize)];
 		return chunk.get_building(coord);
 	}
 
-	pub fn add_building(&mut self, entry: BuildingEntry)
+	pub fn add_building(&mut self, entry: BuildingEntry) {
-	{
 		let chunk = &mut self.chunks[entry.coord.to_chunk_index(self.size.x as usize)];
 		chunk.add_building(entry);
 	}
 }
 
-pub struct BuildingChunk
+pub struct BuildingChunk {
-{
 	pub entries: Vec<BuildingEntry>,
 	pub index: usize,
 	pub offset: IVec2,
 }
 
-impl BuildingChunk
+impl BuildingChunk {
-{
+	pub fn new(offset: IVec2, index: usize) -> Self {
-	pub fn new(offset: IVec2, index: usize) -> Self
-	{
 		return BuildingChunk {
 			entries: Vec::new(),
 			index,
@@ -85,19 +71,16 @@ impl BuildingChunk
 		};
 	}
 
-	pub fn get_building(&self, coord: &HexCoord) -> Option<&BuildingEntry>
+	pub fn get_building(&self, coord: &HexCoord) -> Option<&BuildingEntry> {
-	{
 		return self.entries.iter().find(|b| &b.coord == coord);
 	}
 
-	pub fn add_building(&mut self, entry: BuildingEntry)
+	pub fn add_building(&mut self, entry: BuildingEntry) {
-	{
 		self.entries.push(entry);
 	}
 }
 
-pub struct BuildingEntry
+pub struct BuildingEntry {
-{
 	pub coord: HexCoord,
 	pub entity: Entity,
 	pub is_main: bool,
@@ -106,10 +89,8 @@ pub struct BuildingEntry
 	pub child_entities: Option<Vec<Entity>>,
 }
 
-impl BuildingEntry
+impl BuildingEntry {
-{
+	pub fn new(coord: HexCoord, entity: Entity) -> Self {
-	pub fn new(coord: HexCoord, entity: Entity) -> Self
-	{
 		return BuildingEntry {
 			coord,
 			entity,
@@ -120,8 +101,7 @@ impl BuildingEntry
 		};
 	}
 
-	pub fn new_with_children(coord: HexCoord, entity: Entity, children: Vec<Entity>) -> BuildingEntry
+	pub fn new_with_children(coord: HexCoord, entity: Entity, children: Vec<Entity>) -> BuildingEntry {
-	{
 		return BuildingEntry {
 			coord,
 			entity,
@@ -132,8 +112,7 @@ impl BuildingEntry
 		};
 	}
 
-	pub fn new_with_parent(coord: HexCoord, entity: Entity, main: Entity) -> BuildingEntry
+	pub fn new_with_parent(coord: HexCoord, entity: Entity, main: Entity) -> BuildingEntry {
-	{
 		return BuildingEntry {
 			coord,
 			entity,

game/buildings/src/footprint.rs

@@ -1,39 +1,32 @@
 use bevy::math::{IVec2, Vec3Swizzles};
-use hex::prelude::*;
 use serde::{Deserialize, Serialize};
-use shared::coords::CoordsCollection;
+use world_generation::hex_utils::HexCoord;
 
 #[derive(Serialize, Deserialize, Debug)]
-pub struct BuildingFootprint
+pub struct BuildingFootprint {
-{
 	pub footprint: Vec<IVec2>,
 }
 
-impl BuildingFootprint
+impl BuildingFootprint {
-{
+	pub fn get_footprint(&self, center: &HexCoord) -> Vec<HexCoord> {
-	pub fn get_footprint(&self, position: &HexCoord) -> CoordsCollection
+		let c = center.hex.xy();
-	{
+		return self.footprint.iter().map(|p| HexCoord::from_hex(*p + c)).collect();
-		CoordsCollection::from_points(self.footprint.clone()).with_translation(position)
 	}
 
-	pub fn get_neighbors(&self, position: &HexCoord) -> CoordsCollection
+	pub fn get_footprint_rotated(&self, center: &HexCoord, rotation: i32) -> Vec<HexCoord> {
-	{
+		let c = center.hex.xy();
-		let n_points: Vec<IVec2> = self
+		return self
 			.footprint
 			.iter()
-			.flat_map(|p| HexCoord::from_axial(*p).get_neighbors())
+			.map(|p| HexCoord::from_hex(*p + c).rotate_around(center, rotation))
-			.map(|c| c.hex.xy())
-			.filter(|p| !self.footprint.contains(p))
 			.collect();
-		let mut out_points: Vec<IVec2> = Vec::with_capacity(n_points.len());
-		for p in n_points
-		{
-			if out_points.contains(&p)
-			{
-				continue;
 	}
-			out_points.push(p);
+
+	pub fn get_neighbors(&self, center: &HexCoord) -> Vec<HexCoord> {
+		todo!()
 	}
-		return CoordsCollection::from_points(out_points).with_translation(position);
+
+	pub fn get_neighbors_rotated(&self, center: &HexCoord, rotation: i32) -> Vec<HexCoord> {
+		todo!();
 	}
 }

game/buildings/src/lib.rs

@@ -4,5 +4,4 @@ pub mod building_plugin;
 pub mod buildings_map;
 pub mod footprint;
 pub mod prelude;
-mod buildings;
 pub use building_plugin::*;

game/main/Cargo.toml

@@ -7,35 +7,22 @@ build = "build.rs"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = { version = "0.18.0", features = ["file_watcher"] }
+bevy = { version = "0.14.0", features = ["file_watcher"] }
-bevy-inspector-egui = "0.36.0"
+bevy-inspector-egui = "0.25.0"
-# iyes_perf_ui = "0.3.0"
+iyes_perf_ui = "0.3.0"
-noise = "0.9.0"
+noise = "0.8.2"
 world_generation = { path = "../../engine/world_generation" }
-bevy_rapier3d = { version = "0.33.0", features = [
+rayon = "1.10.0"
-	"simd-stable",
-	"parallel",
-	"debug-render-3d",
-] }
-rayon = "1.11.0"
 buildings = { path = "../buildings" }
 units = { path = "../units" }
 shared = { path = "../shared" }
-bevy_asset_loader = { version = "0.25.0", features = [
+bevy_asset_loader = { version = "0.21.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }
-ron = "0.12.0"
+ron = "0.8.1"
-image = "0.25.9"
+avian3d = { version = "0.1.2" }
-hex = { path = "../../engine/hex" }
+image = "0.25.2"
-
-# bevy_lunex = "0.2.4"
 
 [features]
-tracing = [
+tracing = ["bevy/trace_tracy", "world_generation/tracing", "buildings/tracing"]
-	"bevy/trace_tracy",
-	"world_generation/tracing",
-	"buildings/tracing",
-	"units/tracing",
-	"shared/tracing",
-]

game/main/build.rs

@@ -13,10 +13,6 @@ where
 
 	for path in fs::read_dir(from).unwrap() {
 		let path = path.unwrap().path();
-		println!("{path:?}");
-		if path.starts_with("assets/raw_assets") {
-			continue;
-		}
 		let to = to.clone().join(path.file_name().unwrap());
 
 		if path.is_file() {

game/main/src/camera_system/camera_plugin.rs

@@ -1,215 +1,252 @@
-use bevy::anti_alias::taa::TemporalAntiAliasing;
+use bevy::core_pipeline::experimental::taa::{TemporalAntiAliasBundle, TemporalAntiAliasPlugin};
 use bevy::core_pipeline::prepass::DepthPrepass;
 use bevy::input::mouse::{MouseMotion, MouseScrollUnit, MouseWheel};
 use bevy::prelude::*;
-use bevy::window::{CursorGrabMode, CursorOptions, PrimaryWindow};
+use bevy::window::CursorGrabMode;
-use hex::prelude::*;
+use shared::states::MenuState;
-use shared::sets::GameplaySet;
 use shared::tags::MainCamera;
+use world_generation::hex_utils::HexCoord;
 use world_generation::prelude::Map;
-use world_generation::states::GeneratorState;
 
 use super::components::*;
 
 pub struct PhosCameraPlugin;
 
-impl Plugin for PhosCameraPlugin
+impl Plugin for PhosCameraPlugin {
-{
+	fn build(&self, app: &mut App) {
-	fn build(&self, app: &mut App)
-	{
 		app.register_type::<PhosCamera>();
-		app.register_type::<PhosOrbitCamera>();
 
 		app.add_systems(PreStartup, setup);
 
-		app.add_systems(Update, orbit_camera_upate.in_set(GameplaySet));
+		app.add_systems(Update, rts_camera_system.run_if(in_state(MenuState::InGame)));
+		app.add_systems(PostUpdate, limit_camera_bounds.run_if(in_state(MenuState::InGame)));
+		//Free Cam
+		//app.add_systems(Update, (grab_mouse, (update_camera, update_camera_mouse).chain()));
 
-		app.add_systems(Update, init_bounds.run_if(in_state(GeneratorState::SpawnMap)));
+		app.add_plugins(TemporalAntiAliasPlugin);
 	}
 }
 
-fn init_bounds(mut commands: Commands, cam: Single<(&mut Transform, Entity), With<PhosCamera>>, heightmap: Res<Map>)
+fn setup(mut commands: Commands, mut msaa: ResMut<Msaa>) {
-{
-	let (mut cam_t, cam_entity) = cam.into_inner();
-	cam_t.translation = heightmap.get_center();
-	commands
-		.entity(cam_entity)
-		.insert(CameraBounds::from_size(heightmap.get_world_size()))
-		.insert(PhosOrbitCamera {
-			target: heightmap.get_center_with_height(),
-			..Default::default()
-		});
-}
-
-fn setup(mut commands: Commands)
-{
 	commands
 		.spawn((
-			Camera3d::default(),
+			Camera3dBundle {
-			Transform::from_xyz(0., 30., 0.).looking_to(Vec3::NEG_Z, Vec3::Y),
+				transform: Transform::from_xyz(0., 30., 0.).looking_to(Vec3::NEG_Z, Vec3::Y),
+				..default()
+			},
 			PhosCamera::default(),
 			MainCamera,
 			DepthPrepass,
-			PhosOrbitCamera::default(),
+			PhosCameraTargets::default(),
-			TemporalAntiAliasing::default(),
 		))
-		.insert(Msaa::Off);
+		.insert(TemporalAntiAliasBundle::default());
-	// .insert(RenderLayers::layer(0))
 
-	// *msaa = Msaa::Off;
+	*msaa = Msaa::Off;
+}
+fn update_camera(
+	mut cam_query: Query<(&PhosCamera, &mut Transform)>,
+	keyboard_input: Res<ButtonInput<KeyCode>>,
+	time: Res<Time>,
+	windows: Query<&Window>,
+) {
+	let window = windows.single();
+	if window.cursor.grab_mode != CursorGrabMode::Locked {
+		return;
+	}
+	let (cam, mut transform) = cam_query.single_mut();
+
+	let mut move_vec = Vec3::ZERO;
+	if keyboard_input.pressed(KeyCode::KeyA) {
+		move_vec += Vec3::NEG_X;
+	}
+	if keyboard_input.pressed(KeyCode::KeyD) {
+		move_vec += Vec3::X;
+	}
+	if keyboard_input.pressed(KeyCode::KeyW) {
+		move_vec += Vec3::NEG_Z;
+	}
+	if keyboard_input.pressed(KeyCode::KeyS) {
+		move_vec += Vec3::Z;
 	}
 
-fn orbit_camera_upate(
+	let rot = transform.rotation;
-	cam_query: Single<(&mut Transform, &PhosCamera, &mut PhosOrbitCamera, &CameraBounds)>,
+	move_vec = (rot * move_vec.normalize_or_zero()) * cam.speed * time.delta_seconds();
-	mut wheel: MessageReader<MouseWheel>,
+
-	mut mouse_motion: MessageReader<MouseMotion>,
+	if keyboard_input.pressed(KeyCode::ShiftLeft) {
-	mouse: Res<ButtonInput<MouseButton>>,
+		move_vec += Vec3::from(transform.down());
-	mut cursor_options: Single<&mut CursorOptions, With<PrimaryWindow>>,
+	}
+	if keyboard_input.pressed(KeyCode::Space) {
+		move_vec += Vec3::from(transform.up());
+	}
+
+	transform.translation += move_vec.normalize_or_zero() * cam.speed * time.delta_seconds();
+}
+
+fn update_camera_mouse(
+	mut cam_query: Query<&mut Transform, With<PhosCamera>>,
+	mut mouse_move: EventReader<MouseMotion>,
+	time: Res<Time>,
+	windows: Query<&Window>,
+) {
+	let window = windows.single();
+	if window.cursor.grab_mode != CursorGrabMode::Locked {
+		return;
+	}
+	let mut transform = cam_query.single_mut();
+
+	for ev in mouse_move.read() {
+		let (mut yaw, mut pitch, _) = transform.rotation.to_euler(EulerRot::YXZ);
+		match window.cursor.grab_mode {
+			CursorGrabMode::None => (),
+			_ => {
+				// Using smallest of height or width ensures equal vertical and horizontal sensitivity
+				pitch -= ev.delta.y.to_radians() * time.delta_seconds() * 5.;
+				yaw -= ev.delta.x.to_radians() * time.delta_seconds() * 5.;
+			}
+		}
+
+		pitch = pitch.clamp(-1.54, 1.54);
+
+		// Order is important to prevent unintended roll
+		transform.rotation = Quat::from_axis_angle(Vec3::Y, yaw) * Quat::from_axis_angle(Vec3::X, pitch);
+	}
+}
+
+fn grab_mouse(mut windows: Query<&mut Window>, mouse: Res<ButtonInput<MouseButton>>, key: Res<ButtonInput<KeyCode>>) {
+	let mut window = windows.single_mut();
+
+	if mouse.just_pressed(MouseButton::Middle) {
+		window.cursor.visible = false;
+		window.cursor.grab_mode = CursorGrabMode::Locked;
+	}
+
+	if key.just_pressed(KeyCode::Escape) {
+		window.cursor.visible = true;
+		window.cursor.grab_mode = CursorGrabMode::None;
+	}
+}
+
+fn rts_camera_system(
+	mut cam_query: Query<(&mut Transform, &PhosCamera, &mut PhosCameraTargets)>,
+	mut wheel: EventReader<MouseWheel>,
 	key: Res<ButtonInput<KeyCode>>,
 	time: Res<Time>,
-	map: Res<Map>,
+	heightmap: Res<Map>,
-	#[cfg(debug_assertions)] mut gizmos: Gizmos,
+) {
-)
+	let (mut cam, cam_cfg, mut cam_targets) = cam_query.single_mut();
-{
-	let (mut transform, config, mut orbit, bounds) = cam_query.into_inner();
-
-	let target = orbit.target;
-	let mut cam_pos = target;
-
-	//Apply Camera Dist
-	cam_pos -= orbit.forward * orbit.distance;
-
-	if mouse.pressed(MouseButton::Middle)
-	{
-		let mut orbit_move = Vec2::ZERO;
-		for e in mouse_motion.read()
-		{
-			orbit_move += e.delta;
-		}
-		orbit_move *= config.pan_speed * time.delta_secs() * -1.0;
-		let rot_y = Quat::from_axis_angle(Vec3::Y, orbit_move.x);
-		let right = orbit.forward.cross(Vec3::Y).normalize();
-		let rot_x = Quat::from_axis_angle(right, orbit_move.y);
-		orbit.forward = rot_x * rot_y * orbit.forward;
-		// orbit.forward.y = orbit.forward.y.clamp(-0.9, 0.0);
-		orbit.forward = orbit.forward.normalize();
-		cursor_options.grab_mode = CursorGrabMode::Locked;
-		cursor_options.visible = false;
-	}
-	else
-	{
-		cursor_options.grab_mode = CursorGrabMode::None;
-		cursor_options.visible = true;
-	}
-	if key.pressed(KeyCode::KeyE)
-	{
-		let rot = Quat::from_axis_angle(Vec3::Y, f32::to_radians(config.speed) * time.delta_secs());
-		orbit.forward = rot * orbit.forward;
-	}
-	else if key.pressed(KeyCode::KeyQ)
-	{
-		let rot = Quat::from_axis_angle(Vec3::Y, f32::to_radians(-config.speed) * time.delta_secs());
-		orbit.forward = rot * orbit.forward;
-	}
-
 	let mut cam_move = Vec3::ZERO;
+	let mut cam_pos = cam.translation;
 
-	if key.pressed(KeyCode::KeyA)
+	if key.pressed(KeyCode::KeyA) {
-	{
+		cam_move.x = -1.;
+	} else if key.pressed(KeyCode::KeyD) {
 		cam_move.x = 1.;
 	}
-	else if key.pressed(KeyCode::KeyD)
-	{
-		cam_move.x = -1.;
-	}
 
-	if key.pressed(KeyCode::KeyW)
+	if key.pressed(KeyCode::KeyW) {
-	{
+		cam_move.z = -1.;
+	} else if key.pressed(KeyCode::KeyS) {
 		cam_move.z = 1.;
 	}
-	else if key.pressed(KeyCode::KeyS)
-	{
-		cam_move.z = -1.;
-	}
 
-	let move_speed = if key.pressed(KeyCode::ShiftLeft)
+	let move_speed = if key.pressed(KeyCode::ShiftLeft) {
-	{
+		cam_cfg.speed * 2.
-		config.speed * 2.0
+	} else {
-	}
+		cam_cfg.speed
-	else
-	{
-		config.speed
 	};
 
-	if cam_move != Vec3::ZERO
+	cam_move = cam_move.normalize_or_zero() * move_speed * time.delta_seconds();
-	{
+	cam_pos += cam_move;
-		cam_move = cam_move.normalize();
-		let move_fwd = Vec3::new(orbit.forward.x, 0., orbit.forward.z).normalize();
-		let move_rot = Quat::from_rotation_arc(Vec3::NEG_Z, move_fwd);
-		#[cfg(debug_assertions)]
-		{
-			gizmos.arrow(orbit.target, orbit.target + move_fwd, LinearRgba::WHITE.with_alpha(0.5));
-			gizmos.arrow(orbit.target, orbit.target - (move_rot * cam_move), LinearRgba::BLUE);
-		}
-		orbit.target -= (move_rot * cam_move) * move_speed * time.delta_secs();
-		orbit.target.y = sample_ground(orbit.target, &map);
-
-		orbit.target.x = orbit.target.x.clamp(bounds.min.x, bounds.max.x);
-		orbit.target.z = orbit.target.z.clamp(bounds.min.y, bounds.max.y);
-	}
 
 	let mut scroll = 0.0;
-	for e in wheel.read()
+	for e in wheel.read() {
-	{
+		match e.unit {
-		match e.unit
-		{
 			MouseScrollUnit::Line => scroll += e.y * 5.,
 			MouseScrollUnit::Pixel => scroll += e.y,
 		}
 	}
 
-	orbit.distance -= scroll * time.delta_secs() * config.zoom_speed;
+	let ground_height = sample_ground(cam.translation, &heightmap);
-	orbit.distance = orbit.distance.clamp(config.min_height, config.max_height);
 
-	// let ground_below_cam = sample_ground(cam_pos, &map) + config.min_height;
+	cam_targets.height -= scroll;
-	// if cam_pos.y <= ground_below_cam {
+	if cam_targets.height > cam_cfg.max_height {
-	// 	cam_pos.y = ground_below_cam;
+		cam_targets.height = cam_cfg.max_height;
-	// }
-
-	// if cam_pos.y < target.y {
-	// 	cam_pos.y = target.y;
-	// }
-
-	transform.translation = cam_pos;
-	transform.look_at(target, Vec3::Y);
 	}
 
-fn sample_ground(pos: Vec3, heightmap: &Map) -> f32
+	let min_height = ground_height + cam_cfg.min_height;
-{
+
+	if min_height != cam_targets.last_height {
+		cam_targets.last_height = min_height;
+		cam_targets.anim_time = 0.;
+		cam_targets.rotate_time = 0.;
+	}
+
+	if scroll != 0. {
+		cam_targets.anim_time = 0.;
+		cam_targets.rotate_time = 0.;
+		if cam_targets.height < min_height {
+			cam_targets.height = min_height;
+		}
+	}
+
+	let desired_height = if cam_targets.height < min_height {
+		min_height
+	} else {
+		cam_targets.height
+	};
+	if cam_targets.anim_time < 1. {
+		cam_targets.anim_time += time.delta_seconds() * cam_cfg.zoom_speed;
+		cam_targets.anim_time = cam_targets.anim_time.min(1.);
+	}
+	cam_pos.y = f32::lerp(cam_pos.y, desired_height, cam_targets.anim_time);
+	if cam_pos.y < min_height {
+		cam_pos.y = min_height;
+	}
+	let t = cam_pos.y.remap(cam_cfg.min_height, cam_cfg.max_height, 0., 1.);
+
+	if cam_targets.rotate_time < 1. {
+		cam_targets.rotate_time += time.delta_seconds();
+		cam_targets.rotate_time = cam_targets.rotate_time.min(1.);
+	}
+	let angle = cam_cfg.min_angle.lerp(cam_cfg.max_angle, t);
+	let mut rot = cam.rotation.to_euler(EulerRot::XYZ);
+	rot.0 = -angle;
+	cam.rotation = Quat::from_euler(EulerRot::XYZ, rot.0, rot.1, rot.2);
+	// let rot = Quat::from_axis_angle(Vec3::X, -angle);
+	// cam.rotation = rot;
+
+	cam.translation = cam_pos;
+}
+
+fn sample_ground(pos: Vec3, heightmap: &Map) -> f32 {
 	let tile_under = HexCoord::from_world_pos(pos);
 	let neighbors = heightmap.get_neighbors(&tile_under);
-	let mut ground_height = if heightmap.is_in_bounds(&tile_under)
+	let mut ground_height = if heightmap.is_in_bounds(&tile_under) {
-	{
 		heightmap.sample_height(&tile_under)
-	}
+	} else {
-	else
+		heightmap.sea_level
-	{
-		heightmap.sealevel
 	};
 
-	for n in neighbors
+	for n in neighbors {
-	{
+		if let Some(h) = n {
-		if let Some(h) = n
+			if h > ground_height {
-		{
-			if h > ground_height
-			{
 				ground_height = h;
 			}
 		}
 	}
-	if ground_height < heightmap.sealevel
+	if ground_height < heightmap.sea_level {
-	{
+		ground_height = heightmap.sea_level;
-		ground_height = heightmap.sealevel;
 	}
 	return ground_height;
 }
+
+fn limit_camera_bounds(mut cam_query: Query<(&mut Transform, &CameraBounds)>) {
+	let (mut tranform, bounds) = cam_query.single_mut();
+
+	let mut pos = tranform.translation;
+
+	pos.x = pos.x.clamp(bounds.min.x, bounds.max.x);
+	pos.z = pos.z.clamp(bounds.min.y, bounds.max.y);
+
+	tranform.translation = pos;
+}

game/main/src/camera_system/components.rs

@@ -1,70 +1,66 @@
 use bevy::prelude::*;
-use hex::prelude::*;
+use world_generation::{hex_utils::SHORT_DIAGONAL, prelude::Chunk};
-use rayon::str;
 
 #[derive(Component, Reflect)]
 #[reflect(Component)]
-pub struct PhosCamera
+pub struct PhosCamera {
-{
 	pub min_height: f32,
 	pub max_height: f32,
 	pub speed: f32,
 	pub zoom_speed: f32,
-	pub pan_speed: Vec2,
 	pub min_angle: f32,
 	pub max_angle: f32,
 }
 
-impl Default for PhosCamera
+impl Default for PhosCamera {
-{
+	fn default() -> Self {
-	fn default() -> Self
-	{
 		Self {
 			min_height: 10.,
 			max_height: 420.,
 			speed: 100.,
-			pan_speed: Vec2::new(0.8, 0.5),
+			zoom_speed: 0.3,
-			zoom_speed: 20.,
 			min_angle: (20. as f32).to_radians(),
 			max_angle: 1.,
 		}
 	}
 }
-#[derive(Component, Reflect)]
+
-pub struct PhosOrbitCamera
+#[derive(Component)]
-{
+pub struct PhosCameraTargets {
-	pub target: Vec3,
+	pub height: f32,
-	pub distance: f32,
 	pub forward: Vec3,
+	pub last_height: f32,
+	pub anim_time: f32,
+	pub rotate_time: f32,
 }
 
-impl Default for PhosOrbitCamera
+impl Default for PhosCameraTargets {
-{
+	fn default() -> Self {
-	fn default() -> Self
-	{
 		Self {
-			target: Default::default(),
+			height: Default::default(),
-			distance: 40.0,
+			forward: Vec3::NEG_Z,
-			forward: Vec3::new(0.0, -0.5, 0.5).normalize(),
+			last_height: Default::default(),
+			anim_time: Default::default(),
+			rotate_time: Default::default(),
 		}
 	}
 }
 
 #[derive(Component, Default)]
-pub struct CameraBounds
+pub struct CameraBounds {
-{
 	pub min: Vec2,
 	pub max: Vec2,
 }
 
-impl CameraBounds
+impl CameraBounds {
-{
+	pub fn from_size(size: UVec2) -> Self {
-	pub fn from_size(world_size: Vec2) -> Self
-	{
 		let padding = Chunk::WORLD_SIZE;
 		return Self {
 			min: Vec2::ZERO - padding,
-			max: world_size + padding,
+			max: Vec2::new(
+				(size.x as usize * Chunk::SIZE) as f32 * SHORT_DIAGONAL,
+				(size.y * Chunk::SIZE as u32) as f32 * 1.5,
+			) + padding,
 		};
 	}
 }

game/main/src/main.rs

@@ -1,10 +1,7 @@
-use bevy::image::{ImageAddressMode, ImageFilterMode, ImageSamplerDescriptor};
 use bevy::pbr::wireframe::WireframePlugin;
 use bevy::prelude::*;
+use bevy::render::texture::{ImageAddressMode, ImageFilterMode, ImageSamplerDescriptor};
 use bevy::window::PresentMode;
-#[cfg(debug_assertions)]
-use bevy::window::WindowResolution;
-use bevy_inspector_egui::bevy_egui::EguiPlugin;
 use bevy_inspector_egui::quick::WorldInspectorPlugin;
 use phos::PhosGamePlugin;
 
@@ -13,11 +10,9 @@ mod map_rendering;
 mod phos;
 mod prelude;
 mod shader_extensions;
-mod ui;
 mod utlis;
 
-fn main()
+fn main() {
-{
 	App::new()
 		.add_plugins((
 			DefaultPlugins
@@ -26,7 +21,7 @@ fn main()
 						title: "Phos".into(),
 						name: Some("phos".into()),
 						#[cfg(debug_assertions)]
-						resolution: WindowResolution::new(1920, 1080),
+						resolution: (1920., 1080.).into(),
 						present_mode: PresentMode::AutoNoVsync,
 						#[cfg(not(debug_assertions))]
 						mode: bevy::window::WindowMode::BorderlessFullscreen,
@@ -47,9 +42,8 @@ fn main()
 					watch_for_changes_override: Some(true),
 					..Default::default()
 				}),
-			EguiPlugin::default(),
 			WorldInspectorPlugin::new(),
-			WireframePlugin::default(),
+			WireframePlugin,
 			PhosGamePlugin,
 		))
 		.run();

game/main/src/map_rendering/chunk_rebuild.rs

@@ -1,15 +1,14 @@
+use avian3d::prelude::*;
 use bevy::ecs::world::CommandQueue;
 use bevy::prelude::*;
 use bevy::tasks::*;
-use bevy_rapier3d::geometry::Collider;
+use bevy::utils::futures;
-use bevy_rapier3d::geometry::TriMeshFlags;
 use shared::events::ChunkModifiedEvent;
 use shared::events::TileModifiedEvent;
 use world_generation::prelude::Map;
 use world_generation::states::GeneratorState;
 
 use crate::prelude::RebuildChunk;
-use crate::prelude::WaterMesh;
 use crate::{
 	prelude::{PhosChunk, PhosChunkRegistry},
 	utlis::chunk_utils::prepare_chunk_mesh,
@@ -17,13 +16,11 @@ use crate::{
 
 pub struct ChunkRebuildPlugin;
 
-impl Plugin for ChunkRebuildPlugin
+impl Plugin for ChunkRebuildPlugin {
-{
+	fn build(&self, app: &mut App) {
-	fn build(&self, app: &mut App)
-	{
 		app.init_resource::<PhosChunkRegistry>();
-		app.add_message::<ChunkModifiedEvent>();
+		app.add_event::<ChunkModifiedEvent>();
-		app.add_message::<TileModifiedEvent>();
+		app.add_event::<TileModifiedEvent>();
 		app.add_systems(PreUpdate, chunk_rebuilder.run_if(in_state(GeneratorState::Idle)));
 		app.add_systems(PostUpdate, collider_task_resolver);
 	}
@@ -33,13 +30,10 @@ fn chunk_rebuilder(
 	mut commands: Commands,
 	chunk_query: Query<(Entity, &PhosChunk), (With<RebuildChunk>, Without<ChunkRebuildTask>)>,
 	heightmap: Res<Map>,
-)
+) {
-{
 	let pool = AsyncComputeTaskPool::get();
-	let map_size = UVec2::new(heightmap.width as u32, heightmap.height as u32);
 
-	for (chunk_entity, idx) in &chunk_query
+	for (chunk_entity, idx) in &chunk_query {
-	{
 		#[cfg(feature = "tracing")]
 		let _spawn_span = info_span!("Rebuild Chunk").entered();
 		info!("Rebuilding Chunk");
@@ -51,23 +45,17 @@ fn chunk_rebuilder(
 			#[cfg(feature = "tracing")]
 			let _spawn_span = info_span!("Rebuild Task").entered();
 			let mut queue = CommandQueue::default();
-			let (mesh, water_mesh, collider_data, _, _) =
+			let (mesh, collider_data, _, _) = prepare_chunk_mesh(&chunk_data, chunk_offset, chunk_index);
-				prepare_chunk_mesh(&chunk_data, chunk_data.sealevel, chunk_offset, chunk_index, map_size);
 			#[cfg(feature = "tracing")]
 			let trimesh_span = info_span!("Chunk Trimesh").entered();
-			let c = Collider::trimesh_with_flags(
+			let c = Collider::trimesh(collider_data.0, collider_data.1);
-				collider_data.0,
-				collider_data.1,
-				TriMeshFlags::DELETE_DUPLICATE_TRIANGLES,
-			)
-			.expect("Failed to build chunk mesh");
 			#[cfg(feature = "tracing")]
 			drop(trimesh_span);
 			queue.push(move |world: &mut World| {
 				world.entity_mut(chunk_entity).insert(c).remove::<ChunkRebuildTask>();
 			});
 
-			return (queue, mesh, water_mesh);
+			return (queue, mesh);
 		});
 
 		commands
@@ -78,28 +66,19 @@ fn chunk_rebuilder(
 }
 
 fn collider_task_resolver(
-	mut chunks: Query<(&mut ChunkRebuildTask, &Mesh3d, &WaterMesh), With<PhosChunk>>,
+	mut chunks: Query<(&mut ChunkRebuildTask, &Handle<Mesh>), With<PhosChunk>>,
 	mut commands: Commands,
 	mut meshes: ResMut<Assets<Mesh>>,
-)
+) {
-{
+	for (mut task, mesh_handle) in &mut chunks {
-	for (mut task, mesh_handle, water_mesh_handle) in &mut chunks
+		if let Some((mut c, mesh)) = futures::check_ready(&mut task.task) {
-	{
-		if let Some((mut c, chunk_mesh, water_mesh)) = futures::check_ready(&mut task.task)
-		{
 			commands.append(&mut c);
-			meshes
+			meshes.insert(mesh_handle, mesh);
-				.insert(mesh_handle.id(), chunk_mesh)
-				.expect("Failed to update chunk mesh");
-			meshes
-				.insert(water_mesh_handle.0, water_mesh)
-				.expect("Failed to update chink water mesh");
 		}
 	}
 }
 
 #[derive(Component)]
-struct ChunkRebuildTask
+struct ChunkRebuildTask {
-{
+	pub task: Task<(CommandQueue, Mesh)>,
-	pub task: Task<(CommandQueue, Mesh, Mesh)>,
 }

game/main/src/map_rendering/map_init.rs

@@ -1,40 +1,49 @@
 #[cfg(feature = "tracing")]
 use bevy::log::*;
-use bevy::{light::NotShadowCaster, pbr::ExtendedMaterial, prelude::*};
+use bevy::{
+	pbr::{ExtendedMaterial, NotShadowCaster},
+	prelude::*,
+	render::texture::ImageFormat,
+};
 use bevy_asset_loader::prelude::*;
 
 use bevy_inspector_egui::quick::ResourceInspectorPlugin;
-use hex::prelude::*;
+use image::DynamicImage;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use shared::states::{AssetLoadState, GameplayState, MenuState};
-
 use world_generation::{
 	biome_asset::{BiomeAsset, BiomeAssetPlugin},
 	biome_painter::*,
 	heightmap::generate_heightmap,
-	map::biome_map::BiomeMap,
+	hex_utils::{offset_to_index, SHORT_DIAGONAL},
+	map::{
+		biome_map::{self, BiomeMap},
+		map_utils::{render_biome_noise_map, render_map},
+	},
 	prelude::*,
 	tile_manager::*,
 	tile_mapper::*,
 };
 
 use crate::{
-	prelude::{PhosAssets, PhosChunk, PhosChunkRegistry, WaterMesh},
+	camera_system::components::*,
+	prelude::{PhosAssets, PhosChunk, PhosChunkRegistry},
 	shader_extensions::{
 		chunk_material::ChunkMaterial,
 		water_material::{WaterMaterial, WaterSettings},
 	},
-	utlis::chunk_utils::{paint_map, prepare_chunk_mesh_with_collider},
+	utlis::{
+		chunk_utils::{paint_map, prepare_chunk_mesh_with_collider},
+		render_distance_system::RenderDistanceVisibility,
+	},
 };
 
-use super::{chunk_rebuild::ChunkRebuildPlugin, render_distance_system::RenderDistanceVisibility};
+use super::{chunk_rebuild::ChunkRebuildPlugin, terraforming_test::TerraFormingTestPlugin};
 
 pub struct MapInitPlugin;
 
-impl Plugin for MapInitPlugin
+impl Plugin for MapInitPlugin {
-{
+	fn build(&self, app: &mut App) {
-	fn build(&self, app: &mut App)
-	{
 		app.insert_state(GeneratorState::Startup);
 		app.insert_state(AssetLoadState::Loading);
 
@@ -44,13 +53,17 @@ impl Plugin for MapInitPlugin
 		app.add_plugins(BiomeAssetPlugin);
 
 		app.add_plugins(ResourceInspectorPlugin::<GenerationConfig>::default());
+		app.add_plugins(ResourceInspectorPlugin::<WaterInspect>::default());
 		app.register_type::<ExtendedMaterial<StandardMaterial, WaterMaterial>>();
 		app.register_asset_reflect::<ExtendedMaterial<StandardMaterial, WaterMaterial>>();
 		app.add_plugins((
 			ChunkRebuildPlugin,
 			// TerraFormingTestPlugin,
 			MaterialPlugin::<ExtendedMaterial<StandardMaterial, ChunkMaterial>>::default(),
-			MaterialPlugin::<ExtendedMaterial<StandardMaterial, WaterMaterial>>::default(),
+			MaterialPlugin::<ExtendedMaterial<StandardMaterial, WaterMaterial>> {
+				prepass_enabled: false,
+				..Default::default()
+			},
 		));
 
 		app.configure_loading_state(
@@ -74,18 +87,22 @@ impl Plugin for MapInitPlugin
 		app.add_systems(Update, despawn_map.run_if(in_state(GeneratorState::Regenerate)));
 		app.add_systems(
 			Update,
-			spawn_map.run_if(in_state(AssetLoadState::LoadComplete).and(in_state(GeneratorState::SpawnMap))),
+			spawn_map.run_if(in_state(AssetLoadState::LoadComplete).and_then(in_state(GeneratorState::SpawnMap))),
 		);
 
 		app.insert_resource(TileManager::default());
 	}
 }
 
+#[derive(Resource, Reflect, Default)]
+#[reflect(Resource)]
+struct WaterInspect(Handle<ExtendedMaterial<StandardMaterial, WaterMaterial>>);
+
 fn setup_materials(
+	mut commands: Commands,
 	mut phos_assets: ResMut<PhosAssets>,
 	mut water_materials: ResMut<Assets<ExtendedMaterial<StandardMaterial, WaterMaterial>>>,
-)
+) {
-{
 	let water_material = water_materials.add(ExtendedMaterial {
 		base: StandardMaterial {
 			base_color: Color::srgb(0., 0.878, 1.),
@@ -103,6 +120,7 @@ fn setup_materials(
 			..default()
 		},
 	});
+	commands.insert_resource(WaterInspect(water_material.clone()));
 	phos_assets.water_material = water_material;
 }
 
@@ -111,8 +129,7 @@ fn finalize_biome_painter(
 	mut next_generator_state: ResMut<NextState<GeneratorState>>,
 	biome_painter: Res<BiomePainterAsset>,
 	biomes: Res<Assets<BiomeAsset>>,
-)
+) {
-{
 	let painter = biome_painter.build(&biomes);
 	commands.insert_resource(painter);
 	next_generator_state.set(GeneratorState::GenerateHeightmap);
@@ -123,14 +140,11 @@ fn finalize_texture(
 	mut images: ResMut<Assets<Image>>,
 	mut chunk_materials: ResMut<Assets<ExtendedMaterial<StandardMaterial, ChunkMaterial>>>,
 	mut next_load_state: ResMut<NextState<AssetLoadState>>,
-)
+) {
-{
 	let image = images.get_mut(atlas.handle.id()).unwrap();
 
 	let array_layers = image.height() / image.width();
-	image
+	image.reinterpret_stacked_2d_as_array(array_layers);
-		.reinterpret_stacked_2d_as_array(array_layers)
-		.expect("Failed to reinterpret as array");
 
 	let chunk_material = chunk_materials.add(ExtendedMaterial {
 		base: StandardMaterial::default(),
@@ -145,10 +159,10 @@ fn finalize_texture(
 
 fn create_heightmap(
 	mut commands: Commands,
+	mut cam: Query<(&mut Transform, Entity), With<PhosCamera>>,
 	mut next_state: ResMut<NextState<GeneratorState>>,
 	biome_painter: Res<BiomePainter>,
-)
+) {
-{
 	let config = GenerationConfig {
 		biome_blend: 32,
 		biome_dither: 10.,
@@ -201,6 +215,10 @@ fn create_heightmap(
 	};
 	let (heightmap, biome_map) = generate_heightmap(&config, 42069, &biome_painter);
 
+	let (mut cam_t, cam_entity) = cam.single_mut();
+	cam_t.translation = heightmap.get_center();
+
+	commands.entity(cam_entity).insert(CameraBounds::from_size(config.size));
 	commands.insert_resource(heightmap);
 	commands.insert_resource(biome_map);
 	commands.insert_resource(config);
@@ -219,30 +237,19 @@ fn spawn_map(
 	mut game_state: ResMut<NextState<MenuState>>,
 	mut gameplay_state: ResMut<NextState<GameplayState>>,
 	biome_painter: Res<BiomePainter>,
-)
+) {
-{
 	paint_map(&mut heightmap, &biome_painter, &tile_assets, &tile_mappers);
 
-	//Prepare Mesh Data
-	let map_size = UVec2::new(heightmap.width as u32, heightmap.height as u32);
 	let chunk_meshes: Vec<_> = heightmap
 		.chunks
 		.par_iter()
 		.map(|chunk: &Chunk| {
 			let index = offset_to_index(chunk.chunk_offset, heightmap.width);
-			return prepare_chunk_mesh_with_collider(
+			return prepare_chunk_mesh_with_collider(&heightmap.get_chunk_mesh_data(index), chunk.chunk_offset, index);
-				&heightmap.get_chunk_mesh_data(index),
-				heightmap.sealevel,
-				chunk.chunk_offset,
-				index,
-				map_size,
-			);
 		})
 		.collect();
 
 	let mut registry = PhosChunkRegistry::new(chunk_meshes.len());
-
-	//Spawn Chunks
 	{
 		#[cfg(feature = "tracing")]
 		let _spawn_span = info_span!("Spawn Chunks").entered();
@@ -251,40 +258,40 @@ fn spawn_map(
 			0.,
 			(Chunk::SIZE / 2) as f32 * 1.5,
 		);
-		for (chunk_mesh, water_mesh, collider, pos, index) in chunk_meshes
+		for (mesh, collider, pos, index) in chunk_meshes {
-		{
 			// let mesh_handle = meshes.a
-			let water_mesh_handle = meshes.add(water_mesh);
+			let chunk = commands.spawn((
-			let chunk = commands
+				MaterialMeshBundle {
-				.spawn((
+					mesh: meshes.add(mesh),
-					Mesh3d(meshes.add(chunk_mesh)),
+					material: atlas.chunk_material_handle.clone(),
-					MeshMaterial3d(atlas.chunk_material_handle.clone()),
+					transform: Transform::from_translation(pos),
-					Transform::from_translation(pos),
+					..default()
+				},
 				PhosChunk::new(index),
-					WaterMesh(water_mesh_handle.id()),
 				RenderDistanceVisibility::default().with_offset(visibility_offset),
 				collider,
-				))
+			));
-				.id();
+			registry.chunks.push(chunk.id());
-			let water = commands
-				.spawn((
-					Mesh3d(water_mesh_handle),
-					MeshMaterial3d(atlas.water_material.clone()),
-					Transform::from_translation(pos),
-					PhosChunk::new(index),
-					NotShadowCaster,
-					RenderDistanceVisibility::default().with_offset(visibility_offset),
-				))
-				.id();
-			registry.chunks.push(chunk);
-			registry.waters.push(water);
 		}
 	}
 
+	commands.spawn((
+		MaterialMeshBundle {
+			transform: Transform::from_translation(heightmap.get_center()),
+			mesh: meshes.add(
+				Plane3d::default()
+					.mesh()
+					.size(heightmap.get_world_width(), heightmap.get_world_height()),
+			),
+			material: atlas.water_material.clone(),
+			..default()
+		},
+		NotShadowCaster,
+	));
+
 	commands.insert_resource(registry);
 	generator_state.set(GeneratorState::Idle);
-	if cur_game_state.get() != &MenuState::InGame
+	if cur_game_state.get() != &MenuState::InGame {
-	{
 		game_state.set(MenuState::InGame);
 		gameplay_state.set(GameplayState::PlaceHQ);
 	}
@@ -298,10 +305,8 @@ fn despawn_map(
 	chunks: Query<Entity, With<PhosChunk>>,
 	mut next_state: ResMut<NextState<GeneratorState>>,
 	biome_painter: Res<BiomePainter>,
-)
+) {
-{
+	for chunk in chunks.iter() {
-	for chunk in chunks.iter()
-	{
 		commands.entity(chunk).despawn();
 	}
 

game/main/src/map_rendering/mod.rs

@@ -2,4 +2,3 @@ pub mod chunk_rebuild;
 pub mod map_init;
 pub mod prelude;
 pub mod terraforming_test;
-pub mod render_distance_system;

game/main/src/map_rendering/prelude.rs

@@ -1 +1,2 @@
-
+use bevy::prelude::*;
+use world_generation::biome_painter::BiomePainterAsset;

game/main/src/map_rendering/terraforming_test.rs

@@ -1,20 +1,21 @@
-use bevy::{platform::collections::HashSet, prelude::*};
+use avian3d::prelude::*;
+use bevy::{prelude::*, utils::hashbrown::HashSet, window::PrimaryWindow};
 use shared::{
 	events::{ChunkModifiedEvent, TileModifiedEvent},
 	resources::TileUnderCursor,
 	states::GameplayState,
 };
-use world_generation::{prelude::Map, states::GeneratorState};
+use world_generation::{hex_utils::HexCoord, prelude::Map, states::GeneratorState};
 
-use crate::prelude::{PhosChunkRegistry, RebuildChunk};
+use crate::{
+	camera_system::components::PhosCamera,
+	prelude::{PhosChunkRegistry, RebuildChunk},
+};
 
-#[allow(dead_code)]
 pub struct TerraFormingTestPlugin;
 
-impl Plugin for TerraFormingTestPlugin
+impl Plugin for TerraFormingTestPlugin {
-{
+	fn build(&self, app: &mut App) {
-	fn build(&self, app: &mut App)
-	{
 		app.add_systems(
 			Update,
 			deform
@@ -24,48 +25,40 @@ impl Plugin for TerraFormingTestPlugin
 	}
 }
 
-#[allow(dead_code)]
 fn deform(
 	mut commands: Commands,
 	mouse: Res<ButtonInput<MouseButton>>,
+	spatial_query: SpatialQuery,
 	mut heightmap: ResMut<Map>,
 	chunks: Res<PhosChunkRegistry>,
 	tile_under_cursor: Res<TileUnderCursor>,
-	mut chunk_modified: MessageWriter<ChunkModifiedEvent>,
+	mut chunk_modified: EventWriter<ChunkModifiedEvent>,
-	mut tile_modified: MessageWriter<TileModifiedEvent>,
+	mut tile_modified: EventWriter<TileModifiedEvent>,
-)
+) {
-{
 	let mut multi = 0.;
-	if mouse.just_pressed(MouseButton::Left)
+	if mouse.just_pressed(MouseButton::Left) {
-	{
 		multi = 1.;
-	}
+	} else if mouse.just_pressed(MouseButton::Right) {
-	else if mouse.just_pressed(MouseButton::Right)
-	{
 		multi = -1.;
 	}
 
-	if multi == 0.
+	if multi == 0. {
-	{
 		return;
 	}
 
-	if let Some(contact) = tile_under_cursor.0
+	if let Some(contact) = tile_under_cursor.0 {
-	{
 		#[cfg(feature = "tracing")]
 		let span = info_span!("Deform Mesh").entered();
 		let modified_tiles = heightmap.create_crater(&contact.tile, 5, 5. * multi);
 		let mut chunk_set: HashSet<usize> = HashSet::new();
-		for (tile, height) in modified_tiles
+		for (tile, height) in modified_tiles {
-		{
 			let chunk = tile.to_chunk_index(heightmap.width);
-			if !chunk_set.contains(&chunk)
+			if !chunk_set.contains(&chunk) {
-			{
+				chunk_modified.send(ChunkModifiedEvent { index: chunk });
-				chunk_modified.write(ChunkModifiedEvent { index: chunk });
 				chunk_set.insert(chunk);
 				commands.entity(chunks.chunks[chunk]).insert(RebuildChunk);
 			}
-			tile_modified.write(TileModifiedEvent::HeightChanged(tile, height));
+			tile_modified.send(TileModifiedEvent::HeightChanged(tile, height));
 		}
 		// commands.entity(e).insert(RebuildChunk);
 	}

game/main/src/phos.rs

@@ -1,32 +1,27 @@
 use crate::camera_system::components::PhosCamera;
 use crate::map_rendering::map_init::MapInitPlugin;
-use crate::map_rendering::render_distance_system::RenderDistancePlugin;
-use crate::ui::build_ui::BuildUIPlugin;
 use crate::utlis::editor_plugin::EditorPlugin;
+use crate::utlis::render_distance_system::RenderDistancePlugin;
 use crate::utlis::tile_selection_plugin::TileSelectionPlugin;
 use crate::{camera_system::camera_plugin::PhosCameraPlugin, utlis::debug_plugin::DebugPlugin};
-use bevy::diagnostic::{EntityCountDiagnosticsPlugin, FrameTimeDiagnosticsPlugin};
+use avian3d::{math::*, prelude::*};
-use bevy::light::CascadeShadowConfig;
+use bevy::{
-use bevy::{pbr::wireframe::WireframeConfig, prelude::*};
+	pbr::{wireframe::WireframeConfig, CascadeShadowConfig},
+	prelude::*,
+};
 use bevy_asset_loader::prelude::*;
-use bevy_rapier3d::dynamics::{Ccd, RigidBody, Velocity};
+use buildings::BuildingPugin;
-use bevy_rapier3d::geometry::Collider;
+use iyes_perf_ui::prelude::*;
-use bevy_rapier3d::plugin::{NoUserData, RapierPhysicsPlugin};
-// use buildings::BuildingPugin;
-// use iyes_perf_ui::prelude::*;
-// use shared::animation_plugin::SimpleAnimationPlugin;
 use shared::sets::GameplaySet;
 use shared::states::{GameplayState, MenuState};
 use shared::{despawn::DespawnPuglin, states::AssetLoadState};
-// use units::units_plugin::UnitsPlugin;
+use units::units_plugin::UnitsPlugin;
 use world_generation::states::GeneratorState;
 
 pub struct PhosGamePlugin;
 
-impl Plugin for PhosGamePlugin
+impl Plugin for PhosGamePlugin {
-{
+	fn build(&self, app: &mut App) {
-	fn build(&self, app: &mut App)
-	{
 		app.insert_state(AssetLoadState::Loading);
 		app.insert_state(MenuState::Loading);
 		app.insert_state(GameplayState::Waiting);
@@ -39,10 +34,8 @@ impl Plugin for PhosGamePlugin
 			PhosCameraPlugin,
 			MapInitPlugin,
 			RenderDistancePlugin,
-			// BuildingPugin,
+			BuildingPugin,
-			BuildUIPlugin,
+			UnitsPlugin,
-			// SimpleAnimationPlugin,
-			// UnitsPlugin,
 			DespawnPuglin,
 			TileSelectionPlugin,
 			#[cfg(debug_assertions)]
@@ -60,13 +53,13 @@ impl Plugin for PhosGamePlugin
 		app.add_systems(Update, spawn_sphere);
 
 		//Perf UI
-		app.add_plugins(FrameTimeDiagnosticsPlugin::default())
+		app.add_plugins(bevy::diagnostic::FrameTimeDiagnosticsPlugin)
-			.add_plugins(EntityCountDiagnosticsPlugin::default())
+			.add_plugins(bevy::diagnostic::EntityCountDiagnosticsPlugin)
-			.add_plugins(bevy::diagnostic::SystemInformationDiagnosticsPlugin);
+			.add_plugins(bevy::diagnostic::SystemInformationDiagnosticsPlugin)
-		// .add_plugins(PerfUiPlugin);
+			.add_plugins(PerfUiPlugin);
 
 		//Physics
-		app.add_plugins(RapierPhysicsPlugin::<NoUserData>::default());
+		app.add_plugins(PhysicsPlugins::default());
 		// app.add_plugins(RapierDebugRenderPlugin::default());
 
 		app.insert_resource(WireframeConfig {
@@ -76,56 +69,55 @@ impl Plugin for PhosGamePlugin
 	}
 }
 
-fn configure_gameplay_set(app: &mut App)
+fn configure_gameplay_set(app: &mut App) {
-{
 	app.configure_sets(
 		Update,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
 	);
 	app.configure_sets(
 		PreUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
 	);
 	app.configure_sets(
 		PostUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
 	);
 
 	app.configure_sets(
 		FixedUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
 	);
 	app.configure_sets(
 		FixedPreUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
 	);
 	app.configure_sets(
 		FixedPostUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
 	);
 }
 
-fn init_game(mut commands: Commands, mut materials: ResMut<Assets<StandardMaterial>>)
+fn init_game(mut commands: Commands, mut materials: ResMut<Assets<StandardMaterial>>) {
-{
-	// commands.spawn((
-	// 	PerfUiRoot::default(),
-	// 	PerfUiEntryFPS::default(),
-	// 	PerfUiEntryFPSWorst::default(),
-	// 	PerfUiEntryFrameTime::default(),
-	// 	PerfUiEntryFrameTimeWorst::default(),
-	// ));
-
 	commands.spawn((
-		DirectionalLight {
+		PerfUiRoot::default(),
+		PerfUiEntryFPS::default(),
+		PerfUiEntryFPSWorst::default(),
+		PerfUiEntryFrameTime::default(),
+		PerfUiEntryFrameTimeWorst::default(),
+	));
+
+	commands.spawn(DirectionalLightBundle {
+		directional_light: DirectionalLight {
 			shadows_enabled: true,
 			..default()
 		},
-		CascadeShadowConfig {
+		cascade_shadow_config: CascadeShadowConfig {
 			bounds: vec![200., 400., 600., 800.],
 			..default()
 		},
-		Transform::from_xyz(500., 260.0, 500.).looking_at(Vec3::ZERO, Vec3::Y),
+		transform: Transform::from_xyz(500., 260.0, 500.).looking_at(Vec3::ZERO, Vec3::Y),
-	));
+		..default()
+	});
 
 	let sphere_mat = StandardMaterial {
 		base_color: Color::srgb(1., 1., 0.),
@@ -140,22 +132,23 @@ struct SphereMat(Handle<StandardMaterial>);
 
 fn spawn_sphere(
 	mut commands: Commands,
-	cam: Single<&Transform, With<PhosCamera>>,
+	cam: Query<&Transform, With<PhosCamera>>,
 	keyboard_input: Res<ButtonInput<KeyCode>>,
 	mut meshes: ResMut<Assets<Mesh>>,
 	mat: Res<SphereMat>,
-)
+) {
-{
+	if keyboard_input.just_pressed(KeyCode::KeyF) {
-	if keyboard_input.just_pressed(KeyCode::KeyF)
+		let cam_transform = cam.single();
-	{
 		commands.spawn((
-			Mesh3d(meshes.add(Sphere::new(0.3))),
+			MaterialMeshBundle {
-			MeshMaterial3d(mat.0.clone()),
+				mesh: meshes.add(Sphere::new(0.3)),
-			Transform::from_translation(cam.translation),
+				material: mat.0.clone(),
-			Collider::ball(0.3),
+				transform: Transform::from_translation(cam_transform.translation),
+				..default()
+			},
+			Collider::sphere(0.3),
 			RigidBody::Dynamic,
-			Ccd::enabled(),
+			LinearVelocity(cam_transform.forward() * 50.),
-			Velocity::linear(cam.forward() * 50.),
 		));
 	}
 }

game/main/src/prelude.rs

@@ -3,13 +3,13 @@ use bevy::pbr::ExtendedMaterial;
 use bevy::prelude::*;
 use bevy::prelude::{Component, Image, Resource};
 use bevy_asset_loader::asset_collection::AssetCollection;
+use world_generation::biome_painter::BiomePainterAsset;
 
 use crate::shader_extensions::chunk_material::ChunkMaterial;
 use crate::shader_extensions::water_material::WaterMaterial;
 
 #[derive(AssetCollection, Resource, Default)]
-pub struct PhosAssets
+pub struct PhosAssets {
-{
 	#[asset(key = "chunk_atlas")]
 	pub handle: Handle<Image>,
 	pub chunk_material_handle: Handle<ExtendedMaterial<StandardMaterial, ChunkMaterial>>,
@@ -17,36 +17,25 @@ pub struct PhosAssets
 }
 
 #[derive(Component)]
-pub struct PhosChunk
+pub struct PhosChunk {
-{
 	pub index: usize,
 }
 
-impl PhosChunk
+impl PhosChunk {
-{
+	pub fn new(index: usize) -> Self {
-	pub fn new(index: usize) -> Self
-	{
 		return Self { index };
 	}
 }
 
-#[derive(Component)]
-pub struct WaterMesh(pub AssetId<Mesh>);
-
 #[derive(Resource, Default)]
-pub struct PhosChunkRegistry
+pub struct PhosChunkRegistry {
-{
 	pub chunks: Vec<Entity>,
-	pub waters: Vec<Entity>,
 }
 
-impl PhosChunkRegistry
+impl PhosChunkRegistry {
-{
+	pub fn new(size: usize) -> Self {
-	pub fn new(size: usize) -> Self
-	{
 		return Self {
 			chunks: Vec::with_capacity(size),
-			waters: Vec::with_capacity(size),
 		};
 	}
 }

game/main/src/shader_extensions/chunk_material.rs

@@ -1,76 +1,39 @@
 use bevy::asset::{Asset, Handle};
-use bevy::image::Image;
+use bevy::pbr::MaterialExtension;
-use bevy::pbr::{Material, MaterialExtension};
 use bevy::reflect::TypePath;
-use bevy::render::render_resource::AsBindGroup;
+use bevy::render::render_resource::{AsBindGroup, ShaderRef};
-use bevy::shader::ShaderRef;
+use bevy::render::texture::Image;
-use world_generation::consts::{ATTRIBUTE_PACKED_VERTEX_DATA, ATTRIBUTE_VERTEX_HEIGHT};
 
 #[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
-pub struct ChunkMaterial
+pub struct ChunkMaterial {
-{
 	#[texture(100, dimension = "2d_array")]
 	#[sampler(101)]
 	pub array_texture: Handle<Image>,
 }
 
-impl MaterialExtension for ChunkMaterial
+impl MaterialExtension for ChunkMaterial {
-{
+	fn fragment_shader() -> ShaderRef {
-	fn fragment_shader() -> ShaderRef
-	{
-		"shaders/world/chunk.wgsl".into()
-	}
-}
-
-#[allow(dead_code)]
-#[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
-pub struct PackedChunkMaterial
-{
-	#[texture(100, dimension = "2d_array")]
-	#[sampler(101)]
-	pub array_texture: Handle<Image>,
-}
-
-impl Material for PackedChunkMaterial
-{
-	fn fragment_shader() -> ShaderRef
-	{
 		"shaders/world/chunk.wgsl".into()
 	}
 
-	fn vertex_shader() -> ShaderRef
+	// fn vertex_shader() -> ShaderRef {
-	{
-		"shaders/world/chunk_packed.wgsl".into()
-	}
-
-	fn prepass_vertex_shader() -> ShaderRef
-	{
-		"shaders/world/chunk_packed.wgsl".into()
-	}
-
-	// fn deferred_vertex_shader() -> ShaderRef {
 	// 	"shaders/world/chunk_packed.wgsl".into()
 	// }
 
-	// fn opaque_render_method(&self) -> bevy::pbr::OpaqueRendererMethod {
+	// fn specialize(
-	// 	return OpaqueRendererMethod::Auto;
+	// 	_pipeline: &bevy::pbr::MaterialExtensionPipeline,
+	// 	descriptor: &mut bevy::render::render_resource::RenderPipelineDescriptor,
+	// 	layout: &bevy::render::mesh::MeshVertexBufferLayout,
+	// 	_key: bevy::pbr::MaterialExtensionKey<Self>,
+	// ) -> Result<(), bevy::render::render_resource::SpecializedMeshPipelineError> {
+	// 	let vertex_layout = layout.get_layout(&[
+	// 		// Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
+	// 		// Mesh::ATTRIBUTE_UV_0.at_shader_location(1),
+	// 		// Mesh::ATTRIBUTE_NORMAL.at_shader_location(2),
+	// 		ATTRIBUTE_PACKED_VERTEX_DATA.at_shader_location(7),
+	// 		ATTRIBUTE_VERTEX_HEIGHT.at_shader_location(8),
+	// 	])?;
+	// 	descriptor.vertex.buffers = vec![vertex_layout];
+	// 	Ok(())
 	// }
-
-	fn specialize(
-		_pipeline: &bevy::pbr::MaterialPipeline,
-		descriptor: &mut bevy::render::render_resource::RenderPipelineDescriptor,
-		layout: &bevy::mesh::MeshVertexBufferLayoutRef,
-		_key: bevy::pbr::MaterialPipelineKey<Self>,
-	) -> bevy::ecs::error::Result<(), bevy::render::render_resource::SpecializedMeshPipelineError>
-	{
-		let vertex_layout = layout.0.get_layout(&[
-			// Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
-			// Mesh::ATTRIBUTE_UV_0.at_shader_location(1),
-			// Mesh::ATTRIBUTE_NORMAL.at_shader_location(2),
-			ATTRIBUTE_PACKED_VERTEX_DATA.at_shader_location(7),
-			ATTRIBUTE_VERTEX_HEIGHT.at_shader_location(8),
-		])?;
-		descriptor.vertex.buffers = vec![vertex_layout];
-		Ok(())
-	}
 }

game/main/src/shader_extensions/water_material.rs

@@ -1,30 +1,26 @@
 use bevy::asset::Asset;
+use bevy::math::VectorSpace;
 use bevy::pbr::MaterialExtension;
 use bevy::prelude::*;
 use bevy::reflect::Reflect;
-use bevy::render::render_resource::{AsBindGroup, ShaderType};
+use bevy::render::render_resource::{AsBindGroup, ShaderRef, ShaderType};
-use bevy::shader::ShaderRef;
 
 #[derive(Asset, Reflect, AsBindGroup, Debug, Clone, Default)]
-pub struct WaterMaterial
+pub struct WaterMaterial {
-{
 	#[uniform(100)]
 	pub settings: WaterSettings,
 }
 
 #[derive(Debug, Clone, ShaderType, Reflect)]
-pub struct WaterSettings
+pub struct WaterSettings {
-{
 	pub offset: f32,
 	pub scale: f32,
 	pub f_power: f32,
 	pub deep_color: LinearRgba,
 }
 
-impl Default for WaterSettings
+impl Default for WaterSettings {
-{
+	fn default() -> Self {
-	fn default() -> Self
-	{
 		Self {
 			offset: 0.0,
 			scale: 1.0,
@@ -34,21 +30,18 @@ impl Default for WaterSettings
 	}
 }
 
-impl MaterialExtension for WaterMaterial
+impl MaterialExtension for WaterMaterial {
-{
+	fn fragment_shader() -> ShaderRef {
-	fn fragment_shader() -> ShaderRef
-	{
 		"shaders/world/water.wgsl".into()
 	}
 
 	// fn specialize(
-	// 	pipeline: &bevy::pbr::MaterialExtensionPipeline,
+	// 	_pipeline: &bevy::pbr::MaterialExtensionPipeline,
 	// 	descriptor: &mut bevy::render::render_resource::RenderPipelineDescriptor,
-	// 	layout: &bevy::mesh::MeshVertexBufferLayoutRef,
+	// 	layout: &bevy::render::mesh::MeshVertexBufferLayout,
-	// 	key: bevy::pbr::MaterialExtensionKey<Self>,
+	// 	_key: bevy::pbr::MaterialExtensionKey<Self>,
-	// ) -> std::result::Result<(), bevy::render::render_resource::SpecializedMeshPipelineError>
+	// ) -> Result<(), bevy::render::render_resource::SpecializedMeshPipelineError> {
-	// {
+	// 	let vertex_layout = layout.get_layout(&[
-	// 	let vertex_layout = layout.0.get_layout(&[
 	// 		// Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
 	// 		// Mesh::ATTRIBUTE_UV_0.at_shader_location(1),
 	// 		// Mesh::ATTRIBUTE_NORMAL.at_shader_location(2),

game/main/src/ui/build_ui.rs

@@ -1,39 +0,0 @@
-use bevy::{camera::visibility::RenderLayers, prelude::*};
-use shared::states::AssetLoadState;
-pub struct BuildUIPlugin;
-
-impl Plugin for BuildUIPlugin
-{
-	fn build(&self, app: &mut App)
-	{
-		app.add_systems(Startup, setup_cameras);
-		app.add_systems(Update, spawn_ui.run_if(in_state(AssetLoadState::LoadComplete)));
-	}
-}
-
-fn setup_cameras(mut commands: Commands)
-{
-	commands.spawn((Camera2d, IsDefaultUiCamera, RenderLayers::layer(2)));
-}
-
-fn spawn_ui(mut commands: Commands)
-{
-	commands
-		.spawn((Node {
-			width: Val::Percent(100.),
-			height: Val::Percent(100.),
-			justify_content: JustifyContent::Center,
-			align_items: AlignItems::End,
-			..default()
-		},))
-		// .insert(PickingBehavior::IGNORE)
-		.with_children(|parent| {
-			parent.spawn((
-				Node {
-					width: Val::Px(500.),
-					..Default::default()
-				},
-				BackgroundColor(LinearRgba::GREEN.into()),
-			));
-		});
-}

game/main/src/ui/mod.rs

@@ -1 +0,0 @@
-pub mod build_ui;

game/main/src/utlis/chunk_utils.rs

@@ -1,21 +1,18 @@
+use avian3d::prelude::*;
 #[cfg(feature = "tracing")]
 use bevy::log::*;
 use bevy::{
 	asset::Assets,
 	ecs::system::Res,
-	math::{IVec2, UVec2, Vec3},
+	math::{IVec2, Vec3},
-	mesh::Mesh,
+	render::mesh::Mesh,
 };
-use bevy_rapier3d::geometry::{Collider, TriMeshFlags};
-use hex::prelude::*;
 use rayon::iter::{IntoParallelRefMutIterator, ParallelIterator};
 use world_generation::{
 	biome_painter::BiomePainter,
-	generators::{
+	generators::{chunk_colliders::generate_chunk_collider, mesh_generator::generate_chunk_mesh},
-		chunk_colliders::generate_chunk_collider,
+	hex_utils::offset_to_world,
-		mesh_generator::{generate_chunk_mesh, generate_chunk_water_mesh},
+	prelude::{Chunk, Map, MeshChunkData},
-	},
-	prelude::{Map, MeshChunkData},
 	tile_manager::TileAsset,
 	tile_mapper::TileMapperAsset,
 };
@@ -25,8 +22,7 @@ pub fn paint_map(
 	painter: &BiomePainter,
 	tiles: &Res<Assets<TileAsset>>,
 	mappers: &Res<Assets<TileMapperAsset>>,
-)
+) {
-{
 	map.chunks.par_iter_mut().for_each(|chunk: &mut Chunk| {
 		paint_chunk(chunk, painter, tiles, mappers);
 	});
@@ -37,12 +33,9 @@ pub fn paint_chunk(
 	painter: &BiomePainter,
 	tiles: &Res<Assets<TileAsset>>,
 	mappers: &Res<Assets<TileMapperAsset>>,
-)
+) {
-{
+	for z in 0..Chunk::SIZE {
-	for z in 0..Chunk::SIZE
+		for x in 0..Chunk::SIZE {
-	{
-		for x in 0..Chunk::SIZE
-		{
 			let idx = x + z * Chunk::SIZE;
 			let height = chunk.heights[idx];
 			let biome_id = chunk.biome_id[idx];
@@ -57,21 +50,16 @@ pub fn paint_chunk(
 
 pub fn prepare_chunk_mesh(
 	chunk: &MeshChunkData,
-	sealevel: f32,
 	chunk_offset: IVec2,
 	chunk_index: usize,
-	map_size: UVec2,
+) -> (Mesh, (Vec<Vec3>, Vec<[u32; 3]>), Vec3, usize) {
-) -> (Mesh, Mesh, (Vec<Vec3>, Vec<[u32; 3]>), Vec3, usize)
-{
 	#[cfg(feature = "tracing")]
 	let _gen_mesh = info_span!("Generate Chunk").entered();
-	let chunk_mesh = generate_chunk_mesh(chunk);
+	let mesh = generate_chunk_mesh(chunk);
-	let water_mesh = generate_chunk_water_mesh(chunk, sealevel, map_size.x as usize, map_size.y as usize);
 	let col_data = generate_chunk_collider(chunk);
 
 	return (
-		chunk_mesh,
+		mesh,
-		water_mesh,
 		col_data,
 		offset_to_world(chunk_offset * Chunk::SIZE as i32, 0.),
 		chunk_index,
@@ -80,20 +68,15 @@ pub fn prepare_chunk_mesh(
 
 pub fn prepare_chunk_mesh_with_collider(
 	chunk: &MeshChunkData,
-	sealevel: f32,
 	chunk_offset: IVec2,
 	chunk_index: usize,
-	map_size: UVec2,
+) -> (Mesh, Collider, Vec3, usize) {
-) -> (Mesh, Mesh, Collider, Vec3, usize)
+	let (mesh, (col_verts, col_indicies), pos, index) = prepare_chunk_mesh(chunk, chunk_offset, chunk_index);
-{
-	let (chunk_mesh, water_mesh, (col_verts, col_indicies), pos, index) =
-		prepare_chunk_mesh(chunk, sealevel, chunk_offset, chunk_index, map_size);
 	let collider: Collider;
 	{
 		#[cfg(feature = "tracing")]
 		let _collider_span = info_span!("Create Collider Trimesh").entered();
-		collider = Collider::trimesh_with_flags(col_verts, col_indicies, TriMeshFlags::DELETE_DUPLICATE_TRIANGLES)
+		collider = Collider::trimesh(col_verts, col_indicies);
-			.expect("Failed to generate chunk collision mesh");
 	}
-	return (chunk_mesh, water_mesh, collider, pos, index);
+	return (mesh, collider, pos, index);
 }

game/main/src/utlis/debug_plugin.rs

@@ -1,20 +1,20 @@
-use bevy::prelude::*;
+use bevy::{prelude::*, window::PrimaryWindow};
+use bevy_inspector_egui::bevy_egui::{systems::InputEvents, EguiContexts};
+use bevy_inspector_egui::egui;
+use shared::resources::TileUnderCursor;
 use shared::states::GameplayState;
-use shared::{resources::TileUnderCursor, sets::GameplaySet};
+use shared::tags::MainCamera;
 use world_generation::{
-	consts::{HEX_CORNERS, WATER_HEX_CORNERS},
+	consts::HEX_CORNERS,
+	hex_utils::{HexCoord, INNER_RADIUS},
 	prelude::Map,
 	states::GeneratorState,
 };
 
-use crate::camera_system::components::{PhosCamera, PhosOrbitCamera};
-
 pub struct DebugPlugin;
 
-impl Plugin for DebugPlugin
+impl Plugin for DebugPlugin {
-{
+	fn build(&self, app: &mut App) {
-	fn build(&self, app: &mut App)
-	{
 		app.insert_state(DebugState::Base);
 
 		app.add_systems(
@@ -31,7 +31,6 @@ impl Plugin for DebugPlugin
 				.run_if(in_state(DebugState::Verbose)),
 		);
 
-		app.add_systems(Update, camera_debug.in_set(GameplaySet));
 		app.add_systems(Update, regenerate_map.run_if(in_state(GeneratorState::Idle)));
 
 		app.insert_resource(Shape(Polyline3d::new([
@@ -47,11 +46,10 @@ impl Plugin for DebugPlugin
 }
 
 #[derive(Resource)]
-struct Shape(pub Polyline3d);
+struct Shape(pub Polyline3d<7>);
 
 #[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
-pub enum DebugState
+pub enum DebugState {
-{
 	Base,
 	None,
 	Verbose,
@@ -61,51 +59,41 @@ fn regenerate_map(
 	mut generator_state: ResMut<NextState<GeneratorState>>,
 	mut gameplay_state: ResMut<NextState<GameplayState>>,
 	input: Res<ButtonInput<KeyCode>>,
-)
+) {
-{
+	if input.just_pressed(KeyCode::KeyR) {
-	if input.just_pressed(KeyCode::KeyR)
-	{
 		generator_state.set(GeneratorState::Regenerate);
 		gameplay_state.set(GameplayState::PlaceHQ);
 	}
 }
 
-fn show_tile_heights(map: Res<Map>, mut gizmos: Gizmos, shape: Res<Shape>, tile_under_cursor: Res<TileUnderCursor>)
+fn show_tile_heights(map: Res<Map>, mut gizmos: Gizmos, shape: Res<Shape>, tile_under_cursor: Res<TileUnderCursor>) {
-{
+	if let Some(contact) = tile_under_cursor.0 {
-	if let Some(contact) = tile_under_cursor.0
-	{
 		let height = map.sample_height(&contact.tile);
-		gizmos.primitive_3d(&shape.0, contact.tile.to_world(height + 0.01), Color::WHITE);
+		gizmos.primitive_3d(
+			&shape.0,
+			contact.tile.to_world(height + 0.01),
+			Quat::IDENTITY,
+			Color::WHITE,
+		);
+		let nbors = map.get_neighbors(&contact.tile);
+		let contact_tile_pos = contact.tile.to_world(map.sample_height(&contact.tile));
+
+		// for i in 0..6 {
+		// 	if let Some(s) = nbors[i] {
+		// 		let coord = contact.tile.get_neighbor(i);
+		// 		let p = coord.to_world(s);
+		// 		gizmos.arrow(p, p + Vec3::Y * (i as f32 + 1.0), Color::WHITE);
+		// 	}
+
+		// 	let p = HEX_CORNERS[i] + contact_tile_pos;
+		// 	gizmos.arrow(p, p + Vec3::Y * (i as f32 + 1.0), LinearRgba::rgb(1.0, 0.0, 0.5));
+		// }
 
 		gizmos.line(contact.point, contact.point + Vec3::X, LinearRgba::RED);
 		gizmos.line(contact.point, contact.point + Vec3::Y, LinearRgba::GREEN);
 		gizmos.line(contact.point, contact.point + Vec3::Z, LinearRgba::BLUE);
-
+		//gizmos.sphere(contact_point, Quat::IDENTITY, 0.1, LinearRgba::rgb(1., 0., 0.5));
-		// show_water_corners(contact.tile.to_world(height + 1.0), &mut gizmos);
 	}
 }
 
-#[allow(dead_code)]
-fn show_water_corners(pos: Vec3, gizmos: &mut Gizmos)
-{
-	for i in 0..WATER_HEX_CORNERS.len()
-	{
-		let p = pos + WATER_HEX_CORNERS[i];
-		let p2 = pos + WATER_HEX_CORNERS[(i + 1) % WATER_HEX_CORNERS.len()];
-
-		gizmos.line(p, p2, LinearRgba::RED);
-	}
-}
-
-fn camera_debug(cam_query: Single<(&PhosCamera, &PhosOrbitCamera)>, mut gizmos: Gizmos)
-{
-	let (_config, orbit) = cam_query.into_inner();
-
-	gizmos.sphere(orbit.target, 0.3, LinearRgba::RED);
-	let cam_proxy = orbit.target - (orbit.forward * 10.0);
-	gizmos.ray(orbit.target, orbit.forward * 10.0, LinearRgba::rgb(1.0, 0.0, 1.0));
-
-	gizmos.circle(cam_proxy, 0.3, LinearRgba::rgb(1.0, 1.0, 0.0));
-}
-
 fn verbose_data() {}

game/main/src/utlis/editor_plugin.rs

@@ -1,5 +1,4 @@
-use bevy::asset::RenderAssetUsages;
+use bevy::{prelude::*, render::render_asset::RenderAssetUsages};
-use bevy::prelude::*;
 use bevy_inspector_egui::bevy_egui::EguiContexts;
 use bevy_inspector_egui::egui::{self};
 use image::{ImageBuffer, Rgba};
@@ -11,10 +10,8 @@ use world_generation::{map::map_utils::render_map, prelude::Map, states::Generat
 
 pub struct EditorPlugin;
 
-impl Plugin for EditorPlugin
+impl Plugin for EditorPlugin {
-{
+	fn build(&self, app: &mut App) {
-	fn build(&self, app: &mut App)
-	{
 		app.init_resource::<UIState>();
 
 		app.add_systems(PostUpdate, prepare_image.run_if(in_state(GeneratorState::SpawnMap)));
@@ -28,8 +25,7 @@ impl Plugin for EditorPlugin
 #[derive(Resource)]
 struct MapImage(pub Handle<Image>);
 
-pub fn prepare_image(mut images: ResMut<Assets<Image>>, heightmap: Res<Map>, mut commands: Commands)
+pub fn prepare_image(mut images: ResMut<Assets<Image>>, heightmap: Res<Map>, mut commands: Commands) {
-{
 	let image = render_map(&heightmap, 0.1);
 	let handle = images.add(Image::from_dynamic(image.into(), true, RenderAssetUsages::RENDER_WORLD));
 
@@ -37,17 +33,14 @@ pub fn prepare_image(mut images: ResMut<Assets<Image>>, heightmap: Res<Map>, mut
 }
 
 #[derive(Resource)]
-struct UIState
+struct UIState {
-{
 	pub is_open: bool,
 	pub target_map_type: MapDisplayType,
 	pub cur_map_type: MapDisplayType,
 }
 
-impl Default for UIState
+impl Default for UIState {
-{
+	fn default() -> Self {
-	fn default() -> Self
-	{
 		Self {
 			is_open: true,
 			target_map_type: default(),
@@ -57,8 +50,7 @@ impl Default for UIState
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Default)]
-enum MapDisplayType
+enum MapDisplayType {
-{
 	#[default]
 	HeightMap,
 	Biomes,
@@ -69,39 +61,35 @@ enum MapDisplayType
 }
 
 fn asset_reloaded(
-	mut asset_events: MessageReader<AssetEvent<BiomeAsset>>,
+	mut asset_events: EventReader<AssetEvent<BiomeAsset>>,
-	biomes: Res<Assets<BiomeAsset>>,
+	mut biomes: ResMut<Assets<BiomeAsset>>,
 	biome_painter: Res<BiomePainterAsset>,
 	mut commands: Commands,
-)
+) {
-{
 	let mut rebuild = false;
-	for event in asset_events.read()
+	for event in asset_events.read() {
-	{
+		match event {
-		match event
-		{
 			AssetEvent::Modified {..}=>	rebuild = true,
 			_ => (),
 		}
 	}
-	if rebuild
+	if rebuild {
-	{
 		let painter = biome_painter.build(&biomes);
 		commands.insert_resource(painter);
 	}
 }
 
 fn render_map_ui(
-	// image: Res<MapImage>,
+	image: Res<MapImage>,
 	heightmap: Res<Map>,
 	biome_map: Res<BiomeMap>,
 	mut contexts: EguiContexts,
 	mut state: ResMut<UIState>,
-)
+) {
-{
+	let id = contexts.add_image(image.0.clone_weak());
-	// let id = contexts.add_image(image.0.);
+
 	let mut map_type = state.target_map_type;
-	let ctx = contexts.ctx_mut().expect("Failed to get egui context");
+	let ctx = contexts.ctx_mut();
 	egui::Window::new("Map").open(&mut state.is_open).show(ctx, |ui| {
 		ui.label("Map Test");
 		egui::ComboBox::from_label("Display Type")
@@ -127,13 +115,12 @@ fn render_map_ui(
 				);
 			});
 
-		// ui.add(egui::widgets::Image::new(egui::load::SizedTexture::new(
+		ui.add(egui::widgets::Image::new(egui::load::SizedTexture::new(
-		// 	id,
+			id,
-		// 	[512.0, 512.0],
+			[512.0, 512.0],
-		// )));
+		)));
 
-		if ui.button("Save Image").clicked()
+		if ui.button("Save Image").clicked() {
-		{
 			let img = get_map_image(&heightmap, &biome_map, map_type);
 			_ = img.save(format!("{:?}.png", map_type));
 		}
@@ -148,28 +135,22 @@ fn update_map_render(
 	heightmap: Res<Map>,
 	biome_map: Res<BiomeMap>,
 	image: Res<MapImage>,
-)
+) {
-{
+	if state.cur_map_type == state.target_map_type {
-	if state.cur_map_type == state.target_map_type
-	{
 		return;
 	}
 
 	let result = get_map_image(&heightmap, &biome_map, state.target_map_type);
-	images
+	images.insert(
-		.insert(
 		image.0.id(),
 		Image::from_dynamic(result.into(), true, RenderAssetUsages::RENDER_WORLD),
-		)
+	);
-		.expect("Failed to update map image");
 
 	state.cur_map_type = state.target_map_type;
 }
 
-fn get_map_image(heightmap: &Map, biome_map: &BiomeMap, map_type: MapDisplayType) -> ImageBuffer<Rgba<u8>, Vec<u8>>
+fn get_map_image(heightmap: &Map, biome_map: &BiomeMap, map_type: MapDisplayType) -> ImageBuffer<Rgba<u8>, Vec<u8>> {
-{
+	return match map_type {
-	return match map_type
-	{
 		MapDisplayType::HeightMap => render_map(&heightmap, 0.1),
 		MapDisplayType::Biomes => render_biome_map(&heightmap, &biome_map),
 		MapDisplayType::BiomeNoise => render_biome_noise_map(&biome_map, Vec3::ONE),

game/main/src/utlis/mod.rs

@@ -1,4 +1,5 @@
 pub mod chunk_utils;
+pub mod render_distance_system;
 pub mod debug_plugin;
 pub mod editor_plugin;
 pub mod tile_selection_plugin;

game/main/src/utlis/render_distance_system.rs

@@ -1,82 +1,70 @@
 use bevy::prelude::*;
-use shared::tags::MainCamera;
+
+use crate::camera_system::components::PhosCamera;
 
 pub struct RenderDistancePlugin;
 
-impl Plugin for RenderDistancePlugin
+impl Plugin for RenderDistancePlugin {
-{
+	fn build(&self, app: &mut bevy::prelude::App) {
-	fn build(&self, app: &mut bevy::prelude::App)
-	{
 		app.register_type::<RenderDistanceSettings>();
 		app.add_systems(PostUpdate, render_distance_system)
 			.insert_resource(RenderDistanceSettings::default());
+
+		#[cfg(debug_assertions)]
+		app.insert_resource(RenderDistanceSettings::new(f32::MAX));
 	}
 }
 
 #[derive(Resource, Reflect)]
 #[reflect(Resource)]
-pub struct RenderDistanceSettings
+pub struct RenderDistanceSettings {
-{
 	pub render_distance: f32,
 }
 
-impl RenderDistanceSettings
+impl RenderDistanceSettings {
-{
+	pub fn new(distance: f32) -> Self {
-	pub fn new(distance: f32) -> Self
-	{
 		return Self {
 			render_distance: distance,
 		};
 	}
 }
 
-impl Default for RenderDistanceSettings
+impl Default for RenderDistanceSettings {
-{
+	fn default() -> Self {
-	fn default() -> Self
-	{
 		Self::new(500.)
 	}
 }
 
 #[derive(Component)]
-pub struct RenderDistanceVisibility
+pub struct RenderDistanceVisibility {
-{
 	pub offset: Vec3,
 }
 
-impl RenderDistanceVisibility
+impl RenderDistanceVisibility {
-{
+	pub fn with_offset(mut self, offset: Vec3) -> Self {
-	pub fn with_offset(mut self, offset: Vec3) -> Self
-	{
 		self.offset = offset;
 		return self;
 	}
 }
 
-impl Default for RenderDistanceVisibility
+impl Default for RenderDistanceVisibility {
-{
+	fn default() -> Self {
-	fn default() -> Self
-	{
 		Self { offset: Vec3::ZERO }
 	}
 }
 
 fn render_distance_system(
 	mut objects: Query<(&Transform, &mut Visibility, &RenderDistanceVisibility)>,
-	camera: Single<&Transform, With<MainCamera>>,
+	camera_query: Query<&Transform, With<PhosCamera>>,
 	settings: Res<RenderDistanceSettings>,
-)
+) {
-{
+	let camera = camera_query.single();
 	let cam_pos = Vec3::new(camera.translation.x, 0.0, camera.translation.z);
-	for (t, mut vis, r) in objects.iter_mut()
+	for (t, mut vis, r) in objects.iter_mut() {
-	{
 		let dist = (cam_pos - (t.translation + r.offset)).length();
-		if settings.render_distance < dist
+		if settings.render_distance < dist {
-		{
 			*vis = Visibility::Hidden;
-		}
+		} else {
-		else
-		{
 			*vis = Visibility::Visible;
 		}
 	}

game/main/src/utlis/tile_selection_plugin.rs

@@ -1,18 +1,14 @@
+use avian3d::prelude::{SpatialQuery, SpatialQueryFilter};
 use bevy::{prelude::*, window::PrimaryWindow};
-use bevy_rapier3d::{plugin::ReadRapierContext, prelude::QueryFilter};
-use hex::prelude::*;
 use shared::{
 	resources::{TileContact, TileUnderCursor},
 	tags::MainCamera,
 };
-use world_generation::{prelude::Map, states::GeneratorState};
+use world_generation::{hex_utils::HexCoord, prelude::Map, states::GeneratorState};
-
 pub struct TileSelectionPlugin;
 
-impl Plugin for TileSelectionPlugin
+impl Plugin for TileSelectionPlugin {
-{
+	fn build(&self, app: &mut App) {
-	fn build(&self, app: &mut App)
-	{
 		app.init_resource::<TileUnderCursor>();
 		app.add_systems(
 			PreUpdate,
@@ -22,43 +18,36 @@ impl Plugin for TileSelectionPlugin
 }
 
 fn update_tile_under_cursor(
-	cam_query: Single<(&GlobalTransform, &Camera), With<MainCamera>>,
+	cam_query: Query<(&GlobalTransform, &Camera), With<MainCamera>>,
-	window: Single<&Window, With<PrimaryWindow>>,
+	window: Query<&Window, With<PrimaryWindow>>,
-	rapier: ReadRapierContext,
+	spatial_query: SpatialQuery,
 	map: Res<Map>,
 	mut tile_under_cursor: ResMut<TileUnderCursor>,
-)
+) {
-{
+	let win = window.single();
-	let (cam_transform, camera) = cam_query.into_inner();
+	let (cam_transform, camera) = cam_query.single();
-	let Some(cursor_pos) = window.cursor_position()
+	let Some(cursor_pos) = win.cursor_position() else {
-	else
-	{
 		return;
 	};
 
-	let Ok(cam_ray) = camera.viewport_to_world(cam_transform, cursor_pos)
+	let Some(cam_ray) = camera.viewport_to_world(cam_transform, cursor_pos) else {
-	else
-	{
 		return;
 	};
 
-	let ctx = rapier.single().expect("Failed to get rapier read context");
+	let collision = spatial_query.cast_ray(
-
-	let collision = ctx.cast_ray(
 		cam_ray.origin,
 		cam_ray.direction.into(),
 		500.,
 		true,
-		QueryFilter::only_fixed(),
+		SpatialQueryFilter::default(),
 	);
 
-	if let Some((_e, dist)) = collision
+	if let Some(data) = collision {
-	{
+		let dist = data.time_of_impact;
 		let contact_point = cam_ray.get_point(dist);
 		let contact_coord = HexCoord::from_world_pos(contact_point);
 		//todo: handle correct tile detection when contacting a tile from the side
-		if !map.is_in_bounds(&contact_coord)
+		if !map.is_in_bounds(&contact_coord) {
-		{
 			tile_under_cursor.0 = None;
 			return;
 		}
@@ -68,9 +57,7 @@ fn update_tile_under_cursor(
 			contact_point,
 			contact_coord.to_world(surface),
 		));
-	}
+	} else {
-	else
-	{
 		tile_under_cursor.0 = None;
 	}
 }

game/resources/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "resources"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-bevy = "0.18.0"
-world_generation = { path = "../../engine/world_generation" }
-shared = { path = "../shared" }
-serde = { version = "1.0.228", features = ["derive"] }
-asset_loader = { path = "../../engine/asset_loader" }
-serde_json = "1.0.149"
-ron = "0.12.0"
-bevy_asset_loader = { version = "0.25.0", features = [
-	"standard_dynamic_assets",
-	"3d",
-] }
-
-[features]
-tracing = []

game/resources/src/lib.rs

@@ -1,16 +0,0 @@
-pub mod resource_asset;
-
-pub fn add(left: usize, right: usize) -> usize {
-	left + right
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-
-	#[test]
-	fn it_works() {
-		let result = add(2, 2);
-		assert_eq!(result, 4);
-	}
-}

game/resources/src/resource_asset.rs

@@ -1,49 +0,0 @@
-use asset_loader::create_asset_loader;
-use bevy::prelude::*;
-use bevy_asset_loader::asset_collection::AssetCollection;
-use serde::{Deserialize, Serialize};
-use shared::Tier;
-
-#[derive(Asset, TypePath, Debug, Serialize, Deserialize)]
-pub struct ResourceAsset {
-	pub identifier: String,
-	pub name: String,
-	pub description: String,
-	pub sprite_id: usize,
-	pub tier: Tier,
-}
-
-create_asset_loader!(
-	ResourceAssetPlugin,
-	ResourceAssetLoader,
-	ResourceAsset,
-	&["res", "res.ron"],
-	;?
-);
-
-#[derive(Resource, AssetCollection)]
-pub struct ResourceDatabase {
-	#[asset(key = "resources", collection(typed))]
-	pub units: Vec<Handle<ResourceAsset>>,
-}
-
-impl ResourceDatabase {
-	pub fn create_lookup(&self, assets: &Assets<ResourceAsset>) -> ResourceLookup {
-		let mut identifiers = Vec::with_capacity(self.units.len());
-		for handle in &self.units {
-			if let Some(asset) = assets.get(handle.id()) {
-				identifiers.push(asset.identifier.clone());
-			}
-		}
-		return ResourceLookup {
-			handles: self.units.clone(),
-			identifiers,
-		};
-	}
-}
-
-#[derive(Resource)]
-pub struct ResourceLookup {
-	pub handles: Vec<Handle<ResourceAsset>>,
-	pub identifiers: Vec<String>,
-}

game/shared/Cargo.toml

@@ -6,10 +6,9 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.18.0"
+bevy = "0.14.0"
-serde = { version = "1.0.228", features = ["derive"] }
+serde = { version = "1.0.204", features = ["derive"] }
 world_generation = { path = "../../engine/world_generation" }
-hex = { path = "../../engine/hex" }
 
 
 [features]

game/shared/src/animation_plugin.rs

@@ -1,18 +0,0 @@
-use bevy::prelude::*;
-
-use crate::prefab_defination::RotationAnimation;
-
-pub struct SimpleAnimationPlugin;
-
-impl Plugin for SimpleAnimationPlugin {
-	fn build(&self, app: &mut App) {
-		app.add_systems(Update, rotate);
-	}
-}
-
-fn rotate(mut query: Query<(&mut Transform, &RotationAnimation)>, time: Res<Time>) {
-	for (mut transform, rot) in query.iter_mut() {
-		let cur_rot = transform.rotation;
-		transform.rotation = cur_rot * Quat::from_axis_angle(rot.axis, rot.speed.to_radians() * time.delta_secs());
-	}
-}

game/shared/src/building.rs

@@ -1,7 +1,6 @@
-use bevy::reflect::Reflect;
 use serde::{Deserialize, Serialize};
 
-#[derive(Default, Reflect, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Default, PartialEq, Eq, Serialize, Deserialize)]
 pub struct BuildingIdentifier(pub usize);
 
 impl From<i32> for BuildingIdentifier {

game/shared/src/component_defination.rs

@@ -1,20 +0,0 @@
-use bevy::{
-	ecs::system::EntityCommands, math::{Quat, Vec3}, prelude::*
-};
-use serde::{Deserialize, Serialize};
-
-use crate::prefab_defination::AnimationComponent;
-#[derive(Serialize, Deserialize, Debug)]
-pub struct ComponentDefination {
-	pub path: String,
-	pub animations: Vec<AnimationComponent>,
-}
-
-
-impl ComponentDefination {
-	pub fn apply(&self, commands: &mut EntityCommands){
-		for c in &self.animations {
-			c.apply(commands);
-		}
-	}
-}

game/shared/src/coords.rs

@@ -1,69 +0,0 @@
-use bevy::prelude::*;
-use hex::prelude::*;
-
-#[derive(Default, Debug, Reflect)]
-pub struct CoordsCollection
-{
-	points: Vec<IVec2>,
-	origin: IVec2,
-	translation: IVec2,
-	rotation: i32,
-}
-
-impl CoordsCollection
-{
-	pub fn from_hex(coords: Vec<HexCoord>) -> Self
-	{
-		CoordsCollection {
-			points: coords.iter().map(|c| c.hex.xy()).collect(),
-			..default()
-		}
-	}
-
-	pub fn from_points(points: Vec<IVec2>) -> Self
-	{
-		CoordsCollection { points, ..default() }
-	}
-
-	pub fn with_translation(mut self, translation: &HexCoord) -> Self
-	{
-		self.translation = translation.hex.xy();
-		return self;
-	}
-
-	pub fn with_translation_vec(mut self, translation: IVec2) -> Self
-	{
-		self.translation = translation;
-		return self;
-	}
-
-	pub fn with_origin(mut self, orign: &HexCoord) -> Self
-	{
-		self.origin = orign.hex.xy();
-		return self;
-	}
-
-	pub fn with_rotation(mut self, rotation: i32) -> Self
-	{
-		self.rotation = rotation;
-		return self;
-	}
-
-	pub fn get_coords(&self) -> Vec<HexCoord>
-	{
-		let center = HexCoord::from_axial(self.origin);
-		return self
-			.points
-			.iter()
-			.map(|p| HexCoord::from_axial(p + self.origin).rotate_around(&center, self.rotation))
-			.collect();
-	}
-}
-
-impl Into<Vec<HexCoord>> for CoordsCollection
-{
-	fn into(self) -> Vec<HexCoord>
-	{
-		self.get_coords()
-	}
-}

game/shared/src/despawn.rs

@@ -24,7 +24,7 @@ impl Plugin for DespawnPuglin {
 
 fn despawn_at(mut commands: Commands, time: Res<Time>, entities: Query<(Entity, &DespawnAt), Without<DespawnAfter>>) {
 	for (entity, at) in entities.iter() {
-		let d = at.0 - time.elapsed_secs();
+		let d = at.0 - time.elapsed_seconds();
 		commands
 			.entity(entity)
 			.insert(DespawnAfter(Timer::from_seconds(d, TimerMode::Once)));
@@ -34,7 +34,7 @@ fn despawn_at(mut commands: Commands, time: Res<Time>, entities: Query<(Entity,
 fn despawn_after(mut commands: Commands, mut entities: Query<(&mut DespawnAfter, Entity)>, time: Res<Time>) {
 	for (mut after, entity) in &mut entities.iter_mut() {
 		after.0.tick(time.delta());
-		if after.0.is_finished() {
+		if after.0.finished() {
 			commands.entity(entity).despawn();
 		}
 	}

game/shared/src/events.rs

@@ -1,15 +1,13 @@
 use bevy::prelude::*;
-use hex::prelude::*;
+use world_generation::hex_utils::*;
 
-#[derive(Message)]
+#[derive(Event)]
-pub enum TileModifiedEvent
+pub enum TileModifiedEvent {
-{
 	HeightChanged(HexCoord, f32),
 	TypeChanged(HexCoord, usize),
 }
 
-#[derive(Message)]
+#[derive(Event)]
-pub struct ChunkModifiedEvent
+pub struct ChunkModifiedEvent {
-{
 	pub index: usize,
 }

game/shared/src/identifiers.rs

@@ -1,15 +1,9 @@
-use bevy::reflect::Reflect;
+use bevy::prelude::Resource;
 use serde::{Deserialize, Serialize};
+use world_generation::hex_utils::HexCoord;
 
-#[derive(Serialize, Deserialize, Debug, Reflect)]
+#[derive(Serialize, Deserialize, Debug)]
-pub struct ResourceIdentifier
+pub struct ResourceIdentifier {
-{
 	pub id: u32,
 	pub qty: u32,
 }
-
-#[derive(Serialize, Deserialize, Debug, Reflect)]
-pub struct UnitIdentifier(u32);
-
-#[derive(Serialize, Deserialize, Debug, Reflect)]
-pub struct TileIdentifier(u32);

game/shared/src/lib.rs

@@ -1,40 +1,8 @@
-use bevy::reflect::Reflect;
-use serde::{Deserialize, Serialize};
-
 pub mod building;
-pub mod coords;
 pub mod despawn;
-pub mod events;
 pub mod identifiers;
-pub mod resources;
-pub mod sets;
 pub mod states;
 pub mod tags;
-// pub mod prefab_defination;
+pub mod events;
-// pub mod animation_plugin;
+pub mod sets;
-// pub mod component_defination;
+pub mod resources;
-
-#[derive(Debug, Serialize, Deserialize)]
-pub enum Tier
-{
-	Zero,
-	One,
-	Two,
-	Three,
-	Superior,
-}
-
-#[derive(Serialize, Deserialize, Debug, Reflect)]
-pub enum StatusEffect
-{
-	UnitRange(f32),
-	UnitAttack(f32),
-	UnitHealth(f32),
-	StructureRange(f32),
-	StructureAttack(f32),
-	StructureHealth(f32),
-	BuildSpeedMulti(f32),
-	BuildCostMulti(f32),
-	ConsumptionMulti(f32),
-	ProductionMulti(f32),
-}

game/shared/src/prefab_defination.rs

@@ -1,79 +0,0 @@
-use bevy::{
-	ecs::system::{EntityCommand, EntityCommands},
-	gltf::{Gltf, GltfMesh},
-	math::{Quat, Vec3},
-	prelude::*,
-};
-use serde::{Deserialize, Serialize};
-#[derive(Serialize, Deserialize, Debug)]
-pub struct PrefabDefination {
-	pub path: String,
-	pub pos: Vec3,
-	pub rot: Vec3,
-	pub children: Option<Vec<PrefabDefination>>,
-	pub animations: Option<Vec<AnimationComponent>>,
-}
-
-impl PrefabDefination {
-	pub fn spawn_recursive(&self, gltf: &Gltf, commands: &mut ChildBuilder, meshes: &Assets<GltfMesh>) {
-		let mesh_handle = &gltf.named_meshes[&self.path.clone().into_boxed_str()];
-		if let Some(gltf_mesh) = meshes.get(mesh_handle.id()) {
-			let (m, mat) = gltf_mesh.unpack();
-			let mut entity = commands.spawn((
-				Mesh3d(m),
-				MeshMaterial3d(mat),
-				Transform::from_translation(self.pos).with_rotation(Quat::from_euler(
-					bevy::math::EulerRot::XYZ,
-					self.rot.x,
-					self.rot.y,
-					self.rot.z,
-				)),
-			));
-			if let Some(children) = &self.children {
-				entity.with_children(|b| {
-					for child in children {
-						child.spawn_recursive(gltf, b, meshes);
-					}
-				});
-			}
-		}
-	}
-}
-
-pub trait UnpackGltfMesh {
-	fn unpack(&self) -> (Handle<Mesh>, Handle<StandardMaterial>);
-}
-
-impl UnpackGltfMesh for GltfMesh {
-	fn unpack(&self) -> (Handle<Mesh>, Handle<StandardMaterial>) {
-		let p = &self.primitives[0];
-		let mut mat: Handle<StandardMaterial> = default();
-		if let Some(mesh_material) = &p.material {
-			mat = mesh_material.clone();
-		}
-		return (p.mesh.clone(), mat);
-	}
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub enum AnimationComponent {
-	Rotation(RotationAnimation),
-	Slider,
-}
-
-#[derive(Serialize, Deserialize, Debug, Component, Clone, Copy)]
-pub struct RotationAnimation {
-	pub axis: Vec3,
-	pub speed: f32,
-}
-
-impl AnimationComponent {
-	pub fn apply(&self, commands: &mut EntityCommands) {
-		match self {
-			AnimationComponent::Rotation(comp) => {
-				commands.insert(comp.clone());
-			}
-			AnimationComponent::Slider => todo!(),
-		};
-	}
-}

game/shared/src/resources.rs

@@ -1,21 +1,18 @@
 use bevy::prelude::*;
-use hex::prelude::*;
+use world_generation::hex_utils::HexCoord;
 
 #[derive(Resource, Default)]
 pub struct TileUnderCursor(pub Option<TileContact>);
 
 #[derive(Clone, Copy)]
-pub struct TileContact
+pub struct TileContact {
-{
 	pub tile: HexCoord,
 	pub point: Vec3,
 	pub surface: Vec3,
 }
 
-impl TileContact
+impl TileContact {
-{
+	pub fn new(tile: HexCoord, contact: Vec3, surface: Vec3) -> Self {
-	pub fn new(tile: HexCoord, contact: Vec3, surface: Vec3) -> Self
-	{
 		return Self {
 			tile,
 			point: contact,

game/units/Cargo.toml

@@ -4,22 +4,19 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-bevy = "0.18.0"
+bevy = "0.14.0"
 world_generation = { path = "../../engine/world_generation" }
-hex = { path = "../../engine/hex" }
 shared = { path = "../shared" }
-bevy_rapier3d = "0.33.0"
+bevy_rapier3d = "0.27.0"
-serde = { version = "1.0.228", features = ["derive"] }
+serde = { version = "1.0.204", features = ["derive"] }
 asset_loader = { path = "../../engine/asset_loader" }
-serde_json = "1.0.149"
+serde_json = "1.0.120"
-ron = "0.12.0"
+ron = "0.8.1"
-bevy_asset_loader = { version = "0.25.0", features = [
+bevy_asset_loader = { version = "0.21.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }
 quadtree_rs = "0.1.3"
-pathfinding = "4.14.0"
-ordered-float = "5.1.0"
 
 [features]
-tracing = ["bevy/trace_tracy"]
+tracing = []

game/units/src/assets/unit_asset.rs

@@ -20,7 +20,13 @@ impl UnitAsset {
 	pub fn spawn(&self, transform: Transform) -> CommandQueue {
 		let mut commands = CommandQueue::default();
 
-		let bundle = (transform, Unit);
+		let bundle = (
+			PbrBundle {
+				transform: transform,
+				..default()
+			},
+			Unit,
+		);
 		let domain = self.domain.clone();
 		commands.push(move |world: &mut World| {
 			let mut e = world.spawn(bundle);

game/units/src/components.rs

@@ -1,5 +1,4 @@
 use bevy::{ecs::world::CommandQueue, prelude::*, tasks::Task};
-use hex::prelude::*;
 use serde::{Deserialize, Serialize};
 
 #[derive(Component, Debug)]
@@ -13,20 +12,17 @@ pub struct LandUnit;
 pub struct NavalUnit;
 
 #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
-pub enum UnitDomain
+pub enum UnitDomain {
-{
 	Land,
 	Air,
 	Naval,
 }
 
 #[derive(Component, Debug)]
-pub struct Target(pub HexCoord);
+pub struct Target(pub Vec3);
 
 #[derive(Component, Debug)]
 pub struct Path(pub Vec<Vec3>, pub usize);
 
 #[derive(Component, Debug)]
-pub struct PathTask(pub Task<Option<CommandQueue>>);
+pub struct PathTask(pub Task<CommandQueue>);
-#[derive(Component, Debug)]
-pub struct PathTaskPending(pub usize);

game/units/src/lib.rs

@@ -1,14 +1,11 @@
 pub mod assets;
 pub mod components;
-pub mod nav_data;
-pub mod resources;
 #[cfg(debug_assertions)]
 pub mod units_debug_plugin;
 pub mod units_plugin;
 pub mod units_spacial_set;
 
 #[derive(Clone, Copy)]
-pub enum UnitType
+pub enum UnitType {
-{
 	Basic,
 }

game/units/src/nav_data.rs

@@ -1,119 +0,0 @@
-use bevy::prelude::*;
-use hex::prelude::*;
-use ordered_float::OrderedFloat;
-use world_generation::prelude::Map;
-
-#[derive(Clone, Resource)]
-pub struct NavData
-{
-	pub tiles: Vec<NavTile>,
-	pub map_height: usize,
-	pub map_width: usize,
-}
-
-impl NavData
-{
-	pub fn get_neighbors(&self, coord: &HexCoord) -> Vec<(HexCoord, OrderedFloat<f32>)>
-	{
-		let mut neighbors = Vec::with_capacity(6);
-		let cur_height = self.get_height(coord);
-		for i in 0..6
-		{
-			let n = coord.get_neighbor(i);
-			if !self.is_in_bounds(&n)
-			{
-				continue;
-			}
-			let n_height = self.get_height(&n);
-			neighbors.push((n, OrderedFloat((cur_height - n_height).abs().powi(2))));
-		}
-		return neighbors;
-	}
-	pub fn get(&self, coord: &HexCoord) -> &NavTile
-	{
-		return &self.tiles[coord.to_index(self.map_width)];
-	}
-
-	pub fn get_height(&self, coord: &HexCoord) -> f32
-	{
-		return self.tiles[coord.to_index(self.map_width)].height;
-	}
-
-	pub fn is_in_bounds(&self, pos: &HexCoord) -> bool
-	{
-		return pos.is_in_bounds(self.map_height, self.map_width);
-	}
-
-	pub fn build(map: &Map) -> NavData
-	{
-		#[cfg(feature = "tracing")]
-		let _path_span = info_span!("Build Nav Data").entered();
-		let mut tiles = Vec::with_capacity(map.get_tile_count());
-		let h = map.get_tile_height();
-		let w = map.get_tile_width();
-		for y in 0..h
-		{
-			for x in 0..w
-			{
-				let coord = HexCoord::from_grid_pos(x, y);
-				let height = map.sample_height(&coord);
-				let tile = NavTile {
-					coord,
-					height,
-					move_cost: 1.0,
-				};
-				tiles.push(tile);
-			}
-		}
-
-		return NavData {
-			tiles,
-			map_width: w,
-			map_height: h,
-		};
-	}
-
-	pub fn update(&mut self, map: &Map)
-	{
-		#[cfg(feature = "tracing")]
-		let _path_span = info_span!("Update Nav Data").entered();
-		let h = map.get_tile_height();
-		let w = map.get_tile_width();
-		for y in 0..h
-		{
-			for x in 0..w
-			{
-				let coord = HexCoord::from_grid_pos(x, y);
-				let height = map.sample_height(&coord);
-				let tile = NavTile {
-					coord,
-					height,
-					move_cost: 1.0,
-				};
-				self.tiles[y * w + x] = tile;
-			}
-		}
-	}
-	pub fn update_tile(&mut self, coord: &HexCoord, height: f32, move_cost: f32)
-	{
-		let tile = &mut self.tiles[coord.to_index(self.map_width)];
-		tile.move_cost = move_cost;
-		tile.height = height;
-	}
-}
-
-#[derive(Clone)]
-pub struct NavTile
-{
-	pub height: f32,
-	pub move_cost: f32,
-	pub coord: HexCoord,
-}
-
-impl NavTile
-{
-	pub fn calculate_heuristic(&self, to: &HexCoord) -> OrderedFloat<f32>
-	{
-		return (self.coord.distance(to) as f32).into();
-	}
-}

game/units/src/resources.rs

@@ -1,4 +0,0 @@
-use bevy::prelude::*;
-
-#[derive(Resource, Debug, Default)]
-pub struct PathBatchId(pub usize);

game/units/src/units_debug_plugin.rs

@@ -1,7 +1,10 @@
+use std::f32::consts::E;
+
 use bevy::prelude::*;
 use shared::{resources::TileUnderCursor, sets::GameplaySet, states::AssetLoadState};
+use world_generation::{heightmap, prelude::Map};
 
-use crate::components::{LandUnit, Path, Target, Unit};
+use crate::components::{LandUnit, Target, Unit};
 
 pub struct UnitsDebugPlugin;
 
@@ -10,7 +13,6 @@ impl Plugin for UnitsDebugPlugin {
 		app.add_systems(Update, init.run_if(in_state(AssetLoadState::Loading)));
 
 		app.add_systems(Update, (spawn_test_unit, set_unit_target).in_set(GameplaySet));
-		app.add_systems(FixedUpdate, (visualize_paths).in_set(GameplaySet));
 	}
 }
 
@@ -34,7 +36,11 @@ fn spawn_test_unit(
 	if let Some(contact) = tile_under_cursor.0 {
 		info!("Spawning Test Unit");
 		commands.spawn((
-			(Transform::from_translation(contact.surface), Mesh3d(unit.0.clone())),
+			PbrBundle {
+				transform: Transform::from_translation(contact.surface),
+				mesh: unit.0.clone(),
+				..default()
+			},
 			Unit,
 			LandUnit,
 		));
@@ -54,25 +60,7 @@ fn set_unit_target(
 		for e in units.iter() {
 			info!("Setting Target");
 			let mut e = commands.entity(e);
-			e.insert(Target(contact.tile));
+			e.insert(Target(contact.surface));
-		}
-	}
-}
-
-fn visualize_paths(units: Query<&Path, With<Unit>>, mut gizmos: Gizmos) {
-	for path in units.iter() {
-		if path.1 > path.0.len() {
-			continue;
-		}
-		for node in 1..path.0.len() {
-			let from = path.0[node];
-			let to = path.0[node - 1];
-			let color = if node > path.1 {
-				LinearRgba::rgb(1.0, 0.5, 0.0)
-			} else {
-				LinearRgba::rgb(1.0, 0.5, 1.5)
-			};
-			gizmos.line(from + Vec3::Y * 0.1, to + Vec3::Y * 0.1, color);
 		}
 	}
 }

game/units/src/units_plugin.rs

@@ -1,70 +1,37 @@
-use std::collections::HashMap;
-
 use bevy::{
-	ecs::world::CommandQueue,
+	ecs::world::CommandQueue, prelude::*, tasks::AsyncComputeTaskPool, transform::commands, utils::futures,
-	prelude::*,
+	window::PrimaryWindow,
-	tasks::{futures, AsyncComputeTaskPool},
 };
-use hex::prelude::*;
+use bevy_asset_loader::loading_state::{
-use pathfinding::prelude::astar;
+	config::{ConfigureLoadingState, LoadingStateConfig},
-use shared::{events::TileModifiedEvent, resources::TileUnderCursor, sets::GameplaySet};
+	LoadingStateAppExt,
-use world_generation::{prelude::Map, states::GeneratorState};
+};
+use shared::{resources::TileUnderCursor, sets::GameplaySet, states::AssetLoadState};
+use world_generation::{hex_utils::HexCoord, prelude::Map};
 
-#[cfg(debug_assertions)]
-use crate::units_debug_plugin::UnitsDebugPlugin;
 use crate::{
-	assets::unit_asset::UnitAssetPlugin,
+	assets::{unit_asset::UnitAssetPlugin, unit_database::UnitDatabase},
-	components::{Path, PathTask, PathTaskPending, Target, Unit},
+	components::{Path, PathTask, Target, Unit},
-	nav_data::NavData,
+	units_debug_plugin::UnitsDebugPlugin,
-	resources::PathBatchId,
 };
 
 pub struct UnitsPlugin;
 
-impl Plugin for UnitsPlugin
+impl Plugin for UnitsPlugin {
-{
+	fn build(&self, app: &mut App) {
-	fn build(&self, app: &mut App)
-	{
-		app.init_resource::<PathBatchId>();
 		app.add_plugins(UnitAssetPlugin);
 
 		#[cfg(debug_assertions)]
 		app.add_plugins(UnitsDebugPlugin);
 
 		// app.configure_loading_state(LoadingStateConfig::new(AssetLoadState::Loading).load_collection::<UnitDatabase>());
-		app.add_systems(PostUpdate, build_navdata.run_if(in_state(GeneratorState::SpawnMap)));
 
 		app.add_systems(Update, units_control.in_set(GameplaySet));
-		app.add_systems(Update, (move_unit, update_navdata).in_set(GameplaySet));
+		app.add_systems(Update, move_unit.in_set(GameplaySet));
-		app.add_systems(
+		app.add_systems(FixedPreUpdate, (calculate_path, resolve_path_task).in_set(GameplaySet));
-			FixedPreUpdate,
-			(dispatch_path_requests, resolve_path_task).in_set(GameplaySet),
-		);
 	}
 }
 
-fn build_navdata(mut commands: Commands, map: Res<Map>)
-{
-	let nav_data = NavData::build(&map);
-	commands.insert_resource(nav_data);
-}
-
-fn update_navdata(mut tile_updates: MessageReader<TileModifiedEvent>, mut nav_data: ResMut<NavData>)
-{
-	for event in tile_updates.read()
-	{
-		match event
-		{
-			TileModifiedEvent::HeightChanged(coord, new_height) =>
-			{
-				nav_data.update_tile(coord, *new_height, 1.0);
-			}
-			_ => (),
-		}
-	}
-}
-
-#[allow(unused)]
 fn units_control(tile_under_cursor: Res<TileUnderCursor>) {}
 
 fn move_unit(
@@ -72,214 +39,56 @@ fn move_unit(
 	time: Res<Time>,
 	map: Res<Map>,
 	mut commands: Commands,
-)
+) {
-{
+	for (mut t, mut path, entity) in units.iter_mut() {
-	for (mut t, mut path, entity) in units.iter_mut()
+		if path.1 >= path.0.len() {
-	{
-		if path.1 >= path.0.len()
-		{
 			commands.entity(entity).remove::<Path>();
 			continue;
 		}
 		let p = path.0[path.1];
 		let d = p - t.translation;
-		if d.length() < 0.1
+		if d.length() < 0.1 {
-		{
 			path.1 += 1;
 			continue;
 		}
-		let vel = d.normalize() * 10.0 * time.delta_secs();
+		let vel = d.normalize() * 10.0 * time.delta_seconds();
 		t.translation += vel;
 		let coord = HexCoord::from_world_pos(t.translation);
-		if map.is_in_bounds(&coord)
+		if map.is_in_bounds(&coord) {
-		{
 			t.translation.y = map.sample_height(&coord);
 		}
 	}
 }
 
-fn dispatch_path_requests(
+fn calculate_path(
-	units: Query<(&Transform, &Target, Entity), With<Unit>>,
+	units: Query<(&Transform, &Target, Entity), (With<Unit>, Without<PathTask>)>,
 	map: Res<Map>,
-	nav_data: Res<NavData>,
-	mut batch_id: ResMut<PathBatchId>,
 	mut commands: Commands,
-)
+) {
-{
-	if units.is_empty()
-	{
-		return;
-	}
-	let mut groups: HashMap<HexCoord, Vec<PathRequest>> = HashMap::new();
-
-	#[cfg(feature = "tracing")]
-	let _group_span = info_span!("Grouping").entered();
-	for (transform, target, entity) in units.iter()
-	{
-		let req = PathRequest {
-			entity,
-			from: HexCoord::from_world_pos(transform.translation),
-		};
-		if let Some(group) = groups.get_mut(&target.0)
-		{
-			group.push(req);
-		}
-		else
-		{
-			groups.insert(target.0, vec![req]);
-		}
-	}
-	#[cfg(feature = "tracing")]
-	drop(_group_span);
-
 	let pool = AsyncComputeTaskPool::get();
-	for (target, units) in groups
+	for (transform, target, entity) in units.iter() {
-	{
+		let from = transform.translation;
-		let id = batch_id.0;
+		let to = target.0;
-		batch_id.0 += 1;
 
-		for req in &units
+		let task = pool.spawn(async move {
-		{
-			commands
-				.entity(req.entity)
-				.insert(PathTaskPending(id))
-				.remove::<Target>();
-		}
-
-		let destinations = get_end_points(&target, units.len(), &map);
-		let req = BatchPathRequest::new(units, destinations);
-
-		#[cfg(feature = "tracing")]
-		let _clone_span = info_span!("Nav Data Clone").entered();
-		let local_nav_data = nav_data.clone();
-		#[cfg(feature = "tracing")]
-		drop(_clone_span);
-
-		let batch_task = pool.spawn(async move {
-			let mut i = 0;
 			let mut queue = CommandQueue::default();
-			for entitiy_req in req.entities
+
-			{
-				let dst = req.destination[i];
-				i += 1;
-				#[cfg(feature = "tracing")]
-				let _path_span = info_span!("Path Finding").entered();
-				if let Some(path) = calculate_path(&entitiy_req.from, &dst, &local_nav_data)
-				{
 			queue.push(move |world: &mut World| {
-						let mut unit_e = world.entity_mut(entitiy_req.entity);
+				//todo: calculate path
-
+				world.entity_mut(entity).insert(Path(vec![from, to], 0));
-						if let Some(pending_task) = unit_e.get::<PathTaskPending>()
-						{
-							if pending_task.0 == id
-							{
-								unit_e.insert(path);
-								unit_e.remove::<PathTaskPending>();
-							}
-						}
 			});
-				}
+			return queue;
-			}
-			if queue.is_empty()
-			{
-				return None;
-			}
-			return Some(queue);
 		});
-		commands.spawn(PathTask(batch_task));
+
+		commands.entity(entity).insert(PathTask(task)).remove::<Target>();
 	}
 }
 
-fn get_end_points(coord: &HexCoord, count: usize, map: &Map) -> Vec<HexCoord>
+fn resolve_path_task(mut tasks: Query<(&mut PathTask, Entity), With<Unit>>, mut commands: Commands) {
-{
+	for (mut task, entity) in tasks.iter_mut() {
-	let mut result = Vec::with_capacity(count);
+		if let Some(mut c) = futures::check_ready(&mut task.0) {
-	if count == 1
+			commands.append(&mut c);
-	{
+			commands.entity(entity).remove::<PathTask>();
-		return vec![*coord];
-	}
-	result.push(*coord);
-	let mut r = 1;
-	while result.len() < count
-	{
-		let tiles = HexCoord::select_ring(coord, r);
-		let needed = count - result.len();
-		if needed >= tiles.len()
-		{
-			for t in tiles
-			{
-				if map.is_in_bounds(&t)
-				{
-					result.push(t);
 		}
 	}
 }
-		else
-		{
-			for i in 0..needed
-			{
-				let t = tiles[i];
-				if map.is_in_bounds(&t)
-				{
-					result.push(t);
-				}
-			}
-		}
-		r += 1;
-	}
-
-	return result;
-}
-
-fn resolve_path_task(mut tasks: Query<(&mut PathTask, Entity)>, mut commands: Commands)
-{
-	for (mut task, entity) in tasks.iter_mut()
-	{
-		if let Some(c) = futures::check_ready(&mut task.0)
-		{
-			if let Some(mut queue) = c
-			{
-				commands.append(&mut queue);
-			}
-			commands.entity(entity).despawn();
-		}
-	}
-}
-
-fn calculate_path(from: &HexCoord, to: &HexCoord, nav: &NavData) -> Option<Path>
-{
-	let path = astar(
-		from,
-		|n| nav.get_neighbors(n),
-		|n| nav.get(n).calculate_heuristic(to),
-		|n| n == to,
-	);
-	if let Some((nodes, _cost)) = path
-	{
-		let result: Vec<_> = nodes.iter().map(|f| f.to_world(nav.get_height(f))).collect();
-		return Some(Path(result, 1));
-	}
-	return None;
-}
-
-struct PathRequest
-{
-	pub entity: Entity,
-	pub from: HexCoord,
-}
-
-struct BatchPathRequest
-{
-	pub entities: Vec<PathRequest>,
-	pub destination: Vec<HexCoord>,
-}
-
-impl BatchPathRequest
-{
-	pub fn new(entities: Vec<PathRequest>, dst: Vec<HexCoord>) -> Self
-	{
-		return Self {
-			destination: dst,
-			entities,
-		};
-	}
-}

rust-toolchain.toml

@@ -1,2 +0,0 @@
-[toolchain]
-channel = "nightly"