cleanup

Need to wait for asset_loader upate full release
Need to refactor Prefab system to use the new relationships

Cargo.toml

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

engine/asset_loader/Cargo.toml

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

engine/asset_loader/src/macros.rs

@@ -9,8 +9,7 @@ macro_rules! create_asset_loader {
 		$($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;
+		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) {
@@ -19,7 +18,7 @@ macro_rules! create_asset_loader {
 			}
 		}
 
-		#[derive(Default)]
+		#[derive(Default, TypePath)]
 		pub struct $loader_name;
 
 		impl AssetLoader for $loader_name {
@@ -29,12 +28,12 @@ macro_rules! create_asset_loader {
 
 			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> {
+			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() {

engine/asset_loader_proc/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "asset_loader_proc"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-proc-macro = true
-
-[dependencies]
-serde = "1.0.204"
-serde_json = "1.0.120"
-bevy = "0.14.2"
-ron = "0.8.1"

engine/asset_loader_proc/src/lib.rs

@@ -1 +0,0 @@
-  

engine/world_generation/Cargo.toml

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

engine/world_generation/src/consts.rs

@@ -1,7 +1,4 @@
-use bevy::{
-	prelude::*,
-	render::{mesh::MeshVertexAttribute, render_resource::VertexFormat},
-};
+use bevy::{mesh::MeshVertexAttribute, prelude::*, render::render_resource::VertexFormat};
 
 use crate::hex_utils::{INNER_RADIUS, OUTER_RADIUS};
 

engine/world_generation/src/generators/mesh_generator.rs

@@ -1,14 +1,10 @@
 use crate::hex_utils::HexCoord;
 use crate::{hex_utils::offset3d_to_world, prelude::*};
+use bevy::asset::RenderAssetUsages;
 #[cfg(feature = "tracing")]
 use bevy::log::*;
-use bevy::{
-	prelude::*,
-	render::{
-		mesh::{Indices, PrimitiveTopology},
-		render_asset::RenderAssetUsages,
-	},
-};
+use bevy::mesh::{Indices, PrimitiveTopology};
+use bevy::prelude::*;
 
 pub fn generate_chunk_mesh(chunk: &MeshChunkData) -> Mesh {
 	#[cfg(feature = "tracing")]

engine/world_generation/src/generators/packed_mesh_generator.rs

@@ -1,11 +1,9 @@
-use crate::hex_utils::{offset3d_to_world, HexCoord};
+use crate::hex_utils::HexCoord;
 use crate::prelude::*;
+use bevy::asset::RenderAssetUsages;
 use bevy::{
-	prelude::*,
-	render::{
 	mesh::{Indices, PrimitiveTopology},
-		render_asset::RenderAssetUsages,
-	},
+	prelude::*,
 };
 
 pub fn generate_packed_chunk_mesh(chunk: &MeshChunkData) -> Mesh {

engine/world_generation/src/map/map_utils.rs

@@ -6,18 +6,15 @@ use rayon::prelude::*;
 
 use crate::hex_utils::HexCoord;
 
-use super::{
-	biome_map::BiomeMap,
-	chunk::Chunk,
-	map::Map,
-};
+use super::{biome_map::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);
 
@@ -30,7 +27,8 @@ 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);
 
@@ -40,12 +38,13 @@ 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,
@@ -53,7 +52,8 @@ 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,18 +61,21 @@ 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.sealevel
+		{
 			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);
 		}
@@ -81,24 +84,35 @@ 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 d > 0.0 {
+	if smooth == 0.0 || d.abs() > smooth
+	{
+		if d > 0.0
+		{
 			color.lightness += 0.1;
-		} else if d < 0.0 {
+		}
+		else if d < 0.0
+		{
 			color.lightness -= 0.1;
 		}
-	} else {
-		if d.abs() <= smooth {
+	}
+	else
+	{
+		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();
-			} else {
+				color = LinearRgba::lerp(color.into(), c2, d).into();
+			}
+			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();
 			}
 		}
 	}
@@ -106,13 +120,15 @@ 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);
 
@@ -125,7 +141,8 @@ 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,
@@ -134,19 +151,22 @@ 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

@@ -6,7 +6,8 @@ use crate::hex_utils::HexCoord;
 
 use super::chunk::Chunk;
 
-pub struct MeshChunkData {
+pub struct MeshChunkData
+{
 	pub heights: [f32; Chunk::AREA],
 	pub textures: [[u32; 2]; Chunk::AREA],
 	pub min_height: f32,
@@ -14,13 +15,17 @@ pub struct MeshChunkData {
 	pub distance_to_land: [f32; Chunk::AREA],
 }
 
-impl MeshChunkData {
-	pub fn get_neighbors(&self, coord: &HexCoord) -> [f32; 6] {
+impl MeshChunkData
+{
+	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)];
@@ -29,56 +34,70 @@ impl MeshChunkData {
 		return data;
 	}
 
-	pub fn get_neighbors_with_water_info(&self, coord: &HexCoord) -> ([(f32, Option<f32>); 6], bool) {
+	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 {
+		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;
 			}
 			let idx = n.to_index(Chunk::SIZE);
 			data[i] = (self.heights[idx], Some(self.distance_to_land[idx]));
-			if data[i].0 > self.sealevel {
+			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) {
+	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 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 {
+	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 {
+				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/tile_manager.rs

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

game/buildings/Cargo.toml

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

game/buildings/src/assets/building_asset.rs

@@ -1,24 +1,29 @@
 use asset_loader::create_asset_loader;
-use bevy::prelude::*;
+use bevy::{
+	gltf::{GltfMesh, GltfNode},
+	prelude::*,
+};
 use serde::{Deserialize, Serialize};
 use shared::identifiers::ResourceIdentifier;
 
 use crate::{
 	buildings::{
-		basic_building::BasicBuildingInfo, factory_building::FactoryBuildingInfo,
+		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<Scene>,
+	pub prefab: Handle<Gltf>,
+	pub base_mesh_path: String,
 
 	pub cost: Vec<ResourceIdentifier>,
 	pub consumption: Vec<ResourceIdentifier>,
@@ -27,21 +32,105 @@ pub struct BuildingAsset {
 	pub health: u32,
 
 	pub building_type: BuildingType,
-	pub animations: Vec<AnimationComponent>,
+	// 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 {
+pub enum BuildingType
+{
 	Basic,
 	Gathering(ResourceGatheringBuildingInfo),
 	FactoryBuildingInfo(FactoryBuildingInfo),
+	ResourceConduit(ResourceConduitInfo),
 }
 
-#[derive(Serialize, Deserialize, Debug, Reflect)]
-pub enum AnimationComponent {
-	Rotation,
-	Slider,
-}
 create_asset_loader!(
 	BuildingAssetPlugin,
 	BuildingAssetLoader,

game/buildings/src/building_plugin.rs

@@ -1,21 +1,19 @@
-use std::f32::consts::E;
-
-use bevy::{ecs::world::CommandQueue, prelude::*, window::PrimaryWindow};
+use bevy::{
+	ecs::world::CommandQueue,
+	gltf::{GltfMesh, GltfNode},
+	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::{
@@ -29,8 +27,10 @@ use crate::{
 
 pub struct BuildingPugin;
 
-impl Plugin for BuildingPugin {
-	fn build(&self, app: &mut App) {
+impl Plugin for BuildingPugin
+{
+	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_then(in_state(GeneratorState::Idle))),
+			hq_placement.run_if(in_state(GameplayState::PlaceHQ).and(in_state(GeneratorState::Idle))),
 		);
 		app.add_systems(
 			PreUpdate,
@@ -57,12 +57,15 @@ 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>) {
-	for e in buildings.iter() {
+fn regernerate(mut commands: Commands, buildings: Query<Entity, With<Building>>, cfg: Res<GenerationConfig>)
+{
+	for e in buildings.iter()
+	{
 		commands.entity(e).despawn();
 	}
 	commands.insert_resource(BuildingMap::new(cfg.size));
@@ -71,7 +74,8 @@ 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);
@@ -86,13 +90,15 @@ 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,
@@ -103,15 +109,14 @@ fn hq_placement(
 	}
 }
 
-fn show_indicators(positions: Vec<Vec3>, commands: &mut Commands, indicator: &IndicatorCube) {
-	for p in positions {
+fn show_indicators(positions: Vec<Vec3>, commands: &mut Commands, indicator: &IndicatorCube)
+{
+	for p in positions
+	{
 		commands.spawn((
-			PbrBundle {
-				mesh: indicator.0.clone(),
-				material: indicator.1.clone(),
-				transform: Transform::from_translation(p),
-				..default()
-			},
+			Mesh3d(indicator.0.clone()),
+			MeshMaterial3d(indicator.1.clone()),
+			Transform::from_translation(p),
 			Despawn,
 		));
 	}
@@ -122,44 +127,65 @@ 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);
-			let e = commands.spawn((
-				SceneBundle {
-					scene: building.prefab.clone(),
-					transform: Transform::from_translation(item.pos.to_world(h)),
-					..Default::default()
-				},
-				Building,
-			));
-
-			building_map.add_building(BuildingEntry::new(item.pos, e.id()));
+			if let Some(gltf) = gltf_assets.get(building.prefab.id())
+			{
+				let e = building.spawn(
+					item.pos.to_world(h),
+					Quat::IDENTITY,
+					gltf,
+					&mut commands,
+					&gltf_meshes,
+					&gltf_nodes,
+				);
+				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: EventReader<TileModifiedEvent>,
+	mut tile_updates: MessageReader<TileModifiedEvent>,
 	building_map: Res<BuildingMap>,
 	mut commands: Commands,
-) {
-	for event in tile_updates.read() {
-		match event {
-			TileModifiedEvent::HeightChanged(coord, new_height) => {
-				if let Some(building) = building_map.get_building(coord) {
+)
+{
+	for event in tile_updates.read()
+	{
+		match event
+		{
+			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,4 +1,3 @@
 use serde::{Deserialize, Serialize};
-use shared::identifiers::ResourceIdentifier;
 #[derive(Serialize, Deserialize, Debug)]
 pub struct BasicBuildingInfo {}

game/buildings/src/buildings/conduit_building.rs

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

game/buildings/src/buildings/mod.rs

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

game/main/Cargo.toml

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

game/main/build.rs

@@ -13,6 +13,10 @@ 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,10 +1,8 @@
-use bevy::core_pipeline::experimental::taa::{TemporalAntiAliasBundle, TemporalAntiAliasPlugin};
+use bevy::anti_alias::taa::TemporalAntiAliasing;
 use bevy::core_pipeline::prepass::DepthPrepass;
 use bevy::input::mouse::{MouseMotion, MouseScrollUnit, MouseWheel};
 use bevy::prelude::*;
-use bevy::render::view::RenderLayers;
-use bevy::window::{CursorGrabMode, PrimaryWindow};
-use bevy_lunex::prelude::MainUi;
+use bevy::window::{CursorGrabMode, CursorOptions, PrimaryWindow};
 use shared::sets::GameplaySet;
 use shared::tags::MainCamera;
 use world_generation::hex_utils::HexCoord;
@@ -15,31 +13,24 @@ use super::components::*;
 
 pub struct PhosCameraPlugin;
 
-impl Plugin for PhosCameraPlugin {
-	fn build(&self, app: &mut App) {
+impl Plugin for PhosCameraPlugin
+{
+	fn build(&self, app: &mut App)
+	{
 		app.register_type::<PhosCamera>();
 		app.register_type::<PhosOrbitCamera>();
 
 		app.add_systems(PreStartup, setup);
 
-		// app.add_systems(Update, rts_camera_system.in_set(GameplaySet));
-		// app.add_systems(PostUpdate, limit_camera_bounds.in_set(GameplaySet));
 		app.add_systems(Update, orbit_camera_upate.in_set(GameplaySet));
 
 		app.add_systems(Update, init_bounds.run_if(in_state(GeneratorState::SpawnMap)));
-		//Free Cam
-		//app.add_systems(Update, (grab_mouse, (update_camera, update_camera_mouse).chain()));
-
-		app.add_plugins(TemporalAntiAliasPlugin);
 	}
 }
 
-fn init_bounds(
-	mut commands: Commands,
-	mut cam: Query<(&mut Transform, Entity), With<PhosCamera>>,
-	heightmap: Res<Map>,
-) {
-	let (mut cam_t, cam_entity) = cam.single_mut();
+fn init_bounds(mut commands: Commands, cam: Single<(&mut Transform, Entity), With<PhosCamera>>, heightmap: Res<Map>)
+{
+	let (mut cam_t, cam_entity) = cam.into_inner();
 	cam_t.translation = heightmap.get_center();
 	commands
 		.entity(cam_entity)
@@ -50,38 +41,37 @@ fn init_bounds(
 		});
 }
 
-fn setup(mut commands: Commands, mut msaa: ResMut<Msaa>) {
+fn setup(mut commands: Commands)
+{
 	commands
 		.spawn((
-			Camera3dBundle {
-				transform: Transform::from_xyz(0., 30., 0.).looking_to(Vec3::NEG_Z, Vec3::Y),
-				..default()
-			},
+			Camera3d::default(),
+			Transform::from_xyz(0., 30., 0.).looking_to(Vec3::NEG_Z, Vec3::Y),
 			PhosCamera::default(),
 			MainCamera,
 			DepthPrepass,
 			PhosOrbitCamera::default(),
-			MainUi,
+			TemporalAntiAliasing::default(),
 		))
-		.insert(TemporalAntiAliasBundle::default())
-		.insert(RenderLayers::layer(0));
+		.insert(Msaa::Off);
+	// .insert(RenderLayers::layer(0))
 
-	*msaa = Msaa::Off;
+	// *msaa = Msaa::Off;
 }
 
 fn orbit_camera_upate(
-	mut cam_query: Query<(&mut Transform, &PhosCamera, &mut PhosOrbitCamera, &CameraBounds)>,
-	mut wheel: EventReader<MouseWheel>,
-	mut mouse_motion: EventReader<MouseMotion>,
+	cam_query: Single<(&mut Transform, &PhosCamera, &mut PhosOrbitCamera, &CameraBounds)>,
+	mut wheel: MessageReader<MouseWheel>,
+	mut mouse_motion: MessageReader<MouseMotion>,
 	mouse: Res<ButtonInput<MouseButton>>,
-	mut window_query: Query<&mut Window, With<PrimaryWindow>>,
+	mut cursor_options: Single<&mut CursorOptions, With<PrimaryWindow>>,
 	key: Res<ButtonInput<KeyCode>>,
 	time: Res<Time>,
 	map: Res<Map>,
 	#[cfg(debug_assertions)] mut gizmos: Gizmos,
-) {
-	let (mut transform, config, mut orbit, bounds) = cam_query.single_mut();
-	let mut window = window_query.single_mut();
+)
+{
+	let (mut transform, config, mut orbit, bounds) = cam_query.into_inner();
 
 	let target = orbit.target;
 	let mut cam_pos = target;
@@ -89,53 +79,70 @@ fn orbit_camera_upate(
 	//Apply Camera Dist
 	cam_pos -= orbit.forward * orbit.distance;
 
-	if mouse.pressed(MouseButton::Middle) {
+	if mouse.pressed(MouseButton::Middle)
+	{
 		let mut orbit_move = Vec2::ZERO;
-		for e in mouse_motion.read() {
+		for e in mouse_motion.read()
+		{
 			orbit_move += e.delta;
 		}
-		orbit_move *= config.pan_speed * time.delta_seconds() * -1.0;
+		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();
-		window.cursor.grab_mode = CursorGrabMode::Locked;
-		window.cursor.visible = false;
-	} else {
-		window.cursor.grab_mode = CursorGrabMode::None;
-		window.cursor.visible = true;
+		cursor_options.grab_mode = CursorGrabMode::Locked;
+		cursor_options.visible = false;
 	}
-	if key.pressed(KeyCode::KeyE) {
-		let rot = Quat::from_axis_angle(Vec3::Y, f32::to_radians(config.speed) * time.delta_seconds());
+	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_seconds());
+	}
+	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;
 
-	if key.pressed(KeyCode::KeyA) {
+	if key.pressed(KeyCode::KeyA)
+	{
 		cam_move.x = 1.;
-	} else if key.pressed(KeyCode::KeyD) {
+	}
+	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) {
+	}
+	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)
+	{
 		config.speed * 2.0
-	} else {
+	}
+	else
+	{
 		config.speed
 	};
 
-	if cam_move != Vec3::ZERO {
+	if cam_move != Vec3::ZERO
+	{
 		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);
@@ -144,7 +151,7 @@ fn orbit_camera_upate(
 			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_seconds();
+		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);
@@ -152,14 +159,16 @@ fn orbit_camera_upate(
 	}
 
 	let mut scroll = 0.0;
-	for e in wheel.read() {
-		match e.unit {
+	for e in wheel.read()
+	{
+		match e.unit
+		{
 			MouseScrollUnit::Line => scroll += e.y * 5.,
 			MouseScrollUnit::Pixel => scroll += e.y,
 		}
 	}
 
-	orbit.distance -= scroll * time.delta_seconds() * config.zoom_speed;
+	orbit.distance -= scroll * time.delta_secs() * config.zoom_speed;
 	orbit.distance = orbit.distance.clamp(config.min_height, config.max_height);
 
 	// let ground_below_cam = sample_ground(cam_pos, &map) + config.min_height;
@@ -175,23 +184,31 @@ fn orbit_camera_upate(
 	transform.look_at(target, Vec3::Y);
 }
 
-fn sample_ground(pos: Vec3, heightmap: &Map) -> f32 {
+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.sealevel
 	};
 
-	for n in neighbors {
-		if let Some(h) = n {
-			if h > ground_height {
+	for n in neighbors
+	{
+		if let Some(h) = n
+		{
+			if h > ground_height
+			{
 				ground_height = h;
 			}
 		}
 	}
-	if ground_height < heightmap.sealevel {
+	if ground_height < heightmap.sealevel
+	{
 		ground_height = heightmap.sealevel;
 	}
 	return ground_height;

game/main/src/camera_system/components.rs

@@ -1,10 +1,11 @@
-use bevy::{math::Direction3d, prelude::*};
+use bevy::prelude::*;
 use rayon::str;
-use world_generation::{hex_utils::SHORT_DIAGONAL, prelude::Chunk};
+use world_generation::prelude::Chunk;
 
 #[derive(Component, Reflect)]
 #[reflect(Component)]
-pub struct PhosCamera {
+pub struct PhosCamera
+{
 	pub min_height: f32,
 	pub max_height: f32,
 	pub speed: f32,
@@ -14,8 +15,10 @@ pub struct PhosCamera {
 	pub max_angle: f32,
 }
 
-impl Default for PhosCamera {
-	fn default() -> Self {
+impl Default for PhosCamera
+{
+	fn default() -> Self
+	{
 		Self {
 			min_height: 10.,
 			max_height: 420.,
@@ -28,14 +31,17 @@ impl Default for PhosCamera {
 	}
 }
 #[derive(Component, Reflect)]
-pub struct PhosOrbitCamera {
+pub struct PhosOrbitCamera
+{
 	pub target: Vec3,
 	pub distance: f32,
 	pub forward: Vec3,
 }
 
-impl Default for PhosOrbitCamera {
-	fn default() -> Self {
+impl Default for PhosOrbitCamera
+{
+	fn default() -> Self
+	{
 		Self {
 			target: Default::default(),
 			distance: 40.0,
@@ -45,13 +51,16 @@ impl Default for PhosOrbitCamera {
 }
 
 #[derive(Component, Default)]
-pub struct CameraBounds {
+pub struct CameraBounds
+{
 	pub min: Vec2,
 	pub max: Vec2,
 }
 
-impl CameraBounds {
-	pub fn from_size(world_size: Vec2) -> Self {
+impl CameraBounds
+{
+	pub fn from_size(world_size: Vec2) -> Self
+	{
 		let padding = Chunk::WORLD_SIZE;
 		return Self {
 			min: Vec2::ZERO - padding,

game/main/src/main.rs

@@ -1,9 +1,10 @@
-use std::env;
-
+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;
 
@@ -15,7 +16,8 @@ mod shader_extensions;
 mod ui;
 mod utlis;
 
-fn main() {
+fn main()
+{
 	App::new()
 		.add_plugins((
 			DefaultPlugins
@@ -24,7 +26,7 @@ fn main() {
 						title: "Phos".into(),
 						name: Some("phos".into()),
 						#[cfg(debug_assertions)]
-						resolution: (1920., 1080.).into(),
+						resolution: WindowResolution::new(1920, 1080),
 						present_mode: PresentMode::AutoNoVsync,
 						#[cfg(not(debug_assertions))]
 						mode: bevy::window::WindowMode::BorderlessFullscreen,
@@ -45,8 +47,9 @@ fn main() {
 					watch_for_changes_override: Some(true),
 					..Default::default()
 				}),
+			EguiPlugin::default(),
 			WorldInspectorPlugin::new(),
-			WireframePlugin,
+			WireframePlugin::default(),
 			PhosGamePlugin,
 		))
 		.run();

game/main/src/map_rendering/chunk_rebuild.rs

@@ -1,7 +1,6 @@
 use bevy::ecs::world::CommandQueue;
 use bevy::prelude::*;
 use bevy::tasks::*;
-use bevy::utils::futures;
 use bevy_rapier3d::geometry::Collider;
 use bevy_rapier3d::geometry::TriMeshFlags;
 use shared::events::ChunkModifiedEvent;
@@ -10,6 +9,7 @@ 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,11 +17,13 @@ use crate::{
 
 pub struct ChunkRebuildPlugin;
 
-impl Plugin for ChunkRebuildPlugin {
-	fn build(&self, app: &mut App) {
+impl Plugin for ChunkRebuildPlugin
+{
+	fn build(&self, app: &mut App)
+	{
 		app.init_resource::<PhosChunkRegistry>();
-		app.add_event::<ChunkModifiedEvent>();
-		app.add_event::<TileModifiedEvent>();
+		app.add_message::<ChunkModifiedEvent>();
+		app.add_message::<TileModifiedEvent>();
 		app.add_systems(PreUpdate, chunk_rebuilder.run_if(in_state(GeneratorState::Idle)));
 		app.add_systems(PostUpdate, collider_task_resolver);
 	}
@@ -31,11 +33,13 @@ 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");
@@ -55,14 +59,15 @@ fn chunk_rebuilder(
 				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);
+			return (queue, mesh, water_mesh);
 		});
 
 		commands
@@ -73,19 +78,28 @@ fn chunk_rebuilder(
 }
 
 fn collider_task_resolver(
-	mut chunks: Query<(&mut ChunkRebuildTask, &Handle<Mesh>), With<PhosChunk>>,
+	mut chunks: Query<(&mut ChunkRebuildTask, &Mesh3d, &WaterMesh), With<PhosChunk>>,
 	mut commands: Commands,
 	mut meshes: ResMut<Assets<Mesh>>,
-) {
-	for (mut task, mesh_handle) in &mut chunks {
-		if let Some((mut c, mesh)) = futures::check_ready(&mut task.task) {
+)
+{
+	for (mut task, mesh_handle, water_mesh_handle) in &mut chunks
+	{
+		if let Some((mut c, chunk_mesh, water_mesh)) = futures::check_ready(&mut task.task)
+		{
 			commands.append(&mut c);
-			meshes.insert(mesh_handle, mesh);
+			meshes
+				.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 {
-	pub task: Task<(CommandQueue, Mesh)>,
+struct ChunkRebuildTask
+{
+	pub task: Task<(CommandQueue, Mesh, Mesh)>,
 }

game/main/src/map_rendering/map_init.rs

@@ -1,10 +1,6 @@
 #[cfg(feature = "tracing")]
 use bevy::log::*;
-use bevy::{
-	pbr::{ExtendedMaterial, NotShadowCaster},
-	prelude::*,
-	render::render_resource::{ColorTargetState, FragmentState, RenderPipelineDescriptor},
-};
+use bevy::{light::NotShadowCaster, pbr::ExtendedMaterial, prelude::*};
 use bevy_asset_loader::prelude::*;
 
 use bevy_inspector_egui::quick::ResourceInspectorPlugin;
@@ -22,7 +18,7 @@ use world_generation::{
 };
 
 use crate::{
-	prelude::{PhosAssets, PhosChunk, PhosChunkRegistry},
+	prelude::{PhosAssets, PhosChunk, PhosChunkRegistry, WaterMesh},
 	shader_extensions::{
 		chunk_material::ChunkMaterial,
 		water_material::{WaterMaterial, WaterSettings},
@@ -34,8 +30,10 @@ use super::{chunk_rebuild::ChunkRebuildPlugin, render_distance_system::RenderDis
 
 pub struct MapInitPlugin;
 
-impl Plugin for MapInitPlugin {
-	fn build(&self, app: &mut App) {
+impl Plugin for MapInitPlugin
+{
+	fn build(&self, app: &mut App)
+	{
 		app.insert_state(GeneratorState::Startup);
 		app.insert_state(AssetLoadState::Loading);
 
@@ -51,10 +49,7 @@ impl Plugin for MapInitPlugin {
 			ChunkRebuildPlugin,
 			// TerraFormingTestPlugin,
 			MaterialPlugin::<ExtendedMaterial<StandardMaterial, ChunkMaterial>>::default(),
-			MaterialPlugin::<ExtendedMaterial<StandardMaterial, WaterMaterial>> {
-				prepass_enabled: false,
-				..Default::default()
-			},
+			MaterialPlugin::<ExtendedMaterial<StandardMaterial, WaterMaterial>>::default(),
 		));
 
 		app.configure_loading_state(
@@ -78,7 +73,7 @@ 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_then(in_state(GeneratorState::SpawnMap))),
+			spawn_map.run_if(in_state(AssetLoadState::LoadComplete).and(in_state(GeneratorState::SpawnMap))),
 		);
 
 		app.insert_resource(TileManager::default());
@@ -88,7 +83,8 @@ impl Plugin for MapInitPlugin {
 fn setup_materials(
 	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.),
@@ -114,7 +110,8 @@ 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);
@@ -125,11 +122,14 @@ 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.reinterpret_stacked_2d_as_array(array_layers);
+	image
+		.reinterpret_stacked_2d_as_array(array_layers)
+		.expect("Failed to reinterpret as array");
 
 	let chunk_material = chunk_materials.add(ExtendedMaterial {
 		base: StandardMaterial::default(),
@@ -146,7 +146,8 @@ fn create_heightmap(
 	mut commands: Commands,
 	mut next_state: ResMut<NextState<GeneratorState>>,
 	biome_painter: Res<BiomePainter>,
-) {
+)
+{
 	let config = GenerationConfig {
 		biome_blend: 32,
 		biome_dither: 10.,
@@ -217,7 +218,8 @@ 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
@@ -248,29 +250,26 @@ fn spawn_map(
 			0.,
 			(Chunk::SIZE / 2) as f32 * 1.5,
 		);
-		for (chunk_mesh, water_mesh, collider, pos, index) in chunk_meshes {
+		for (chunk_mesh, water_mesh, collider, pos, index) in chunk_meshes
+		{
 			// let mesh_handle = meshes.a
+			let water_mesh_handle = meshes.add(water_mesh);
 			let chunk = commands
 				.spawn((
-					MaterialMeshBundle {
-						mesh: meshes.add(chunk_mesh),
-						material: atlas.chunk_material_handle.clone(),
-						transform: Transform::from_translation(pos),
-						..default()
-					},
+					Mesh3d(meshes.add(chunk_mesh)),
+					MeshMaterial3d(atlas.chunk_material_handle.clone()),
+					Transform::from_translation(pos),
 					PhosChunk::new(index),
+					WaterMesh(water_mesh_handle.id()),
 					RenderDistanceVisibility::default().with_offset(visibility_offset),
 					collider,
 				))
 				.id();
 			let water = commands
 				.spawn((
-					MaterialMeshBundle {
-						mesh: meshes.add(water_mesh),
-						material: atlas.water_material.clone(),
-						transform: Transform::from_translation(pos),
-						..default()
-					},
+					Mesh3d(water_mesh_handle),
+					MeshMaterial3d(atlas.water_material.clone()),
+					Transform::from_translation(pos),
 					PhosChunk::new(index),
 					NotShadowCaster,
 					RenderDistanceVisibility::default().with_offset(visibility_offset),
@@ -283,7 +282,8 @@ fn spawn_map(
 
 	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);
 	}
@@ -297,8 +297,10 @@ 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/prelude.rs

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

game/main/src/map_rendering/render_distance_system.rs

@@ -1,12 +1,12 @@
 use bevy::prelude::*;
 use shared::tags::MainCamera;
 
-use crate::camera_system::components::PhosCamera;
-
 pub struct RenderDistancePlugin;
 
-impl Plugin for RenderDistancePlugin {
-	fn build(&self, app: &mut bevy::prelude::App) {
+impl Plugin for RenderDistancePlugin
+{
+	fn build(&self, app: &mut bevy::prelude::App)
+	{
 		app.register_type::<RenderDistanceSettings>();
 		app.add_systems(PostUpdate, render_distance_system)
 			.insert_resource(RenderDistanceSettings::default());
@@ -15,54 +15,68 @@ impl Plugin for RenderDistancePlugin {
 
 #[derive(Resource, Reflect)]
 #[reflect(Resource)]
-pub struct RenderDistanceSettings {
+pub struct RenderDistanceSettings
+{
 	pub render_distance: f32,
 }
 
-impl RenderDistanceSettings {
-	pub fn new(distance: f32) -> Self {
+impl RenderDistanceSettings
+{
+	pub fn new(distance: f32) -> Self
+	{
 		return Self {
 			render_distance: distance,
 		};
 	}
 }
 
-impl Default for RenderDistanceSettings {
-	fn default() -> Self {
+impl Default for RenderDistanceSettings
+{
+	fn default() -> Self
+	{
 		Self::new(500.)
 	}
 }
 
 #[derive(Component)]
-pub struct RenderDistanceVisibility {
+pub struct RenderDistanceVisibility
+{
 	pub offset: Vec3,
 }
 
-impl RenderDistanceVisibility {
-	pub fn with_offset(mut self, offset: Vec3) -> Self {
+impl RenderDistanceVisibility
+{
+	pub fn with_offset(mut self, offset: Vec3) -> Self
+	{
 		self.offset = offset;
 		return self;
 	}
 }
 
-impl Default for RenderDistanceVisibility {
-	fn default() -> Self {
+impl Default for RenderDistanceVisibility
+{
+	fn default() -> Self
+	{
 		Self { offset: Vec3::ZERO }
 	}
 }
 
 fn render_distance_system(
 	mut objects: Query<(&Transform, &mut Visibility, &RenderDistanceVisibility)>,
-	camera_query: Query<&Transform, With<MainCamera>>,
+	camera: Single<&Transform, With<MainCamera>>,
 	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/map_rendering/terraforming_test.rs

@@ -1,21 +1,20 @@
-use bevy::{prelude::*, utils::hashbrown::HashSet, window::PrimaryWindow};
-use bevy_rapier3d::{pipeline::QueryFilter, plugin::RapierContext};
+use bevy::{platform::collections::HashSet, prelude::*};
 use shared::{
 	events::{ChunkModifiedEvent, TileModifiedEvent},
 	resources::TileUnderCursor,
 	states::GameplayState,
 };
-use world_generation::{hex_utils::HexCoord, prelude::Map, states::GeneratorState};
+use world_generation::{prelude::Map, states::GeneratorState};
 
-use crate::{
-	camera_system::components::PhosCamera,
-	prelude::{PhosChunkRegistry, RebuildChunk},
-};
+use crate::prelude::{PhosChunkRegistry, RebuildChunk};
 
+#[allow(dead_code)]
 pub struct TerraFormingTestPlugin;
 
-impl Plugin for TerraFormingTestPlugin {
-	fn build(&self, app: &mut App) {
+impl Plugin for TerraFormingTestPlugin
+{
+	fn build(&self, app: &mut App)
+	{
 		app.add_systems(
 			Update,
 			deform
@@ -25,39 +24,48 @@ impl Plugin for TerraFormingTestPlugin {
 	}
 }
 
+#[allow(dead_code)]
 fn deform(
 	mut commands: Commands,
 	mouse: Res<ButtonInput<MouseButton>>,
 	mut heightmap: ResMut<Map>,
 	chunks: Res<PhosChunkRegistry>,
 	tile_under_cursor: Res<TileUnderCursor>,
-	mut chunk_modified: EventWriter<ChunkModifiedEvent>,
-	mut tile_modified: EventWriter<TileModifiedEvent>,
-) {
+	mut chunk_modified: MessageWriter<ChunkModifiedEvent>,
+	mut tile_modified: MessageWriter<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) {
-				chunk_modified.send(ChunkModifiedEvent { index: chunk });
+			if !chunk_set.contains(&chunk)
+			{
+				chunk_modified.write(ChunkModifiedEvent { index: chunk });
 				chunk_set.insert(chunk);
 				commands.entity(chunks.chunks[chunk]).insert(RebuildChunk);
 			}
-			tile_modified.send(TileModifiedEvent::HeightChanged(tile, height));
+			tile_modified.write(TileModifiedEvent::HeightChanged(tile, height));
 		}
 		// commands.entity(e).insert(RebuildChunk);
 	}

game/main/src/phos.rs

@@ -1,30 +1,32 @@
 use crate::camera_system::components::PhosCamera;
 use crate::map_rendering::map_init::MapInitPlugin;
 use crate::map_rendering::render_distance_system::RenderDistancePlugin;
-use crate::ui::game::build_ui::BuildUiPlugin;
+use crate::ui::build_ui::BuildUIPlugin;
 use crate::utlis::editor_plugin::EditorPlugin;
 use crate::utlis::tile_selection_plugin::TileSelectionPlugin;
 use crate::{camera_system::camera_plugin::PhosCameraPlugin, utlis::debug_plugin::DebugPlugin};
-use bevy::{
-	pbr::{wireframe::WireframeConfig, CascadeShadowConfig},
-	prelude::*,
-};
+use bevy::diagnostic::{EntityCountDiagnosticsPlugin, FrameTimeDiagnosticsPlugin};
+use bevy::light::CascadeShadowConfig;
+use bevy::{pbr::wireframe::WireframeConfig, prelude::*};
 use bevy_asset_loader::prelude::*;
 use bevy_rapier3d::dynamics::{Ccd, RigidBody, Velocity};
 use bevy_rapier3d::geometry::Collider;
 use bevy_rapier3d::plugin::{NoUserData, RapierPhysicsPlugin};
-use buildings::BuildingPugin;
-use iyes_perf_ui::prelude::*;
+// 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 {
-	fn build(&self, app: &mut App) {
+impl Plugin for PhosGamePlugin
+{
+	fn build(&self, app: &mut App)
+	{
 		app.insert_state(AssetLoadState::Loading);
 		app.insert_state(MenuState::Loading);
 		app.insert_state(GameplayState::Waiting);
@@ -37,9 +39,10 @@ impl Plugin for PhosGamePlugin {
 			PhosCameraPlugin,
 			MapInitPlugin,
 			RenderDistancePlugin,
-			BuildingPugin,
-			BuildUiPlugin,
-			UnitsPlugin,
+			// BuildingPugin,
+			BuildUIPlugin,
+			// SimpleAnimationPlugin,
+			// UnitsPlugin,
 			DespawnPuglin,
 			TileSelectionPlugin,
 			#[cfg(debug_assertions)]
@@ -57,10 +60,10 @@ impl Plugin for PhosGamePlugin {
 		app.add_systems(Update, spawn_sphere);
 
 		//Perf UI
-		app.add_plugins(bevy::diagnostic::FrameTimeDiagnosticsPlugin)
-			.add_plugins(bevy::diagnostic::EntityCountDiagnosticsPlugin)
-			.add_plugins(bevy::diagnostic::SystemInformationDiagnosticsPlugin)
-			.add_plugins(PerfUiPlugin);
+		app.add_plugins(FrameTimeDiagnosticsPlugin::default())
+			.add_plugins(EntityCountDiagnosticsPlugin::default())
+			.add_plugins(bevy::diagnostic::SystemInformationDiagnosticsPlugin);
+		// .add_plugins(PerfUiPlugin);
 
 		//Physics
 		app.add_plugins(RapierPhysicsPlugin::<NoUserData>::default());
@@ -73,55 +76,56 @@ 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_then(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
 	);
 	app.configure_sets(
 		PreUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
 	);
 	app.configure_sets(
 		PostUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
 	);
 
 	app.configure_sets(
 		FixedUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
 	);
 	app.configure_sets(
 		FixedPreUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
 	);
 	app.configure_sets(
 		FixedPostUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
 	);
 }
 
-fn init_game(mut commands: Commands, mut materials: ResMut<Assets<StandardMaterial>>) {
-	commands.spawn((
-		PerfUiRoot::default(),
-		PerfUiEntryFPS::default(),
-		PerfUiEntryFPSWorst::default(),
-		PerfUiEntryFrameTime::default(),
-		PerfUiEntryFrameTimeWorst::default(),
-	));
+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(DirectionalLightBundle {
-		directional_light: DirectionalLight {
+	commands.spawn((
+		DirectionalLight {
 			shadows_enabled: true,
 			..default()
 		},
-		cascade_shadow_config: CascadeShadowConfig {
+		CascadeShadowConfig {
 			bounds: vec![200., 400., 600., 800.],
 			..default()
 		},
-		transform: Transform::from_xyz(500., 260.0, 500.).looking_at(Vec3::ZERO, Vec3::Y),
-		..default()
-	});
+		Transform::from_xyz(500., 260.0, 500.).looking_at(Vec3::ZERO, Vec3::Y),
+	));
 
 	let sphere_mat = StandardMaterial {
 		base_color: Color::srgb(1., 1., 0.),
@@ -136,24 +140,22 @@ struct SphereMat(Handle<StandardMaterial>);
 
 fn spawn_sphere(
 	mut commands: Commands,
-	cam: Query<&Transform, With<PhosCamera>>,
+	cam: Single<&Transform, With<PhosCamera>>,
 	keyboard_input: Res<ButtonInput<KeyCode>>,
 	mut meshes: ResMut<Assets<Mesh>>,
 	mat: Res<SphereMat>,
-) {
-	if keyboard_input.just_pressed(KeyCode::KeyF) {
-		let cam_transform = cam.single();
+)
+{
+	if keyboard_input.just_pressed(KeyCode::KeyF)
+	{
 		commands.spawn((
-			MaterialMeshBundle {
-				mesh: meshes.add(Sphere::new(0.3)),
-				material: mat.0.clone(),
-				transform: Transform::from_translation(cam_transform.translation),
-				..default()
-			},
+			Mesh3d(meshes.add(Sphere::new(0.3))),
+			MeshMaterial3d(mat.0.clone()),
+			Transform::from_translation(cam.translation),
 			Collider::ball(0.3),
 			RigidBody::Dynamic,
 			Ccd::enabled(),
-			Velocity::linear(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,24 +17,33 @@ pub struct PhosAssets {
 }
 
 #[derive(Component)]
-pub struct PhosChunk {
+pub struct PhosChunk
+{
 	pub index: usize,
 }
 
-impl PhosChunk {
-	pub fn new(index: usize) -> Self {
+impl PhosChunk
+{
+	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 {
-	pub fn new(size: usize) -> Self {
+impl PhosChunkRegistry
+{
+	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,41 +1,50 @@
 use bevy::asset::{Asset, Handle};
+use bevy::image::Image;
 use bevy::pbr::{Material, MaterialExtension};
 use bevy::reflect::TypePath;
-use bevy::render::mesh::{MeshVertexAttribute, MeshVertexBufferLayoutRef};
-use bevy::render::render_resource::{AsBindGroup, ShaderRef};
-use bevy::render::texture::Image;
+use bevy::render::render_resource::AsBindGroup;
+use bevy::shader::ShaderRef;
 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 {
-	fn fragment_shader() -> ShaderRef {
+impl MaterialExtension for ChunkMaterial
+{
+	fn fragment_shader() -> ShaderRef
+	{
 		"shaders/world/chunk.wgsl".into()
 	}
 }
 
+#[allow(dead_code)]
 #[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
-pub struct PackedChunkMaterial {
+pub struct PackedChunkMaterial
+{
 	#[texture(100, dimension = "2d_array")]
 	#[sampler(101)]
 	pub array_texture: Handle<Image>,
 }
 
-impl Material for PackedChunkMaterial {
-	fn fragment_shader() -> ShaderRef {
+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 {
+	fn prepass_vertex_shader() -> ShaderRef
+	{
 		"shaders/world/chunk_packed.wgsl".into()
 	}
 
@@ -48,11 +57,12 @@ impl Material for PackedChunkMaterial {
 	// }
 
 	fn specialize(
-		_pipeline: &bevy::pbr::MaterialPipeline<Self>,
+		_pipeline: &bevy::pbr::MaterialPipeline,
 		descriptor: &mut bevy::render::render_resource::RenderPipelineDescriptor,
-		layout: &MeshVertexBufferLayoutRef,
+		layout: &bevy::mesh::MeshVertexBufferLayoutRef,
 		_key: bevy::pbr::MaterialPipelineKey<Self>,
-	) -> Result<(), bevy::render::render_resource::SpecializedMeshPipelineError> {
+	) -> 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),

game/main/src/shader_extensions/water_material.rs

@@ -1,26 +1,30 @@
 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, ShaderRef, ShaderType};
+use bevy::render::render_resource::{AsBindGroup, 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 {
-	fn default() -> Self {
+impl Default for WaterSettings
+{
+	fn default() -> Self
+	{
 		Self {
 			offset: 0.0,
 			scale: 1.0,
@@ -30,18 +34,21 @@ impl Default for WaterSettings {
 	}
 }
 
-impl MaterialExtension for WaterMaterial {
-	fn fragment_shader() -> ShaderRef {
+impl MaterialExtension for WaterMaterial
+{
+	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::render::mesh::MeshVertexBufferLayout,
-	// 	_key: bevy::pbr::MaterialExtensionKey<Self>,
-	// ) -> Result<(), bevy::render::render_resource::SpecializedMeshPipelineError> {
-	// 	let vertex_layout = layout.get_layout(&[
+	// 	layout: &bevy::mesh::MeshVertexBufferLayoutRef,
+	// 	key: bevy::pbr::MaterialExtensionKey<Self>,
+	// ) -> std::result::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),

game/main/src/ui/build_ui.rs

@@ -0,0 +1,39 @@
+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/game/build_ui.rs

@@ -1,54 +0,0 @@
-use bevy::{prelude::*, render::view::RenderLayers};
-use bevy_lunex::prelude::*;
-use shared::tags::MainCamera;
-
-pub struct BuildUiPlugin;
-
-impl Plugin for BuildUiPlugin {
-	fn build(&self, app: &mut App) {
-		// app.add_plugins(UiDefaultPlugins)
-		// 	.add_plugins(UiDebugPlugin::<MainUi>::new());
-
-		app.add_systems(PostStartup, setup_ui);
-	}
-}
-
-fn setup_ui(mut commands: Commands, assets: Res<AssetServer>) {
-	commands
-		.spawn((
-			Camera2dBundle {
-				transform: Transform::from_xyz(0.0, 0.0, 1000.0),
-				..default()
-			},
-			MainUi,
-		))
-		.insert(RenderLayers::layer(1));
-
-	commands
-		.spawn((
-			UiTreeBundle::<MainUi> {
-				tree: UiTree::new2d("BuildUi"),
-				..default()
-			},
-			Name::new("Build UI"),
-			SourceFromCamera,
-			RenderLayers::layer(1),
-		))
-		.with_children(|ui| {
-			ui.spawn((
-				UiLink::<MainUi>::path("Root"),
-				UiLayout::boundary()
-					.pos1(Ab(20.0))
-					.pos2(Rl(100.0) - Ab(20.0))
-					.pack::<Base>(),
-				RenderLayers::layer(1),
-			));
-
-			ui.spawn((
-				UiLink::<MainUi>::path("Root/Rect"),
-				UiLayout::solid().size((Ab(1920.0), Ab(1080.0))).pack::<Base>(),
-				UiImage2dBundle::from(assets.load("textures/world/test2.png")),
-				RenderLayers::layer(1),
-			));
-		});
-}

game/main/src/ui/game/mod.rs

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

game/main/src/ui/mod.rs

@@ -1 +1 @@
-pub mod game;
+pub mod build_ui;

game/main/src/utlis/chunk_utils.rs

@@ -4,7 +4,7 @@ use bevy::{
 	asset::Assets,
 	ecs::system::Res,
 	math::{IVec2, UVec2, Vec3},
-	render::mesh::Mesh,
+	mesh::Mesh,
 };
 use bevy_rapier3d::geometry::{Collider, TriMeshFlags};
 use rayon::iter::{IntoParallelRefMutIterator, ParallelIterator};
@@ -13,7 +13,6 @@ use world_generation::{
 	generators::{
 		chunk_colliders::generate_chunk_collider,
 		mesh_generator::{generate_chunk_mesh, generate_chunk_water_mesh},
-		packed_mesh_generator::generate_packed_chunk_mesh,
 	},
 	hex_utils::offset_to_world,
 	prelude::{Chunk, Map, MeshChunkData},
@@ -26,7 +25,8 @@ 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,9 +37,12 @@ pub fn paint_chunk(
 	painter: &BiomePainter,
 	tiles: &Res<Assets<TileAsset>>,
 	mappers: &Res<Assets<TileMapperAsset>>,
-) {
-	for z in 0..Chunk::SIZE {
-		for x in 0..Chunk::SIZE {
+)
+{
+	for z 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];
@@ -58,7 +61,8 @@ pub fn prepare_chunk_mesh(
 	chunk_offset: IVec2,
 	chunk_index: usize,
 	map_size: UVec2,
-) -> (Mesh, 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);
@@ -80,14 +84,16 @@ pub fn prepare_chunk_mesh_with_collider(
 	chunk_offset: IVec2,
 	chunk_index: usize,
 	map_size: UVec2,
-) -> (Mesh, Mesh, Collider, Vec3, usize) {
+) -> (Mesh, Mesh, Collider, Vec3, usize)
+{
 	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_with_flags(col_verts, col_indicies, TriMeshFlags::DELETE_DUPLICATE_TRIANGLES)
+			.expect("Failed to generate chunk collision mesh");
 	}
 	return (chunk_mesh, water_mesh, collider, pos, index);
 }

game/main/src/utlis/debug_plugin.rs

@@ -1,4 +1,4 @@
-use bevy::{gizmos::gizmos, prelude::*};
+use bevy::prelude::*;
 use shared::states::GameplayState;
 use shared::{resources::TileUnderCursor, sets::GameplaySet};
 use world_generation::{
@@ -11,8 +11,10 @@ use crate::camera_system::components::{PhosCamera, PhosOrbitCamera};
 
 pub struct DebugPlugin;
 
-impl Plugin for DebugPlugin {
-	fn build(&self, app: &mut App) {
+impl Plugin for DebugPlugin
+{
+	fn build(&self, app: &mut App)
+	{
 		app.insert_state(DebugState::Base);
 
 		app.add_systems(
@@ -45,10 +47,11 @@ impl Plugin for DebugPlugin {
 }
 
 #[derive(Resource)]
-struct Shape(pub Polyline3d<7>);
+struct Shape(pub Polyline3d);
 
 #[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
-pub enum DebugState {
+pub enum DebugState
+{
 	Base,
 	None,
 	Verbose,
@@ -58,22 +61,21 @@ 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>) {
-	if let Some(contact) = tile_under_cursor.0 {
+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
+	{
 		let height = map.sample_height(&contact.tile);
-		gizmos.primitive_3d(
-			&shape.0,
-			contact.tile.to_world(height + 0.01),
-			Quat::IDENTITY,
-			Color::WHITE,
-		);
+		gizmos.primitive_3d(&shape.0, contact.tile.to_world(height + 0.01), Color::WHITE);
 
 		gizmos.line(contact.point, contact.point + Vec3::X, LinearRgba::RED);
 		gizmos.line(contact.point, contact.point + Vec3::Y, LinearRgba::GREEN);
@@ -83,8 +85,11 @@ fn show_tile_heights(map: Res<Map>, mut gizmos: Gizmos, shape: Res<Shape>, tile_
 	}
 }
 
-fn show_water_corners(pos: Vec3, gizmos: &mut Gizmos) {
-	for i in 0..WATER_HEX_CORNERS.len() {
+#[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()];
 
@@ -92,14 +97,15 @@ fn show_water_corners(pos: Vec3, gizmos: &mut Gizmos) {
 	}
 }
 
-fn camera_debug(mut cam_query: Query<(&PhosCamera, &PhosOrbitCamera)>, mut gizmos: Gizmos) {
-	let (config, orbit) = cam_query.single();
+fn camera_debug(cam_query: Single<(&PhosCamera, &PhosOrbitCamera)>, mut gizmos: Gizmos)
+{
+	let (_config, orbit) = cam_query.into_inner();
 
-	gizmos.sphere(orbit.target, Quat::IDENTITY, 0.3, LinearRgba::RED);
+	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, Dir3::Y, 0.3, LinearRgba::rgb(1.0, 1.0, 0.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,4 +1,5 @@
-use bevy::{prelude::*, render::render_asset::RenderAssetUsages};
+use bevy::asset::RenderAssetUsages;
+use bevy::prelude::*;
 use bevy_inspector_egui::bevy_egui::EguiContexts;
 use bevy_inspector_egui::egui::{self};
 use image::{ImageBuffer, Rgba};
@@ -10,8 +11,10 @@ use world_generation::{map::map_utils::render_map, prelude::Map, states::Generat
 
 pub struct EditorPlugin;
 
-impl Plugin for EditorPlugin {
-	fn build(&self, app: &mut App) {
+impl Plugin for EditorPlugin
+{
+	fn build(&self, app: &mut App)
+	{
 		app.init_resource::<UIState>();
 
 		app.add_systems(PostUpdate, prepare_image.run_if(in_state(GeneratorState::SpawnMap)));
@@ -25,7 +28,8 @@ 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));
 
@@ -33,14 +37,17 @@ 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 {
-	fn default() -> Self {
+impl Default for UIState
+{
+	fn default() -> Self
+	{
 		Self {
 			is_open: true,
 			target_map_type: default(),
@@ -50,7 +57,8 @@ impl Default for UIState {
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Default)]
-enum MapDisplayType {
+enum MapDisplayType
+{
 	#[default]
 	HeightMap,
 	Biomes,
@@ -61,35 +69,39 @@ enum MapDisplayType {
 }
 
 fn asset_reloaded(
-	mut asset_events: EventReader<AssetEvent<BiomeAsset>>,
-	mut biomes: ResMut<Assets<BiomeAsset>>,
+	mut asset_events: MessageReader<AssetEvent<BiomeAsset>>,
+	biomes: Res<Assets<BiomeAsset>>,
 	biome_painter: Res<BiomePainterAsset>,
 	mut commands: Commands,
-) {
+)
+{
 	let mut rebuild = false;
-	for event in asset_events.read() {
-		match event {
-			AssetEvent::Modified {..}=>	rebuild = true,
+	for event in asset_events.read()
+	{
+		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();
+	let ctx = contexts.ctx_mut().expect("Failed to get egui context");
 	egui::Window::new("Map").open(&mut state.is_open).show(ctx, |ui| {
 		ui.label("Map Test");
 		egui::ComboBox::from_label("Display Type")
@@ -115,12 +127,13 @@ fn render_map_ui(
 				);
 			});
 
-		ui.add(egui::widgets::Image::new(egui::load::SizedTexture::new(
-			id,
-			[512.0, 512.0],
-		)));
+		// ui.add(egui::widgets::Image::new(egui::load::SizedTexture::new(
+		// 	id,
+		// 	[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));
 		}
@@ -135,22 +148,28 @@ 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.insert(
+	images
+		.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>> {
-	return match map_type {
+fn get_map_image(heightmap: &Map, biome_map: &BiomeMap, map_type: MapDisplayType) -> ImageBuffer<Rgba<u8>, Vec<u8>>
+{
+	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/tile_selection_plugin.rs

@@ -1,5 +1,5 @@
 use bevy::{prelude::*, window::PrimaryWindow};
-use bevy_rapier3d::{plugin::RapierContext, prelude::QueryFilter};
+use bevy_rapier3d::{plugin::ReadRapierContext, prelude::QueryFilter};
 use shared::{
 	resources::{TileContact, TileUnderCursor},
 	tags::MainCamera,
@@ -7,8 +7,10 @@ use shared::{
 use world_generation::{hex_utils::HexCoord, prelude::Map, states::GeneratorState};
 pub struct TileSelectionPlugin;
 
-impl Plugin for TileSelectionPlugin {
-	fn build(&self, app: &mut App) {
+impl Plugin for TileSelectionPlugin
+{
+	fn build(&self, app: &mut App)
+	{
 		app.init_resource::<TileUnderCursor>();
 		app.add_systems(
 			PreUpdate,
@@ -18,28 +20,29 @@ impl Plugin for TileSelectionPlugin {
 }
 
 fn update_tile_under_cursor(
-	cam_query: Query<(&GlobalTransform, &Camera), With<MainCamera>>,
-	window: Query<&Window, With<PrimaryWindow>>,
-	rapier_context: Res<RapierContext>,
+	cam_query: Single<(&GlobalTransform, &Camera), With<MainCamera>>,
+	window: Single<&Window, With<PrimaryWindow>>,
+	rapier: ReadRapierContext,
 	map: Res<Map>,
 	mut tile_under_cursor: ResMut<TileUnderCursor>,
-) {
-	let win_r = window.get_single();
-	if win_r.is_err() {
-		return;
-	}
-	let win = win_r.unwrap();
-
-	let (cam_transform, camera) = cam_query.single();
-	let Some(cursor_pos) = win.cursor_position() else {
+)
+{
+	let (cam_transform, camera) = cam_query.into_inner();
+	let Some(cursor_pos) = window.cursor_position()
+	else
+	{
 		return;
 	};
 
-	let Some(cam_ray) = camera.viewport_to_world(cam_transform, cursor_pos) else {
+	let Ok(cam_ray) = camera.viewport_to_world(cam_transform, cursor_pos)
+	else
+	{
 		return;
 	};
 
-	let collision = rapier_context.cast_ray(
+	let ctx = rapier.single().expect("Failed to get rapier read context");
+
+	let collision = ctx.cast_ray(
 		cam_ray.origin,
 		cam_ray.direction.into(),
 		500.,
@@ -47,11 +50,13 @@ fn update_tile_under_cursor(
 		QueryFilter::only_fixed(),
 	);
 
-	if let Some((_e, dist)) = collision {
+	if let Some((_e, dist)) = collision
+	{
 		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;
 		}
@@ -61,7 +66,9 @@ fn update_tile_under_cursor(
 			contact_point,
 			contact_coord.to_world(surface),
 		));
-	} else {
+	}
+	else
+	{
 		tile_under_cursor.0 = None;
 	}
 }

game/resources/Cargo.toml

@@ -4,14 +4,14 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-bevy = "0.14.2"
+bevy = "0.18.0"
 world_generation = { path = "../../engine/world_generation" }
 shared = { path = "../shared" }
-serde = { version = "1.0.204", features = ["derive"] }
+serde = { version = "1.0.228", features = ["derive"] }
 asset_loader = { path = "../../engine/asset_loader" }
-serde_json = "1.0.120"
-ron = "0.8.1"
-bevy_asset_loader = { version = "0.21.0", features = [
+serde_json = "1.0.149"
+ron = "0.12.0"
+bevy_asset_loader = { version = "0.25.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }

game/shared/Cargo.toml

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

game/shared/src/animation_plugin.rs

@@ -0,0 +1,18 @@
+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/component_defination.rs

@@ -0,0 +1,20 @@
+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/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_seconds();
+		let d = at.0 - time.elapsed_secs();
 		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.finished() {
+		if after.0.is_finished() {
 			commands.entity(entity).despawn();
 		}
 	}

game/shared/src/events.rs

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

game/shared/src/identifiers.rs

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

game/shared/src/lib.rs

@@ -9,6 +9,9 @@ pub mod resources;
 pub mod sets;
 pub mod states;
 pub mod tags;
+// pub mod prefab_defination;
+// pub mod animation_plugin;
+// pub mod component_defination;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub enum Tier {

game/shared/src/prefab_defination.rs

@@ -0,0 +1,79 @@
+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/units/Cargo.toml

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

game/units/src/assets/unit_asset.rs

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

game/units/src/lib.rs

@@ -1,6 +1,3 @@
-use bevy::reflect::Reflect;
-use serde::{Deserialize, Serialize};
-
 pub mod assets;
 pub mod components;
 pub mod nav_data;
@@ -11,6 +8,7 @@ pub mod units_plugin;
 pub mod units_spacial_set;
 
 #[derive(Clone, Copy)]
-pub enum UnitType {
+pub enum UnitType
+{
 	Basic,
 }

game/units/src/units_debug_plugin.rs

@@ -34,11 +34,7 @@ fn spawn_test_unit(
 	if let Some(contact) = tile_under_cursor.0 {
 		info!("Spawning Test Unit");
 		commands.spawn((
-			PbrBundle {
-				transform: Transform::from_translation(contact.surface),
-				mesh: unit.0.clone(),
-				..default()
-			},
+			(Transform::from_translation(contact.surface), Mesh3d(unit.0.clone())),
 			Unit,
 			LandUnit,
 		));

game/units/src/units_plugin.rs

@@ -1,6 +1,10 @@
 use std::collections::HashMap;
 
-use bevy::{ecs::world::CommandQueue, prelude::*, tasks::AsyncComputeTaskPool, utils::futures};
+use bevy::{
+	ecs::world::CommandQueue,
+	prelude::*,
+	tasks::{futures, AsyncComputeTaskPool},
+};
 use pathfinding::prelude::astar;
 use shared::{events::TileModifiedEvent, resources::TileUnderCursor, sets::GameplaySet};
 use world_generation::{hex_utils::HexCoord, prelude::Map, states::GeneratorState};
@@ -41,7 +45,7 @@ fn build_navdata(mut commands: Commands, map: Res<Map>) {
 	commands.insert_resource(nav_data);
 }
 
-fn update_navdata(mut tile_updates: EventReader<TileModifiedEvent>, mut nav_data: ResMut<NavData>) {
+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) => {
@@ -71,7 +75,7 @@ fn move_unit(
 			path.1 += 1;
 			continue;
 		}
-		let vel = d.normalize() * 10.0 * time.delta_seconds();
+		let vel = d.normalize() * 10.0 * time.delta_secs();
 		t.translation += vel;
 		let coord = HexCoord::from_world_pos(t.translation);
 		if map.is_in_bounds(&coord) {

rust-toolchain.toml

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