Merge branch 'master' into avian

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;
+	}
+}