setup

.github/workflows/rust.yml

@@ -1,24 +0,0 @@
-name: Rust
-
-on:
-  push:
-    branches: [ "master" ]
-  pull_request:
-    branches: [ "master" ]
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install deps
-      run: sudo apt install libasound2-dev libudev-dev
-    - name: Build
-      run: cargo build
-    - name: Run tests
-      run: cargo test

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
+  </state>
+</component>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/phos-neo.iml" filepath="$PROJECT_DIR$/.idea/phos-neo.iml" />
+    </modules>
+  </component>
+</project>

.idea/phos-neo.iml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="EMPTY_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/engine/world_generation/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/game/camera_system/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/game/main/src" isTestSource="false" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

.vscode/launch.json

@@ -12,7 +12,7 @@
 			"name": "Debug",
 			"program": "${workspaceRoot}/target/debug/phos.exe",
 			"args": [],
-			"cwd": "${workspaceRoot}/game/main",
+			"cwd": "${workspaceRoot}/target/debug",
 			"preLaunchTask": "Build",
 			// "environment": [
 			// 	{

Cargo.toml

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

engine/asset_loader/Cargo.toml

@@ -6,7 +6,6 @@ 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.0"
-ron = "0.8.1"
+serde = "1.0.197"
+serde_json = "1.0.115"
+bevy = "0.13.2"

engine/asset_loader/src/lib.rs

@@ -6,18 +6,63 @@ pub mod macros {
 			$plugin_name: ident,
 			$loader_name: ident,
 			$asset_type: ident,
+			$asset_loadstate_name: ident,
 			$extensions: expr,
 			$($string_name: ident -> $handle_name: ident)* ;
 			$($string_array_name: ident -> $handle_array_name: ident)* ?
 		) => {
 			use bevy::prelude::*;
-			use bevy::asset::{AssetLoader, AssetEvent, AssetEvents, LoadContext, LoadState, AsyncReadExt, io::Reader};
+			use bevy::asset::{AssetLoader, AssetEvent, LoadContext, AsyncReadExt, io::Reader};
 			use bevy::utils::BoxedFuture;
 			pub struct $plugin_name;
 			impl Plugin for $plugin_name {
 				fn build(&self, app: &mut App) {
 					app.init_asset::<$asset_type>()
-						.init_asset_loader::<$loader_name>();
+						.init_asset_loader::<$loader_name>()
+						.insert_resource($asset_loadstate_name::default())
+						.add_systems(Update, finalize);
+				}
+			}
+
+			fn finalize(
+				mut asset_events: EventReader<AssetEvent<$asset_type>>,
+				mut assets: ResMut<Assets<$asset_type>>,
+				mut load_state: ResMut<$asset_loadstate_name>,
+				 asset_server: Res<AssetServer>
+			) {
+				for event in asset_events.read() {
+					match event {
+						AssetEvent::Added { id } => load_state.added += 1,
+						AssetEvent::LoadedWithDependencies { id } => {
+							let asset = assets.get_mut(id.clone()).unwrap();
+
+							$(
+								asset.$handle_name = asset_server.load(&asset.$string_name);
+							)*
+							$(
+								for i in 0..asset.$string_array_name.len(){
+									asset.$handle_array_name.push(asset_server.load(&asset.$string_array_name[i]));
+								}
+							)?
+							load_state.loaded += 1;
+						},
+						_ => (),
+					}
+				}
+			}
+
+			#[derive(Resource, Debug, Default)]
+			pub struct $asset_loadstate_name{
+				pub loaded: u32,
+				pub added: u32,
+			}
+
+			impl $asset_loadstate_name{
+				pub fn is_all_loaded(&self) -> bool{
+					if self.added == 0{
+						return false;
+					}
+					return self.loaded >= self.added;
 				}
 			}
 
@@ -31,33 +76,25 @@ pub mod macros {
 
 				type Error = String;
 
-				async fn load<'a>(
+				fn load<'a>(
 					&'a self,
-					reader: &'a mut Reader<'_>,
+					reader: &'a mut Reader,
 					_settings: &'a Self::Settings,
-					load_context: &'a mut LoadContext<'_>,
-				) -> Result<Self::Asset, Self::Error> {
-					let mut bytes = Vec::new();
-					let read_result = reader.read_to_end(&mut bytes).await;
+					_load_context: &'a mut LoadContext,
+				) -> BoxedFuture<'a, Result<Self::Asset, Self::Error>> {
+					return Box::pin(async move {
+						let mut data: String = String::new();
+						let read_result = reader.read_to_string(&mut data).await;
 						if read_result.is_err() {
 							return Err(read_result.err().unwrap().to_string());
 						}
-					let serialized: Result<Self::Asset, _> =
-						ron::de::from_bytes::<Self::Asset>(&bytes);
+						let serialized: Result<Self::Asset, serde_json::Error> =
+							serde_json::from_str(&data);
 						if serialized.is_err() {
 							return Err(serialized.err().unwrap().to_string());
 						}
-					let mut asset = serialized.unwrap();
-					$(
-
-						asset.$handle_name = load_context.load(&asset.$string_name);
-					)*
-					$(
-						for i in 0..asset.$string_array_name.len(){
-							asset.$handle_array_name.push(load_context.load(&asset.$string_array_name[i]));
-						}
-					)?
-					return Ok(asset);
+						return Ok(serialized.unwrap());
+					});
 				}
 
 				fn extensions(&self) -> &[&str] {

engine/data/Cargo.toml

@@ -1,6 +0,0 @@
-[package]
-name = "data"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]

engine/data/src/lib.rs

@@ -1 +0,0 @@
-

engine/world_generation/Cargo.toml

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

engine/world_generation/src/biome_asset.rs

@@ -1,33 +0,0 @@
-use asset_loader::create_asset_loader;
-use serde::{Deserialize, Serialize};
-
-use crate::{prelude::NoiseConfig, tile_mapper::TileMapperAsset};
-
-#[derive(Serialize, Deserialize, Asset, TypePath, Debug, Clone)]
-pub struct BiomeAsset {
-	pub moisture: f32,
-	pub temperature: f32,
-	pub continentality: f32,
-	pub name: String,
-	#[serde(skip)]
-	pub tile_mapper: Handle<TileMapperAsset>,
-	pub tile_mapper_path: String,
-	pub noise: NoiseConfig,
-}
-
-impl BiomeAsset {
-	pub fn distance(&self, data: Vec3) -> f32 {
-		let a = Vec3::new(self.moisture, self.temperature, self.continentality);
-		return (a - data).length();
-	}
-}
-
-create_asset_loader!(
-	BiomeAssetPlugin,
-	BiomeAssetLoader,
-	BiomeAsset,
-	&["biome", "biome.ron"],
-	tile_mapper_path -> tile_mapper
-	;
-	?
-);

engine/world_generation/src/biome_painter.rs

@@ -1,89 +1,34 @@
-use bevy::prelude::*;
-use bevy::render::render_resource::encase::rts_array::Length;
+use asset_loader::create_asset_loader;
+use bevy::{
+	asset::{Asset, Handle},
+	reflect::TypePath,
+};
+use serde::{Deserialize, Serialize};
 
-use crate::{biome_asset::BiomeAsset, map::biome_map::BiomeData};
-use bevy_asset_loader::prelude::*;
+use crate::tile_mapper::TileMapperAsset;
 
