ui testing

Building prefab loading

engine/asset_loader/Cargo.toml

@@ -9,5 +9,5 @@ edition = "2021"
 [dependencies]
 serde = "1.0.204"
 serde_json = "1.0.120"
-bevy = "0.14.2"
+bevy = "0.15.1"
 ron = "0.8.1"

engine/asset_loader/src/macros.rs

@@ -29,11 +29,11 @@ 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<'_>,
+			async fn load(
+		        &self,
+				reader: & mut dyn bevy::asset::io::Reader,
+				_: &Self::Settings,
+				load_context: &mut LoadContext<'_>,
 		    ) -> Result<Self::Asset, Self::Error> {
 				let mut bytes = Vec::new();
 				let read_result = reader.read_to_end(&mut bytes).await;

engine/asset_loader_proc/Cargo.toml

@@ -9,5 +9,5 @@ proc-macro = true
 [dependencies]
 serde = "1.0.204"
 serde_json = "1.0.120"
-bevy = "0.14.2"
+bevy = "0.15.1"
 ron = "0.8.1"

engine/world_generation/Cargo.toml

@@ -6,14 +6,14 @@ 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.15.1"
 noise = "0.9.0"
 serde = { version = "1.0.203", features = ["derive"] }
 serde_json = "1.0.115"
 asset_loader = { path = "../asset_loader" }
 rayon = "1.10.0"
-bevy-inspector-egui = "0.25.0"
-bevy_asset_loader = { version = "0.21.0", features = [
+bevy-inspector-egui = "0.28.1"
+bevy_asset_loader = { version = "0.22.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }

engine/world_generation/src/consts.rs

@@ -41,9 +41,9 @@ pub const HEX_NORMALS: [Vec3; 6] = [
 ];
 
 pub const ATTRIBUTE_PACKED_VERTEX_DATA: MeshVertexAttribute =
-	MeshVertexAttribute::new("PackedVertexData", 988540817, VertexFormat::Uint32);
+	MeshVertexAttribute::new("PackedVertexData", 7, VertexFormat::Uint32);
 pub const ATTRIBUTE_VERTEX_HEIGHT: MeshVertexAttribute =
-	MeshVertexAttribute::new("VertexHeight", 988540717, VertexFormat::Float32);
+	MeshVertexAttribute::new("VertexHeight", 8, VertexFormat::Float32);
 
 pub const ATTRIBUTE_TEXTURE_INDEX: MeshVertexAttribute =
 	MeshVertexAttribute::new("TextureIndex", 988540917, VertexFormat::Uint32);

engine/world_generation/src/generators/packed_mesh_generator.rs

@@ -1,9 +1,5 @@
-use crate::hex_utils::HexCoord;
-use crate::map::biome_map::BiomeChunk;
+use crate::hex_utils::{offset3d_to_world, HexCoord};
 use crate::prelude::*;
-use crate::tile_manager::TileAsset;
-use crate::tile_mapper::TileMapperAsset;
-use crate::{biome_asset::BiomeAsset, biome_painter::BiomePainterAsset};
 use bevy::{
 	prelude::*,
 	render::{
@@ -12,15 +8,7 @@ use bevy::{
 	},
 };
 
-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 {
+pub fn generate_packed_chunk_mesh(chunk: &MeshChunkData) -> 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);
@@ -28,16 +16,10 @@ pub fn generate_packed_chunk_mesh(
 
 	for z 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 coord =
-				HexCoord::from_offset(IVec2::new(x as i32, z as i32) + (chunk.chunk_offset * Chunk::SIZE as i32));
-			let n = map.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();
+			let idx = x + z * Chunk::SIZE;
+			let height = chunk.heights[idx];
+			let coord = HexCoord::from_grid_pos(x, z);
+			let n = chunk.get_neighbors(&coord);
 
 			create_packed_tile(
 				UVec2::new(x as u32, z as u32),
@@ -46,8 +28,8 @@ pub fn generate_packed_chunk_mesh(
 				&mut packed_data,
 				&mut indices,
 				&mut heights,
-				tile.texture_id,
-				tile.side_texture_id,
+				chunk.textures[idx][0],
+				chunk.textures[idx][1],
 			);
 		}
 	}
@@ -65,7 +47,7 @@ pub fn generate_packed_chunk_mesh(
 fn create_packed_tile(
 	offset: UVec2,
 	height: f32,
-	neighbors: &[Option<f32>; 6],
+	neighbors: &[f32; 6],
 	packed_data: &mut Vec<u32>,
 	indices: &mut Vec<u32>,
 	heights: &mut Vec<f32>,
@@ -85,9 +67,7 @@ fn create_packed_tile(
 	}
 
 	for i in 0..neighbors.len() {
-		let cur_n = neighbors[i];
-		match cur_n {
-			Some(n_height) => {
+		let n_height = neighbors[i];
 		if n_height < height {
 			create_packed_tile_wall(
 				offset,
@@ -101,9 +81,6 @@ fn create_packed_tile(
 			);
 		}
 	}
-			_ => {}
-		}
-	}
 }
 
 fn create_packed_tile_wall(

engine/world_generation/src/map/map_utils.rs

@@ -1,16 +1,12 @@
 use std::ops::Add;
 
-use bevy::{math::VectorSpace, prelude::*};
+use bevy::{asset::AssetLoader, math::VectorSpace, prelude::*};
 use image::ImageBuffer;
 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,
@@ -40,7 +36,7 @@ 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);
 	});
 }
@@ -95,10 +91,10 @@ fn get_height_color_blend(base_color: Hsla, height: f32, height2: f32, smooth: f
 			d /= smooth;
 			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 {
 				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();
 			}
 		}
 	}

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.15.1"
 world_generation = { path = "../../engine/world_generation" }
 shared = { path = "../shared" }
-bevy_rapier3d = "0.27.0"
+bevy_rapier3d = "0.28.0"
 serde = { version = "1.0.204", 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 = [
+bevy_asset_loader = { version = "0.22.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }

game/buildings/src/assets/building_asset.rs

@@ -1,9 +1,19 @@
 use asset_loader::create_asset_loader;
-use bevy::prelude::*;
+use bevy::{
+	gltf::{GltfMesh, GltfNode},
+	prelude::*,
+};
 use serde::{Deserialize, Serialize};
-use shared::identifiers::ResourceIdentifier;
+use shared::{component_defination::ComponentDefination, identifiers::ResourceIdentifier, prefab_defination::*};
 
-use crate::footprint::BuildingFootprint;
+use crate::{
+	buildings::{
+		conduit_building::ResourceConduitInfo, factory_building::FactoryBuildingInfo,
+		resource_gathering::ResourceGatheringBuildingInfo,
+	},
+	footprint::BuildingFootprint,
+	prelude::Building,
+};
 
 #[derive(Asset, TypePath, Debug, Serialize, Deserialize)]
 pub struct BuildingAsset {
@@ -12,11 +22,108 @@ pub struct BuildingAsset {
 	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>,
 	pub production: Vec<ResourceIdentifier>,
+
+	pub health: u32,
+
+	pub building_type: BuildingType,
+	pub components: Option<Vec<ComponentDefination>>,
+}
+
+impl BuildingAsset {
+	pub fn spawn(
+		&self,
+		pos: Vec3,
+		rot: Quat,
+		gltf: &Gltf,
+		commands: &mut Commands,
+		meshes: &Assets<GltfMesh>,
+		nodes: &Assets<GltfNode>,
+	) -> Option<Entity> {
+		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/building_plugin.rs

@@ -1,6 +1,11 @@
 use std::f32::consts::E;
 
-use bevy::{ecs::world::CommandQueue, prelude::*, window::PrimaryWindow};
+use bevy::{
+	ecs::world::CommandQueue,
+	gltf::{GltfMesh, GltfNode},
+	prelude::*,
+	window::PrimaryWindow,
+};
 use bevy_asset_loader::loading_state::{
 	config::{ConfigureLoadingState, LoadingStateConfig},
 	LoadingStateAppExt,
@@ -87,7 +92,6 @@ fn hq_placement(
 	mut build_queue: ResMut<BuildQueue>,
 	mut next_state: ResMut<NextState<GameplayState>>,
 ) {
-
 	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);
@@ -106,12 +110,9 @@ fn hq_placement(
 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,6 +123,9 @@ 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>,
 ) {
@@ -130,16 +134,21 @@ fn process_build_queue(
 		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();

game/buildings/src/buildings/basic_building.rs

@@ -0,0 +1,3 @@
+use serde::{Deserialize, Serialize};
+#[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/factory_building.rs

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

game/buildings/src/buildings/mod.rs

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,8 @@
+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

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

@@ -4,4 +4,5 @@ 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,12 +7,12 @@ 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"
+bevy = { version = "0.15.1", features = ["file_watcher"] }
+bevy-inspector-egui = "0.28.1"
+# iyes_perf_ui = "0.3.0"
 noise = "0.8.2"
 world_generation = { path = "../../engine/world_generation" }
-bevy_rapier3d = { version = "0.27.0", features = [ 
+bevy_rapier3d = { version = "0.28.0", features = [
 	"simd-stable",
 	"parallel",
 	"debug-render-3d",
@@ -21,12 +21,13 @@ rayon = "1.10.0"
 buildings = { path = "../buildings" }
 units = { path = "../units" }
 shared = { path = "../shared" }
-bevy_asset_loader = { version = "0.21.0", features = [
+bevy_asset_loader = { version = "0.22.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }
 ron = "0.8.1"
 image = "0.25.2"
+# 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,4 +1,4 @@
-use bevy::core_pipeline::experimental::taa::{TemporalAntiAliasBundle, TemporalAntiAliasPlugin};
+use bevy::core_pipeline::experimental::taa::{TemporalAntiAliasBundle, TemporalAntiAliasPlugin, TemporalAntiAliasing};
 use bevy::core_pipeline::prepass::DepthPrepass;
 use bevy::input::mouse::{MouseMotion, MouseScrollUnit, MouseWheel};
 use bevy::prelude::*;
@@ -20,13 +20,9 @@ impl Plugin for PhosCameraPlugin {
 
 		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);
 	}
@@ -48,21 +44,21 @@ 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(),
+			TemporalAntiAliasing::default(),
 		))
-		.insert(TemporalAntiAliasBundle::default());
+		.insert(Msaa::Off);
+	// .insert(RenderLayers::layer(0))
 
-	*msaa = Msaa::Off;
+	// *msaa = Msaa::Off;
 }
 
 fn orbit_camera_upate(
@@ -90,24 +86,24 @@ fn orbit_camera_upate(
 		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;
+		window.cursor_options.grab_mode = CursorGrabMode::Locked;
+		window.cursor_options.visible = false;
 	} else {
-		window.cursor.grab_mode = CursorGrabMode::None;
-		window.cursor.visible = true;
+		window.cursor_options.grab_mode = CursorGrabMode::None;
+		window.cursor_options.visible = true;
 	}
 	if key.pressed(KeyCode::KeyE) {
-		let rot = Quat::from_axis_angle(Vec3::Y, f32::to_radians(config.speed) * time.delta_seconds());
+		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());
+		let rot = Quat::from_axis_angle(Vec3::Y, f32::to_radians(-config.speed) * time.delta_secs());
 		orbit.forward = rot * orbit.forward;
 	}
 
@@ -140,7 +136,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);
@@ -155,7 +151,7 @@ fn orbit_camera_upate(
 		}
 	}
 
-	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;

game/main/src/main.rs

@@ -1,6 +1,8 @@
+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;
 use bevy_inspector_egui::quick::WorldInspectorPlugin;
 use phos::PhosGamePlugin;
@@ -10,8 +12,8 @@ mod map_rendering;
 mod phos;
 mod prelude;
 mod shader_extensions;
-mod utlis;
 mod ui;
+mod utlis;
 
 fn main() {
 	App::new()

game/main/src/map_rendering/chunk_rebuild.rs

@@ -73,14 +73,14 @@ fn chunk_rebuilder(
 }
 
 fn collider_task_resolver(
-	mut chunks: Query<(&mut ChunkRebuildTask, &Handle<Mesh>), With<PhosChunk>>,
+	mut chunks: Query<(&mut ChunkRebuildTask, &Mesh3d), 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) {
 			commands.append(&mut c);
-			meshes.insert(mesh_handle, mesh);
+			meshes.insert(mesh_handle.id(), mesh);
 		}
 	}
 }

game/main/src/map_rendering/map_init.rs

@@ -3,6 +3,7 @@ use bevy::log::*;
 use bevy::{
 	pbr::{ExtendedMaterial, NotShadowCaster},
 	prelude::*,
+	render::render_resource::{ColorTargetState, FragmentState, RenderPipelineDescriptor},
 };
 use bevy_asset_loader::prelude::*;
 
@@ -219,6 +220,7 @@ fn spawn_map(
 ) {
 	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
@@ -236,6 +238,8 @@ fn spawn_map(
 		.collect();
 
 	let mut registry = PhosChunkRegistry::new(chunk_meshes.len());
+
+	//Spawn Chunks
 	{
 		#[cfg(feature = "tracing")]
 		let _spawn_span = info_span!("Spawn Chunks").entered();
@@ -248,12 +252,9 @@ fn spawn_map(
 			// let mesh_handle = meshes.a
 			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),
 					RenderDistanceVisibility::default().with_offset(visibility_offset),
 					collider,
@@ -261,12 +262,9 @@ fn spawn_map(
 				.id();
 			let water = commands
 				.spawn((
-					MaterialMeshBundle {
-						mesh: meshes.add(water_mesh),
-						material: atlas.water_material.clone(),
-						transform: Transform::from_translation(pos),
-						..default()
-					},
+					Mesh3d(meshes.add(water_mesh)),
+					MeshMaterial3d(atlas.water_material.clone()),
+					Transform::from_translation(pos),
 					PhosChunk::new(index),
 					NotShadowCaster,
 					RenderDistanceVisibility::default().with_offset(visibility_offset),
@@ -277,20 +275,6 @@ fn spawn_map(
 		}
 	}
 
-	// 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 {

game/main/src/map_rendering/render_distance_system.rs

@@ -1,4 +1,5 @@
 use bevy::prelude::*;
+use shared::tags::MainCamera;
 
 use crate::camera_system::components::PhosCamera;
 
@@ -52,7 +53,7 @@ impl Default for RenderDistanceVisibility {
 
 fn render_distance_system(
 	mut objects: Query<(&Transform, &mut Visibility, &RenderDistanceVisibility)>,
-	camera_query: Query<&Transform, With<PhosCamera>>,
+	camera_query: Query<&Transform, With<MainCamera>>,
 	settings: Res<RenderDistanceSettings>,
 ) {
 	let camera = camera_query.single();

game/main/src/phos.rs

@@ -1,6 +1,7 @@
 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::tile_selection_plugin::TileSelectionPlugin;
 use crate::{camera_system::camera_plugin::PhosCameraPlugin, utlis::debug_plugin::DebugPlugin};
@@ -13,7 +14,8 @@ 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 iyes_perf_ui::prelude::*;
+use shared::animation_plugin::SimpleAnimationPlugin;
 use shared::sets::GameplaySet;
 use shared::states::{GameplayState, MenuState};
 use shared::{despawn::DespawnPuglin, states::AssetLoadState};
@@ -37,6 +39,8 @@ impl Plugin for PhosGamePlugin {
 			MapInitPlugin,
 			RenderDistancePlugin,
 			BuildingPugin,
+			BuildUIPlugin,
+			SimpleAnimationPlugin,
 			UnitsPlugin,
 			DespawnPuglin,
 			TileSelectionPlugin,
@@ -57,8 +61,8 @@ impl Plugin for PhosGamePlugin {
 		//Perf UI
 		app.add_plugins(bevy::diagnostic::FrameTimeDiagnosticsPlugin)
 			.add_plugins(bevy::diagnostic::EntityCountDiagnosticsPlugin)
-			.add_plugins(bevy::diagnostic::SystemInformationDiagnosticsPlugin)
-			.add_plugins(PerfUiPlugin);
+			.add_plugins(bevy::diagnostic::SystemInformationDiagnosticsPlugin);
+		// .add_plugins(PerfUiPlugin);
 
 		//Physics
 		app.add_plugins(RapierPhysicsPlugin::<NoUserData>::default());
@@ -74,52 +78,51 @@ impl Plugin for PhosGamePlugin {
 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(),
-	));
+	// 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.),
@@ -142,12 +145,9 @@ fn spawn_sphere(
 	if keyboard_input.just_pressed(KeyCode::KeyF) {
 		let cam_transform = cam.single();
 		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_transform.translation),
 			Collider::ball(0.3),
 			RigidBody::Dynamic,
 			Ccd::enabled(),

game/main/src/shader_extensions/chunk_material.rs

@@ -1,8 +1,10 @@
 use bevy::asset::{Asset, Handle};
-use bevy::pbr::MaterialExtension;
+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 world_generation::consts::{ATTRIBUTE_PACKED_VERTEX_DATA, ATTRIBUTE_VERTEX_HEIGHT};
 
 #[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
 pub struct ChunkMaterial {
@@ -15,25 +17,50 @@ impl MaterialExtension for ChunkMaterial {
 	fn fragment_shader() -> ShaderRef {
 		"shaders/world/chunk.wgsl".into()
 	}
+}
 
-	// fn vertex_shader() -> ShaderRef {
+#[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 {
+		"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 specialize(
-	// 	_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 opaque_render_method(&self) -> bevy::pbr::OpaqueRendererMethod {
+	// 	return OpaqueRendererMethod::Auto;
 	// }
+
+	fn specialize(
+		_pipeline: &bevy::pbr::MaterialPipeline<Self>,
+		descriptor: &mut bevy::render::render_resource::RenderPipelineDescriptor,
+		layout: &MeshVertexBufferLayoutRef,
+		_key: bevy::pbr::MaterialPipelineKey<Self>,
+	) -> 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/ui/build_ui.rs

@@ -0,0 +1,38 @@
+use bevy::{
+	prelude::*,
+	render::{camera::RenderTarget, view::RenderLayers},
+};
+use shared::{states::AssetLoadState, tags::MainCamera};
+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, UiBoxShadowSamples(6)));
+}
+
+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,11 +0,0 @@
-use bevy::prelude::*;
-
-pub struct BuildUiPlugin;
-
-impl Plugin for BuildUiPlugin {
-	fn build(&self, app: &mut App) {
-		app.add_systems(PostStartup, setup);
-	}
-}
-
-fn setup(mut commands: Commands) {}

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

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

game/main/src/ui/mod.rs

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

game/main/src/utlis/chunk_utils.rs

@@ -13,6 +13,7 @@ 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},

game/main/src/utlis/debug_plugin.rs

@@ -29,7 +29,7 @@ impl Plugin for DebugPlugin {
 				.run_if(in_state(DebugState::Verbose)),
 		);
 
-		app.add_systems(Update, camera_debug.in_set(GameplaySet));
+		// 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([
@@ -68,12 +68,7 @@ fn regenerate_map(
 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);
@@ -95,11 +90,11 @@ 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();
 
-	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

@@ -14,11 +14,11 @@ 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)));
-		app.add_systems(
-			Update,
-			(render_map_ui, update_map_render, asset_reloaded).run_if(in_state(GeneratorState::Idle)),
-		);
+		// app.add_systems(PostUpdate, prepare_image.run_if(in_state(GeneratorState::SpawnMap)));
+		// app.add_systems(
+		// 	Update,
+		// 	(render_map_ui, update_map_render, asset_reloaded).run_if(in_state(GeneratorState::Idle)),
+		// );
 	}
 }
 

game/main/src/utlis/tile_selection_plugin.rs

@@ -1,5 +1,8 @@
 use bevy::{prelude::*, window::PrimaryWindow};
-use bevy_rapier3d::{plugin::RapierContext, prelude::QueryFilter};
+use bevy_rapier3d::{
+	plugin::{RapierContext, ReadDefaultRapierContext},
+	prelude::QueryFilter,
+};
 use shared::{
 	resources::{TileContact, TileUnderCursor},
 	tags::MainCamera,
@@ -20,7 +23,7 @@ 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>,
+	rapier_context: ReadDefaultRapierContext,
 	map: Res<Map>,
 	mut tile_under_cursor: ResMut<TileUnderCursor>,
 ) {
@@ -35,7 +38,7 @@ fn update_tile_under_cursor(
 		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;
 	};
 

game/resources/Cargo.toml

@@ -4,14 +4,14 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-bevy = "0.14.2"
+bevy = "0.15.1"
 world_generation = { path = "../../engine/world_generation" }
 shared = { path = "../shared" }
 serde = { version = "1.0.204", 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 = [
+bevy_asset_loader = { version = "0.22.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }

game/shared/Cargo.toml

@@ -6,7 +6,7 @@ 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.15.1"
 serde = { version = "1.0.204", 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/building.rs

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

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)));

game/shared/src/identifiers.rs

@@ -1,9 +1,15 @@
-use bevy::prelude::Resource;
+use bevy::reflect::Reflect;
 use serde::{Deserialize, Serialize};
 use world_generation::hex_utils::HexCoord;
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Reflect)]
 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,3 +1,4 @@
+use bevy::reflect::Reflect;
 use serde::{Deserialize, Serialize};
 
 pub mod building;
@@ -8,6 +9,9 @@ pub mod resources;
 pub mod sets;
 pub mod states;
 pub mod tags;
+pub mod prefab_defination;
+pub mod component_defination;
+pub mod animation_plugin;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub enum Tier {
@@ -17,3 +21,17 @@ pub enum Tier {
 	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

@@ -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,15 +4,15 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-bevy = "0.14.2"
+bevy = "0.15.1"
 world_generation = { path = "../../engine/world_generation" }
 shared = { path = "../shared" }
-bevy_rapier3d = "0.27.0"
+bevy_rapier3d = "0.28.0"
 serde = { version = "1.0.204", 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 = [
+bevy_asset_loader = { version = "0.22.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }

game/units/src/lib.rs

@@ -1,3 +1,5 @@
+use bevy::reflect::Reflect;
+use serde::{Deserialize, Serialize};
 
 pub mod assets;
 pub mod components;

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

@@ -71,7 +71,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) {