Merge branch 'master' into avian

.github/workflows/rust.yml

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

.vscode/launch.json

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

Cargo.toml

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

engine/data/Cargo.toml

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

engine/data/src/lib.rs

@@ -0,0 +1 @@
+

engine/world_generation/Cargo.toml

@@ -18,6 +18,8 @@ bevy_asset_loader = { version = "0.21.0", features = [
 	"3d",
 ] }
 ron = "0.8.1"
+image = "0.25.2"
+num = "0.4.3"
 
 [features]
 tracing = ["bevy/trace_tracy"]

engine/world_generation/src/biome_painter.rs

@@ -38,7 +38,7 @@ impl BiomePainterAsset {
 	}
 }
 
-#[derive(Resource)]
+#[derive(Resource, Clone)]
 pub struct BiomePainter {
 	pub biomes: Vec<BiomeAsset>,
 }

engine/world_generation/src/generators/chunk_colliders.rs

@@ -31,7 +31,7 @@ fn create_tile_collider(pos: Vec3, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32
 		verts.push(p);
 	}
 
-	//Top Surfave
+	//Top Surface
 	indices.push([idx, idx + 1, idx + 5]);
 	indices.push([idx + 1, idx + 2, idx + 5]);
 	indices.push([idx + 2, idx + 4, idx + 5]);