-#[derive(AssetCollection, Debug, Clone, Resource)]
+#[derive(Serialize, Deserialize, Debug, TypePath, Asset)]
 pub struct BiomePainterAsset {
-	#[asset(key = "biomes", collection(typed))]
-	pub biomes: Vec<Handle<BiomeAsset>>,
+	#[serde(skip)]
+	pub biomes: Vec<Handle<TileMapperAsset>>,
+	pub biomes_path: [String; 16],
 }
 
 impl BiomePainterAsset {
-	pub fn sample_biome(&self, assets: &Assets<BiomeAsset>, data: &BiomeData) -> AssetId<BiomeAsset> {
-		assert!(self.biomes.length() != 0, "There are no biomes");
-		let mut biome = self.biomes.first().unwrap().id();
-		let mut dist = f32::INFINITY;
-
-		for b in &self.biomes {
-			let asset = assets.get(b.id()).unwrap();
-			let d = asset.distance(data.into());
-			if d < dist {
-				biome = b.id();
-				dist = d;
-			}
-		}
-
-		return biome;
-	}
-
-	pub fn build(&self, assets: &Assets<BiomeAsset>) -> BiomePainter {
-		let mut biomes = Vec::with_capacity(self.biomes.len());
-		for b in &self.biomes {
-			let asset = assets.get(b.id()).unwrap();
-			biomes.push(asset.clone());
-		}
-		return BiomePainter { biomes };
+	pub fn sample_biome(&self, moisture: f32, temperature: f32) -> Handle<TileMapperAsset> {
+		let x = (moisture.clamp(0., 1.) * 3.).ceil() as usize;
+		let y = (temperature.clamp(0., 1.) * 3.).ceil() as usize;
+		return self.biomes[x + y * 4].clone();
 	}
 }
 
-#[derive(Resource, Clone)]
-pub struct BiomePainter {
-	pub biomes: Vec<BiomeAsset>,
-}
-
-impl BiomePainter {
-	pub fn sample_biome(&self, data: &BiomeData) -> &BiomeAsset {
-		assert!(self.biomes.length() != 0, "There are no biomes");
-		let mut biome = &self.biomes[0];
-		let mut dist = f32::INFINITY;
-
-		for b in &self.biomes {
-			let d = b.distance(data.into());
-			if d < dist {
-				biome = b;
-				dist = d;
-			}
-		}
-
-		return biome;
-	}
-
-	pub fn sample_biome_index(&self, data: &BiomeData) -> usize {
-		assert!(self.biomes.length() != 0, "There are no biomes");
-		let mut biome = 0;
-		let mut dist = f32::INFINITY;
-
-		for i in 0..self.biomes.len() {
-			let d = self.biomes[i].distance(data.into());
-			if d < dist {
-				biome = i;
-				dist = d;
-			}
-		}
-
-		return biome;
-	}
-}
-
-// create_asset_loader!(
-// 	BiomePainterPlugin,
-// 	BiomePainterLoader,
-// 	BiomePainterAsset,
-// 	BiomePainterLoadState,
-// 	&["bimoes.json"],
-// 	;
-// 	biomes_path -> biomes
-// 	?
-// );
+create_asset_loader!(
+	BiomePainterPlugin,
+	BiomePainterLoader,
+	BiomePainterAsset,
+	BiomePainterLoadState,
+	&["bimoes.json"],
+	;
+	biomes_path -> biomes
+	?
+);

engine/world_generation/src/chunk_colliders.rs

@@ -5,7 +5,7 @@ use bevy::prelude::*;
 
 const CHUNK_TOTAL: usize = Chunk::SIZE * Chunk::SIZE;
 
-pub fn generate_chunk_collider(chunk: &MeshChunkData) -> (Vec<Vec3>, Vec<[u32; 3]>) {
+pub fn generate_chunk_collider(chunk: &Chunk, map: &Map) -> (Vec<Vec3>, Vec<[u32; 3]>) {
 	#[cfg(feature = "tracing")]
 	let span = info_span!("generate_chunk_collider").entered();
 	let vertex_count: usize = CHUNK_TOTAL * 6;
@@ -14,8 +14,9 @@ pub fn generate_chunk_collider(chunk: &MeshChunkData) -> (Vec<Vec3>, Vec<[u32; 3
 	for z in 0..Chunk::SIZE {
 		for x in 0..Chunk::SIZE {
 			let height = chunk.heights[x + z * Chunk::SIZE];
-			let coord = HexCoord::from_grid_pos(x, z);
-			let neighbors = chunk.get_neighbors(&coord);
+			let coord =
+				HexCoord::from_offset(IVec2::new(x as i32, z as i32) + (chunk.chunk_offset * Chunk::SIZE as i32));
+			let neighbors = map.get_neighbors(&coord);
 			let off_pos = Vec3::new(x as f32, height, z as f32);
 			let tile_pos = offset3d_to_world(off_pos);
 			create_tile_collider(tile_pos, &mut verts, &mut indices, &neighbors);
@@ -24,21 +25,23 @@ pub fn generate_chunk_collider(chunk: &MeshChunkData) -> (Vec<Vec3>, Vec<[u32; 3
 	return (verts, indices);
 }
 
-fn create_tile_collider(pos: Vec3, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32; 3]>, neighbors: &[f32; 6]) {
+fn create_tile_collider(pos: Vec3, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32; 3]>, neighbors: &[Option<f32>; 6]) {
 	let idx = verts.len() as u32;
 	for i in 0..6 {
 		let p = pos + HEX_CORNERS[i];
 		verts.push(p);
 	}
 
-	//Top Surface
+	//Top Surfave
 	indices.push([idx, idx + 1, idx + 5]);
 	indices.push([idx + 1, idx + 2, idx + 5]);
 	indices.push([idx + 2, idx + 4, idx + 5]);
 	indices.push([idx + 2, idx + 3, idx + 4]);
 
 	for i in 0..neighbors.len() {
-		let n_height = neighbors[i];
+		let cur_n = neighbors[i];
+		match cur_n {
+			Some(n_height) => {
 				if n_height < pos.y {
 					create_tile_wall_collider(
 						idx,
@@ -49,12 +52,15 @@ fn create_tile_collider(pos: Vec3, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32
 					);
 				}
 			}
+			_ => {}
+		}
+	}
 }
 
 fn create_tile_wall_collider(idx: u32, pos: Vec3, dir: usize, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32; 3]>) {
 	let idx2 = verts.len() as u32;
 
-	verts.push(pos + HEX_CORNERS[(dir) % 6]);
+	verts.push(pos + HEX_CORNERS[dir]);
 	verts.push(pos + HEX_CORNERS[(dir + 1) % 6]);
 
 	let off = dir as u32;

engine/world_generation/src/consts.rs

@@ -1,34 +0,0 @@
-use bevy::{
-	prelude::*,
-	render::{mesh::MeshVertexAttribute, render_resource::VertexFormat},
-};
-
-use crate::hex_utils::{INNER_RADIUS, OUTER_RADIUS};
-
-pub const TEX_MULTI: Vec2 = Vec2::new(1000., 1.);
-
-pub const HEX_CORNERS: [Vec3; 6] = [
-	Vec3::new(0., 0., OUTER_RADIUS),
-	Vec3::new(INNER_RADIUS, 0., 0.5 * OUTER_RADIUS),
-	Vec3::new(INNER_RADIUS, 0., -0.5 * OUTER_RADIUS),
-	Vec3::new(0., 0., -OUTER_RADIUS),
-	Vec3::new(-INNER_RADIUS, 0., -0.5 * OUTER_RADIUS),
-	Vec3::new(-INNER_RADIUS, 0., 0.5 * OUTER_RADIUS),
-];
-
-pub const HEX_NORMALS: [Vec3; 6] = [
-	Vec3::new(INNER_RADIUS / 2., 0., (OUTER_RADIUS + 0.5 * OUTER_RADIUS) / 2.),
-	Vec3::Z,
-	Vec3::new(INNER_RADIUS / -2., 0., (OUTER_RADIUS + 0.5 * OUTER_RADIUS) / 2.),
-	Vec3::new(INNER_RADIUS / -2., 0., (OUTER_RADIUS + 0.5 * OUTER_RADIUS) / -2.),
-	Vec3::NEG_Z,
-	Vec3::new(INNER_RADIUS / 2., 0., (OUTER_RADIUS + 0.5 * OUTER_RADIUS) / -2.),
-];
-
-pub const ATTRIBUTE_PACKED_VERTEX_DATA: MeshVertexAttribute =
-	MeshVertexAttribute::new("PackedVertexData", 988540817, VertexFormat::Uint32);
-pub const ATTRIBUTE_VERTEX_HEIGHT: MeshVertexAttribute =
-	MeshVertexAttribute::new("VertexHeight", 988540717, VertexFormat::Float32);
-
-pub const ATTRIBUTE_TEXTURE_INDEX: MeshVertexAttribute =
-	MeshVertexAttribute::new("TextureIndex", 988540917, VertexFormat::Uint32);

engine/world_generation/src/generators/mod.rs

@@ -1,3 +0,0 @@
-pub mod chunk_colliders;
-pub mod mesh_generator;
-pub mod packed_mesh_generator;

engine/world_generation/src/heightmap.rs

@@ -1,222 +1,73 @@
-use core::f32;
-
-use bevy::math::{IVec2, UVec2};
+use bevy::math::IVec2;
 use bevy::prelude::{FloatExt, Vec2};
-use bevy::utils::default;
-use noise::{NoiseFn, Simplex, SuperSimplex};
+use noise::{NoiseFn, SuperSimplex};
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 
-use crate::biome_painter::BiomePainter;
-use crate::map::biome_map::{BiomeChunk, BiomeData, BiomeMap};
-use crate::{map, prelude::*};
+use crate::prelude::*;
 
-pub fn generate_heightmap(cfg: &GenerationConfig, seed: u32, painter: &BiomePainter) -> (Map, BiomeMap) {
-	let biomes = generate_biomes(cfg, seed, painter);
-	let biomes_borrow = &biomes;
+pub fn generate_heightmap(cfg: &GenerationConfig, seed: u32) -> Map {
 	// let mut chunks: Vec<Chunk> = Vec::with_capacity(cfg.size.length_squared() as usize);
-	let chunks: Vec<Chunk> = (0..cfg.size.y)
+	let chunks = (0..cfg.size.y)
 		.into_par_iter()
 		.flat_map(|z| {
-			(0..cfg.size.x).into_par_iter().map(move |x| {
-				let biome_chunk = &biomes_borrow.chunks[x as usize + z as usize * cfg.size.x as usize];
-				return generate_chunk(x, z, cfg, seed, &biome_chunk, painter);
-			})
+			(0..cfg.size.x)
+				.into_par_iter()
+				.map(move |x| generate_chunk(x as f64, z as f64, cfg, seed))
 		})
 		.collect();
-	let mut min = f32::MAX;
-	let mut max = f32::MIN;
-	for chunk in &chunks {
-		if chunk.min_level < min {
-			min = chunk.min_level;
-		}
-		if chunk.max_level > max {
-			max = chunk.max_level;
-		}
-	}
-
-	return (
-		Map {
+	return Map {
 		chunks,
 		height: cfg.size.y as usize,
 		width: cfg.size.x as usize,
 		sea_level: cfg.sea_level as f32,
-			min_level: min,
-			max_level: max,
-			biome_count: painter.biomes.len(),
-		},
-		biomes,
-	);
-}
-
-pub fn generate_biomes(cfg: &GenerationConfig, seed: u32, biome_painter: &BiomePainter) -> BiomeMap {
-	let mut map = BiomeMap::new(cfg.size, biome_painter.biomes.len());
-	map.chunks = (0..cfg.size.y)
-		.into_par_iter()
-		.flat_map(|y| {
-			(0..cfg.size.x).into_par_iter().map(move |x| {
-				return generate_biome_chunk(x as usize, y as usize, cfg, seed, biome_painter);
-			})
-		})
-		.collect();
-	map.blend(cfg.biome_blend);
-	return map;
-}
-
-pub fn generate_biome_chunk(
-	chunk_x: usize,
-	chunk_y: usize,
-	cfg: &GenerationConfig,
-	seed: u32,
-	biome_painter: &BiomePainter,
-) -> BiomeChunk {
-	let mut chunk = BiomeChunk {
-		offset: UVec2::new(chunk_x as u32, chunk_y as u32),
-		data: [BiomeData::default(); Chunk::AREA],
-		tiles: Vec::with_capacity(Chunk::AREA),
 	};
-	let noise_m = Simplex::new(seed + 1);
-	let noise_t = Simplex::new(seed + 2);
-	let noise_c = Simplex::new(seed + 3);
-
-	for z in 0..Chunk::SIZE {
-		for x in 0..Chunk::SIZE {
-			let moisture = sample_point(
-				x as f64 + chunk_x as f64 * Chunk::SIZE as f64,
-				z as f64 + chunk_y as f64 * Chunk::SIZE as f64,
-				&cfg.moisture_noise,
-				&noise_m,
-				cfg.size.as_vec2(),
-				cfg.border_size,
-				100.0,
-			);
-			let temperature = sample_point(
-				x as f64 + chunk_x as f64 * Chunk::SIZE as f64,
-				z as f64 + chunk_y as f64 * Chunk::SIZE as f64,
-				&cfg.temperature_noise,
-				&noise_t,
-				cfg.size.as_vec2(),
-				cfg.border_size,
-				50.0,
-			);
-			let continentality = sample_point(
-				x as f64 + chunk_x as f64 * Chunk::SIZE as f64,
-				z as f64 + chunk_y as f64 * Chunk::SIZE as f64,
-				&cfg.continent_noise,
-				&noise_c,
-				cfg.size.as_vec2(),
-				cfg.border_size,
-				0.0,
-			);
-			let data = BiomeData {
-				moisture: moisture.clamp(0., 100.),
-				temperature: temperature.clamp(0., 100.),
-				continentality: continentality.clamp(0., 100.),
-			};
-			let mut b = vec![0.; biome_painter.biomes.len()];
-			b[biome_painter.sample_biome_index(&data)] = 1.;
-
-			chunk.data[x + z * Chunk::SIZE] = data;
-			chunk.tiles.push(b);
-		}
-	}
-
-	return chunk;
 }
 
-pub fn generate_noise_map(size: UVec2, seed: u32, cfg: &NoiseConfig, border_size: f32) -> Vec<f32> {
+pub fn generate_chunk(chunk_x: f64, chunk_z: f64, cfg: &GenerationConfig, seed: u32) -> Chunk {
+	let mut result: [f32; Chunk::SIZE * Chunk::SIZE] = [0.; Chunk::SIZE * Chunk::SIZE];
+	let mut moisture = [0.; Chunk::SIZE * Chunk::SIZE];
+	let mut temp = [0.; Chunk::SIZE * Chunk::SIZE];
 	let noise = SuperSimplex::new(seed);
-
-	let data: Vec<_> = (0..(size.y as usize * Chunk::SIZE))
-		.into_par_iter()
-		.flat_map(|y| {
-			let mut row = Vec::with_capacity(size.x as usize * Chunk::SIZE);
-			for x in 0..row.capacity() {
-				row.push(sample_point(
-					x as f64,
-					y as f64,
-					cfg,
-					&noise,
-					size.as_vec2(),
-					border_size,
-					0.0,
-				));
-			}
-			return row;
-		})
-		.collect();
-	return data;
-}
-
-pub fn generate_chunk(
-	chunk_x: u32,
-	chunk_z: u32,
-	cfg: &GenerationConfig,
-	seed: u32,
-	biome_chunk: &BiomeChunk,
-	biome_painter: &BiomePainter,
-) -> Chunk {
-	let mut result: [f32; Chunk::SIZE * Chunk::SIZE] = [0.; Chunk::AREA];
-	let mut data = [BiomeData::default(); Chunk::AREA];
-	let mut biome_ids = [0; Chunk::AREA];
-	let noise = Simplex::new(seed);
-	let mut min = f32::MAX;
-	let mut max = f32::MIN;
 	for z in 0..Chunk::SIZE {
 		for x in 0..Chunk::SIZE {
-			let biome_data = biome_chunk.get_biome_data(x, z);
-			let biome_blend = biome_chunk.get_biome(x, z);
-			let mut sample = 0.;
-			for i in 0..biome_blend.len() {
-				let blend = biome_blend[i];
-				if blend == 0. {
-					continue;
-				}
-				let biome = &biome_painter.biomes[i];
-				sample += sample_point(
-					x as f64 + chunk_x as f64 * Chunk::SIZE as f64,
-					z as f64 + chunk_z as f64 * Chunk::SIZE as f64,
-					&biome.noise,
+			let sample = sample_point(
+				x as f64 + chunk_x * Chunk::SIZE as f64,
+				z as f64 + chunk_z * Chunk::SIZE as f64,
+				&cfg,
 				&noise,
-					cfg.size.as_vec2(),
-					cfg.border_size,
-					0.0,
-				) * blend;
-			}
-			let idx = x + z * Chunk::SIZE;
-			biome_ids[idx] = biome_chunk.get_biome_id_dithered(x, z, &noise, cfg.biome_dither);
-			result[idx] = sample;
-			if sample > max {
-				max = sample;
-			}
-			if sample < min {
-				min = sample;
-			}
-			data[idx] = biome_data.clone();
+			);
+			result[x + z * Chunk::SIZE] = sample;
+			moisture[x + z * Chunk::SIZE] = noise.get([
+				(x as f64 + chunk_x * Chunk::SIZE as f64) / &cfg.noise_scale,
+				(z as f64 + chunk_z * Chunk::SIZE as f64) / &cfg.noise_scale,
+			]) as f32;
+			temp[x + z * Chunk::SIZE] =
+				sample_tempurature(z as f32 + chunk_z as f32 * Chunk::SIZE as f32, sample, &cfg, 100.);
 		}
 	}
 	return Chunk {
 		heights: result,
-		biome_id: biome_ids,
+		moisture: moisture,
+		temperature: temp,
 		chunk_offset: IVec2::new(chunk_x as i32, chunk_z as i32),
-		max_level: max,
-		min_level: min,
-		..default()
 	};
 }
 
-fn sample_point(
-	x: f64,
-	z: f64,
-	cfg: &NoiseConfig,
-	noise: &impl NoiseFn<f64, 2>,
-	size: Vec2,
-	border_size: f32,
-	border_value: f32,
-) -> f32 {
-	let x_s = x / cfg.scale;
-	let z_s = z / cfg.scale;
+fn sample_tempurature(z: f32, height: f32, cfg: &GenerationConfig, equator: f32) -> f32 {
+	let d = (equator - z).abs();
+	let max_d = equator.max(cfg.get_total_height() as f32 - equator);
+	let t_mod = d.remap(0., max_d, 0., 1.).clamp(0., 1.);
+
+	// let max_d = d.max()
+	return (height.remap(0., 50., 0., 1.).clamp(0., 1.) + t_mod) / 2.;
+}
+
+fn sample_point(x: f64, z: f64, cfg: &GenerationConfig, noise: &impl NoiseFn<f64, 2>) -> f32 {
+	let x_s = x / cfg.noise_scale;
+	let z_s = z / cfg.noise_scale;
 
 	let mut elevation: f64 = 0.;
+	let mut first_layer: f64 = 0.;
 	for i in 0..cfg.layers.len() {
 		let value: f64;
 		let layer = &cfg.layers[i];
@@ -225,22 +76,30 @@ fn sample_point(
 		} else {
 			value = sample_simple(x_s, z_s, layer, noise);
 		}
+		if i == 0 {
+			first_layer = value;
+		}
+		if layer.first_layer_mask {
+			elevation += mask(first_layer, value, cfg.sea_level);
+		} else {
 			elevation += value;
 		}
-
-	if border_size == 0.0 {
-		return elevation as f32;
 	}
 
-	let outer = size * Chunk::SIZE as f32;
+	let outer = cfg.size.as_vec2() * Chunk::SIZE as f32;
 
 	let p = Vec2::new(x as f32, z as f32);
 	let d1 = p.x.min(p.y);
 	let od = outer - p;
 	let d2 = od.x.min(od.y);
-	let d = d1.min(d2).min(border_size).remap(0., border_size, 0., 1.);
+	let d = d1.min(d2).min(cfg.border_size).remap(0., cfg.border_size, 0., 1.);
 
-	return border_value.lerp(elevation as f32, d);
+	return (elevation as f32) * d;
+}
+
+fn mask(mask: f64, value: f64, sea_level: f64) -> f64 {
+	let m = (mask - sea_level).max(0.);
+	return value * m;
 }
 
 fn sample_simple(x: f64, z: f64, cfg: &GeneratorLayer, noise: &impl NoiseFn<f64, 2>) -> f64 {

engine/world_generation/src/hex_utils.rs

@@ -1,9 +1,5 @@
-use num::{PrimInt, Saturating};
-use std::fmt::Display;
-
 use crate::prelude::Chunk;
 use bevy::prelude::*;
-use serde::{Deserialize, Serialize};
 
 pub const OUTER_RADIUS: f32 = 1.;
 pub const INNER_RADIUS: f32 = OUTER_RADIUS * (SQRT_3 / 2.);
@@ -56,21 +52,15 @@ pub fn tile_to_world_distance(dist: u32) -> f32 {
 	return dist as f32 * (2. * INNER_RADIUS);
 }
 
-pub fn get_tile_count(radius: usize) -> usize {
+pub fn get_tile_count(radius: u32) -> u32 {
 	return 1 + 3 * (radius + 1) * radius;
 }
 
-#[derive(Default, Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Copy, Eq, PartialEq)]
 pub struct HexCoord {
 	pub hex: IVec3,
 }
 
-impl Display for HexCoord {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		f.write_fmt(format_args!("HexCoord{}", self.hex))
-	}
-}
-
 impl HexCoord {
 	pub const DIRECTIONS: [IVec3; 6] = [
 		IVec3::new(0, 1, -1),
@@ -145,7 +135,6 @@ impl HexCoord {
 		};
 	}
 
-	/// Converts this coordinate to it's chunk local equivalent
 	pub fn to_chunk(&self) -> HexCoord {
 		let c_pos = self.to_chunk_pos();
 		let off = self.to_offset();
@@ -166,20 +155,14 @@ impl HexCoord {
 		return IVec2::new(self.hex.x + (self.hex.y / 2), self.hex.y);
 	}
 
-	/// Convert the current coordiante to an index
 	pub fn to_index(&self, width: usize) -> usize {
 		return ((self.hex.x + self.hex.y * width as i32) + (self.hex.y / 2)) as usize;
 	}
-
-	/// Gets the index of this coord in the chunk array.
-	///
-	/// [`width`] is in number of chunks
 	pub fn to_chunk_index(&self, width: usize) -> usize {
 		let pos = self.to_chunk_pos();
 		return (pos.x + pos.y * width as i32) as usize;
 	}
 
-	/// Gets the index of this tile in the chunk
 	pub fn to_chunk_local_index(&self) -> usize {
 		return self.to_chunk().to_index(Chunk::SIZE);
 	}
@@ -237,77 +220,4 @@ impl HexCoord {
 			self.get_neighbor(5),
 		];
 	}
-
-	pub fn hex_select(&self, radius: usize, include_center: bool) -> Vec<HexCoord> {
-		assert!(radius != 0, "Radius cannot be zero");
-		let mut result = Vec::with_capacity(get_tile_count(radius));
-
-		if include_center {
-			result.push(*self);
-		}
-
-		for k in 0..(radius + 1) {
-			let mut p = self.scale(4, k);
-			for i in 0..6 {
-				for _j in 0..k {
-					p = p.get_neighbor(i);
-					result.push(p);
-				}
-			}
-		}
-
-		return result;
-	}
-
-	pub fn hex_select_bounded(
-		&self,
-		radius: usize,
-		include_center: bool,
-		height: usize,
-		width: usize,
-	) -> Vec<HexCoord> {
-		assert!(radius != 0, "Radius cannot be zero");
-		let mut result = Vec::with_capacity(get_tile_count(radius));
-
-		if include_center {
-			if self.is_in_bounds(height, width) {
-				result.push(*self);
-			}
-		}
-
-		for k in 0..(radius + 1) {
-			let mut p = self.scale(4, k);
-			for i in 0..6 {
-				for _j in 0..k {
-					p = p.get_neighbor(i);
-					if p.is_in_bounds(height, width) {
-						result.push(p);
-					}
-				}
-			}
-		}
-
-		return result;
-	}
-
-	pub fn select_ring(&self, radius: usize) -> Vec<HexCoord> {
-		assert!(radius != 0, "Radius cannot be zero");
-		let mut result = Vec::with_capacity(radius * 6);
-
-		let mut p = self.scale(4, radius);
-
-		if radius == 1 {
-			result.push(*self);
-			return result;
-		}
-
-		for i in 0..6 {
-			for _j in 0..radius {
-				result.push(p);
-				p = p.get_neighbor(i);
-			}
-		}
-
-		return result;
-	}
 }

engine/world_generation/src/lib.rs

@@ -1,11 +1,159 @@
 pub mod biome_painter;
-pub mod consts;
-pub mod generators;
+pub mod chunk_colliders;
 pub mod heightmap;
 pub mod hex_utils;
-pub mod map;
-pub mod prelude;
-pub mod states;
+pub mod mesh_generator;
+pub mod packed_mesh_generator;
 pub mod tile_manager;
 pub mod tile_mapper;
-pub mod biome_asset;
+
+pub mod prelude {
+	use crate::hex_utils::{tile_to_world_distance, HexCoord, INNER_RADIUS, OUTER_RADIUS, SHORT_DIAGONAL};
+	use bevy::math::{IVec2, UVec2, Vec2, Vec3};
+	use bevy::prelude::Resource;
+	use bevy::prelude::*;
+	use bevy::render::mesh::MeshVertexAttribute;
+	use bevy::render::render_resource::VertexFormat;
+	use bevy_inspector_egui::InspectorOptions;
+	pub const TEX_MULTI: Vec2 = Vec2::new(1000., 1.);
+
+	pub const HEX_CORNERS: [Vec3; 6] = [
+		Vec3::new(0., 0., OUTER_RADIUS),
+		Vec3::new(INNER_RADIUS, 0., 0.5 * OUTER_RADIUS),
+		Vec3::new(INNER_RADIUS, 0., -0.5 * OUTER_RADIUS),
+		Vec3::new(0., 0., -OUTER_RADIUS),
+		Vec3::new(-INNER_RADIUS, 0., -0.5 * OUTER_RADIUS),
+		Vec3::new(-INNER_RADIUS, 0., 0.5 * OUTER_RADIUS),
+	];
+
+	pub const HEX_NORMALS: [Vec3; 6] = [
+		Vec3::new(INNER_RADIUS / 2., 0., (OUTER_RADIUS + 0.5 * OUTER_RADIUS) / 2.),
+		Vec3::Z,
+		Vec3::new(INNER_RADIUS / -2., 0., (OUTER_RADIUS + 0.5 * OUTER_RADIUS) / 2.),
+		Vec3::new(INNER_RADIUS / -2., 0., (OUTER_RADIUS + 0.5 * OUTER_RADIUS) / -2.),
+		Vec3::NEG_Z,
+		Vec3::new(INNER_RADIUS / 2., 0., (OUTER_RADIUS + 0.5 * OUTER_RADIUS) / -2.),
+	];
+
+	#[derive(Resource, Reflect, Default)]
+	#[reflect(Resource)]
+	pub struct GenerationConfig {
+		pub noise_scale: f64,
+		pub sea_level: f64,
+		pub border_size: f32,
+		pub size: UVec2,
+		pub layers: Vec<GeneratorLayer>,
+	}
+
+	impl GenerationConfig {
+		pub fn get_total_width(&self) -> usize {
+			return self.size.x as usize * Chunk::SIZE;
+		}
+		pub fn get_total_height(&self) -> usize {
+			return self.size.y as usize * Chunk::SIZE;
+		}
+	}
+
+	#[derive(Reflect, InspectorOptions)]
+	pub struct GeneratorLayer {
+		pub strength: f64,
+		pub min_value: f64,
+		pub base_roughness: f64,
+		pub roughness: f64,
+		pub persistence: f64,
+		pub is_rigid: bool,
+		pub weight: f64,
+		pub weight_multi: f64,
+		pub layers: usize,
+		pub first_layer_mask: bool,
+	}
+
+	pub struct Chunk {
+		pub heights: [f32; Chunk::SIZE * Chunk::SIZE],
+		pub moisture: [f32; Chunk::SIZE * Chunk::SIZE],
+		pub temperature: [f32; Chunk::SIZE * Chunk::SIZE],
+		pub chunk_offset: IVec2,
+	}
+
+	impl Chunk {
+		pub const SIZE: usize = 64;
+		pub const WORLD_WIDTH: f32 = Chunk::SIZE as f32 * SHORT_DIAGONAL;
+		pub const WORLD_HEIGHT: f32 = Chunk::SIZE as f32 * 1.5;
+		pub const WORLD_SIZE: Vec2 = Vec2::new(Chunk::WORLD_WIDTH, Chunk::WORLD_HEIGHT);
+	}
+
+	#[derive(Resource)]
+	pub struct Map {
+		pub chunks: Vec<Chunk>,
+		pub height: usize,
+		pub width: usize,
+		pub sea_level: f32,
+	}
+
+	impl Map {
+		pub fn get_neighbors(&self, pos: &HexCoord) -> [Option<f32>; 6] {
+			let mut results: [Option<f32>; 6] = [None; 6];
+			let w = self.width * Chunk::SIZE;
+			let h = self.height * Chunk::SIZE;
+			let n_tiles = pos.get_neighbors();
+			for i in 0..6 {
+				let n_tile = n_tiles[i];
+				if !n_tile.is_in_bounds(h, w) {
+					continue;
+				}
+				let c_idx = n_tile.to_chunk_index(self.width);
+				let chunk = &self.chunks[c_idx];
+				let local = n_tile.to_chunk_local_index();
+				results[i] = Some(chunk.heights[local]);
+			}
+			return results;
+		}
+
+		pub fn sample_height(&self, pos: &HexCoord) -> f32 {
+			let chunk = &self.chunks[pos.to_chunk_index(self.width)];
+			return chunk.heights[pos.to_chunk_local_index()];
+		}
+
+		pub fn is_in_bounds(&self, pos: &HexCoord) -> bool {
+			return pos.is_in_bounds(self.height * Chunk::SIZE, self.width * Chunk::SIZE);
+		}
+
+		pub fn get_moisture(&self, pos: &HexCoord) -> f32 {
+			let chunk = &self.chunks[pos.to_chunk_index(self.width)];
+			return chunk.moisture[pos.to_chunk_local_index()];
+		}
+
+		pub fn get_tempurature(&self, pos: &HexCoord) -> f32 {
+			let chunk = &self.chunks[pos.to_chunk_index(self.width)];
+			return chunk.temperature[pos.to_chunk_local_index()];
+		}
+
+		pub fn get_center(&self) -> Vec3 {
+			let w = self.get_world_width();
+			let h = self.get_world_height();
+			return Vec3::new(w / 2., self.sea_level, h / 2.);
+		}
+
+		pub fn get_world_width(&self) -> f32 {
+			return (self.width * Chunk::SIZE) as f32 * SHORT_DIAGONAL;
+		}
+		pub fn get_world_height(&self) -> f32 {
+			return (self.height * Chunk::SIZE) as f32 * 1.5;
+		}
+
+		pub fn get_world_size(&self) -> Vec2 {
+			return Vec2::new(self.get_world_width(), self.get_world_height());
+		}
+
+		pub fn set_height(&mut self, pos: &HexCoord, height: f32) {
+			self.chunks[pos.to_chunk_index(self.width)].heights[pos.to_chunk_local_index()] = height;
+		}
+	}
+	pub const ATTRIBUTE_PACKED_VERTEX_DATA: MeshVertexAttribute =
+		MeshVertexAttribute::new("PackedVertexData", 988540817, VertexFormat::Uint32);
+	pub const ATTRIBUTE_VERTEX_HEIGHT: MeshVertexAttribute =
+		MeshVertexAttribute::new("VertexHeight", 988540717, VertexFormat::Float32);
+
+	pub const ATTRIBUTE_TEXTURE_INDEX: MeshVertexAttribute =
+		MeshVertexAttribute::new("TextureIndex", 988540917, VertexFormat::Uint32);
+}

engine/world_generation/src/map/biome_map.rs

@@ -1,239 +0,0 @@
-use bevy::{
-	math::{UVec2, Vec3},
-	prelude::Resource,
-};
-use noise::NoiseFn;
-use rayon::iter::{IntoParallelIterator, ParallelIterator};
-
-use super::chunk::Chunk;
-
-#[derive(Clone, Resource)]
-pub struct BiomeMap {
-	pub height: usize,
-	pub width: usize,
-	pub size: UVec2,
-	pub biome_count: usize,
-	pub chunks: Vec<BiomeChunk>,
-}
-
-#[derive(Default, Clone, Copy)]
-pub struct BiomeData {
-	pub moisture: f32,
-	pub temperature: f32,
-	pub continentality: f32,
-}
-
-impl Into<Vec3> for &BiomeData {
-	fn into(self) -> Vec3 {
-		return Vec3::new(self.moisture, self.temperature, self.continentality);
-	}
-}
-
-impl Into<Vec3> for BiomeData {
-	fn into(self) -> Vec3 {
-		return Vec3::new(self.moisture, self.temperature, self.continentality);
-	}
-}
-
-impl BiomeMap {
-	pub fn new(size: UVec2, biome_count: usize) -> Self {
-		let len = size.x as usize * size.y as usize * Chunk::AREA;
-		return BiomeMap {
-			size,
-			height: size.y as usize * Chunk::SIZE,
-			width: size.x as usize * Chunk::SIZE,
-			biome_count,
-			chunks: Vec::with_capacity(len),
-		};
-	}
-
-	pub fn blend(&mut self, count: usize) {
-		assert!(count != 0, "Count cannot be 0");
-		for _ in 0..count {
-			self.blend_once();
-		}
-	}
-
-	fn blend_once(&mut self) {
-		let c: Vec<BiomeChunk> = (0..self.chunks.len())
-			.into_par_iter()
-			.map(|i| &self.chunks[i])
-			.map(|chunk| {
-				let tiles: Vec<_> = (0..Chunk::SIZE)
-					.into_par_iter()
-					.map(|y| {
-						let mut new_tiles = Vec::with_capacity(self.width);
-						for x in 0..Chunk::SIZE {
-							let tx = x as u32 + chunk.offset.x * Chunk::SIZE as u32;
-							let ty = y as u32 + chunk.offset.y * Chunk::SIZE as u32;
-							let kernel = self.get_kernel(tx as i32, ty as i32);
-
-							let r = kernel
-								.iter()
-								.filter_map(|f| *f)
-								.fold(vec![0.; self.biome_count], |a, b| {
-									return a.iter().zip(b).map(|v| v.0 + v.1).collect();
-								});
-
-							let sum: f32 = r.iter().sum();
-							if sum == 0. {
-								new_tiles.push(vec![0.; self.biome_count]);
-								continue;
-							}
-							new_tiles.push(r.iter().map(|f| f / sum).collect());
-						}
-						return new_tiles;
-					})
-					.flatten()
-					.collect();
-				return BiomeChunk {
-					offset: chunk.offset,
-					tiles,
-					data: chunk.data,
-				};
-			})
-			.collect();
-		self.chunks = c;
-	}
-
-	fn get_kernel(&self, x: i32, y: i32) -> [Option<&Vec<f32>>; 9] {
-		return [
-			self.get_biome(x - 1, y - 1),
-			self.get_biome(x, y - 1),
-			self.get_biome(x + 1, y - 1),
-			self.get_biome(x - 1, y),
-			self.get_biome(x, y),
-			self.get_biome(x + 1, y),
-			self.get_biome(x - 1, y + 1),
-			self.get_biome(x, y + 1),
-			self.get_biome(x + 1, y + 1),
-		];
-	}
-
-	pub fn get_biome(&self, x: i32, y: i32) -> Option<&Vec<f32>> {
-		if x < 0 || y < 0 {
-			return None;
-		}
-		if x >= self.width as i32 || y >= self.height as i32 {
-			return None;
-		}
-
-		let cx = (x as f32 / Chunk::SIZE as f32).floor() as usize;
-		let cy = (y as f32 / Chunk::SIZE as f32).floor() as usize;
-
-		let chunk = &self.chunks[cx + cy * self.size.x as usize];
-		return Some(chunk.get_biome(x as usize - cx * Chunk::SIZE, y as usize - cy * Chunk::SIZE));
-	}
-
-	pub fn get_biome_id(&self, x: usize, y: usize) -> usize {
-		let cx = (x as f32 / Chunk::SIZE as f32).floor() as usize;
-		let cy = (y as f32 / Chunk::SIZE as f32).floor() as usize;
-
-		let chunk = &self.chunks[cx + cy * self.size.x as usize];
-
-		return chunk.get_biome_id(x - (cx * Chunk::SIZE), y - (cy * Chunk::SIZE));
-	}
-
-	pub fn get_biome_id_dithered(&self, x: usize, y: usize, noise: &impl NoiseFn<f64, 2>, scale: f64) -> usize {
-		let cx = (x as f32 / Chunk::SIZE as f32).floor() as usize;
-		let cy = (y as f32 / Chunk::SIZE as f32).floor() as usize;
-
-		let chunk = &self.chunks[cx + cy * self.size.x as usize];
-
-		return chunk.get_biome_id_dithered(x - (cx * Chunk::SIZE), y - (cy * Chunk::SIZE), noise, scale);
-	}
-
-	pub fn get_biome_data(&self, x: usize, y: usize) -> &BiomeData {
-		let cx = (x as f32 / Chunk::SIZE as f32).floor() as usize;
-		let cy = (y as f32 / Chunk::SIZE as f32).floor() as usize;
-
-		let chunk = &self.chunks[cx + cy * self.size.x as usize];
-
-		return chunk.get_biome_data(x - (cx * Chunk::SIZE), y - (cy * Chunk::SIZE));
-	}
-}
-
-#[derive(Clone)]
-pub struct BiomeChunk {
-	pub tiles: Vec<Vec<f32>>,
-	pub offset: UVec2,
-	pub data: [BiomeData; Chunk::AREA],
-}
-
-impl BiomeChunk {
-	pub fn get_biome(&self, x: usize, y: usize) -> &Vec<f32> {
-		return &self.tiles[x + y * Chunk::SIZE];
-	}
-
-	pub fn get_biome_data(&self, x: usize, y: usize) -> &BiomeData {
-		return &self.data[x + y * Chunk::SIZE];
-	}
-
-	pub fn get_biome_id(&self, x: usize, y: usize) -> usize {
-		let b = self.get_biome(x, y);
-		let mut max = 0.;
-		let mut idx = 0;
-		for i in 0..b.len() {
-			let blend = b[i];
-			if blend > max {
-				max = blend;
-				idx = i;
-			}
-		}
-		return idx;
-	}
-
-	pub fn get_biome_id_dithered(&self, x: usize, y: usize, noise: &impl NoiseFn<f64, 2>, scale: f64) -> usize {
-		let mut cur_id = self.get_biome_id(x, y);
-		let b = self.get_biome(x, y);
-		let n = (noise.get([x as f64 / scale, y as f64 / scale]) as f32 - 0.5)/ 2.0;
-		let mut max = b[cur_id] + n;
-		for i in 0..b.len() {
-			let blend = b[i];
-			if blend == 0. {
-				continue;
-			}
-			if blend > max {
-				max = blend + n;
-				cur_id = i;
-			}
-		}
-
-		return cur_id;
-	}
-}
-
-#[cfg(test)]
-mod tests {
-
-	use super::*;
-
-	#[test]
-	fn biome_blend() {
-		let mut biome = BiomeMap::new(UVec2::splat(4), 8);
-		let w = biome.size.x as usize;
-		let h = biome.size.y as usize;
-
-		for y in 0..h {
-			for x in 0..w {
-				let mut b = vec![0.; biome.biome_count];
-				let idx = (x + y) % biome.biome_count;
-				b[idx] = 1.;
-				biome.chunks.push(generate_chunk(x, y, b));
-			}
-		}
-
-		biome.blend(8);
-		assert!(biome.chunks.iter().all(|f| f.tiles.len() == Chunk::AREA), "Data Lost");
-	}
-
-	fn generate_chunk(x: usize, y: usize, biome: Vec<f32>) -> BiomeChunk {
-		let chunk = BiomeChunk {
-			offset: UVec2::new(x as u32, y as u32),
-			data: [BiomeData::default(); Chunk::AREA],
-			tiles: (0..Chunk::AREA).into_iter().map(|_| biome.clone()).collect(),
-		};
-
-		return chunk;
-	}
-}

engine/world_generation/src/map/chunk.rs

@@ -1,80 +0,0 @@
-use crate::hex_utils::SHORT_DIAGONAL;
-use bevy::prelude::*;
-
-use super::biome_map::BiomeData;
-
-#[derive(Clone)]
-pub struct Chunk {
-	pub heights: [f32; Chunk::AREA],
-	pub textures: [[u32; 2]; Chunk::AREA],
-	// pub biome_data: [BiomeData; Chunk::AREA],
-	pub biome_id: [usize; Chunk::AREA],
-	pub chunk_offset: IVec2,
-	pub min_level: f32,
-	pub max_level: f32,
-}
-
-impl Default for Chunk {
-	fn default() -> Self {
-		Self {
-			heights: [0.; Chunk::AREA],
-			textures: [[0; 2]; Chunk::AREA],
-			// biome_data: [BiomeData::default(); Chunk::AREA],
-			biome_id: [0; Chunk::AREA],
-			chunk_offset: Default::default(),
-			min_level: 0.0,
-			max_level: 0.0,
-		}
-	}
-}
-
-impl Chunk {
-	pub const SIZE: usize = 64;
-	pub const AREA: usize = Chunk::SIZE * Chunk::SIZE;
-	pub const WORLD_WIDTH: f32 = Chunk::SIZE as f32 * SHORT_DIAGONAL;
-	pub const WORLD_HEIGHT: f32 = Chunk::SIZE as f32 * 1.5;
-	pub const WORLD_SIZE: Vec2 = Vec2::new(Chunk::WORLD_WIDTH, Chunk::WORLD_HEIGHT);
-
-	pub fn get_pos_z_edge(&self) -> [f32; Chunk::SIZE] {
-		let mut data = [0.; Chunk::SIZE];
-
-		for x in 0..Chunk::SIZE {
-			let idx = x + (Chunk::SIZE - 1) * Chunk::SIZE;
-			data[x] = self.heights[idx];
-		}
-
-		return data;
-	}
-
-	pub fn get_neg_z_edge(&self) -> [f32; Chunk::SIZE] {
-		let mut data = [0.; Chunk::SIZE];
-
-		for x in 0..Chunk::SIZE {
-			data[x] = self.heights[x];
-		}
-
-		return data;
-	}
-
-	pub fn get_pos_x_edge(&self) -> [f32; Chunk::SIZE] {
-		let mut data = [0.; Chunk::SIZE];
-
-		for z in 0..Chunk::SIZE {
-			let idx = (Chunk::SIZE - 1) + z * Chunk::SIZE;
-			data[z] = self.heights[idx];
-		}
-
-		return data;
-	}
-
-	pub fn get_neg_x_edge(&self) -> [f32; Chunk::SIZE] {
-		let mut data = [0.; Chunk::SIZE];
-
-		for z in 0..Chunk::SIZE {
-			let idx = z * Chunk::SIZE;
-			data[z] = self.heights[idx];
-		}
-
-		return data;
-	}
-}

engine/world_generation/src/map/config.rs

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

engine/world_generation/src/map/map.rs

@@ -1,233 +0,0 @@
-use bevy::prelude::*;
-
-use crate::hex_utils::*;
-
-use super::{
-	biome_map::{BiomeData, BiomeMap},
-	chunk::Chunk,
-	mesh_chunk::MeshChunkData,
-};
-
-#[derive(Resource, Clone)]
-pub struct Map {
-	pub chunks: Vec<Chunk>,
-	pub height: usize,
-	pub width: usize,
-	pub sea_level: f32,
-	pub min_level: f32,
-	pub max_level: f32,
-	pub biome_count: usize,
-}
-
-impl Map {
-	pub fn get_chunk_mesh_data(&self, chunk_index: usize) -> MeshChunkData {
-		#[cfg(feature = "tracing")]
-		let _spawn_span = info_span!("Chunk Mesh Data").entered();
-		let chunk = &self.chunks[chunk_index];
-
-		return MeshChunkData {
-			min_height: self.min_level,
-			heights: chunk.heights.clone(),
-			textures: chunk.textures.clone(),
-		};
-	}
-
-	pub fn get_neighbors(&self, pos: &HexCoord) -> [Option<f32>; 6] {
-		let mut results: [Option<f32>; 6] = [None; 6];
-		let w = self.width * Chunk::SIZE;
-		let h = self.height * Chunk::SIZE;
-		let n_tiles = pos.get_neighbors();
-		for i in 0..6 {
-			let n_tile = n_tiles[i];
-			if !n_tile.is_in_bounds(h, w) {
-				continue;
-			}
-			let c_idx = n_tile.to_chunk_index(self.width);
-			let chunk = &self.chunks[c_idx];
-			let local = n_tile.to_chunk_local_index();
-			results[i] = Some(chunk.heights[local]);
-		}
-		return results;
-	}
-
-	pub fn sample_height(&self, pos: &HexCoord) -> f32 {
-		assert!(
-			self.is_in_bounds(pos),
-			"The provided coordinate is not within the map bounds"
-		);
-
-		let chunk = &self.chunks[pos.to_chunk_index(self.width)];
-		return chunk.heights[pos.to_chunk_local_index()];
-	}
-
-	pub fn sample_height_mut(&mut self, pos: &HexCoord) -> &mut f32 {
-		assert!(
-			self.is_in_bounds(pos),
-			"The provided coordinate is not within the map bounds"
-		);
-
-		let chunk = &mut self.chunks[pos.to_chunk_index(self.width)];
-		return &mut chunk.heights[pos.to_chunk_local_index()];
-	}
-
-	pub fn is_in_bounds(&self, pos: &HexCoord) -> bool {
-		return pos.is_in_bounds(self.height * Chunk::SIZE, self.width * Chunk::SIZE);
-	}
-
-	pub fn get_biome_id(&self, pos: &HexCoord) -> usize {
-		assert!(
-			self.is_in_bounds(pos),
-			"The provided coordinate is not within the map bounds"
-		);
-
-		let chunk = &self.chunks[pos.to_chunk_index(self.width)];
-		return chunk.biome_id[pos.to_chunk_local_index()];
-	}
-	/*
-	pub fn get_biome_noise(&self, pos: &HexCoord) -> &BiomeData {
-		assert!(
-			self.is_in_bounds(pos),
-			"The provided coordinate is not within the map bounds"
-		);
-
-		let chunk = &self.chunks[pos.to_chunk_index(self.width)];
-		return &chunk.biome_data[pos.to_chunk_local_index()];
-	}
-
-	pub fn get_moisture(&self, pos: &HexCoord) -> f32 {
-		assert!(
-			self.is_in_bounds(pos),
-			"The provided coordinate is not within the map bounds"
-		);
-
-		let chunk = &self.chunks[pos.to_chunk_index(self.width)];
-		return chunk.biome_data[pos.to_chunk_local_index()].moisture;
-	}
-
-	pub fn get_tempurature(&self, pos: &HexCoord) -> f32 {
-		assert!(
-			self.is_in_bounds(pos),
-			"The provided coordinate is not within the map bounds"
-		);
-
-		let chunk = &self.chunks[pos.to_chunk_index(self.width)];
-		return chunk.biome_data[pos.to_chunk_local_index()].temperature;
-	}
-
-	pub fn get_continentality(&self, pos: &HexCoord) -> f32 {
-		assert!(
-			self.is_in_bounds(pos),
-			"The provided coordinate is not within the map bounds"
-		);
-
-		let chunk = &self.chunks[pos.to_chunk_index(self.width)];
-		return chunk.biome_data[pos.to_chunk_local_index()].continentality;
-	}
-	*/
-
-	pub fn get_center(&self) -> Vec3 {
-		let w = self.get_world_width();
-		let h = self.get_world_height();
-		return Vec3::new(w / 2., self.sea_level, h / 2.);
-	}
-
-	pub fn get_world_width(&self) -> f32 {
-		return (self.width * Chunk::SIZE) as f32 * SHORT_DIAGONAL;
-	}
-	pub fn get_world_height(&self) -> f32 {
-		return (self.height * Chunk::SIZE) as f32 * 1.5;
-	}
-
-	pub fn get_world_size(&self) -> Vec2 {
-		return Vec2::new(self.get_world_width(), self.get_world_height());
-	}
-
-	pub fn set_height(&mut self, pos: &HexCoord, height: f32) {
-		self.chunks[pos.to_chunk_index(self.width)].heights[pos.to_chunk_local_index()] = height;
-	}
-
-	pub fn create_crater(&mut self, pos: &HexCoord, radius: usize, depth: f32) -> Vec<(HexCoord, f32)> {
-		assert!(radius != 0, "Radius cannot be zero");
-
-		let tiles = self.hex_select_mut(pos, radius, true, |p, h, r| {
-			let d = (r as f32) / (radius as f32);
-			let cur = *h;
-			let h2 = cur - depth;
-			*h = h2.lerp(cur, d * d).max(0.);
-
-			return (*p, *h);
-		});
-
-		return tiles;
-	}
-
-	pub fn hex_select<OP, Ret>(&self, center: &HexCoord, radius: usize, include_center: bool, op: OP) -> Vec<Ret>
-	where
-		OP: (Fn(&HexCoord, f32, usize) -> Ret) + Sync + Send,
-	{
-		assert!(radius != 0, "Radius cannot be zero");
-
-		let mut result = if include_center {
-			Vec::with_capacity(get_tile_count(radius) + 1)
-		} else {
-			Vec::with_capacity(get_tile_count(radius))
-		};
-		if include_center {
-			let h = self.sample_height(&center);
-			result.push((op)(center, h, 0));
-		}
-
-		for k in 0..(radius + 1) {
-			let mut p = center.scale(4, k);
-			for i in 0..6 {
-				for _j in 0..k {
-					p = p.get_neighbor(i);
-					if self.is_in_bounds(&p) {
-						let h = self.sample_height(&p);
-						result.push((op)(&p, h, k));
-					}
-				}
-			}
-		}
-
-		return result;
-	}
-
-	pub fn hex_select_mut<OP, Ret>(
-		&mut self,
-		center: &HexCoord,
-		radius: usize,
-		include_center: bool,
-		op: OP,
-	) -> Vec<Ret>
-	where
-		OP: (Fn(&HexCoord, &mut f32, usize) -> Ret) + Sync + Send,
-	{
-		assert!(radius != 0, "Radius cannot be zero");
-
-		let mut result = if include_center {
-			Vec::with_capacity(get_tile_count(radius) + 1)
-		} else {
-			Vec::with_capacity(get_tile_count(radius))
-		};
-		if include_center {
-			let h = self.sample_height_mut(&center);
-			result.push((op)(center, h, 0));
-		}
-
-		for k in 0..(radius + 1) {
-			let mut p = center.scale(4, k);
-			for i in 0..6 {
-				for _j in 0..k {
-					p = p.get_neighbor(i);
-					if self.is_in_bounds(&p) {
-						let h = self.sample_height_mut(&p);
-						result.push((op)(&p, h, k));
-					}
-				}
-			}
-		}
-
-		return result;
-	}
-}

engine/world_generation/src/map/map_utils.rs

@@ -1,157 +0,0 @@
-use std::ops::Add;
-
-use bevy::{math::VectorSpace, prelude::*};
-use image::ImageBuffer;
-use rayon::prelude::*;
-
-use crate::{biome_painter::BiomePainter, hex_utils::HexCoord};
-
-use super::{
-	biome_map::{self, BiomeMap},
-	chunk::Chunk,
-	map::Map,
-};
-
-pub fn render_image(
-	size: UVec2,
-	data: &Vec<f32>,
-	color1: LinearRgba,
-	color2: LinearRgba,
-) -> ImageBuffer<image::Rgba<u8>, Vec<u8>> {
-	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);
-
-	return image;
-}
-
-pub fn update_image(
-	size: UVec2,
-	data: &Vec<f32>,
-	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);
-
-	let w = size.x * Chunk::SIZE as u32;
-
-	image.par_enumerate_pixels_mut().for_each(|(x, y, pixel)| {
-		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);
-		*pixel = to_pixel(&col);
-	});
-}
-
-fn to_pixel(col: &LinearRgba) -> image::Rgba<u8> {
-	return image::Rgba([
-		(col.red * 255.0) as u8,
-		(col.green * 255.0) as u8,
-		(col.blue * 255.0) as u8,
-		255,
-	]);
-}
-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,
-	);
-	update_map(map, smooth, &mut image);
-	return image;
-}
-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.sea_level {
-			color.hue = 217.0;
-		}
-
-		if map.is_in_bounds(&right) {
-			let h2 = map.sample_height(&right);
-			color = get_height_color_blend(color, height, h2, smooth);
-		}
-
-		*pixel = to_pixel(&color.into());
-	});
-}
-
-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 {
-			color.lightness += 0.1;
-		} else if d < 0.0 {
-			color.lightness -= 0.1;
-		}
-	} else {
-		if d.abs() <= smooth {
-			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();
-			} else {
-				let c2: LinearRgba = color.with_lightness(color.lightness - 0.1).into();
-				color = LinearRgba::lerp(&color.into(), c2, d.abs()).into();
-			}
-		}
-	}
-
-	return color;
-}
-
-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>>) {
-	image.par_enumerate_pixels_mut().for_each(|(x, y, pixel)| {
-		let tile = map.get_biome_data(x as usize, y as usize);
-
-		let color = LinearRgba::rgb(
-			(tile.temperature / 100.0) * multi.x,
-			(tile.continentality / 100.0) * multi.y,
-			(tile.moisture / 100.0) * multi.z,
-		);
-		*pixel = to_pixel(&color);
-	});
-}
-
-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,
-	);
-	update_biome_map(map, biome_map, &mut image);
-	return image;
-}
-
-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() {
-			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) {
-			let h1 = map.sample_height(&coord);
-			let h2 = map.sample_height(&right);
-			color = get_height_color_blend(color.into(), h1, h2, 0.5).into();
-		}
-
-		*pixel = to_pixel(&color.into());
-	});
-}

engine/world_generation/src/map/mesh_chunk.rs

@@ -1,25 +0,0 @@
-use crate::hex_utils::HexCoord;
-
-use super::chunk::Chunk;
-
-pub struct MeshChunkData {
-	pub heights: [f32; Chunk::AREA],
-	pub textures: [[u32; 2]; Chunk::AREA],
-	pub min_height: f32,
-}
-
-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 {
-			let n = n_tiles[i];
-			if !n.is_in_bounds(Chunk::SIZE, Chunk::SIZE) {
-				continue;
-			}
-			data[i] = self.heights[n.to_index(Chunk::SIZE)];
-		}
-
-		return data;
-	}
-}

engine/world_generation/src/map/mod.rs

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

engine/world_generation/src/mesh_generator.rs

@@ -1,4 +1,7 @@
+use crate::biome_painter::BiomePainterAsset;
 use crate::hex_utils::HexCoord;
+use crate::tile_manager::TileAsset;
+use crate::tile_mapper::TileMapperAsset;
 use crate::{hex_utils::offset3d_to_world, prelude::*};
 #[cfg(feature = "tracing")]
 use bevy::log::*;
@@ -10,7 +13,13 @@ use bevy::{
 	},
 };
 
-pub fn generate_chunk_mesh(chunk: &MeshChunkData) -> Mesh {
+pub fn generate_chunk_mesh(
+	chunk: &Chunk,
+	map: &Map,
+	painter: &BiomePainterAsset,
+	tiles: &Res<Assets<TileAsset>>,
+	mappers: &Res<Assets<TileMapperAsset>>,
+) -> Mesh {
 	#[cfg(feature = "tracing")]
 	let span = info_span!("generate_chunk_mesh").entered();
 
@@ -22,12 +31,17 @@ pub fn generate_chunk_mesh(chunk: &MeshChunkData) -> Mesh {
 
 	for z in 0..Chunk::SIZE {
 		for x in 0..Chunk::SIZE {
-			let idx = x + z * Chunk::SIZE;
-			let height = chunk.heights[idx];
+			let height = chunk.heights[x + z * Chunk::SIZE];
+			let moisture = chunk.moisture[x + z * Chunk::SIZE];
+			let temperature = chunk.temperature[x + z * Chunk::SIZE];
 			let off_pos = Vec3::new(x as f32, height, z as f32);
 			let tile_pos = offset3d_to_world(off_pos);
-			let coord = HexCoord::from_grid_pos(x, z);
-			let n = chunk.get_neighbors(&coord);
+			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 = mappers.get(painter.sample_biome(moisture, temperature));
+			let tile_handle = biome.unwrap().sample_tile(height);
+			let tile = tiles.get(tile_handle).unwrap();
 
 			create_tile(
 				tile_pos,
@@ -37,8 +51,8 @@ pub fn generate_chunk_mesh(chunk: &MeshChunkData) -> Mesh {
 				&mut indices,
 				&mut normals,
 				// &mut tex,
-				chunk.textures[idx][0],
-				chunk.textures[idx][1],
+				tile.texture_id,
+				tile.side_texture_id,
 			);
 		}
 	}
@@ -56,7 +70,7 @@ pub fn generate_chunk_mesh(chunk: &MeshChunkData) -> Mesh {
 
 fn create_tile(
 	pos: Vec3,
-	neighbors: &[f32; 6],
+	neighbors: &[Option<f32>; 6],
 	verts: &mut Vec<Vec3>,
 	uvs: &mut Vec<Vec2>,
 	indices: &mut Vec<u32>,
@@ -87,11 +101,16 @@ fn create_tile(
 	indices.push(idx + 4);
 
 	for i in 0..neighbors.len() {
-		let n_height = neighbors[i];
+		let cur_n = neighbors[i];
+		match cur_n {
+			Some(n_height) => {
 				if n_height < pos.y {
 					create_tile_wall(pos, i, n_height, verts, uvs, indices, normals, side_tex_off);
 				}
 			}
+			_ => {}
+		}
+	}
 }
 
 fn create_tile_wall(
@@ -135,60 +154,3 @@ fn create_tile_wall(
 	uvs.push((Vec2::new(0., pos.y - height) / TEX_MULTI) + tex_off);
 	uvs.push((Vec2::new(1., pos.y - height) / TEX_MULTI) + tex_off);
 }
-
-#[cfg(test)]
-mod tests {
-
-	use super::*;
-
-	#[test]
-	fn generate_tile_wall() {
-		let mut verts = Vec::new();
-		let mut uvs = Vec::new();
-		let mut normals = Vec::new();
-		let mut indices = Vec::new();
-
-		create_tile_wall(
-			Vec3::ZERO,
-			3,
-			5.0,
-			&mut verts,
-			&mut uvs,
-			&mut indices,
-			&mut normals,
-			Vec2::new(3.0, 0.0),
-		);
-
-		assert!(verts.len() == 4, "Number of verts don't match");
-		assert!(uvs.len() == 4, "Number of uvs don't match");
-		assert!(normals.len() == 4, "Number of normals don't match");
-		assert!(indices.len() == 6, "Number of normals don't match");
-
-		let index = uvs[0].x.floor();
-		assert!(index == 3.0, "Texture Index could not be decoded");
-	}
-
-	#[test]
-	fn generate_tile() {
-		let mut verts = Vec::new();
-		let mut uvs = Vec::new();
-		let mut normals = Vec::new();
-		let mut indices = Vec::new();
-
-		//4 side faces
-		let nbors = [2.0, 2.0, 0.0, 0.0, 0.0, 0.0];
-
-		create_tile(Vec3::Y, &nbors, &mut verts, &mut uvs, &mut indices, &mut normals, 3, 7);
-
-		assert!(verts.len() == (6 + 4 * 4), "Number of verts don't match");
-		assert!(uvs.len() == (6 + 4 * 4), "Number of uvs don't match");
-		assert!(normals.len() == (6 + 4 * 4), "Number of normals don't match");
-		//12 tris for surface, 6 tris per side
-		assert!(indices.len() == (12 + 4 * 6), "Number of indicies don't match");
-
-		let top_index = uvs[0].x.floor();
-		assert!(top_index == 3.0, "Top Texture Index could not be decoded");
-		let side_index = uvs[6].x.floor();
-		assert!(side_index == 7.0, "Top Texture Index could not be decoded");
-	}
-}

engine/world_generation/src/packed_mesh_generator.rs

@@ -1,9 +1,8 @@
+use crate::biome_painter::BiomePainterAsset;
 use crate::hex_utils::HexCoord;
-use crate::map::biome_map::{self, BiomeChunk, BiomeMap};
 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::{
@@ -15,10 +14,8 @@ 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 {
 	let vertex_count: usize = Chunk::SIZE * Chunk::SIZE * 6;
@@ -29,14 +26,13 @@ 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 moisture = chunk.moisture[x + z * Chunk::SIZE];
+			let temperature = chunk.temperature[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 biome = mappers.get(painter.sample_biome(moisture, temperature));
+			let tile_handle = biome.unwrap().sample_tile(height);
 			let tile = tiles.get(tile_handle).unwrap();
 
 			create_packed_tile(

engine/world_generation/src/prelude.rs

@@ -1,6 +0,0 @@
-pub use crate::consts::*;
-pub use crate::map::chunk::*;
-pub use crate::map::config::*;
-pub use crate::map::map::*;
-pub use crate::map::mesh_chunk::*;
-pub use crate::states::*;

engine/world_generation/src/states.rs

@@ -1,11 +0,0 @@
-use bevy::prelude::*;
-
-#[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
-pub enum GeneratorState {
-	Startup,
-	GenerateHeightmap,
-	SpawnMap,
-	Idle,
-	Regenerate,
-	Cleanup,
-}

engine/world_generation/src/tile_manager.rs

@@ -1,5 +1,9 @@
 use asset_loader::create_asset_loader;
-use bevy::{asset::Asset, ecs::system::Resource, reflect::TypePath};
+use bevy::{
+	asset::{Asset, Handle},
+	ecs::system::Resource,
+	reflect::TypePath,
+};
 use serde::{Deserialize, Serialize};
 #[derive(Resource, Debug)]
 pub struct TileManager {
@@ -20,7 +24,7 @@ impl TileManager {
 	}
 }
 
-#[derive(Serialize, Deserialize, Debug, TypePath, Asset, Clone)]
+#[derive(Serialize, Deserialize, Debug, TypePath, Asset)]
 pub struct TileAsset {
 	#[serde(skip)]
 	pub id: usize,
@@ -33,4 +37,4 @@ pub struct TileAsset {
 	pub side_texture: String,
 }
 
-create_asset_loader!(TileAssetPlugin, TileAssetLoader, TileAsset, &["tile", "tile.ron"],;?);
+create_asset_loader!(TileAssetPlugin, TileAssetLoader, TileAsset, TileAssetLoadState, &["tile.json"],;?);

engine/world_generation/src/tile_mapper.rs

@@ -1,6 +1,9 @@
 use asset_loader::create_asset_loader;
 use bevy::prelude::*;
-use bevy::{asset::Asset, reflect::TypePath};
+use bevy::{
+	asset::{Asset, Handle},
+	reflect::TypePath,
+};
 use serde::{Deserialize, Serialize};
 
 use crate::tile_manager::TileAsset;
@@ -16,14 +19,14 @@ pub struct TileMapperAsset {
 }
 
 impl TileMapperAsset {
-	pub fn sample_tile(&self, height: f32) -> AssetId<TileAsset> {
+	pub fn sample_tile(&self, height: f32) -> Handle<TileAsset> {
 		for i in 0..self.thresholds.len() {
 			let t = self.thresholds[i];
 			if t >= height {
-				return self.tiles[i].id();
+				return self.tiles[i].clone();
 			}
 		}
-		return self.tiles.last().unwrap().id();
+		return self.tiles.last().unwrap().clone();
 	}
 }
 
@@ -31,7 +34,8 @@ create_asset_loader!(
 	TileMapperAssetPlugin,
 	TileMapperAssetLoader,
 	TileMapperAsset,
-	&["mapper", "mapper.ron"],;
+	TileMapperLoadState,
+	&["mapper.json"],;
 	tiles_path -> tiles
 	?
 );

game/buildings/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "buildings"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-bevy = "0.14.0"
-world_generation = { path = "../../engine/world_generation" }
-shared = { path = "../shared" }
-bevy_rapier3d = "0.27.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 = [
-	"standard_dynamic_assets",
-	"3d",
-] }
-
-[features]
-tracing = []

game/buildings/src/assets/building_asset.rs

@@ -1,29 +0,0 @@
-use asset_loader::create_asset_loader;
-use bevy::prelude::*;
-use serde::{Deserialize, Serialize};
-use shared::identifiers::ResourceIdentifier;
-
-use crate::footprint::BuildingFootprint;
-
-#[derive(Asset, TypePath, Debug, Serialize, Deserialize)]
-pub struct BuildingAsset {
-	pub name: String,
-	pub description: String,
-	pub footprint: BuildingFootprint,
-	pub prefab_path: String,
-	#[serde(skip)]
-	pub prefab: Handle<Scene>,
-
-	pub cost: Vec<ResourceIdentifier>,
-	pub consumption: Vec<ResourceIdentifier>,
-	pub production: Vec<ResourceIdentifier>,
-}
-
-create_asset_loader!(
-	BuildingAssetPlugin,
-	BuildingAssetLoader,
-	BuildingAsset,
-	&["building", "building.ron"],
-	prefab_path -> prefab
-	;?
-);

game/buildings/src/assets/building_database.rs

@@ -1,11 +0,0 @@
-use bevy::{asset::Handle, prelude::Resource};
-
-use super::building_asset::BuildingAsset;
-use bevy::prelude::*;
-use bevy_asset_loader::prelude::*;
-
-#[derive(Resource, AssetCollection)]
-pub struct BuildingDatabase {
-	#[asset(key = "buildings", collection(typed))]
-	pub buildings: Vec<Handle<BuildingAsset>>,
-}

game/buildings/src/assets/mod.rs

@@ -1,2 +0,0 @@
-pub mod building_asset;
-pub mod building_database;

game/buildings/src/build_queue.rs

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

game/buildings/src/building_plugin.rs

@@ -1,173 +0,0 @@
-use std::f32::consts::E;
-
-use bevy::{ecs::world::CommandQueue, prelude::*, window::PrimaryWindow};
-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 crate::{
-	assets::{
-		building_asset::{BuildingAsset, BuildingAssetPlugin},
-		building_database::BuildingDatabase,
-	},
-	build_queue::{BuildQueue, QueueEntry},
-	buildings_map::{BuildingEntry, BuildingMap},
-	prelude::Building,
-};
-
-pub struct BuildingPugin;
-
-impl Plugin for BuildingPugin {
-	fn build(&self, app: &mut App) {
-		app.insert_resource(BuildQueue::default());
-		app.add_plugins(BuildingAssetPlugin);
-
-		app.configure_loading_state(
-			LoadingStateConfig::new(AssetLoadState::Loading).load_collection::<BuildingDatabase>(),
-		);
-
-		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))),
-		);
-		app.add_systems(
-			PreUpdate,
-			prepare_building_map.run_if(in_state(GeneratorState::SpawnMap)),
-		);
-		app.add_systems(Update, regernerate.run_if(in_state(GeneratorState::Regenerate)));
-		app.add_systems(
-			PostUpdate,
-			update_building_heights.run_if(in_state(GeneratorState::Idle)),
-		);
-
-		app.add_systems(PreUpdate, process_build_queue.run_if(in_state(GameplayState::Playing)));
-	}
-}
-
-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() {
-		commands.entity(e).despawn();
-	}
-	commands.insert_resource(BuildingMap::new(cfg.size));
-}
-
-#[derive(Resource)]
-struct IndicatorCube(Handle<Mesh>, Handle<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);
-	commands.insert_resource(IndicatorCube(mesh_handle, mat_handle));
-}
-
-fn hq_placement(
-	mut commands: Commands,
-	mouse: Res<ButtonInput<MouseButton>>,
-	tile_under_cursor: Res<TileUnderCursor>,
-	map: Res<Map>,
-	indicator: Res<IndicatorCube>,
-	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);
-
-		if mouse.just_pressed(MouseButton::Left) {
-			build_queue.queue.push(QueueEntry {
-				building: 0.into(),
-				pos: contact.tile,
-			});
-
-			next_state.set(GameplayState::Playing);
-		}
-	}
-}
-
-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()
-			},
-			Despawn,
-		));
-	}
-}
-
-fn process_build_queue(
-	mut queue: ResMut<BuildQueue>,
-	mut commands: Commands,
-	db: Res<BuildingDatabase>,
-	building_assets: Res<Assets<BuildingAsset>>,
-	mut building_map: ResMut<BuildingMap>,
-	heightmap: Res<Map>,
-) {
-	for item in &queue.queue {
-		let handle = &db.buildings[item.building.0];
-		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()));
-		}
-	}
-	queue.queue.clear();
-}
-
-fn update_building_heights(
-	mut tile_updates: EventReader<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) {
-					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>() {
-							transform.translation.y = h;
-						}
-					});
-
-					commands.append(&mut queue);
-				}
-			}
-			_ => (),
-		}
-	}
-}