@@ -54,7 +54,7 @@ fn create_tile_collider(pos: Vec3, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32
 fn create_tile_wall_collider(idx: u32, pos: Vec3, dir: usize, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32; 3]>) {
 	let idx2 = verts.len() as u32;
 
-	verts.push(pos + HEX_CORNERS[dir]);
+	verts.push(pos + HEX_CORNERS[(dir) % 6]);
 	verts.push(pos + HEX_CORNERS[(dir + 1) % 6]);
 
 	let off = dir as u32;

engine/world_generation/src/generators/mesh_generator.rs

@@ -135,3 +135,60 @@ 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/generators/packed_mesh_generator.rs

@@ -1,4 +1,5 @@
 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;
@@ -14,6 +15,7 @@ use bevy::{
 pub fn generate_packed_chunk_mesh(
 	chunk: &Chunk,
 	map: &Map,
+	biome_chunk: &BiomeChunk,
 	painter: &BiomePainterAsset,
 	tiles: &Res<Assets<TileAsset>>,
 	biomes: &Res<Assets<BiomeAsset>>,
@@ -27,7 +29,7 @@ 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 = chunk.biome_data[x + z * Chunk::SIZE];
+			let data = biome_chunk.data[x + z * Chunk::SIZE];
 			let coord =
 				HexCoord::from_offset(IVec2::new(x as i32, z as i32) + (chunk.chunk_offset * Chunk::SIZE as i32));
 			let n = map.get_neighbors(&coord);

engine/world_generation/src/heightmap.rs

@@ -1,31 +1,51 @@
+use core::f32;
+
 use bevy::math::{IVec2, UVec2};
 use bevy::prelude::{FloatExt, Vec2};
 use bevy::utils::default;
-use noise::{NoiseFn, SuperSimplex};
+use noise::{NoiseFn, Simplex, SuperSimplex};
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 
 use crate::biome_painter::BiomePainter;
 use crate::map::biome_map::{BiomeChunk, BiomeData, BiomeMap};
-use crate::prelude::*;
+use crate::{map, prelude::*};
 
-pub fn generate_heightmap(cfg: &GenerationConfig, seed: u32, painter: &BiomePainter) -> Map {
-	let biomes = &generate_biomes(cfg, seed, painter);
+pub fn generate_heightmap(cfg: &GenerationConfig, seed: u32, painter: &BiomePainter) -> (Map, BiomeMap) {
+	let biomes = generate_biomes(cfg, seed, painter);
+	let biomes_borrow = &biomes;
 	// let mut chunks: Vec<Chunk> = Vec::with_capacity(cfg.size.length_squared() as usize);
-	let chunks = (0..cfg.size.y)
+	let chunks: Vec<Chunk> = (0..cfg.size.y)
 		.into_par_iter()
 		.flat_map(|z| {
 			(0..cfg.size.x).into_par_iter().map(move |x| {
-				let biome_chunk = &biomes.chunks[x as usize + z as usize * cfg.size.x as usize];
+				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);
 			})
 		})
 		.collect();
-	return Map {
-		chunks,
-		height: cfg.size.y as usize,
-		width: cfg.size.x as usize,
-		sea_level: cfg.sea_level as f32,
-	};
+	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 {
+			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 {
@@ -54,9 +74,9 @@ pub fn generate_biome_chunk(
 		data: [BiomeData::default(); Chunk::AREA],
 		tiles: Vec::with_capacity(Chunk::AREA),
 	};
-	let noise_m = SuperSimplex::new(seed + 1);
-	let noise_t = SuperSimplex::new(seed + 2);
-	let noise_c = SuperSimplex::new(seed + 3);
+	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 {
@@ -67,6 +87,7 @@ pub fn generate_biome_chunk(
 				&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,
@@ -75,6 +96,7 @@ pub fn generate_biome_chunk(
 				&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,
@@ -83,6 +105,7 @@ pub fn generate_biome_chunk(
 				&noise_c,
 				cfg.size.as_vec2(),
 				cfg.border_size,
+				0.0,
 			);
 			let data = BiomeData {
 				moisture: moisture.clamp(0., 100.),
@@ -100,6 +123,30 @@ pub fn generate_biome_chunk(
 	return chunk;
 }
 
+pub fn generate_noise_map(size: UVec2, seed: u32, cfg: &NoiseConfig, border_size: f32) -> Vec<f32> {
+	let noise = SuperSimplex::new(seed);
+
+	let data: Vec<_> = (0..(size.y as usize * Chunk::SIZE))
+		.into_par_iter()
+		.flat_map(|y| {
+			let mut row = Vec::with_capacity(size.x as usize * Chunk::SIZE);
+			for x in 0..row.capacity() {
+				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,
@@ -111,7 +158,9 @@ pub fn generate_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 = SuperSimplex::new(seed);
+	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);
@@ -130,29 +179,44 @@ pub fn generate_chunk(
 					&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();
 		}
 	}
 	return Chunk {
 		heights: result,
-		biome_data: data,
 		biome_id: biome_ids,
 		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) -> f32 {
+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;
 
 	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];
@@ -161,14 +225,11 @@ fn sample_point(x: f64, z: f64, cfg: &NoiseConfig, noise: &impl NoiseFn<f64, 2>,
 		} 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);
-		} else {
-			elevation += value;
-		}
+		elevation += value;
+	}
+
+	if border_size == 0.0 {
+		return elevation as f32;
 	}
 
 	let outer = size * Chunk::SIZE as f32;
@@ -179,11 +240,7 @@ fn sample_point(x: f64, z: f64, cfg: &NoiseConfig, noise: &impl NoiseFn<f64, 2>,
 	let d2 = od.x.min(od.y);
 	let d = d1.min(d2).min(border_size).remap(0., border_size, 0., 1.);
 
-	return (elevation as f32) * d;
-}
-
-fn mask(mask: f64, value: f64) -> f64 {
-	return value * mask;
+	return border_value.lerp(elevation as f32, d);
 }
 
 fn sample_simple(x: f64, z: f64, cfg: &GeneratorLayer, noise: &impl NoiseFn<f64, 2>) -> f64 {

engine/world_generation/src/hex_utils.rs

@@ -1,3 +1,6 @@
+use num::{PrimInt, Saturating};
+use std::fmt::Display;
+
 use crate::prelude::Chunk;
 use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
@@ -62,6 +65,12 @@ 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),
@@ -136,6 +145,7 @@ 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();
@@ -156,14 +166,20 @@ 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);
 	}
@@ -243,6 +259,37 @@ impl HexCoord {
 		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);

engine/world_generation/src/map/biome_map.rs

@@ -1,9 +1,13 @@
-use bevy::math::{UVec2, Vec3};
+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,
@@ -130,6 +134,15 @@ impl BiomeMap {
 		return chunk.get_biome_id(x - (cx * Chunk::SIZE), y - (cy * Chunk::SIZE));
 	}
 
+	pub fn get_biome_id_dithered(&self, x: usize, y: usize, noise: &impl NoiseFn<f64, 2>, scale: f64) -> usize {
+		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;
@@ -149,7 +162,7 @@ pub struct BiomeChunk {
 
 impl BiomeChunk {
 	pub fn get_biome(&self, x: usize, y: usize) -> &Vec<f32> {
-		return &self.tiles[x as usize + y as usize * Chunk::SIZE];
+		return &self.tiles[x + y * Chunk::SIZE];
 	}
 
 	pub fn get_biome_data(&self, x: usize, y: usize) -> &BiomeData {
@@ -171,16 +184,18 @@ impl BiomeChunk {
 	}
 
 	pub fn get_biome_id_dithered(&self, x: usize, y: usize, noise: &impl NoiseFn<f64, 2>, scale: f64) -> usize {
-		let cur_id = self.get_biome_id(x, y);
+		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) * b[cur_id];
+		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 n < blend {
-				return i;
+			if blend > max {
+				max = blend + n;
+				cur_id = i;
 			}
 		}
 

engine/world_generation/src/map/chunk.rs

@@ -7,9 +7,11 @@ use super::biome_map::BiomeData;
 pub struct Chunk {
 	pub heights: [f32; Chunk::AREA],
 	pub textures: [[u32; 2]; Chunk::AREA],
-	pub biome_data: [BiomeData; 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 {
@@ -17,9 +19,11 @@ impl Default for Chunk {
 		Self {
 			heights: [0.; Chunk::AREA],
 			textures: [[0; 2]; Chunk::AREA],
-			biome_data: [BiomeData::default(); 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,
 		}
 	}
 }

engine/world_generation/src/map/config.rs

@@ -1,10 +1,11 @@
 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)]
+#[derive(Resource, Reflect, Default, Clone)]
 #[reflect(Resource)]
 pub struct GenerationConfig {
 	pub sea_level: f64,
@@ -43,5 +44,4 @@ pub struct GeneratorLayer {
 	pub weight: f64,
 	pub weight_multi: f64,
 	pub layers: usize,
-	pub first_layer_mask: bool,
 }

engine/world_generation/src/map/map.rs

@@ -2,7 +2,11 @@ use bevy::prelude::*;
 
 use crate::hex_utils::*;
 
-use super::{chunk::Chunk, mesh_chunk::MeshChunkData};
+use super::{
+	biome_map::{BiomeData, BiomeMap},
+	chunk::Chunk,
+	mesh_chunk::MeshChunkData,
+};
 
 #[derive(Resource, Clone)]
 pub struct Map {
@@ -10,6 +14,9 @@ pub struct Map {
 	pub height: usize,
 	pub width: usize,
 	pub sea_level: f32,
+	pub min_level: f32,
+	pub max_level: f32,
+	pub biome_count: usize,
 }
 
 impl Map {
@@ -19,6 +26,7 @@ impl Map {
 		let chunk = &self.chunks[chunk_index];
 
 		return MeshChunkData {
+			min_height: self.min_level,
 			heights: chunk.heights.clone(),
 			textures: chunk.textures.clone(),
 		};
@@ -43,11 +51,21 @@ impl Map {
 	}
 
 	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()];
 	}
@@ -56,16 +74,57 @@ impl Map {
 		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();
@@ -87,22 +146,19 @@ impl Map {
 		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<usize> {
+	pub fn create_crater(&mut self, pos: &HexCoord, radius: usize, depth: f32) -> Vec<(HexCoord, f32)> {
 		assert!(radius != 0, "Radius cannot be zero");
-		let width = self.width;
 
-		let mut chunks = self.hex_select_mut(pos, radius, true, |p, h, r| {
+		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.to_chunk_index(width);
+			return (*p, *h);
 		});
 
-		chunks.dedup();
-
-		return chunks;
+		return tiles;
 	}
 
 	pub fn hex_select<OP, Ret>(&self, center: &HexCoord, radius: usize, include_center: bool, op: OP) -> Vec<Ret>
@@ -111,20 +167,25 @@ impl Map {
 	{
 		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);
-			(op)(&center, h, 0);
+			result.push((op)(center, h, 0));
 		}
 
-		let mut result = Vec::with_capacity(get_tile_count(radius));
-
 		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);
-					let h = self.sample_height(&p);
-					result.push((op)(&p, h, k));
+					if self.is_in_bounds(&p) {
+						let h = self.sample_height(&p);
+						result.push((op)(&p, h, k));
+					}
 				}
 			}
 		}
@@ -144,20 +205,25 @@ impl Map {
 	{
 		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);
-			(op)(&center, h, 0);
+			result.push((op)(center, h, 0));
 		}
 
-		let mut result = Vec::with_capacity(get_tile_count(radius));
-
 		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);
-					let h = self.sample_height_mut(&p);
-					result.push((op)(&p, h, k));
+					if self.is_in_bounds(&p) {
+						let h = self.sample_height_mut(&p);
+						result.push((op)(&p, h, k));
+					}
 				}
 			}
 		}

engine/world_generation/src/map/map_utils.rs

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

@@ -5,11 +5,12 @@ 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 = [0.; 6];
+		let mut data = [self.min_height; 6];
 		let n_tiles = coord.get_neighbors();
 		for i in 0..6 {
 			let n = n_tiles[i];

engine/world_generation/src/map/mod.rs

@@ -3,3 +3,4 @@ pub mod mesh_chunk;
 pub mod config;
 pub mod map;
 pub mod biome_map;
+pub mod map_utils;

engine/world_generation/src/states.rs

@@ -7,5 +7,5 @@ pub enum GeneratorState {
 	SpawnMap,
 	Idle,
 	Regenerate,
+	Cleanup,
 }
-

game/buildings/src/assets/building_asset.rs

@@ -1,7 +1,7 @@
 use asset_loader::create_asset_loader;
 use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
-use shared::resource::ResourceIdentifier;
+use shared::identifiers::ResourceIdentifier;
 
 use crate::footprint::BuildingFootprint;
 

game/buildings/src/build_queue.rs

@@ -1,3 +1,5 @@
+use std::path::Display;
+
 use bevy::prelude::Resource;
 use shared::building::BuildingIdentifier;
 use world_generation::hex_utils::HexCoord;

game/buildings/src/building_plugin.rs

@@ -1,19 +1,30 @@
-use bevy::{prelude::*, window::PrimaryWindow};
+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::{pipeline::QueryFilter, plugin::RapierContext};
+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::{hex_utils::HexCoord, map::map::Map};
+use world_generation::{
+	heightmap, hex_utils::HexCoord, map::map::Map, prelude::GenerationConfig, states::GeneratorState,
+};
 
 use crate::{
-	assets::{building_asset::BuildingAssetPlugin, building_database::BuildingDatabase},
+	assets::{
+		building_asset::{BuildingAsset, BuildingAssetPlugin},
+		building_database::BuildingDatabase,
+	},
 	build_queue::{BuildQueue, QueueEntry},
+	buildings_map::{BuildingEntry, BuildingMap},
+	prelude::Building,
 };
 
 pub struct BuildingPugin;
@@ -27,13 +38,36 @@ impl Plugin for BuildingPugin {
 			LoadingStateConfig::new(AssetLoadState::Loading).load_collection::<BuildingDatabase>(),
 		);
 
-		app.add_systems(Startup, init.run_if(in_state(AssetLoadState::Loading)));
-		app.add_systems(Update, hq_placement.run_if(in_state(GameplayState::PlaceHQ)));
+		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>);
 
@@ -45,44 +79,23 @@ fn init(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>, mut materials:
 }
 
 fn hq_placement(
-	cam_query: Query<(&GlobalTransform, &Camera), With<MainCamera>>,
 	mut commands: Commands,
-	window: Query<&Window, With<PrimaryWindow>>,
 	mouse: Res<ButtonInput<MouseButton>>,
-	rapier_context: Res<RapierContext>,
+	tile_under_cursor: Res<TileUnderCursor>,
 	map: Res<Map>,
 	indicator: Res<IndicatorCube>,
 	mut build_queue: ResMut<BuildQueue>,
 	mut next_state: ResMut<NextState<GameplayState>>,
 ) {
-	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 = rapier_context.cast_ray(
-		cam_ray.origin,
-		cam_ray.direction.into(),
-		500.,
-		true,
-		QueryFilter::only_fixed(),
-	);
-
-	if let Some((_e, dist)) = collision {
-		let contact_point = cam_ray.get_point(dist);
-		let contact_coord = HexCoord::from_world_pos(contact_point);
-		let positions = map.hex_select(&contact_coord, 3, true, |pos, h, _| pos.to_world(h));
+	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_coord,
+				pos: contact.tile,
 			});
 
 			next_state.set(GameplayState::Playing);
@@ -104,4 +117,57 @@ fn show_indicators(positions: Vec<Vec3>, commands: &mut Commands, indicator: &In
 	}
 }
 
-fn process_build_queue(mut queue: ResMut<BuildQueue>) {}
+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,14 +1,16 @@
 use bevy::prelude::*;
-use world_generation::hex_utils::HexCoord;
+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),
 		};
 
@@ -23,18 +25,39 @@ impl BuildingMap {
 		return db;
 	}
 
-	pub fn get_buildings_in_range(&self, coord: &HexCoord, radius: usize) -> Option<Vec<&BuildingEntry>> {
+	pub fn get_buildings_in_range(&self, coord: &HexCoord, radius: usize) -> Vec<&BuildingEntry> {
 		assert!(radius != 0, "Radius cannot be zero");
-		todo!();
+
+		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> {
-		todo!();
+		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<BuildingChunk>,
+	pub entries: Vec<BuildingEntry>,
 	pub index: usize,
 	pub offset: IVec2,
 }
@@ -49,7 +72,11 @@ impl BuildingChunk {
 	}
 
 	pub fn get_building(&self, coord: &HexCoord) -> Option<&BuildingEntry> {
-		todo!();
+		return self.entries.iter().find(|b| &b.coord == coord);
+	}
+
+	pub fn add_building(&mut self, entry: BuildingEntry) {
+		self.entries.push(entry);
 	}
 }
 

game/buildings/src/lib.rs

@@ -3,4 +3,5 @@ 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

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

game/main/Cargo.toml

@@ -7,13 +7,14 @@ build = "build.rs"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.14.0"
+bevy = { version = "0.14.0", features = ["file_watcher"] }
 bevy-inspector-egui = "0.25.0"
 iyes_perf_ui = "0.3.0"
 noise = "0.8.2"
 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",
@@ -21,6 +22,7 @@ bevy_asset_loader = { version = "0.21.0", features = [
 ] }
 ron = "0.8.1"
 avian3d = { version = "0.1.1" }
+image = "0.25.2"
 
 [features]
 tracing = ["bevy/trace_tracy", "world_generation/tracing", "buildings/tracing"]

game/main/src/camera_system/camera_plugin.rs

@@ -31,7 +31,7 @@ fn setup(mut commands: Commands, mut msaa: ResMut<Msaa>) {
 	commands
 		.spawn((
 			Camera3dBundle {
-				transform: Transform::from_xyz(0., 30., 0.).looking_to(Vec3::Z, Vec3::Y),
+				transform: Transform::from_xyz(0., 30., 0.).looking_to(Vec3::NEG_Z, Vec3::Y),
 				..default()
 			},
 			PhosCamera::default(),
@@ -138,15 +138,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 +156,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() {
@@ -209,8 +209,11 @@ 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 rot = Quat::from_axis_angle(Vec3::X, -angle);
-	cam.rotation = rot;
+	let mut rot = cam.rotation.to_euler(EulerRot::XYZ);
+	rot.0 = -angle;
+	cam.rotation = Quat::from_euler(EulerRot::XYZ, rot.0, rot.1, rot.2);
+	// let rot = Quat::from_axis_angle(Vec3::X, -angle);
+	// cam.rotation = rot;
 
 	cam.translation = cam_pos;
 }

game/main/src/camera_system/components.rs

@@ -38,7 +38,7 @@ impl Default for PhosCameraTargets {
 	fn default() -> Self {
 		Self {
 			height: Default::default(),
-			forward: Vec3::Z,
+			forward: Vec3::NEG_Z,
 			last_height: Default::default(),
 			anim_time: Default::default(),
 			rotate_time: Default::default(),

game/main/src/main.rs

@@ -36,6 +36,11 @@ 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

@@ -3,6 +3,10 @@ use bevy::ecs::world::CommandQueue;
 use bevy::prelude::*;
 use bevy::tasks::*;
 use bevy::utils::futures;
+use bevy_rapier3d::geometry::Collider;
+use bevy_rapier3d::geometry::TriMeshFlags;
+use shared::events::ChunkModifiedEvent;
+use shared::events::TileModifiedEvent;
 use world_generation::prelude::Map;
 use world_generation::states::GeneratorState;
 
@@ -17,7 +21,9 @@ pub struct ChunkRebuildPlugin;
 impl Plugin for ChunkRebuildPlugin {
 	fn build(&self, app: &mut App) {
 		app.init_resource::<PhosChunkRegistry>();
-		app.add_systems(PreUpdate, chunk_rebuilder.run_if(in_state(GeneratorState::SpawnMap)));
+		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);
 	}
 }
@@ -32,7 +38,7 @@ fn chunk_rebuilder(
 	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;

game/main/src/map_rendering/map_init.rs

@@ -3,10 +3,12 @@ use bevy::log::*;
 use bevy::{
 	pbr::{ExtendedMaterial, NotShadowCaster},
 	prelude::*,
+	render::texture::ImageFormat,
 };
 use bevy_asset_loader::prelude::*;
 
 use bevy_inspector_egui::quick::ResourceInspectorPlugin;
+use image::DynamicImage;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use shared::states::{AssetLoadState, GameplayState, MenuState};
 use world_generation::{
@@ -14,6 +16,10 @@ use world_generation::{
 	biome_painter::*,
 	heightmap::generate_heightmap,
 	hex_utils::{offset_to_index, SHORT_DIAGONAL},
+	map::{
+		biome_map::{self, BiomeMap},
+		map_utils::{render_biome_noise_map, render_map},
+	},
 	prelude::*,
 	tile_manager::*,
 	tile_mapper::*,
@@ -52,7 +58,7 @@ impl Plugin for MapInitPlugin {
 		app.register_asset_reflect::<ExtendedMaterial<StandardMaterial, WaterMaterial>>();
 		app.add_plugins((
 			ChunkRebuildPlugin,
-			TerraFormingTestPlugin,
+			// TerraFormingTestPlugin,
 			MaterialPlugin::<ExtendedMaterial<StandardMaterial, ChunkMaterial>>::default(),
 			MaterialPlugin::<ExtendedMaterial<StandardMaterial, WaterMaterial>> {
 				prepass_enabled: false,
@@ -81,9 +87,7 @@ impl Plugin for MapInitPlugin {
 		app.add_systems(Update, despawn_map.run_if(in_state(GeneratorState::Regenerate)));
 		app.add_systems(
 			Update,
-			spawn_map
-				.run_if(in_state(AssetLoadState::LoadComplete))
-				.run_if(in_state(GeneratorState::SpawnMap)),
+			spawn_map.run_if(in_state(AssetLoadState::LoadComplete).and_then(in_state(GeneratorState::SpawnMap))),
 		);
 
 		app.insert_resource(TileManager::default());
@@ -101,14 +105,16 @@ fn setup_materials(
 ) {
 	let water_material = water_materials.add(ExtendedMaterial {
 		base: StandardMaterial {
-			base_color: Color::srgba(0., 0.5, 1., 0.8),
+			base_color: Color::srgb(0., 0.878, 1.),
 			alpha_mode: AlphaMode::Blend,
+			metallic: 1.0,
 			..Default::default()
 		},
 		extension: WaterMaterial {
 			settings: WaterSettings {
-				offset: 0.5,
-				scale: 100.,
+				offset: -4.97,
+				scale: 1.,
+				deep_color: LinearRgba::rgb(0.0, 0.04, 0.085).into(),
 				..Default::default()
 			},
 			..default()
@@ -124,8 +130,8 @@ fn finalize_biome_painter(
 	biome_painter: Res<BiomePainterAsset>,
 	biomes: Res<Assets<BiomeAsset>>,
 ) {
-	let biome_painter = biome_painter.build(&biomes);
-	commands.insert_resource(biome_painter);
+	let painter = biome_painter.build(&biomes);
+	commands.insert_resource(painter);
 	next_generator_state.set(GeneratorState::GenerateHeightmap);
 }
 
@@ -158,10 +164,10 @@ fn create_heightmap(
 	biome_painter: Res<BiomePainter>,
 ) {
 	let config = GenerationConfig {
-		biome_blend: 16,
-		biome_dither: 16.,
+		biome_blend: 32,
+		biome_dither: 10.,
 		continent_noise: NoiseConfig {
-			scale: 500.,
+			scale: 800.,
 			layers: vec![GeneratorLayer {
 				base_roughness: 2.14,
 				roughness: 0.87,
@@ -172,11 +178,10 @@ fn create_heightmap(
 				weight: 0.,
 				weight_multi: 0.,
 				layers: 1,
-				first_layer_mask: false,
 			}],
 		},
 		moisture_noise: NoiseConfig {
-			scale: 500.,
+			scale: 900.,
 			layers: vec![GeneratorLayer {
 				base_roughness: 2.14,
 				roughness: 0.87,
@@ -187,11 +192,10 @@ fn create_heightmap(
 				weight: 0.,
 				weight_multi: 0.,
 				layers: 1,
-				first_layer_mask: false,
 			}],
 		},
 		temperature_noise: NoiseConfig {
-			scale: 500.,
+			scale: 700.,
 			layers: vec![GeneratorLayer {
 				base_roughness: 2.14,
 				roughness: 0.87,
@@ -202,7 +206,6 @@ fn create_heightmap(
 				weight: 0.,
 				weight_multi: 0.,
 				layers: 1,
-				first_layer_mask: false,
 			}],
 		},
 		sea_level: 8.5,
@@ -210,13 +213,14 @@ fn create_heightmap(
 		size: UVec2::splat(16),
 		// size: UVec2::splat(1),
 	};
-	let heightmap = generate_heightmap(&config, 42069, &biome_painter);
+	let (heightmap, biome_map) = generate_heightmap(&config, 42069, &biome_painter);
 
 	let (mut cam_t, cam_entity) = cam.single_mut();
 	cam_t.translation = heightmap.get_center();
 
 	commands.entity(cam_entity).insert(CameraBounds::from_size(config.size));
 	commands.insert_resource(heightmap);
+	commands.insert_resource(biome_map);
 	commands.insert_resource(config);
 	next_state.set(GeneratorState::SpawnMap);
 }
@@ -296,6 +300,7 @@ fn spawn_map(
 fn despawn_map(
 	mut commands: Commands,
 	mut heightmap: ResMut<Map>,
+	mut biome_map: ResMut<BiomeMap>,
 	cfg: Res<GenerationConfig>,
 	chunks: Query<Entity, With<PhosChunk>>,
 	mut next_state: ResMut<NextState<GeneratorState>>,
@@ -305,6 +310,6 @@ fn despawn_map(
 		commands.entity(chunk).despawn();
 	}
 
-	*heightmap = generate_heightmap(&cfg, 4, &biome_painter);
+	(*heightmap, *biome_map) = generate_heightmap(&cfg, 4, &biome_painter);
 	next_state.set(GeneratorState::SpawnMap);
 }

game/main/src/map_rendering/terraforming_test.rs

@@ -1,5 +1,10 @@
 use avian3d::prelude::*;
-use bevy::{prelude::*, window::PrimaryWindow};
+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 crate::{
@@ -11,18 +16,24 @@ pub struct TerraFormingTestPlugin;
 
 impl Plugin for TerraFormingTestPlugin {
 	fn build(&self, app: &mut App) {
-		app.add_systems(Update, deform.run_if(in_state(GeneratorState::Idle)));
+		app.add_systems(
+			Update,
+			deform
+				.run_if(in_state(GeneratorState::Idle))
+				.run_if(in_state(GameplayState::Playing)),
+		);
 	}
 }
 
 fn deform(
-	cam_query: Query<(&GlobalTransform, &Camera), With<PhosCamera>>,
 	mut commands: Commands,
-	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>,
 ) {
 	let mut multi = 0.;
 	if mouse.just_pressed(MouseButton::Left) {
@@ -35,36 +46,20 @@ fn deform(
 		return;
 	}
 
-	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(hit) = collision {
+	if let Some(contact) = tile_under_cursor.0 {
 		#[cfg(feature = "tracing")]
 		let span = info_span!("Deform Mesh").entered();
-
-		let e = hit.entity;
-		let dist = hit.time_of_impact;
-		let contact_point = cam_ray.get_point(dist);
-		let contact_coord = HexCoord::from_world_pos(contact_point);
-		let modified_chunks = heightmap.create_crater(&contact_coord, 5, 5. * multi);
-		for c in modified_chunks {
-			commands.entity(chunks.chunks[c]).insert(RebuildChunk);
+		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);
+			}
+			tile_modified.send(TileModifiedEvent::HeightChanged(tile, height));
 		}
-		commands.entity(e).insert(RebuildChunk);
+		// commands.entity(e).insert(RebuildChunk);
 	}
 }

game/main/src/phos.rs

@@ -1,18 +1,24 @@
-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::utlis::render_distance_system::RenderDistancePlugin;
-use avian3d::prelude::*;
-use avian3d::PhysicsPlugins;
+use crate::utlis::tile_selection_plugin::TileSelectionPlugin;
+use crate::{camera_system::camera_plugin::PhosCameraPlugin, utlis::debug_plugin::DebugPlugin};
 use bevy::{
 	pbr::{wireframe::WireframeConfig, CascadeShadowConfig},
 	prelude::*,
 };
 use bevy_asset_loader::prelude::*;
+use bevy_rapier3d::dynamics::{Ccd, RigidBody, Velocity};
+use bevy_rapier3d::geometry::Collider;
+use bevy_rapier3d::plugin::{NoUserData, RapierPhysicsPlugin};
 use buildings::BuildingPugin;
 use iyes_perf_ui::prelude::*;
+use shared::sets::GameplaySet;
 use shared::states::{GameplayState, MenuState};
 use shared::{despawn::DespawnPuglin, states::AssetLoadState};
+use units::units_plugin::UnitsPlugin;
+use world_generation::states::GeneratorState;
 
 pub struct PhosGamePlugin;
 
@@ -30,10 +36,18 @@ impl Plugin for PhosGamePlugin {
 			PhosCameraPlugin,
 			MapInitPlugin,
 			RenderDistancePlugin,
-			//BuildingPugin,
+			BuildingPugin,
+			UnitsPlugin,
 			DespawnPuglin,
+			TileSelectionPlugin,
+			#[cfg(debug_assertions)]
+			EditorPlugin,
+			#[cfg(debug_assertions)]
+			DebugPlugin,
 		));
 
+		configure_gameplay_set(app);
+
 		//Systems - Startup
 		app.add_systems(Startup, init_game);
 
@@ -47,7 +61,7 @@ impl Plugin for PhosGamePlugin {
 			.add_plugins(PerfUiPlugin);
 
 		//Physics
-		app.add_plugins(PhysicsPlugins::default());
+		app.add_plugins(RapierPhysicsPlugin::<NoUserData>::default());
 		// app.add_plugins(RapierDebugRenderPlugin::default());
 
 		app.insert_resource(WireframeConfig {
@@ -57,6 +71,34 @@ impl Plugin for PhosGamePlugin {
 	}
 }
 
+fn configure_gameplay_set(app: &mut App) {
+	app.configure_sets(
+		Update,
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
+	);
+	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(),
@@ -106,9 +148,10 @@ fn spawn_sphere(
 				transform: Transform::from_translation(cam_transform.translation),
 				..default()
 			},
-			Collider::sphere(0.3),
+			Collider::ball(0.3),
 			RigidBody::Dynamic,
-			LinearVelocity(cam_transform.forward() * 50.),
+			Ccd::enabled(),
+			Velocity::linear(cam_transform.forward() * 50.),
 		));
 	}
 }

game/main/src/shader_extensions/water_material.rs

@@ -15,7 +15,8 @@ pub struct WaterMaterial {
 pub struct WaterSettings {
 	pub offset: f32,
 	pub scale: f32,
-	pub deep_color: Vec3,
+	pub f_power: f32,
+	pub deep_color: LinearRgba,
 }
 
 impl Default for WaterSettings {
@@ -23,7 +24,8 @@ impl Default for WaterSettings {
 		Self {
 			offset: 0.0,
 			scale: 1.0,
-			deep_color: Vec3::ZERO,
+			f_power: 2.0,
+			deep_color: default(),
 		}
 	}
 }

game/main/src/utlis/debug_plugin.rs

@@ -0,0 +1,100 @@
+use bevy::{prelude::*, window::PrimaryWindow};
+use bevy_inspector_egui::bevy_egui::{systems::InputEvents, EguiContexts};
+use bevy_inspector_egui::egui;
+use bevy_rapier3d::prelude::*;
+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

@@ -0,0 +1,161 @@
+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,2 +1,5 @@
 pub mod chunk_utils;
 pub mod render_distance_system;
+pub mod debug_plugin;
+pub mod editor_plugin;
+pub mod tile_selection_plugin;

game/main/src/utlis/render_distance_system.rs

@@ -9,6 +9,9 @@ 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));
 	}
 }
 
@@ -56,8 +59,9 @@ 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 = (camera.translation - (t.translation + r.offset)).length();
+		let dist = (cam_pos - (t.translation + r.offset)).length();
 		if settings.render_distance < dist {
 			*vis = Visibility::Hidden;
 		} else {

game/main/src/utlis/tile_selection_plugin.rs

@@ -0,0 +1,62 @@
+use bevy::{prelude::*, window::PrimaryWindow};
+use bevy_rapier3d::{plugin::RapierContext, prelude::QueryFilter};
+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>>,
+	rapier_context: Res<RapierContext>,
+	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 = rapier_context.cast_ray(
+		cam_ray.origin,
+		cam_ray.direction.into(),
+		500.,
+		true,
+		QueryFilter::only_fixed(),
+	);
+
+	if let Some((_e, dist)) = collision {
+		let contact_point = cam_ray.get_point(dist);
+		let contact_coord = HexCoord::from_world_pos(contact_point);
+		//todo: handle correct tile detection when contacting a tile from the side
+		if !map.is_in_bounds(&contact_coord) {
+			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

@@ -8,6 +8,7 @@ edition = "2021"
 [dependencies]
 bevy = "0.14.0"
 serde = { version = "1.0.204", features = ["derive"] }
+world_generation = { path = "../../engine/world_generation" }
 
 
 [features]

game/shared/src/building.rs

@@ -1,10 +1,28 @@
 use serde::{Deserialize, Serialize};
 
 #[derive(Default, PartialEq, Eq, Serialize, Deserialize)]
-pub struct BuildingIdentifier(u32);
+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/events.rs

@@ -0,0 +1,13 @@
+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,4 +1,6 @@
+use bevy::prelude::Resource;
 use serde::{Deserialize, Serialize};
+use world_generation::hex_utils::HexCoord;
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ResourceIdentifier {

game/shared/src/lib.rs

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

game/shared/src/resources.rs

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

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

game/shared/src/tags.rs

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

game/units/Cargo.toml

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

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

game/units/src/assets/unit_asset.rs

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

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

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

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

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

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

@@ -0,0 +1,82 @@
+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,
+	};
+}