game/buildings/src/buildings_map.rs

@@ -1,125 +0,0 @@
-use bevy::prelude::*;
-use world_generation::{hex_utils::HexCoord, prelude::Chunk};
-
-#[derive(Resource)]
-pub struct BuildingMap {
-	pub chunks: Vec<BuildingChunk>,
-	pub size: UVec2,
-}
-
-impl BuildingMap {
-	pub fn new(size: UVec2) -> Self {
-		let mut db = BuildingMap {
-			size,
-			chunks: Vec::with_capacity(size.length_squared() as usize),
-		};
-
-		for y in 0..size.y as i32 {
-			for x in 0..size.x as i32 {
-				let offset = IVec2::new(x, y);
-				let index = (x + y * size.x as i32) as usize;
-				db.chunks.push(BuildingChunk::new(offset, index));
-			}
-		}
-
-		return db;
-	}
-
-	pub fn get_buildings_in_range(&self, coord: &HexCoord, radius: usize) -> Vec<&BuildingEntry> {
-		assert!(radius != 0, "Radius cannot be zero");
-
-		let w = self.size.x as usize * Chunk::SIZE;
-		let h = self.size.y as usize * Chunk::SIZE;
-		let coords = coord.hex_select_bounded(radius, true, h, w);
-		return self.get_buildings_in_coords(coords);
-	}
-
-	pub fn get_buildings_in_coords(&self, coords: Vec<HexCoord>) -> Vec<&BuildingEntry> {
-		let mut result = Vec::new();
-		for coord in &coords {
-			if let Some(buidling) = self.get_building(coord) {
-				result.push(buidling);
-			}
-		}
-
-		return result;
-	}
-
-	pub fn get_building(&self, coord: &HexCoord) -> Option<&BuildingEntry> {
-		let chunk = &self.chunks[coord.to_chunk_index(self.size.x as usize)];
-		return chunk.get_building(coord);
-	}
-
-	pub fn add_building(&mut self, entry: BuildingEntry) {
-		let chunk = &mut self.chunks[entry.coord.to_chunk_index(self.size.x as usize)];
-		chunk.add_building(entry);
-	}
-}
-
-pub struct BuildingChunk {
-	pub entries: Vec<BuildingEntry>,
-	pub index: usize,
-	pub offset: IVec2,
-}
-
-impl BuildingChunk {
-	pub fn new(offset: IVec2, index: usize) -> Self {
-		return BuildingChunk {
-			entries: Vec::new(),
-			index,
-			offset,
-		};
-	}
-
-	pub fn get_building(&self, coord: &HexCoord) -> Option<&BuildingEntry> {
-		return self.entries.iter().find(|b| &b.coord == coord);
-	}
-
-	pub fn add_building(&mut self, entry: BuildingEntry) {
-		self.entries.push(entry);
-	}
-}
-
-pub struct BuildingEntry {
-	pub coord: HexCoord,
-	pub entity: Entity,
-	pub is_main: bool,
-	pub main_entity: Option<Entity>,
-	pub has_children: bool,
-	pub child_entities: Option<Vec<Entity>>,
-}
-
-impl BuildingEntry {
-	pub fn new(coord: HexCoord, entity: Entity) -> Self {
-		return BuildingEntry {
-			coord,
-			entity,
-			child_entities: None,
-			has_children: false,
-			main_entity: None,
-			is_main: true,
-		};
-	}
-
-	pub fn new_with_children(coord: HexCoord, entity: Entity, children: Vec<Entity>) -> BuildingEntry {
-		return BuildingEntry {
-			coord,
-			entity,
-			child_entities: Some(children),
-			has_children: true,
-			main_entity: None,
-			is_main: true,
-		};
-	}
-
-	pub fn new_with_parent(coord: HexCoord, entity: Entity, main: Entity) -> BuildingEntry {
-		return BuildingEntry {
-			coord,
-			entity,
-			child_entities: None,
-			has_children: false,
-			main_entity: Some(main),
-			is_main: false,
-		};
-	}
-}

game/buildings/src/footprint.rs

@@ -1,32 +0,0 @@
-use bevy::math::{IVec2, Vec3Swizzles};
-use serde::{Deserialize, Serialize};
-use world_generation::hex_utils::HexCoord;
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct BuildingFootprint {
-	pub footprint: Vec<IVec2>,
-}
-
-impl BuildingFootprint {
-	pub fn get_footprint(&self, center: &HexCoord) -> Vec<HexCoord> {
-		let c = center.hex.xy();
-		return self.footprint.iter().map(|p| HexCoord::from_hex(*p + c)).collect();
-	}
-
-	pub fn get_footprint_rotated(&self, center: &HexCoord, rotation: i32) -> Vec<HexCoord> {
-		let c = center.hex.xy();
-		return self
-			.footprint
-			.iter()
-			.map(|p| HexCoord::from_hex(*p + c).rotate_around(center, rotation))
-			.collect();
-	}
-
-	pub fn get_neighbors(&self, center: &HexCoord) -> Vec<HexCoord> {
-		todo!()
-	}
-
-	pub fn get_neighbors_rotated(&self, center: &HexCoord, rotation: i32) -> Vec<HexCoord> {
-		todo!();
-	}
-}

game/buildings/src/lib.rs

@@ -1,7 +0,0 @@
-pub mod assets;
-pub mod build_queue;
-pub mod building_plugin;
-pub mod buildings_map;
-pub mod footprint;
-pub mod prelude;
-pub use building_plugin::*;

game/buildings/src/prelude.rs

@@ -1,3 +0,0 @@
-use bevy::prelude::*;
-#[derive(Component)]
-pub struct Building;

game/main/Cargo.toml

@@ -7,22 +7,14 @@ build = "build.rs"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = { version = "0.14.0", features = ["file_watcher"] }
-bevy-inspector-egui = "0.25.0"
-iyes_perf_ui = "0.3.0"
+bevy = "0.13.2"
+bevy-inspector-egui = "0.23.4"
+iyes_perf_ui = "0.2.3"
 noise = "0.8.2"
-world_generation = { path = "../../engine/world_generation" }
+world_generation ={path="../../engine/world_generation"}
 rayon = "1.10.0"
-buildings = { path = "../buildings" }
-units = { path = "../units" }
-shared = { path = "../shared" }
-bevy_asset_loader = { version = "0.21.0", features = [
-	"standard_dynamic_assets",
-	"3d",
-] }
-ron = "0.8.1"
-avian3d = { version = "0.1.2" }
-image = "0.25.2"
+bevy_xpbd_3d = { version= "0.4.2", features= ["simd", "parallel"] }
+
 
 [features]
-tracing = ["bevy/trace_tracy", "world_generation/tracing", "buildings/tracing"]
+tracing = ["bevy/trace_tracy", "world_generation/tracing"]

game/main/src/camera_system/camera_plugin.rs

@@ -1,10 +1,7 @@
 use bevy::core_pipeline::experimental::taa::{TemporalAntiAliasBundle, TemporalAntiAliasPlugin};
-use bevy::core_pipeline::prepass::DepthPrepass;
 use bevy::input::mouse::{MouseMotion, MouseScrollUnit, MouseWheel};
 use bevy::prelude::*;
 use bevy::window::CursorGrabMode;
-use shared::states::MenuState;
-use shared::tags::MainCamera;
 use world_generation::hex_utils::HexCoord;
 use world_generation::prelude::Map;
 
@@ -18,8 +15,8 @@ impl Plugin for PhosCameraPlugin {
 
 		app.add_systems(PreStartup, setup);
 
-		app.add_systems(Update, rts_camera_system.run_if(in_state(MenuState::InGame)));
-		app.add_systems(PostUpdate, limit_camera_bounds.run_if(in_state(MenuState::InGame)));
+		app.add_systems(Update, rts_camera_system);
+		app.add_systems(PostUpdate, limit_camera_bounds);
 		//Free Cam
 		//app.add_systems(Update, (grab_mouse, (update_camera, update_camera_mouse).chain()));
 
@@ -31,12 +28,10 @@ fn setup(mut commands: Commands, mut msaa: ResMut<Msaa>) {
 	commands
 		.spawn((
 			Camera3dBundle {
-				transform: Transform::from_xyz(0., 30., 0.).looking_to(Vec3::NEG_Z, Vec3::Y),
+				transform: Transform::from_xyz(0., 30., 0.).looking_to(Vec3::Z, Vec3::Y),
 				..default()
 			},
 			PhosCamera::default(),
-			MainCamera,
-			DepthPrepass,
 			PhosCameraTargets::default(),
 		))
 		.insert(TemporalAntiAliasBundle::default());
@@ -138,15 +133,15 @@ fn rts_camera_system(
 	let mut cam_pos = cam.translation;
 
 	if key.pressed(KeyCode::KeyA) {
-		cam_move.x = -1.;
-	} else if key.pressed(KeyCode::KeyD) {
 		cam_move.x = 1.;
+	} else if key.pressed(KeyCode::KeyD) {
+		cam_move.x = -1.;
 	}
 
 	if key.pressed(KeyCode::KeyW) {
-		cam_move.z = -1.;
-	} else if key.pressed(KeyCode::KeyS) {
 		cam_move.z = 1.;
+	} else if key.pressed(KeyCode::KeyS) {
+		cam_move.z = -1.;
 	}
 
 	let move_speed = if key.pressed(KeyCode::ShiftLeft) {
@@ -156,7 +151,7 @@ fn rts_camera_system(
 	};
 
 	cam_move = cam_move.normalize_or_zero() * move_speed * time.delta_seconds();
-	cam_pos += cam_move;
+	cam_pos -= cam_move;
 
 	let mut scroll = 0.0;
 	for e in wheel.read() {
@@ -199,9 +194,6 @@ fn rts_camera_system(
 		cam_targets.anim_time = cam_targets.anim_time.min(1.);
 	}
 	cam_pos.y = f32::lerp(cam_pos.y, desired_height, cam_targets.anim_time);
-	if cam_pos.y < min_height {
-		cam_pos.y = min_height;
-	}
 	let t = cam_pos.y.remap(cam_cfg.min_height, cam_cfg.max_height, 0., 1.);
 
 	if cam_targets.rotate_time < 1. {
@@ -209,11 +201,8 @@ fn rts_camera_system(
 		cam_targets.rotate_time = cam_targets.rotate_time.min(1.);
 	}
 	let angle = cam_cfg.min_angle.lerp(cam_cfg.max_angle, t);
-	let mut rot = cam.rotation.to_euler(EulerRot::XYZ);
-	rot.0 = -angle;
-	cam.rotation = Quat::from_euler(EulerRot::XYZ, rot.0, rot.1, rot.2);
-	// let rot = Quat::from_axis_angle(Vec3::X, -angle);
-	// cam.rotation = rot;
+	let rot = Quat::from_axis_angle(Vec3::X, -angle);
+	cam.rotation = rot;
 
 	cam.translation = cam_pos;
 }

game/main/src/camera_system/components.rs

@@ -1,5 +1,8 @@
 use bevy::prelude::*;
-use world_generation::{hex_utils::SHORT_DIAGONAL, prelude::Chunk};
+use world_generation::{
+	hex_utils::{tile_to_world_distance, SHORT_DIAGONAL},
+	prelude::Chunk,
+};
 
 #[derive(Component, Reflect)]
 #[reflect(Component)]
@@ -16,8 +19,8 @@ impl Default for PhosCamera {
 	fn default() -> Self {
 		Self {
 			min_height: 10.,
-			max_height: 420.,
-			speed: 100.,
+			max_height: 120.,
+			speed: 30.,
 			zoom_speed: 0.3,
 			min_angle: (20. as f32).to_radians(),
 			max_angle: 1.,
@@ -38,7 +41,7 @@ impl Default for PhosCameraTargets {
 	fn default() -> Self {
 		Self {
 			height: Default::default(),
-			forward: Vec3::NEG_Z,
+			forward: Vec3::Z,
 			last_height: Default::default(),
 			anim_time: Default::default(),
 			rotate_time: Default::default(),

game/main/src/main.rs

@@ -20,10 +20,8 @@ fn main() {
 					primary_window: Some(Window {
 						title: "Phos".into(),
 						name: Some("phos".into()),
-						#[cfg(debug_assertions)]
-						resolution: (1920., 1080.).into(),
+						// resolution: (1920., 1080.).into(),
 						present_mode: PresentMode::AutoNoVsync,
-						#[cfg(not(debug_assertions))]
 						mode: bevy::window::WindowMode::BorderlessFullscreen,
 						..default()
 					}),
@@ -36,11 +34,6 @@ fn main() {
 						mag_filter: ImageFilterMode::Nearest,
 						..default()
 					},
-				})
-				.set(AssetPlugin {
-					#[cfg(not(debug_assertions))]
-					watch_for_changes_override: Some(true),
-					..Default::default()
 				}),
 			WorldInspectorPlugin::new(),
 			WireframePlugin,

game/main/src/map_rendering/chunk_rebuild.rs

@@ -1,84 +1,97 @@
-use avian3d::prelude::*;
-use bevy::ecs::world::CommandQueue;
 use bevy::prelude::*;
-use bevy::tasks::*;
-use bevy::utils::futures;
-use shared::events::ChunkModifiedEvent;
-use shared::events::TileModifiedEvent;
-use world_generation::prelude::Map;
-use world_generation::states::GeneratorState;
-
-use crate::prelude::RebuildChunk;
-use crate::{
-	prelude::{PhosChunk, PhosChunkRegistry},
-	utlis::chunk_utils::prepare_chunk_mesh,
+use bevy_xpbd_3d::plugins::collision::Collider;
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+use world_generation::{
+	biome_painter::BiomePainterAsset,
+	chunk_colliders::generate_chunk_collider,
+	hex_utils::{self, offset_to_world, SHORT_DIAGONAL},
+	mesh_generator::generate_chunk_mesh,
+	prelude::{Chunk, Map},
+	tile_manager::TileAsset,
+	tile_mapper::TileMapperAsset,
 };
 
+use crate::{
+	prelude::{ChunkAtlas, PhosChunk, PhosChunkRegistry},
+	utlis::render_distance_system::RenderDistanceVisibility,
+};
+
+use super::prelude::CurrentBiomePainter;
 pub struct ChunkRebuildPlugin;
 
 impl Plugin for ChunkRebuildPlugin {
 	fn build(&self, app: &mut App) {
+		app.insert_resource(ChunkRebuildQueue::default());
 		app.init_resource::<PhosChunkRegistry>();
-		app.add_event::<ChunkModifiedEvent>();
-		app.add_event::<TileModifiedEvent>();
-		app.add_systems(PreUpdate, chunk_rebuilder.run_if(in_state(GeneratorState::Idle)));
-		app.add_systems(PostUpdate, collider_task_resolver);
+		app.add_systems(PreUpdate, chunk_rebuilder);
 	}
 }
 
+#[derive(Resource, Default)]
+pub struct ChunkRebuildQueue {
+	pub queue: Vec<usize>,
+}
+
 fn chunk_rebuilder(
 	mut commands: Commands,
-	chunk_query: Query<(Entity, &PhosChunk), (With<RebuildChunk>, Without<ChunkRebuildTask>)>,
+	mut queue: ResMut<ChunkRebuildQueue>,
+	mut chunks: ResMut<PhosChunkRegistry>,
+	atlas: Res<ChunkAtlas>,
 	heightmap: Res<Map>,
-) {
-	let pool = AsyncComputeTaskPool::get();
-
-	for (chunk_entity, idx) in &chunk_query {
-		#[cfg(feature = "tracing")]
-		let _spawn_span = info_span!("Rebuild Chunk").entered();
-		info!("Rebuilding Chunk");
-		let chunk_index = idx.index;
-		let chunk_data = heightmap.get_chunk_mesh_data(chunk_index);
-		let chunk_offset = heightmap.chunks[chunk_index].chunk_offset;
-
-		let task = pool.spawn(async move {
-			#[cfg(feature = "tracing")]
-			let _spawn_span = info_span!("Rebuild Task").entered();
-			let mut queue = CommandQueue::default();
-			let (mesh, collider_data, _, _) = prepare_chunk_mesh(&chunk_data, chunk_offset, chunk_index);
-			#[cfg(feature = "tracing")]
-			let trimesh_span = info_span!("Chunk Trimesh").entered();
-			let c = Collider::trimesh(collider_data.0, collider_data.1);
-			#[cfg(feature = "tracing")]
-			drop(trimesh_span);
-			queue.push(move |world: &mut World| {
-				world.entity_mut(chunk_entity).insert(c).remove::<ChunkRebuildTask>();
-			});
-
-			return (queue, mesh);
-		});
-
-		commands
-			.entity(chunk_entity)
-			.insert(ChunkRebuildTask { task })
-			.remove::<RebuildChunk>();
-	}
-}
-
-fn collider_task_resolver(
-	mut chunks: Query<(&mut ChunkRebuildTask, &Handle<Mesh>), With<PhosChunk>>,
-	mut commands: Commands,
+	tile_assets: Res<Assets<TileAsset>>,
+	tile_mappers: Res<Assets<TileMapperAsset>>,
 	mut meshes: ResMut<Assets<Mesh>>,
+	biome_painters: Res<Assets<BiomePainterAsset>>,
+	painter: Res<CurrentBiomePainter>,
 ) {
-	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);
+	if queue.queue.len() == 0 {
+		return;
 	}
-	}
-}
+	queue.queue.dedup();
 
-#[derive(Component)]
-struct ChunkRebuildTask {
-	pub task: Task<(CommandQueue, Mesh)>,
+	for chunk_index in &queue.queue {
+		let chunk = chunks.chunks[*chunk_index];
+		commands.entity(chunk).despawn();
+	}
+
+	let b_painter = biome_painters.get(painter.handle.clone());
+
+	let cur_painter = b_painter.unwrap();
+
+	let chunk_meshes: Vec<_> = queue
+		.queue
+		.par_iter()
+		.map(|idx| {
+			let chunk = &heightmap.chunks[*idx];
+			let mesh = generate_chunk_mesh(chunk, &heightmap, cur_painter, &tile_assets, &tile_mappers);
+			let (col_verts, col_indicies) = generate_chunk_collider(chunk, &heightmap);
+			let collider = Collider::trimesh(col_verts, col_indicies);
+			return (
+				mesh,
+				collider,
+				offset_to_world(chunk.chunk_offset * Chunk::SIZE as i32, 0.),
+				hex_utils::offset_to_index(chunk.chunk_offset, heightmap.width),
+			);
+		})
+		.collect();
+
+	for (mesh, collider, pos, index) in chunk_meshes {
+		let chunk = commands.spawn((
+			MaterialMeshBundle {
+				mesh: meshes.add(mesh),
+				material: atlas.chunk_material_handle.clone(),
+				transform: Transform::from_translation(pos),
+				..default()
+			},
+			PhosChunk::new(index),
+			RenderDistanceVisibility::default().with_offset(Vec3::new(
+				(Chunk::SIZE / 2) as f32 * SHORT_DIAGONAL,
+				0.,
+				(Chunk::SIZE / 2) as f32 * 1.5,
+			)),
+			collider,
+		));
+		chunks.chunks[index] = chunk.id();
+	}
+	queue.queue.clear();
 }

game/main/src/map_rendering/map_init.rs

@@ -1,25 +1,15 @@
 #[cfg(feature = "tracing")]
 use bevy::log::*;
-use bevy::{
-	pbr::{ExtendedMaterial, NotShadowCaster},
-	prelude::*,
-	render::texture::ImageFormat,
-};
-use bevy_asset_loader::prelude::*;
-
+use bevy::{asset::LoadState, pbr::ExtendedMaterial, prelude::*};
 use bevy_inspector_egui::quick::ResourceInspectorPlugin;
-use image::DynamicImage;
+use bevy_xpbd_3d::plugins::collision::Collider;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
-use shared::states::{AssetLoadState, GameplayState, MenuState};
 use world_generation::{
-	biome_asset::{BiomeAsset, BiomeAssetPlugin},
 	biome_painter::*,
+	chunk_colliders::generate_chunk_collider,
 	heightmap::generate_heightmap,
-	hex_utils::{offset_to_index, SHORT_DIAGONAL},
-	map::{
-		biome_map::{self, BiomeMap},
-		map_utils::{render_biome_noise_map, render_map},
-	},
+	hex_utils::{self, offset_to_world, SHORT_DIAGONAL},
+	mesh_generator::generate_chunk_mesh,
 	prelude::*,
 	tile_manager::*,
 	tile_mapper::*,
@@ -27,125 +17,92 @@ use world_generation::{
 
 use crate::{
 	camera_system::components::*,
-	prelude::{PhosAssets, PhosChunk, PhosChunkRegistry},
-	shader_extensions::{
-		chunk_material::ChunkMaterial,
-		water_material::{WaterMaterial, WaterSettings},
-	},
-	utlis::{
-		chunk_utils::{paint_map, prepare_chunk_mesh_with_collider},
-		render_distance_system::RenderDistanceVisibility,
-	},
+	prelude::{ChunkAtlas, PhosChunk, PhosChunkRegistry, PhosMap},
+	shader_extensions::chunk_material::ChunkMaterial,
+	utlis::render_distance_system::RenderDistanceVisibility,
 };
 
-use super::{chunk_rebuild::ChunkRebuildPlugin, terraforming_test::TerraFormingTestPlugin};
+use super::{
+	chunk_rebuild::ChunkRebuildPlugin, prelude::CurrentBiomePainter, terraforming_test::TerraFormingTestPlugin,
+};
 
 pub struct MapInitPlugin;
 
 impl Plugin for MapInitPlugin {
 	fn build(&self, app: &mut App) {
-		app.insert_state(GeneratorState::Startup);
-		app.insert_state(AssetLoadState::Loading);
-
-		//Assets
-		app.add_plugins(TileAssetPlugin);
-		app.add_plugins(TileMapperAssetPlugin);
-		app.add_plugins(BiomeAssetPlugin);
-
-		app.add_plugins(ResourceInspectorPlugin::<GenerationConfig>::default());
-		app.add_plugins(ResourceInspectorPlugin::<WaterInspect>::default());
-		app.register_type::<ExtendedMaterial<StandardMaterial, WaterMaterial>>();
-		app.register_asset_reflect::<ExtendedMaterial<StandardMaterial, WaterMaterial>>();
 		app.add_plugins((
+			ResourceInspectorPlugin::<PhosMap>::default(),
+			ResourceInspectorPlugin::<GenerationConfig>::default(),
 			ChunkRebuildPlugin,
-			// TerraFormingTestPlugin,
-			MaterialPlugin::<ExtendedMaterial<StandardMaterial, ChunkMaterial>>::default(),
-			MaterialPlugin::<ExtendedMaterial<StandardMaterial, WaterMaterial>> {
-				prepass_enabled: false,
-				..Default::default()
-			},
+			TerraFormingTestPlugin,
 		));
 
-		app.configure_loading_state(
-			LoadingStateConfig::new(AssetLoadState::Loading)
-				.with_dynamic_assets_file::<StandardDynamicAssetCollection>("phos.assets.ron")
-				.load_collection::<PhosAssets>()
-				.load_collection::<BiomePainterAsset>(),
-		);
-
-		app.add_systems(
-			Update,
-			create_heightmap.run_if(in_state(GeneratorState::GenerateHeightmap)),
-		);
-
-		app.add_systems(
-			Update,
-			(finalize_texture, setup_materials, finalize_biome_painter)
-				.run_if(in_state(AssetLoadState::FinalizeAssets)),
-		);
-
-		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))),
-		);
+		app.add_systems(Startup, (load_textures, load_tiles));
+		app.add_systems(PostStartup, create_map);
 
+		app.add_systems(Update, finalize_texture);
+		app.add_systems(PostUpdate, (despawn_map, spawn_map).chain());
 		app.insert_resource(TileManager::default());
+		app.insert_resource(PhosMap::default());
 	}
 }
 
-#[derive(Resource, Reflect, Default)]
-#[reflect(Resource)]
-struct WaterInspect(Handle<ExtendedMaterial<StandardMaterial, WaterMaterial>>);
-
-fn setup_materials(
+fn load_textures(
 	mut commands: Commands,
-	mut phos_assets: ResMut<PhosAssets>,
-	mut water_materials: ResMut<Assets<ExtendedMaterial<StandardMaterial, WaterMaterial>>>,
+	asset_server: Res<AssetServer>,
+	mut standard_materials: ResMut<Assets<StandardMaterial>>,
 ) {
-	let water_material = water_materials.add(ExtendedMaterial {
-		base: StandardMaterial {
-			base_color: Color::srgb(0., 0.878, 1.),
+	let main_tex = asset_server.load("textures/world/stack.png");
+
+	let water_material = standard_materials.add(StandardMaterial {
+		base_color: Color::AQUAMARINE.with_a(0.5),
 		alpha_mode: AlphaMode::Blend,
-			metallic: 1.0,
-			..Default::default()
-		},
-		extension: WaterMaterial {
-			settings: WaterSettings {
-				offset: -4.97,
-				scale: 1.,
-				deep_color: LinearRgba::rgb(0.0, 0.04, 0.085).into(),
-				..Default::default()
-			},
 		..default()
-		},
 	});
-	commands.insert_resource(WaterInspect(water_material.clone()));
-	phos_assets.water_material = water_material;
+	commands.insert_resource(ChunkAtlas {
+		handle: main_tex.clone(),
+		is_loaded: false,
+		chunk_material_handle: Handle::default(),
+		water_material: water_material,
+	});
 }
 
-fn finalize_biome_painter(
-	mut commands: Commands,
-	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);
+fn load_tiles(mut commands: Commands, asset_server: Res<AssetServer>) {
+	let handle: Handle<BiomePainterAsset> = asset_server.load("biome_painters/terra.biomes.json");
+	commands.insert_resource(CurrentBiomePainter { handle });
 }
 
 fn finalize_texture(
-	mut atlas: ResMut<PhosAssets>,
+	asset_server: Res<AssetServer>,
+	mut atlas: ResMut<ChunkAtlas>,
+	mut map: ResMut<PhosMap>,
 	mut images: ResMut<Assets<Image>>,
+	painter: Res<CurrentBiomePainter>,
+	painter_load: Res<BiomePainterLoadState>,
+	tile_load: Res<TileAssetLoadState>,
 	mut chunk_materials: ResMut<Assets<ExtendedMaterial<StandardMaterial, ChunkMaterial>>>,
-	mut next_load_state: ResMut<NextState<AssetLoadState>>,
+	mapper_load: Res<TileMapperLoadState>,
 ) {
-	let image = images.get_mut(atlas.handle.id()).unwrap();
+	if atlas.is_loaded {
+		return;
+	}
 
-	let array_layers = image.height() / image.width();
+	if !painter_load.is_all_loaded() || !tile_load.is_all_loaded() || !mapper_load.is_all_loaded() {
+		return;
+	}
+
+	if asset_server.load_state(atlas.handle.clone()) != LoadState::Loaded {
+		return;
+	}
+	if asset_server.load_state(painter.handle.clone()) != LoadState::Loaded {
+		return;
+	}
+	let image = images.get_mut(&atlas.handle).unwrap();
+
+	let array_layers = 14;
 	image.reinterpret_stacked_2d_as_array(array_layers);
 
+	atlas.is_loaded = true;
 	let chunk_material = chunk_materials.add(ExtendedMaterial {
 		base: StandardMaterial::default(),
 		extension: ChunkMaterial {
@@ -153,103 +110,135 @@ fn finalize_texture(
 		},
 	});
 	atlas.chunk_material_handle = chunk_material;
-
-	next_load_state.set(AssetLoadState::LoadComplete);
+	map.ready = true;
+	map.regenerate = true;
 }
 
-fn create_heightmap(
-	mut commands: Commands,
-	mut cam: Query<(&mut Transform, Entity), With<PhosCamera>>,
-	mut next_state: ResMut<NextState<GeneratorState>>,
-	biome_painter: Res<BiomePainter>,
-) {
+fn create_map(mut commands: Commands, mut cam: Query<(&mut Transform, Entity), With<PhosCamera>>) {
 	let config = GenerationConfig {
-		biome_blend: 32,
-		biome_dither: 10.,
-		continent_noise: NoiseConfig {
-			scale: 800.,
-			layers: vec![GeneratorLayer {
+		layers: vec![
+			GeneratorLayer {
 				base_roughness: 2.14,
 				roughness: 0.87,
-				strength: 100.,
-				min_value: 0.,
+				strength: 8.3,
+				min_value: -0.2,
 				persistence: 0.77,
 				is_rigid: false,
 				weight: 0.,
 				weight_multi: 0.,
-				layers: 1,
-			}],
+				layers: 4,
+				first_layer_mask: false,
 			},
-		moisture_noise: NoiseConfig {
-			scale: 900.,
-			layers: vec![GeneratorLayer {
-				base_roughness: 2.14,
-				roughness: 0.87,
-				strength: 100.,
-				min_value: 0.,
-				persistence: 0.77,
+			GeneratorLayer {
+				base_roughness: 2.85,
+				roughness: 2.,
+				strength: -0.23,
+				min_value: -0.,
+				persistence: 1.,
 				is_rigid: false,
 				weight: 0.,
 				weight_multi: 0.,
-				layers: 1,
-			}],
+				layers: 4,
+				first_layer_mask: false,
 			},
-		temperature_noise: NoiseConfig {
-			scale: 700.,
-			layers: vec![GeneratorLayer {
-				base_roughness: 2.14,
-				roughness: 0.87,
-				strength: 100.,
+			GeneratorLayer {
+				base_roughness: 2.6,
+				roughness: 4.,
+				strength: 3.1,
 				min_value: 0.,
-				persistence: 0.77,
-				is_rigid: false,
-				weight: 0.,
-				weight_multi: 0.,
-				layers: 1,
-			}],
+				persistence: 1.57,
+				is_rigid: true,
+				weight: 1.,
+				weight_multi: 0.35,
+				layers: 4,
+				first_layer_mask: true,
 			},
+			GeneratorLayer {
+				base_roughness: 3.87,
+				roughness: 5.8,
+				strength: -1.,
+				min_value: 0.,
+				persistence: 0.,
+				is_rigid: true,
+				weight: 1.,
+				weight_multi: 4.57,
+				layers: 3,
+				first_layer_mask: true,
+			},
+			GeneratorLayer {
+				base_roughness: 3.87,
+				roughness: 5.8,
+				strength: -1.5,
+				min_value: 0.,
+				persistence: 0.3,
+				is_rigid: true,
+				weight: 1.,
+				weight_multi: 4.57,
+				layers: 3,
+				first_layer_mask: false,
+			},
+		],
+		noise_scale: 450.,
 		sea_level: 8.5,
 		border_size: 64.,
-		size: UVec2::splat(16),
-		// size: UVec2::splat(1),
+		//size: UVec2::splat(1024 / Chunk::SIZE as u32),
+		size: UVec2::splat(2),
 	};
-	let (heightmap, biome_map) = generate_heightmap(&config, 42069, &biome_painter);
+	let heightmap = generate_heightmap(&config, 4);
 
 	let (mut cam_t, cam_entity) = cam.single_mut();
 	cam_t.translation = heightmap.get_center();
 
 	commands.entity(cam_entity).insert(CameraBounds::from_size(config.size));
+
 	commands.insert_resource(heightmap);
-	commands.insert_resource(biome_map);
 	commands.insert_resource(config);
-	next_state.set(GeneratorState::SpawnMap);
 }
 
 fn spawn_map(
-	mut heightmap: ResMut<Map>,
+	heightmap: Res<Map>,
 	mut commands: Commands,
 	mut meshes: ResMut<Assets<Mesh>>,
-	atlas: Res<PhosAssets>,
+	atlas: Res<ChunkAtlas>,
+	mut map: ResMut<PhosMap>,
 	tile_assets: Res<Assets<TileAsset>>,
 	tile_mappers: Res<Assets<TileMapperAsset>>,
-	mut generator_state: ResMut<NextState<GeneratorState>>,
-	cur_game_state: Res<State<MenuState>>,
-	mut game_state: ResMut<NextState<MenuState>>,
-	mut gameplay_state: ResMut<NextState<GameplayState>>,
-	biome_painter: Res<BiomePainter>,
+	biome_painters: Res<Assets<BiomePainterAsset>>,
+	painter: Res<CurrentBiomePainter>,
 ) {
-	paint_map(&mut heightmap, &biome_painter, &tile_assets, &tile_mappers);
+	if !map.ready || !map.regenerate {
+		return;
+	}
+	let b_painter = biome_painters.get(painter.handle.clone());
+	map.regenerate = false;
+
+	let cur_painter = b_painter.unwrap();
 
 	let chunk_meshes: Vec<_> = heightmap
 		.chunks
 		.par_iter()
 		.map(|chunk: &Chunk| {
-			let index = offset_to_index(chunk.chunk_offset, heightmap.width);
-			return prepare_chunk_mesh_with_collider(&heightmap.get_chunk_mesh_data(index), chunk.chunk_offset, index);
+			#[cfg(feature = "tracing")]
+			let _gen_mesh = info_span!("Generate Chunk").entered();
+			let mesh = generate_chunk_mesh(chunk, &heightmap, cur_painter, &tile_assets, &tile_mappers);
+			let (col_verts, col_indicies) = generate_chunk_collider(chunk, &heightmap);
+			let collider: Collider;
+			{
+				#[cfg(feature = "tracing")]
+				let _collider_span = info_span!("Create Collider Trimesh").entered();
+				collider = Collider::trimesh(col_verts, col_indicies);
+			}
+			return (
+				mesh,
+				collider,
+				offset_to_world(chunk.chunk_offset * Chunk::SIZE as i32, 0.),
+				hex_utils::offset_to_index(chunk.chunk_offset, heightmap.width),
+			);
 		})
 		.collect();
 
 	let mut registry = PhosChunkRegistry::new(chunk_meshes.len());
+
 	{
 		#[cfg(feature = "tracing")]
 		let _spawn_span = info_span!("Spawn Chunks").entered();
@@ -275,8 +264,7 @@ fn spawn_map(
 		}
 	}
 
-	commands.spawn((
-		MaterialMeshBundle {
+	commands.spawn((PbrBundle {
 		transform: Transform::from_translation(heightmap.get_center()),
 		mesh: meshes.add(
 			Plane3d::default()
@@ -285,31 +273,24 @@ fn spawn_map(
 		),
 		material: atlas.water_material.clone(),
 		..default()
-		},
-		NotShadowCaster,
-	));
+	},));
 
 	commands.insert_resource(registry);
-	generator_state.set(GeneratorState::Idle);
-	if cur_game_state.get() != &MenuState::InGame {
-		game_state.set(MenuState::InGame);
-		gameplay_state.set(GameplayState::PlaceHQ);
-	}
 }
 
 fn despawn_map(
 	mut commands: Commands,
 	mut heightmap: ResMut<Map>,
-	mut biome_map: ResMut<BiomeMap>,
 	cfg: Res<GenerationConfig>,
+	map: Res<PhosMap>,
 	chunks: Query<Entity, With<PhosChunk>>,
-	mut next_state: ResMut<NextState<GeneratorState>>,
-	biome_painter: Res<BiomePainter>,
 ) {
+	if !map.regenerate {
+		return;
+	}
 	for chunk in chunks.iter() {
 		commands.entity(chunk).despawn();
 	}
 
-	(*heightmap, *biome_map) = generate_heightmap(&cfg, 4, &biome_painter);
-	next_state.set(GeneratorState::SpawnMap);
+	*heightmap = generate_heightmap(&cfg, 4);
 }

game/main/src/map_rendering/prelude.rs

@@ -1,2 +1,7 @@
 use bevy::prelude::*;
 use world_generation::biome_painter::BiomePainterAsset;
+
+#[derive(Resource)]
+pub struct CurrentBiomePainter {
+	pub handle: Handle<BiomePainterAsset>,
+}

game/main/src/map_rendering/terraforming_test.rs

@@ -1,44 +1,32 @@
-use avian3d::prelude::*;
-use bevy::{prelude::*, utils::hashbrown::HashSet, window::PrimaryWindow};
-use shared::{
-	events::{ChunkModifiedEvent, TileModifiedEvent},
-	resources::TileUnderCursor,
-	states::GameplayState,
-};
-use world_generation::{hex_utils::HexCoord, prelude::Map, states::GeneratorState};
+use bevy::{prelude::*, window::PrimaryWindow};
+use bevy_xpbd_3d::plugins::spatial_query::{SpatialQuery, SpatialQueryFilter};
+use world_generation::{hex_utils::HexCoord, prelude::Map};
 
-use crate::{
-	camera_system::components::PhosCamera,
-	prelude::{PhosChunkRegistry, RebuildChunk},
-};
+use crate::{camera_system::components::PhosCamera, prelude::PhosChunkRegistry};
+
+use super::chunk_rebuild::ChunkRebuildQueue;
 
 pub struct TerraFormingTestPlugin;
 
 impl Plugin for TerraFormingTestPlugin {
 	fn build(&self, app: &mut App) {
-		app.add_systems(
-			Update,
-			deform
-				.run_if(in_state(GeneratorState::Idle))
-				.run_if(in_state(GameplayState::Playing)),
-		);
+		app.add_systems(Update, deform);
 	}
 }
 
 fn deform(
-	mut commands: Commands,
+	cam_query: Query<(&GlobalTransform, &Camera), With<PhosCamera>>,
+	window: Query<&Window, With<PrimaryWindow>>,
 	mouse: Res<ButtonInput<MouseButton>>,
 	spatial_query: SpatialQuery,
 	mut heightmap: ResMut<Map>,
-	chunks: Res<PhosChunkRegistry>,
-	tile_under_cursor: Res<TileUnderCursor>,
-	mut chunk_modified: EventWriter<ChunkModifiedEvent>,
-	mut tile_modified: EventWriter<TileModifiedEvent>,
+	mut rebuild: ResMut<ChunkRebuildQueue>,
+	time: Res<Time>,
 ) {
 	let mut multi = 0.;
-	if mouse.just_pressed(MouseButton::Left) {
+	if mouse.pressed(MouseButton::Left) {
 		multi = 1.;
-	} else if mouse.just_pressed(MouseButton::Right) {
+	} else if mouse.pressed(MouseButton::Right) {
 		multi = -1.;
 	}
 
@@ -46,20 +34,40 @@ fn deform(
 		return;
 	}
 
-	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 {
-			let chunk = tile.to_chunk_index(heightmap.width);
-			if !chunk_set.contains(&chunk) {
-				chunk_modified.send(ChunkModifiedEvent { index: chunk });
-				chunk_set.insert(chunk);
-				commands.entity(chunks.chunks[chunk]).insert(RebuildChunk);
+	let win = window.single();
+	let (cam_transform, camera) = cam_query.single();
+	let Some(cursor_pos) = win.cursor_position() else {
+		return;
+	};
+
+	let Some(cam_ray) = camera.viewport_to_world(cam_transform, cursor_pos) else {
+		return;
+	};
+
+	let collision = spatial_query.cast_ray(
+		cam_ray.origin,
+		cam_ray.direction.into(),
+		100.,
+		true,
+		SpatialQueryFilter::default(),
+	);
+
+	if let Some(hit) = collision {
+		let contact_point = cam_ray.get_point(hit.time_of_impact);
+		let contact_coord = HexCoord::from_world_pos(contact_point);
+		let cur_height = heightmap.sample_height(&contact_coord);
+		heightmap.set_height(&contact_coord, cur_height + 1. * time.delta_seconds() * multi);
+		let cur_chunk = contact_coord.to_chunk_index(heightmap.width);
+
+		if contact_coord.is_on_chunk_edge() {
+			let neighbors = contact_coord.get_neighbors();
+			let mut other_chunks: Vec<_> = neighbors
+				.iter()
+				.map(|c| c.to_chunk_index(heightmap.width))
+				.filter(|c| c != &cur_chunk)
+				.collect();
+			rebuild.queue.append(&mut other_chunks);
 		}
-			tile_modified.send(TileModifiedEvent::HeightChanged(tile, height));
-		}
-		// commands.entity(e).insert(RebuildChunk);
+		rebuild.queue.push(cur_chunk);
 	}
 }

game/main/src/phos.rs

@@ -1,51 +1,32 @@
+use crate::camera_system::camera_plugin::PhosCameraPlugin;
 use crate::camera_system::components::PhosCamera;
 use crate::map_rendering::map_init::MapInitPlugin;
-use crate::utlis::editor_plugin::EditorPlugin;
+use crate::shader_extensions::chunk_material::ChunkMaterial;
 use crate::utlis::render_distance_system::RenderDistancePlugin;
-use crate::utlis::tile_selection_plugin::TileSelectionPlugin;
-use crate::{camera_system::camera_plugin::PhosCameraPlugin, utlis::debug_plugin::DebugPlugin};
-use avian3d::{math::*, prelude::*};
+use bevy::pbr::ExtendedMaterial;
 use bevy::{
 	pbr::{wireframe::WireframeConfig, CascadeShadowConfig},
 	prelude::*,
 };
-use bevy_asset_loader::prelude::*;
-use buildings::BuildingPugin;
+use bevy_xpbd_3d::components::{LinearVelocity, RigidBody};
+use bevy_xpbd_3d::plugins::collision::Collider;
+use bevy_xpbd_3d::plugins::PhysicsPlugins;
 use iyes_perf_ui::prelude::*;
-use shared::sets::GameplaySet;
-use shared::states::{GameplayState, MenuState};
-use shared::{despawn::DespawnPuglin, states::AssetLoadState};
-use units::units_plugin::UnitsPlugin;
-use world_generation::states::GeneratorState;
+use world_generation::biome_painter::BiomePainterPlugin;
+use world_generation::tile_manager::TileAssetPlugin;
+use world_generation::tile_mapper::TileMapperAssetPlugin;
 
 pub struct PhosGamePlugin;
 
 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);
-
-		app.add_loading_state(
-			LoadingState::new(AssetLoadState::Loading).continue_to_state(AssetLoadState::FinalizeAssets),
-		);
-
 		app.add_plugins((
 			PhosCameraPlugin,
 			MapInitPlugin,
+			MaterialPlugin::<ExtendedMaterial<StandardMaterial, ChunkMaterial>>::default(),
 			RenderDistancePlugin,
-			BuildingPugin,
-			UnitsPlugin,
-			DespawnPuglin,
-			TileSelectionPlugin,
-			#[cfg(debug_assertions)]
-			EditorPlugin,
-			#[cfg(debug_assertions)]
-			DebugPlugin,
 		));
 
-		configure_gameplay_set(app);
-
 		//Systems - Startup
 		app.add_systems(Startup, init_game);
 
@@ -58,45 +39,21 @@ impl Plugin for PhosGamePlugin {
 			.add_plugins(bevy::diagnostic::SystemInformationDiagnosticsPlugin)
 			.add_plugins(PerfUiPlugin);
 
+		//Assets
+		app.add_plugins(TileAssetPlugin);
+		app.add_plugins(TileMapperAssetPlugin);
+		app.add_plugins(BiomePainterPlugin);
 		//Physics
 		app.add_plugins(PhysicsPlugins::default());
 		// app.add_plugins(RapierDebugRenderPlugin::default());
 
 		app.insert_resource(WireframeConfig {
 			global: false,
-			default_color: Srgba::hex("FF0064").unwrap().into(),
+			default_color: Color::hex("FF0064").unwrap(),
 		});
 	}
 }
 
-fn configure_gameplay_set(app: &mut App) {
-	app.configure_sets(
-		Update,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
-	);
-	app.configure_sets(
-		PreUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
-	);
-	app.configure_sets(
-		PostUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
-	);
-
-	app.configure_sets(
-		FixedUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
-	);
-	app.configure_sets(
-		FixedPreUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
-	);
-	app.configure_sets(
-		FixedPostUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
-	);
-}
-
 fn init_game(mut commands: Commands, mut materials: ResMut<Assets<StandardMaterial>>) {
 	commands.spawn((
 		PerfUiRoot::default(),
@@ -120,7 +77,7 @@ fn init_game(mut commands: Commands, mut materials: ResMut<Assets<StandardMateri
 	});
 
 	let sphere_mat = StandardMaterial {
-		base_color: Color::srgb(1., 1., 0.),
+		base_color: Color::CYAN,
 		..default()
 	};
 	let handle = materials.add(sphere_mat);

game/main/src/prelude.rs

@@ -2,18 +2,23 @@ use bevy::asset::Handle;
 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 bevy::reflect::Reflect;
 
 use crate::shader_extensions::chunk_material::ChunkMaterial;
-use crate::shader_extensions::water_material::WaterMaterial;
 
-#[derive(AssetCollection, Resource, Default)]
-pub struct PhosAssets {
-	#[asset(key = "chunk_atlas")]
+#[derive(Resource)]
+pub struct ChunkAtlas {
 	pub handle: Handle<Image>,
 	pub chunk_material_handle: Handle<ExtendedMaterial<StandardMaterial, ChunkMaterial>>,
-	pub water_material: Handle<ExtendedMaterial<StandardMaterial, WaterMaterial>>,
+	pub water_material: Handle<StandardMaterial>,
+	pub is_loaded: bool,
+}
+
+#[derive(Resource, Default, Reflect)]
+#[reflect(Resource)]
+pub struct PhosMap {
+	pub ready: bool,
+	pub regenerate: bool,
 }
 
 #[derive(Component)]
@@ -39,6 +44,3 @@ impl PhosChunkRegistry {
 		};
 	}
 }
-
-#[derive(Component)]
-pub struct RebuildChunk;

game/main/src/shader_extensions/mod.rs

@@ -1,2 +1 @@
 pub mod chunk_material;
-pub mod water_material;

game/main/src/shader_extensions/water_material.rs

@@ -1,54 +0,0 @@
-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};
-
-#[derive(Asset, Reflect, AsBindGroup, Debug, Clone, Default)]
-pub struct WaterMaterial {
-	#[uniform(100)]
-	pub settings: WaterSettings,
-}
-
-#[derive(Debug, Clone, ShaderType, Reflect)]
-pub struct WaterSettings {
-	pub offset: f32,
-	pub scale: f32,
-	pub f_power: f32,
-	pub deep_color: LinearRgba,
-}
-
-impl Default for WaterSettings {
-	fn default() -> Self {
-		Self {
-			offset: 0.0,
-			scale: 1.0,
-			f_power: 2.0,
-			deep_color: default(),
-		}
-	}
-}
-
-impl MaterialExtension for WaterMaterial {
-	fn fragment_shader() -> ShaderRef {
-		"shaders/world/water.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(())
-	// }
-}

game/main/src/utlis/chunk_utils.rs

@@ -1,82 +0,0 @@
-use avian3d::prelude::*;
-#[cfg(feature = "tracing")]
-use bevy::log::*;
-use bevy::{
-	asset::Assets,
-	ecs::system::Res,
-	math::{IVec2, Vec3},
-	render::mesh::Mesh,
-};
-use rayon::iter::{IntoParallelRefMutIterator, ParallelIterator};
-use world_generation::{
-	biome_painter::BiomePainter,
-	generators::{chunk_colliders::generate_chunk_collider, mesh_generator::generate_chunk_mesh},
-	hex_utils::offset_to_world,
-	prelude::{Chunk, Map, MeshChunkData},
-	tile_manager::TileAsset,
-	tile_mapper::TileMapperAsset,
-};
-
-pub fn paint_map(
-	map: &mut 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);
-	});
-}
-
-pub fn paint_chunk(
-	chunk: &mut Chunk,
-	painter: &BiomePainter,
-	tiles: &Res<Assets<TileAsset>>,
-	mappers: &Res<Assets<TileMapperAsset>>,
-) {
-	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];
-			let biome = &painter.biomes[biome_id];
-			let mapper = mappers.get(biome.tile_mapper.id());
-			let tile_handle = mapper.unwrap().sample_tile(height);
-			let tile = tiles.get(tile_handle).unwrap();
-			chunk.textures[idx] = [tile.texture_id, tile.side_texture_id];
-		}
-	}
-}
-
-pub fn prepare_chunk_mesh(
-	chunk: &MeshChunkData,
-	chunk_offset: IVec2,
-	chunk_index: usize,
-) -> (Mesh, (Vec<Vec3>, Vec<[u32; 3]>), Vec3, usize) {
-	#[cfg(feature = "tracing")]
-	let _gen_mesh = info_span!("Generate Chunk").entered();
-	let mesh = generate_chunk_mesh(chunk);
-	let col_data = generate_chunk_collider(chunk);
-
-	return (
-		mesh,
-		col_data,
-		offset_to_world(chunk_offset * Chunk::SIZE as i32, 0.),
-		chunk_index,
-	);
-}
-
-pub fn prepare_chunk_mesh_with_collider(
-	chunk: &MeshChunkData,
-	chunk_offset: IVec2,
-	chunk_index: usize,
-) -> (Mesh, Collider, Vec3, usize) {
-	let (mesh, (col_verts, col_indicies), pos, index) = prepare_chunk_mesh(chunk, chunk_offset, chunk_index);
-	let collider: Collider;
-	{
-		#[cfg(feature = "tracing")]
-		let _collider_span = info_span!("Create Collider Trimesh").entered();
-		collider = Collider::trimesh(col_verts, col_indicies);
-	}
-	return (mesh, collider, pos, index);
-}

game/main/src/utlis/debug_plugin.rs

@@ -1,99 +0,0 @@
-use bevy::{prelude::*, window::PrimaryWindow};
-use bevy_inspector_egui::bevy_egui::{systems::InputEvents, EguiContexts};
-use bevy_inspector_egui::egui;
-use shared::resources::TileUnderCursor;
-use shared::states::GameplayState;
-use shared::tags::MainCamera;
-use world_generation::{
-	consts::HEX_CORNERS,
-	hex_utils::{HexCoord, INNER_RADIUS},
-	prelude::Map,
-	states::GeneratorState,
-};
-
-pub struct DebugPlugin;
-
-impl Plugin for DebugPlugin {
-	fn build(&self, app: &mut App) {
-		app.insert_state(DebugState::Base);
-
-		app.add_systems(
-			Update,
-			show_tile_heights
-				.run_if(in_state(GeneratorState::Idle))
-				.run_if(not(in_state(DebugState::None))),
-		);
-
-		app.add_systems(
-			Update,
-			verbose_data
-				.run_if(in_state(GeneratorState::Idle))
-				.run_if(in_state(DebugState::Verbose)),
-		);
-
-		app.add_systems(Update, regenerate_map.run_if(in_state(GeneratorState::Idle)));
-
-		app.insert_resource(Shape(Polyline3d::new([
-			HEX_CORNERS[0],
-			HEX_CORNERS[1],
-			HEX_CORNERS[2],
-			HEX_CORNERS[3],
-			HEX_CORNERS[4],
-			HEX_CORNERS[5],
-			HEX_CORNERS[0],
-		])));
-	}
-}
-
-#[derive(Resource)]
-struct Shape(pub Polyline3d<7>);
-
-#[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
-pub enum DebugState {
-	Base,
-	None,
-	Verbose,
-}
-
-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) {
-		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 {
-		let height = map.sample_height(&contact.tile);
-		gizmos.primitive_3d(
-			&shape.0,
-			contact.tile.to_world(height + 0.01),
-			Quat::IDENTITY,
-			Color::WHITE,
-		);
-		let nbors = map.get_neighbors(&contact.tile);
-		let contact_tile_pos = contact.tile.to_world(map.sample_height(&contact.tile));
-
-		// for i in 0..6 {
-		// 	if let Some(s) = nbors[i] {
-		// 		let coord = contact.tile.get_neighbor(i);
-		// 		let p = coord.to_world(s);
-		// 		gizmos.arrow(p, p + Vec3::Y * (i as f32 + 1.0), Color::WHITE);
-		// 	}
-
-		// 	let p = HEX_CORNERS[i] + contact_tile_pos;
-		// 	gizmos.arrow(p, p + Vec3::Y * (i as f32 + 1.0), LinearRgba::rgb(1.0, 0.0, 0.5));
-		// }
-
-		gizmos.line(contact.point, contact.point + Vec3::X, LinearRgba::RED);
-		gizmos.line(contact.point, contact.point + Vec3::Y, LinearRgba::GREEN);
-		gizmos.line(contact.point, contact.point + Vec3::Z, LinearRgba::BLUE);
-		//gizmos.sphere(contact_point, Quat::IDENTITY, 0.1, LinearRgba::rgb(1., 0., 0.5));
-	}
-}
-
-fn verbose_data() {}

game/main/src/utlis/editor_plugin.rs

@@ -1,161 +0,0 @@
-use bevy::{prelude::*, render::render_asset::RenderAssetUsages};
-use bevy_inspector_egui::bevy_egui::EguiContexts;
-use bevy_inspector_egui::egui::{self};
-use image::{ImageBuffer, Rgba};
-use world_generation::biome_asset::BiomeAsset;
-use world_generation::biome_painter::BiomePainterAsset;
-use world_generation::map::biome_map::BiomeMap;
-use world_generation::map::map_utils::{render_biome_map, render_biome_noise_map};
-use world_generation::{map::map_utils::render_map, prelude::Map, states::GeneratorState};
-
-pub struct EditorPlugin;
-
-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)),
-		);
-	}
-}
-
-#[derive(Resource)]
-struct MapImage(pub Handle<Image>);
-
-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));
-
-	commands.insert_resource(MapImage(handle));
-}
-
-#[derive(Resource)]
-struct UIState {
-	pub is_open: bool,
-	pub target_map_type: MapDisplayType,
-	pub cur_map_type: MapDisplayType,
-}
-
-impl Default for UIState {
-	fn default() -> Self {
-		Self {
-			is_open: true,
-			target_map_type: default(),
-			cur_map_type: default(),
-		}
-	}
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Default)]
-enum MapDisplayType {
-	#[default]
-	HeightMap,
-	Biomes,
-	BiomeNoise,
-	BiomeNoiseTemp,
-	BiomeNoiseContinent,
-	BiomeNoiseMoisture,
-}
-
-fn asset_reloaded(
-	mut asset_events: EventReader<AssetEvent<BiomeAsset>>,
-	mut biomes: ResMut<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,
-			_ => (),
-		}
-	}
-	if rebuild {
-		let painter = biome_painter.build(&biomes);
-		commands.insert_resource(painter);
-	}
-}
-
-fn render_map_ui(
-	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 mut map_type = state.target_map_type;
-	let ctx = contexts.ctx_mut();
-	egui::Window::new("Map").open(&mut state.is_open).show(ctx, |ui| {
-		ui.label("Map Test");
-		egui::ComboBox::from_label("Display Type")
-			.selected_text(format!("{:?}", map_type))
-			.show_ui(ui, |ui| {
-				ui.selectable_value(&mut map_type, MapDisplayType::HeightMap, "Heightmap");
-				ui.selectable_value(&mut map_type, MapDisplayType::Biomes, "Biomes");
-				ui.selectable_value(&mut map_type, MapDisplayType::BiomeNoise, "Biome Noise");
-				ui.selectable_value(
-					&mut map_type,
-					MapDisplayType::BiomeNoiseTemp,
-					"Biome Noise: Tempurature",
-				);
-				ui.selectable_value(
-					&mut map_type,
-					MapDisplayType::BiomeNoiseContinent,
-					"Biome Noise: Continent",
-				);
-				ui.selectable_value(
-					&mut map_type,
-					MapDisplayType::BiomeNoiseMoisture,
-					"Biome Noise: Moisture",
-				);
-			});
-
-		ui.add(egui::widgets::Image::new(egui::load::SizedTexture::new(
-			id,
-			[512.0, 512.0],
-		)));
-
-		if ui.button("Save Image").clicked() {
-			let img = get_map_image(&heightmap, &biome_map, map_type);
-			_ = img.save(format!("{:?}.png", map_type));
-		}
-	});
-
-	state.target_map_type = map_type;
-}
-
-fn update_map_render(
-	mut state: ResMut<UIState>,
-	mut images: ResMut<Assets<Image>>,
-	heightmap: Res<Map>,
-	biome_map: Res<BiomeMap>,
-	image: Res<MapImage>,
-) {
-	if state.cur_map_type == state.target_map_type {
-		return;
-	}
-
-	let result = get_map_image(&heightmap, &biome_map, state.target_map_type);
-	images.insert(
-		image.0.id(),
-		Image::from_dynamic(result.into(), true, RenderAssetUsages::RENDER_WORLD),
-	);
-
-	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 {
-		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),
-		MapDisplayType::BiomeNoiseTemp => render_biome_noise_map(&biome_map, Vec3::X),
-		MapDisplayType::BiomeNoiseContinent => render_biome_noise_map(&biome_map, Vec3::Y),
-		MapDisplayType::BiomeNoiseMoisture => render_biome_noise_map(&biome_map, Vec3::Z),
-	};
-}

game/main/src/utlis/mod.rs

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

game/main/src/utlis/render_distance_system.rs

@@ -9,9 +9,6 @@ impl Plugin for RenderDistancePlugin {
 		app.register_type::<RenderDistanceSettings>();
 		app.add_systems(PostUpdate, render_distance_system)
 			.insert_resource(RenderDistanceSettings::default());
-
-		#[cfg(debug_assertions)]
-		app.insert_resource(RenderDistanceSettings::new(f32::MAX));
 	}
 }
 
@@ -37,6 +34,7 @@ impl Default for RenderDistanceSettings {
 
 #[derive(Component)]
 pub struct RenderDistanceVisibility {
+	pub distance_multiplier: f32,
 	pub offset: Vec3,
 }
 
@@ -45,11 +43,19 @@ impl RenderDistanceVisibility {
 		self.offset = offset;
 		return self;
 	}
+
+	pub fn with_multiplier(mut self, distance_multiplier: f32) -> Self {
+		self.distance_multiplier = distance_multiplier;
+		return self;
+	}
 }
 
 impl Default for RenderDistanceVisibility {
 	fn default() -> Self {
-		Self { offset: Vec3::ZERO }
+		Self {
+			distance_multiplier: 1.,
+			offset: Vec3::ZERO,
+		}
 	}
 }
 
@@ -59,9 +65,8 @@ fn render_distance_system(
 	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() {
-		let dist = (cam_pos - (t.translation + r.offset)).length();
+		let dist = (camera.translation - (t.translation + r.offset)).length() * r.distance_multiplier;
 		if settings.render_distance < dist {
 			*vis = Visibility::Hidden;
 		} else {

game/main/src/utlis/tile_selection_plugin.rs

@@ -1,63 +0,0 @@
-use avian3d::prelude::{SpatialQuery, SpatialQueryFilter};
-use bevy::{prelude::*, window::PrimaryWindow};
-use shared::{
-	resources::{TileContact, TileUnderCursor},
-	tags::MainCamera,
-};
-use world_generation::{hex_utils::HexCoord, prelude::Map, states::GeneratorState};
-pub struct TileSelectionPlugin;
-
-impl Plugin for TileSelectionPlugin {
-	fn build(&self, app: &mut App) {
-		app.init_resource::<TileUnderCursor>();
-		app.add_systems(
-			PreUpdate,
-			update_tile_under_cursor.run_if(in_state(GeneratorState::Idle)),
-		);
-	}
-}
-
-fn update_tile_under_cursor(
-	cam_query: Query<(&GlobalTransform, &Camera), With<MainCamera>>,
-	window: Query<&Window, With<PrimaryWindow>>,
-	spatial_query: SpatialQuery,
-	map: Res<Map>,
-	mut tile_under_cursor: ResMut<TileUnderCursor>,
-) {
-	let win = window.single();
-	let (cam_transform, camera) = cam_query.single();
-	let Some(cursor_pos) = win.cursor_position() else {
-		return;
-	};
-
-	let Some(cam_ray) = camera.viewport_to_world(cam_transform, cursor_pos) else {
-		return;
-	};
-
-	let collision = spatial_query.cast_ray(
-		cam_ray.origin,
-		cam_ray.direction.into(),
-		500.,
-		true,
-		SpatialQueryFilter::default(),
-	);
-
-	if let Some(data) = collision {
-		let dist = data.time_of_impact;
-		let contact_point = cam_ray.get_point(dist);
-		let contact_coord = HexCoord::from_world_pos(contact_point);
-		//todo: handle correct tile detection when contacting a tile from the side
-		if !map.is_in_bounds(&contact_coord) {
-			tile_under_cursor.0 = None;
-			return;
-		}
-		let surface = map.sample_height(&contact_coord);
-		tile_under_cursor.0 = Some(TileContact::new(
-			contact_coord,
-			contact_point,
-			contact_coord.to_world(surface),
-		));
-	} else {
-		tile_under_cursor.0 = None;
-	}
-}

game/shared/Cargo.toml

@@ -1,15 +0,0 @@
-[package]
-name = "shared"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-bevy = "0.14.0"
-serde = { version = "1.0.204", features = ["derive"] }
-world_generation = { path = "../../engine/world_generation" }
-
-
-[features]
-tracing = []

game/shared/src/building.rs

@@ -1,28 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Default, PartialEq, Eq, Serialize, Deserialize)]
-pub struct BuildingIdentifier(pub usize);
-
-impl From<i32> for BuildingIdentifier {
-	fn from(value: i32) -> Self {
-		return BuildingIdentifier(value as usize);
-	}
-}
-
-impl From<u32> for BuildingIdentifier {
-	fn from(value: u32) -> Self {
-		return BuildingIdentifier(value as usize);
-	}
-}
-
-impl From<usize> for BuildingIdentifier {
-	fn from(value: usize) -> Self {
-		return BuildingIdentifier(value);
-	}
-}
-
-impl Into<usize> for BuildingIdentifier {
-	fn into(self) -> usize {
-		return self.0;
-	}
-}

game/shared/src/despawn.rs

@@ -1,47 +0,0 @@
-use crate::states::MenuState;
-use bevy::prelude::*;
-
-pub struct DespawnPuglin;
-
-#[derive(Component)]
-pub struct DespawnAt(f32);
-
-#[derive(Component)]
-pub struct DespawnAfter(Timer);
-
-#[derive(Component)]
-pub struct Despawn;
-
-impl Plugin for DespawnPuglin {
-	fn build(&self, app: &mut App) {
-		app.add_systems(PostUpdate, despawn_at);
-		app.add_systems(
-			PreUpdate,
-			(despawn, despawn_after).run_if(not(in_state(MenuState::Paused))),
-		);
-	}
-}
-
-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();
-		commands
-			.entity(entity)
-			.insert(DespawnAfter(Timer::from_seconds(d, TimerMode::Once)));
-	}
-}
-
-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() {
-			commands.entity(entity).despawn();
-		}
-	}
-}
-
-fn despawn(mut commands: Commands, entities: Query<Entity, With<Despawn>>) {
-	for entity in entities.iter() {
-		commands.entity(entity).despawn();
-	}
-}

game/shared/src/events.rs

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

game/shared/src/identifiers.rs

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

game/shared/src/lib.rs

@@ -1,8 +0,0 @@
-pub mod building;
-pub mod despawn;
-pub mod identifiers;
-pub mod states;
-pub mod tags;
-pub mod events;
-pub mod sets;
-pub mod resources;

game/shared/src/resources.rs

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

game/shared/src/sets.rs

@@ -1,4 +0,0 @@
-use bevy::prelude::*;
-
-#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
-pub struct GameplaySet;

game/shared/src/states.rs

@@ -1,24 +0,0 @@
-use bevy::prelude::*;
-
-#[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
-pub enum MenuState {
-	Loading,
-	Startup,
-	MainMenu,
-	InGame,
-	Paused,
-}
-
-#[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
-pub enum GameplayState {
-	Waiting,
-	PlaceHQ,
-	Playing,
-}
-
-#[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
-pub enum AssetLoadState {
-	Loading,
-	FinalizeAssets,
-	LoadComplete,
-}

game/shared/src/tags.rs

@@ -1,9 +0,0 @@
-use bevy::prelude::*;
-#[derive(Component)]
-pub struct MainCamera;
-
-#[derive(Component, Clone, Copy)]
-pub enum Faction {
-	Player,
-	Phos,
-}

game/units/Cargo.toml

@@ -1,22 +0,0 @@
-[package]
-name = "units"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-bevy = "0.14.0"
-world_generation = { path = "../../engine/world_generation" }
-shared = { path = "../shared" }
-bevy_rapier3d = "0.27.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 = [
-	"standard_dynamic_assets",
-	"3d",
-] }
-quadtree_rs = "0.1.3"
-
-[features]
-tracing = []

game/units/src/assets/mod.rs

@@ -1,3 +0,0 @@
-
-pub mod unit_asset;
-pub mod unit_database;

game/units/src/assets/unit_asset.rs

@@ -1,57 +0,0 @@
-use asset_loader::create_asset_loader;
-use bevy::{ecs::world::CommandQueue, prelude::*};
-use serde::{Deserialize, Serialize};
-
-use crate::components::{AirUnit, LandUnit, NavalUnit, Unit, UnitDomain};
-
-#[derive(Asset, TypePath, Debug, Serialize, Deserialize)]
-pub struct UnitAsset {
-	pub name: String,
-	pub description: String,
-	pub size: u32,
-	pub prefab_path: String,
-	#[serde(skip)]
-	pub prefab: Handle<Scene>,
-	pub unit_type: UnitType,
-	pub domain: UnitDomain,
-}
-
-impl UnitAsset {
-	pub fn spawn(&self, transform: Transform) -> CommandQueue {
-		let mut commands = CommandQueue::default();
-
-		let bundle = (
-			PbrBundle {
-				transform: transform,
-				..default()
-			},
-			Unit,
-		);
-		let domain = self.domain.clone();
-		commands.push(move |world: &mut World| {
-			let mut e = world.spawn(bundle);
-			match domain {
-				UnitDomain::Land => e.insert(LandUnit),
-				UnitDomain::Air => e.insert(AirUnit),
-				UnitDomain::Naval => e.insert(NavalUnit),
-			};
-		});
-
-		todo!();
-	}
-}
-
-create_asset_loader!(
-	UnitAssetPlugin,
-	UnitAssetLoader,
-	UnitAsset,
-	&["unit", "unit.ron"],
-	prefab_path -> prefab
-	;?
-);
-
-#[derive(Debug, Serialize, Deserialize)]
-pub enum UnitType {
-	Basic,
-	Turret,
-}

game/units/src/assets/unit_database.rs

@@ -1,10 +0,0 @@
-use bevy::prelude::*;
-use bevy_asset_loader::asset_collection::AssetCollection;
-
-use super::unit_asset::UnitAsset;
-
-#[derive(Resource, AssetCollection)]
-pub struct UnitDatabase {
-	#[asset(key = "units", collection(typed))]
-	pub units: Vec<Handle<UnitAsset>>,
-}

game/units/src/components.rs

@@ -1,28 +0,0 @@
-use bevy::{ecs::world::CommandQueue, prelude::*, tasks::Task};
-use serde::{Deserialize, Serialize};
-
-#[derive(Component, Debug)]
-pub struct Unit;
-
-#[derive(Component, Debug)]
-pub struct AirUnit;
-#[derive(Component, Debug)]
-pub struct LandUnit;
-#[derive(Component, Debug)]
-pub struct NavalUnit;
-
-#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
-pub enum UnitDomain {
-	Land,
-	Air,
-	Naval,
-}
-
-#[derive(Component, Debug)]
-pub struct Target(pub Vec3);
-
-#[derive(Component, Debug)]
-pub struct Path(pub Vec<Vec3>, pub usize);
-
-#[derive(Component, Debug)]
-pub struct PathTask(pub Task<CommandQueue>);

game/units/src/lib.rs

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

game/units/src/units_debug_plugin.rs

@@ -1,66 +0,0 @@
-use std::f32::consts::E;
-
-use bevy::prelude::*;
-use shared::{resources::TileUnderCursor, sets::GameplaySet, states::AssetLoadState};
-use world_generation::{heightmap, prelude::Map};
-
-use crate::components::{LandUnit, Target, Unit};
-
-pub struct UnitsDebugPlugin;
-
-impl Plugin for UnitsDebugPlugin {
-	fn build(&self, app: &mut App) {
-		app.add_systems(Update, init.run_if(in_state(AssetLoadState::Loading)));
-
-		app.add_systems(Update, (spawn_test_unit, set_unit_target).in_set(GameplaySet));
-	}
-}
-
-#[derive(Resource)]
-struct TestUnit(pub Handle<Mesh>);
-
-fn init(mut meshes: ResMut<Assets<Mesh>>, mut commands: Commands) {
-	let mesh_handle = meshes.add(Cuboid::from_length(1.0));
-	commands.insert_resource(TestUnit(mesh_handle));
-}
-
-fn spawn_test_unit(
-	mut commands: Commands,
-	input: Res<ButtonInput<KeyCode>>,
-	tile_under_cursor: Res<TileUnderCursor>,
-	unit: Res<TestUnit>,
-) {
-	if !input.just_pressed(KeyCode::KeyT) {
-		return;
-	}
-	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()
-			},
-			Unit,
-			LandUnit,
-		));
-	}
-}
-
-fn set_unit_target(
-	mut commands: Commands,
-	units: Query<Entity, With<Unit>>,
-	input: Res<ButtonInput<MouseButton>>,
-	tile_under_cursor: Res<TileUnderCursor>,
-) {
-	if !input.just_pressed(MouseButton::Right) {
-		return;
-	}
-	if let Some(contact) = tile_under_cursor.0 {
-		for e in units.iter() {
-			info!("Setting Target");
-			let mut e = commands.entity(e);
-			e.insert(Target(contact.surface));
-		}
-	}
-}

game/units/src/units_plugin.rs

@@ -1,94 +0,0 @@
-use bevy::{
-	ecs::world::CommandQueue, prelude::*, tasks::AsyncComputeTaskPool, transform::commands, utils::futures,
-	window::PrimaryWindow,
-};
-use bevy_asset_loader::loading_state::{
-	config::{ConfigureLoadingState, LoadingStateConfig},
-	LoadingStateAppExt,
-};
-use shared::{resources::TileUnderCursor, sets::GameplaySet, states::AssetLoadState};
-use world_generation::{hex_utils::HexCoord, prelude::Map};
-
-use crate::{
-	assets::{unit_asset::UnitAssetPlugin, unit_database::UnitDatabase},
-	components::{Path, PathTask, Target, Unit},
-	units_debug_plugin::UnitsDebugPlugin,
-};
-
-pub struct UnitsPlugin;
-
-impl Plugin for UnitsPlugin {
-	fn build(&self, app: &mut App) {
-		app.add_plugins(UnitAssetPlugin);
-
-		#[cfg(debug_assertions)]
-		app.add_plugins(UnitsDebugPlugin);
-
-		// app.configure_loading_state(LoadingStateConfig::new(AssetLoadState::Loading).load_collection::<UnitDatabase>());
-
-		app.add_systems(Update, units_control.in_set(GameplaySet));
-		app.add_systems(Update, move_unit.in_set(GameplaySet));
-		app.add_systems(FixedPreUpdate, (calculate_path, resolve_path_task).in_set(GameplaySet));
-	}
-}
-
-fn units_control(tile_under_cursor: Res<TileUnderCursor>) {}
-
-fn move_unit(
-	mut units: Query<(&mut Transform, &mut Path, Entity), With<Unit>>,
-	time: Res<Time>,
-	map: Res<Map>,
-	mut commands: Commands,
-) {
-	for (mut t, mut path, entity) in units.iter_mut() {
-		if path.1 >= path.0.len() {
-			commands.entity(entity).remove::<Path>();
-			continue;
-		}
-		let p = path.0[path.1];
-		let d = p - t.translation;
-		if d.length() < 0.1 {
-			path.1 += 1;
-			continue;
-		}
-		let vel = d.normalize() * 10.0 * time.delta_seconds();
-		t.translation += vel;
-		let coord = HexCoord::from_world_pos(t.translation);
-		if map.is_in_bounds(&coord) {
-			t.translation.y = map.sample_height(&coord);
-		}
-	}
-}
-
-fn calculate_path(
-	units: Query<(&Transform, &Target, Entity), (With<Unit>, Without<PathTask>)>,
-	map: Res<Map>,
-	mut commands: Commands,
-) {
-	let pool = AsyncComputeTaskPool::get();
-	for (transform, target, entity) in units.iter() {
-		let from = transform.translation;
-		let to = target.0;
-
-		let task = pool.spawn(async move {
-			let mut queue = CommandQueue::default();
-
-			queue.push(move |world: &mut World| {
-				//todo: calculate path
-				world.entity_mut(entity).insert(Path(vec![from, to], 0));
-			});
-			return queue;
-		});
-
-		commands.entity(entity).insert(PathTask(task)).remove::<Target>();
-	}
-}
-
-fn resolve_path_task(mut tasks: Query<(&mut PathTask, Entity), With<Unit>>, mut commands: Commands) {
-	for (mut task, entity) in tasks.iter_mut() {
-		if let Some(mut c) = futures::check_ready(&mut task.0) {
-			commands.append(&mut c);
-			commands.entity(entity).remove::<PathTask>();
-		}
-	}
-}

game/units/src/units_spacial_set.rs

@@ -1,82 +0,0 @@
-use bevy::prelude::*;
-use quadtree_rs::{area::AreaBuilder, point::Point, Quadtree};
-use shared::tags::Faction;
-
-use crate::{components::UnitDomain, UnitType};
-
-#[derive(Clone, Copy)]
-pub struct UnitEntity {
-	pub entity: Entity,
-	pub domain: UnitDomain,
-	pub unit_type: UnitType,
-	pub faction: Faction,
-	pub position: Vec3,
-}
-
-pub struct UnitSpacialSet {
-	tree: Quadtree<usize, UnitEntity>,
-}
-
-impl UnitSpacialSet {
-	pub fn new(map_size: f32) -> Self {
-		let n = f32::log2(map_size) / f32::log2(2.0);
-		return Self {
-			tree: Quadtree::new(n.ceil() as usize),
-		};
-	}
-
-	pub fn add_unit(&mut self, unit: UnitEntity, pos: Vec3) -> Option<u64> {
-		return self.tree.insert_pt(convert_to_point(pos.xz()), unit);
-	}
-
-	pub fn move_unit(&mut self, handle: u64, pos: Vec3) -> Option<u64> {
-		if let Some(existing) = self.tree.get(handle) {
-			if existing.anchor() == convert_to_point(pos.xz()) {
-				return None;
-			}
-		} else {
-			return None;
-		}
-
-		if let Some(entry) = self.tree.delete_by_handle(handle) {
-			let p = convert_to_point(pos.xz());
-			let mut entry = *entry.value_ref();
-			entry.position = pos;
-			return self.tree.insert_pt(p, entry);
-		}
-		return None;
-	}
-
-	pub fn get_units_in_circle(self, center: Vec3, radius: f32) -> Vec<Entity> {
-		let anchor = center.xz() - Vec2::new(radius, radius);
-		let d = (radius * 2.0) as usize;
-		let area = AreaBuilder::default()
-			.anchor(convert_to_point(anchor))
-			.dimensions((d, d))
-			.build()
-			.unwrap();
-		let query = self.tree.query(area);
-		return query
-			.filter(|e| e.value_ref().position.distance(center) <= radius)
-			.map(|e| e.value_ref().entity)
-			.collect();
-	}
-
-	pub fn get_units_in_rect(self, anchor: Vec2, size: Vec2) -> Vec<Entity> {
-		let area = AreaBuilder::default()
-			.anchor(convert_to_point(anchor))
-			.dimensions((size.x as usize, size.y as usize))
-			.build()
-			.unwrap();
-		let query = self.tree.query(area);
-		return query.map(|e| e.value_ref().entity).collect();
-	}
-}
-
-fn convert_to_point(pos: Vec2) -> Point<usize> {
-	let p = pos.as_uvec2();
-	return Point {
-		x: p.x as usize,
-		y: p.y as usize,
-	};
-}

rustfmt.toml

@@ -1,4 +1,2 @@
-hard_tabs = true
-max_width = 120
-brace_style = "AlwaysNextLine"
-control_brace_style = "AlwaysNextLine"
+hard_tabs=true
+max_width=120